From 97fde01ec17dac2edbd4cb84df2a6e13375db637 Mon Sep 17 00:00:00 2001
From: Ben van Hartingsveldt <ben.vanhartingsveldt@yocto.com>
Date: Wed, 28 Aug 2024 11:46:24 +0200
Subject: [PATCH] Add helper functions

---
 README.md                       |   5 +-
 src/EPPElementHelper.php        |  53 +++++++++
 src/EPPElementImpl.php          |   4 +-
 src/EPPNamespaces.php           |  20 ++++
 tests/EPPDocumentHelperTest.php |  13 ++-
 tests/EPPElementTest.php        | 199 ++++++++++++++++----------------
 6 files changed, 185 insertions(+), 109 deletions(-)
 create mode 100644 src/EPPElementHelper.php
 create mode 100644 src/EPPNamespaces.php

diff --git a/README.md b/README.md
index 4402d25..1cc0a45 100644
--- a/README.md
+++ b/README.md
@@ -34,14 +34,15 @@ $hello = $epp->getHello();
 
 ```php
 use YOCLIB\EPP\EPPDocumentHelper;
+use YOCLIB\EPP\EPPNamespaces;
 use YOCLIB\EPP\Connections\EPPTCPConnection;
 use YOCLIB\EPP\Registries\SIDNTest;
 
 $doc = EPPDocumentHelper::createEPPDocument();
 
-$epp = $doc->createElementNS('urn:ietf:params:xml:ns:epp-1.0','epp');
+$epp = $doc->createElementNS(EPPNamespaces::EPP_1_0,'epp');
 
-$hello = $doc->createElementNS('urn:ietf:params:xml:ns:epp-1.0','hello');
+$hello = $doc->createElementNS(EPPNamespaces::EPP_1_0,'hello');
 
 $epp->appendChild($hello);
 
diff --git a/src/EPPElementHelper.php b/src/EPPElementHelper.php
new file mode 100644
index 0000000..5194055
--- /dev/null
+++ b/src/EPPElementHelper.php
@@ -0,0 +1,53 @@
+<?php
+namespace YOCLIB\EPP;
+
+use Wikimedia\IDLeDOM\Document;
+use Wikimedia\IDLeDOM\Node;
+use YOCLIB\EPP\Elements\EPPExtensionValueElement;
+use YOCLIB\EPP\Elements\EPPMessageElement;
+use YOCLIB\EPP\Elements\EPPResultElement;
+use YOCLIB\EPP\Elements\EPPValueElement;
+
+class EPPElementHelper{
+
+    /**
+     * @param Document $document
+     * @param string $code
+     * @param EPPMessageElement $msg
+     * @param ?EPPValueElement|?EPPExtensionValueElement|null $valueOrExtValue
+     * @return EPPResultElement
+     */
+    public static function createEPPResultElement(Document $document,string $code,EPPMessageElement $msg,$valueOrExtValue=null): EPPResultElement{
+        /**@var EPPResultElement $resultElement*/
+        $resultElement = $document->createElementNS(EPPNamespaces::EPP_1_0,'result');
+        $resultElement->setAttribute('code',$code);
+
+        $resultElement->appendChild($msg);
+
+        if($valueOrExtValue){
+            $resultElement->appendChild($valueOrExtValue);
+        }
+
+        return $resultElement;
+    }
+
+    /**
+     * @param Document $document
+     * @param string $lang
+     * @param string|Node $content
+     * @return EPPMessageElement
+     */
+    public static function createEPPMessageElement(Document $document,string $lang,... $content): EPPMessageElement{
+        /**@var EPPMessageElement $messageElement*/
+        $messageElement = $document->createElementNS(EPPNamespaces::EPP_1_0,'msg');
+        if(is_string($content[0] ?? null)){
+            $messageElement->textContent = $content;
+        }else{
+            foreach($content AS $node){
+                $messageElement->appendChild($node);
+            }
+        }
+        return $messageElement;
+    }
+
+}
\ No newline at end of file
diff --git a/src/EPPElementImpl.php b/src/EPPElementImpl.php
index 3ea2521..3e8cac1 100644
--- a/src/EPPElementImpl.php
+++ b/src/EPPElementImpl.php
@@ -86,7 +86,7 @@ public static function __createElementNS(Document $doc, ?string $ns, string $lna
     }
 
     private static function __getElements(): array{
-        if(!isset(self::$ELEMENTS['urn:ietf:params:xml:ns:epp-1.0'])){
+        if(!isset(self::$ELEMENTS[EPPNamespaces::EPP_1_0])){
             self::$ELEMENTS = array_merge(self::$ELEMENTS,self::getCustomElementsEPP());
         }
         return self::$ELEMENTS;
@@ -99,7 +99,7 @@ private static function __lookupClass(?string $ns, string $lname){
 
     public static function getCustomElementsEPP(): array{
         return [
-            'urn:ietf:params:xml:ns:epp-1.0' => [
+            EPPNamespaces::EPP_1_0 => [
                 'absolute' => EPPAbsoluteElementImpl::class,
                 'access' => EPPAccessElementImpl::class,
                 'admin' => EPPAdministrationElementImpl::class,
diff --git a/src/EPPNamespaces.php b/src/EPPNamespaces.php
new file mode 100644
index 0000000..a88acb1
--- /dev/null
+++ b/src/EPPNamespaces.php
@@ -0,0 +1,20 @@
+<?php
+namespace YOCLIB\EPP;
+
+class EPPNamespaces{
+
+    public const CONTACT_1_0 = 'urn:ietf:params:xml:ns:contact-1.0';
+
+    public const DOMAIN_1_0 = 'urn:ietf:params:xml:ns:domain-1.0';
+
+    public const EPP_1_0 = 'urn:ietf:params:xml:ns:epp-1.0';
+
+    public const EPPCOM_1_0 = 'urn:ietf:params:xml:ns:eppcom-1.0';
+
+    public const EPP_ORG_1_0 = 'urn:ietf:params:xml:ns:epp:org-1.0';
+
+    public const EPP_ORGEXT_1_0 = 'urn:ietf:params:xml:ns:epp:orgext-1.0';
+
+    public const HOST_1_0 = 'urn:ietf:params:xml:ns:host-1.0';
+
+}
\ No newline at end of file
diff --git a/tests/EPPDocumentHelperTest.php b/tests/EPPDocumentHelperTest.php
index 080f5f0..b5c1ddb 100644
--- a/tests/EPPDocumentHelperTest.php
+++ b/tests/EPPDocumentHelperTest.php
@@ -9,6 +9,7 @@
 use YOCLIB\EPP\Elements\EPPHelloElement;
 use YOCLIB\EPP\Elements\EPPUnknownElement;
 use YOCLIB\EPP\EPPDocumentHelper;
+use YOCLIB\EPP\EPPNamespaces;
 
 class EPPDocumentHelperTest extends TestCase{
 
@@ -29,16 +30,16 @@ public function testSetContentType(): void{
     public function testCreateElementNS(): void{
         $document = EPPDocumentHelper::createEPPDocument();
 
-        $this->assertInstanceOf(EPPEppElement::class,$document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','epp'));
-        $this->assertInstanceOf(EPPHelloElement::class,$document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','hello'));
-        $this->assertInstanceOf(EPPUnknownElement::class,$document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','does-not-exist'));
+        $this->assertInstanceOf(EPPEppElement::class,$document->createElementNS(EPPNamespaces::EPP_1_0,'epp'));
+        $this->assertInstanceOf(EPPHelloElement::class,$document->createElementNS(EPPNamespaces::EPP_1_0,'hello'));
+        $this->assertInstanceOf(EPPUnknownElement::class,$document->createElementNS(EPPNamespaces::EPP_1_0,'does-not-exist'));
         $this->assertInstanceOf(Element::class,$document->createElementNS('does-not-exist','does-not-exist'));
 
         $document->setContentType('application/xml');
 
-        $this->assertInstanceOf(Element::class,$document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','epp'));
-        $this->assertInstanceOf(Element::class,$document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','hello'));
-        $this->assertInstanceOf(Element::class,$document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','does-not-exist'));
+        $this->assertInstanceOf(Element::class,$document->createElementNS(EPPNamespaces::EPP_1_0,'epp'));
+        $this->assertInstanceOf(Element::class,$document->createElementNS(EPPNamespaces::EPP_1_0,'hello'));
+        $this->assertInstanceOf(Element::class,$document->createElementNS(EPPNamespaces::EPP_1_0,'does-not-exist'));
         $this->assertInstanceOf(Element::class,$document->createElementNS('does-not-exist','does-not-exist'));
     }
 
diff --git a/tests/EPPElementTest.php b/tests/EPPElementTest.php
index b1e5e76..afd62cd 100644
--- a/tests/EPPElementTest.php
+++ b/tests/EPPElementTest.php
@@ -71,6 +71,7 @@
 use YOCLIB\EPP\Elements\EPPValueElement;
 use YOCLIB\EPP\Elements\EPPVersionElement;
 use YOCLIB\EPP\EPPDocumentHelper;
+use YOCLIB\EPP\EPPNamespaces;
 
 class EPPElementTest extends TestCase{
 
@@ -78,7 +79,7 @@ public function testEPPAccessElement(): void{
         $document = EPPDocumentHelper::createEPPDocument();
 
         /**@var EPPAccessElement $access*/
-        $access = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','access');
+        $access = $document->createElementNS(EPPNamespaces::EPP_1_0,'access');
         $this->assertInstanceOf(EPPAccessElement::class,$access);
 
         $this->assertNull($access->getAll());
@@ -88,37 +89,37 @@ public function testEPPAccessElement(): void{
         $this->assertNull($access->getPersonal());
         $this->assertNull($access->getPersonalOrOther());
 
-        $all = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','all');
+        $all = $document->createElementNS(EPPNamespaces::EPP_1_0,'all');
         $access->appendChild($all);
 
         $this->assertEquals($all,$access->getAll());
         $this->assertInstanceOf(EPPAllElement::class,$all);
 
-        $none = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','none');
+        $none = $document->createElementNS(EPPNamespaces::EPP_1_0,'none');
         $access->appendChild($none);
 
         $this->assertEquals($none,$access->getNone());
         $this->assertInstanceOf(EPPNoneElement::class,$none);
 
-        $null = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','null');
+        $null = $document->createElementNS(EPPNamespaces::EPP_1_0,'null');
         $access->appendChild($null);
 
         $this->assertEquals($null,$access->getNull());
         $this->assertInstanceOf(EPPNullElement::class,$null);
 
-        $other = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','other');
+        $other = $document->createElementNS(EPPNamespaces::EPP_1_0,'other');
         $access->appendChild($other);
 
         $this->assertEquals($other,$access->getOther());
         $this->assertInstanceOf(EPPOtherElement::class,$other);
 
-        $personal = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','personal');
+        $personal = $document->createElementNS(EPPNamespaces::EPP_1_0,'personal');
         $access->appendChild($personal);
 
         $this->assertEquals($personal,$access->getPersonal());
         $this->assertInstanceOf(EPPPersonalElement::class,$personal);
 
-        $personalAndOther = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','personalAndOther');
+        $personalAndOther = $document->createElementNS(EPPNamespaces::EPP_1_0,'personalAndOther');
         $access->appendChild($personalAndOther);
 
         $this->assertEquals($personalAndOther,$access->getPersonalOrOther());
@@ -129,7 +130,7 @@ public function testEPPCommandElement(): void{
         $document = EPPDocumentHelper::createEPPDocument();
 
         /**@var EPPCommandElement $command*/
-        $command = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','command');
+        $command = $document->createElementNS(EPPNamespaces::EPP_1_0,'command');
         $this->assertInstanceOf(EPPCommandElement::class,$command);
 
         $this->assertNull($command->getCheck());
@@ -145,73 +146,73 @@ public function testEPPCommandElement(): void{
         $this->assertNull($command->getExtension());
         $this->assertNull($command->getClientTransactionID());
 
-        $check = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','check');
+        $check = $document->createElementNS(EPPNamespaces::EPP_1_0,'check');
         $command->appendChild($check);
 
         $this->assertEquals($check,$command->getCheck());
         $this->assertInstanceOf(EPPCheckElement::class,$check);
 
-        $create = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','create');
+        $create = $document->createElementNS(EPPNamespaces::EPP_1_0,'create');
         $command->appendChild($create);
 
         $this->assertEquals($create,$command->getCreate());
         $this->assertInstanceOf(EPPCreateElement::class,$create);
 
-        $delete = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','delete');
+        $delete = $document->createElementNS(EPPNamespaces::EPP_1_0,'delete');
         $command->appendChild($delete);
 
         $this->assertEquals($delete,$command->getDelete());
         $this->assertInstanceOf(EPPDeleteElement::class,$delete);
 
-        $info = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','info');
+        $info = $document->createElementNS(EPPNamespaces::EPP_1_0,'info');
         $command->appendChild($info);
 
         $this->assertEquals($info,$command->getInformation());
         $this->assertInstanceOf(EPPInformationElement::class,$info);
 
-        $login = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','login');
+        $login = $document->createElementNS(EPPNamespaces::EPP_1_0,'login');
         $command->appendChild($login);
 
         $this->assertEquals($login,$command->getLogin());
         $this->assertInstanceOf(EPPLoginElement::class,$login);
 
-        $logout = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','logout');
+        $logout = $document->createElementNS(EPPNamespaces::EPP_1_0,'logout');
         $command->appendChild($logout);
 
         $this->assertEquals($logout,$command->getLogout());
         $this->assertInstanceOf(EPPLogoutElement::class,$logout);
 
-        $poll = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','poll');
+        $poll = $document->createElementNS(EPPNamespaces::EPP_1_0,'poll');
         $command->appendChild($poll);
 
         $this->assertEquals($poll,$command->getPoll());
         $this->assertInstanceOf(EPPPollElement::class,$poll);
 
-        $renew = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','renew');
+        $renew = $document->createElementNS(EPPNamespaces::EPP_1_0,'renew');
         $command->appendChild($renew);
 
         $this->assertEquals($renew,$command->getRenew());
         $this->assertInstanceOf(EPPRenewElement::class,$renew);
 
-        $transfer = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','transfer');
+        $transfer = $document->createElementNS(EPPNamespaces::EPP_1_0,'transfer');
         $command->appendChild($transfer);
 
         $this->assertEquals($transfer,$command->getTransfer());
         $this->assertInstanceOf(EPPTransferElement::class,$transfer);
 
-        $update = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','update');
+        $update = $document->createElementNS(EPPNamespaces::EPP_1_0,'update');
         $command->appendChild($update);
 
         $this->assertEquals($update,$command->getUpdate());
         $this->assertInstanceOf(EPPUpdateElement::class,$update);
 
-        $extension = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','extension');
+        $extension = $document->createElementNS(EPPNamespaces::EPP_1_0,'extension');
         $command->appendChild($extension);
 
         $this->assertEquals($extension,$command->getExtension());
         $this->assertInstanceOf(EPPExtensionElement::class,$extension);
 
-        $clTRID = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','clTRID');
+        $clTRID = $document->createElementNS(EPPNamespaces::EPP_1_0,'clTRID');
         $command->appendChild($clTRID);
 
         $this->assertEquals($clTRID,$command->getClientTransactionID());
@@ -222,26 +223,26 @@ public function testEPPDataCollectionPolicyElement(): void{
         $document = EPPDocumentHelper::createEPPDocument();
 
         /**@var EPPDataCollectionPolicyElement $dcp*/
-        $dcp = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','dcp');
+        $dcp = $document->createElementNS(EPPNamespaces::EPP_1_0,'dcp');
         $this->assertInstanceOf(EPPDataCollectionPolicyElement::class,$dcp);
 
         $this->assertNull($dcp->getAccess());
         $this->assertEmpty($dcp->getStatement());
         $this->assertNull($dcp->getExpiry());
 
-        $access = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','access');
+        $access = $document->createElementNS(EPPNamespaces::EPP_1_0,'access');
         $dcp->appendChild($access);
 
         $this->assertEquals($access,$dcp->getAccess());
         $this->assertInstanceOf(EPPAccessElement::class,$access);
 
-        $statement = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','statement');
+        $statement = $document->createElementNS(EPPNamespaces::EPP_1_0,'statement');
         $dcp->appendChild($statement);
 
         $this->assertEquals($statement,$dcp->getStatement()[0]);
         $this->assertInstanceOf(EPPStatementElement::class,$statement);
 
-        $expiry = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','expiry');
+        $expiry = $document->createElementNS(EPPNamespaces::EPP_1_0,'expiry');
         $dcp->appendChild($expiry);
 
         $this->assertEquals($expiry,$dcp->getExpiry());
@@ -252,7 +253,7 @@ public function testEPPEppElement(): void{
         $document = EPPDocumentHelper::createEPPDocument();
 
         /**@var EPPEppElement $epp*/
-        $epp = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','epp');
+        $epp = $document->createElementNS(EPPNamespaces::EPP_1_0,'epp');
         $this->assertInstanceOf(EPPEppElement::class,$epp);
 
         $this->assertNull($epp->getGreeting());
@@ -261,31 +262,31 @@ public function testEPPEppElement(): void{
         $this->assertNull($epp->getResponse());
         $this->assertNull($epp->getExtension());
 
-        $greeting = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','greeting');
+        $greeting = $document->createElementNS(EPPNamespaces::EPP_1_0,'greeting');
         $epp->appendChild($greeting);
 
         $this->assertEquals($greeting,$epp->getGreeting());
         $this->assertInstanceOf(EPPGreetingElement::class,$greeting);
 
-        $hello = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','hello');
+        $hello = $document->createElementNS(EPPNamespaces::EPP_1_0,'hello');
         $epp->appendChild($hello);
 
         $this->assertEquals($hello,$epp->getHello());
         $this->assertInstanceOf(EPPHelloElement::class,$hello);
 
-        $command = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','command');
+        $command = $document->createElementNS(EPPNamespaces::EPP_1_0,'command');
         $epp->appendChild($command);
 
         $this->assertEquals($command,$epp->getCommand());
         $this->assertInstanceOf(EPPCommandElement::class,$command);
 
-        $response = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','response');
+        $response = $document->createElementNS(EPPNamespaces::EPP_1_0,'response');
         $epp->appendChild($response);
 
         $this->assertEquals($response,$epp->getResponse());
         $this->assertInstanceOf(EPPResponseElement::class,$response);
 
-        $extension = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','extension');
+        $extension = $document->createElementNS(EPPNamespaces::EPP_1_0,'extension');
         $epp->appendChild($extension);
 
         $this->assertEquals($extension,$epp->getExtension());
@@ -296,19 +297,19 @@ public function testEPPExpiryElement(): void{
         $document = EPPDocumentHelper::createEPPDocument();
 
         /**@var EPPExpiryElement $expiry*/
-        $expiry = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','expiry');
+        $expiry = $document->createElementNS(EPPNamespaces::EPP_1_0,'expiry');
         $this->assertInstanceOf(EPPExpiryElement::class,$expiry);
 
         $this->assertNull($expiry->getAbsolute());
         $this->assertNull($expiry->getRelative());
 
-        $absolute = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','absolute');
+        $absolute = $document->createElementNS(EPPNamespaces::EPP_1_0,'absolute');
         $expiry->appendChild($absolute);
 
         $this->assertEquals($absolute,$expiry->getAbsolute());
         $this->assertInstanceOf(EPPAbsoluteElement::class,$absolute);
 
-        $relative = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','relative');
+        $relative = $document->createElementNS(EPPNamespaces::EPP_1_0,'relative');
         $expiry->appendChild($relative);
 
         $this->assertEquals($relative,$expiry->getRelative());
@@ -319,19 +320,19 @@ public function testEPPExtensionValueElement(): void{
         $document = EPPDocumentHelper::createEPPDocument();
 
         /**@var EPPExtensionValueElement $extValue*/
-        $extValue = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','extValue');
+        $extValue = $document->createElementNS(EPPNamespaces::EPP_1_0,'extValue');
         $this->assertInstanceOf(EPPExtensionValueElement::class,$extValue);
 
         $this->assertNull($extValue->getValue());
         $this->assertNull($extValue->getReason());
 
-        $value = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','value');
+        $value = $document->createElementNS(EPPNamespaces::EPP_1_0,'value');
         $extValue->appendChild($value);
 
         $this->assertEquals($value,$extValue->getValue());
         $this->assertInstanceOf(EPPValueElement::class,$value);
 
-        $reason = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','reason');
+        $reason = $document->createElementNS(EPPNamespaces::EPP_1_0,'reason');
         $extValue->appendChild($reason);
 
         $this->assertEquals($reason,$extValue->getReason());
@@ -342,7 +343,7 @@ public function testEPPGreetingElement(): void{
         $document = EPPDocumentHelper::createEPPDocument();
 
         /**@var EPPGreetingElement $greeting*/
-        $greeting = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','greeting');
+        $greeting = $document->createElementNS(EPPNamespaces::EPP_1_0,'greeting');
         $this->assertInstanceOf(EPPGreetingElement::class,$greeting);
 
         $this->assertNull($greeting->getServerID());
@@ -350,25 +351,25 @@ public function testEPPGreetingElement(): void{
         $this->assertNull($greeting->getServiceMenu());
         $this->assertNull($greeting->getDataCollectionPolicy());
 
-        $svID = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','svID');
+        $svID = $document->createElementNS(EPPNamespaces::EPP_1_0,'svID');
         $greeting->appendChild($svID);
 
         $this->assertEquals($svID,$greeting->getServerID());
         $this->assertInstanceOf(EPPServerIdElement::class,$svID);
 
-        $svDate = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','svDate');
+        $svDate = $document->createElementNS(EPPNamespaces::EPP_1_0,'svDate');
         $greeting->appendChild($svDate);
 
         $this->assertEquals($svDate,$greeting->getServerDate());
         $this->assertInstanceOf(EPPServerDateElement::class,$svDate);
 
-        $svcMenu = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','svcMenu');
+        $svcMenu = $document->createElementNS(EPPNamespaces::EPP_1_0,'svcMenu');
         $greeting->appendChild($svcMenu);
 
         $this->assertEquals($svcMenu,$greeting->getServiceMenu());
         $this->assertInstanceOf(EPPServiceMenuElement::class,$svcMenu);
 
-        $dcp = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','dcp');
+        $dcp = $document->createElementNS(EPPNamespaces::EPP_1_0,'dcp');
         $greeting->appendChild($dcp);
 
         $this->assertEquals($dcp,$greeting->getDataCollectionPolicy());
@@ -379,7 +380,7 @@ public function testEPPLoginElement(): void{
         $document = EPPDocumentHelper::createEPPDocument();
 
         /**@var EPPLoginElement $login*/
-        $login = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','login');
+        $login = $document->createElementNS(EPPNamespaces::EPP_1_0,'login');
         $this->assertInstanceOf(EPPLoginElement::class,$login);
 
         $this->assertNull($login->getClientID());
@@ -388,31 +389,31 @@ public function testEPPLoginElement(): void{
         $this->assertNull($login->getOptions());
         $this->assertNull($login->getServices());
 
-        $clID = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','clID');
+        $clID = $document->createElementNS(EPPNamespaces::EPP_1_0,'clID');
         $login->appendChild($clID);
 
         $this->assertEquals($clID,$login->getClientID());
         $this->assertInstanceOf(EPPClientIdElement::class,$clID);
 
-        $pw = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','pw');
+        $pw = $document->createElementNS(EPPNamespaces::EPP_1_0,'pw');
         $login->appendChild($pw);
 
         $this->assertEquals($pw,$login->getPassword());
         $this->assertInstanceOf(EPPPasswordElement::class,$pw);
 
-        $newPW = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','newPW');
+        $newPW = $document->createElementNS(EPPNamespaces::EPP_1_0,'newPW');
         $login->appendChild($newPW);
 
         $this->assertEquals($newPW,$login->getNewPassword());
         $this->assertInstanceOf(EPPNewPasswordElement::class,$newPW);
 
-        $options = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','options');
+        $options = $document->createElementNS(EPPNamespaces::EPP_1_0,'options');
         $login->appendChild($options);
 
         $this->assertEquals($options,$login->getOptions());
         $this->assertInstanceOf(EPPOptionsElement::class,$options);
 
-        $svcs = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','svcs');
+        $svcs = $document->createElementNS(EPPNamespaces::EPP_1_0,'svcs');
         $login->appendChild($svcs);
 
         $this->assertEquals($svcs,$login->getServices());
@@ -423,19 +424,19 @@ public function testEPPMessageQueueElement(): void{
         $document = EPPDocumentHelper::createEPPDocument();
 
         /**@var EPPMessageQueueElement $msgQ*/
-        $msgQ = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','msgQ');
+        $msgQ = $document->createElementNS(EPPNamespaces::EPP_1_0,'msgQ');
         $this->assertInstanceOf(EPPMessageQueueElement::class,$msgQ);
 
         $this->assertNull($msgQ->getQueueDate());
         $this->assertNull($msgQ->getMessage());
 
-        $qDate = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','qDate');
+        $qDate = $document->createElementNS(EPPNamespaces::EPP_1_0,'qDate');
         $msgQ->appendChild($qDate);
 
         $this->assertEquals($qDate,$msgQ->getQueueDate());
         $this->assertInstanceOf(EPPQueueDateElement::class,$qDate);
 
-        $msg = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','msg');
+        $msg = $document->createElementNS(EPPNamespaces::EPP_1_0,'msg');
         $msgQ->appendChild($msg);
 
         $this->assertEquals($msg,$msgQ->getMessage());
@@ -446,19 +447,19 @@ public function testEPPOptionsElement(): void{
         $document = EPPDocumentHelper::createEPPDocument();
 
         /**@var EPPOptionsElement $options*/
-        $options = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','options');
+        $options = $document->createElementNS(EPPNamespaces::EPP_1_0,'options');
         $this->assertInstanceOf(EPPOptionsElement::class,$options);
 
         $this->assertNull($options->getVersion());
         $this->assertNull($options->getLanguage());
 
-        $version = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','version');
+        $version = $document->createElementNS(EPPNamespaces::EPP_1_0,'version');
         $options->appendChild($version);
 
         $this->assertEquals($version,$options->getVersion());
         $this->assertInstanceOf(EPPVersionElement::class,$version);
 
-        $lang = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','lang');
+        $lang = $document->createElementNS(EPPNamespaces::EPP_1_0,'lang');
         $options->appendChild($lang);
 
         $this->assertEquals($lang,$options->getLanguage());
@@ -469,12 +470,12 @@ public function testEPPOursElement(): void{
         $document = EPPDocumentHelper::createEPPDocument();
 
         /**@var EPPOursElement $ours*/
-        $ours = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','ours');
+        $ours = $document->createElementNS(EPPNamespaces::EPP_1_0,'ours');
         $this->assertInstanceOf(EPPOursElement::class,$ours);
 
         $this->assertNull($ours->getRecipientDescription());
 
-        $recDesc = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','recDesc');
+        $recDesc = $document->createElementNS(EPPNamespaces::EPP_1_0,'recDesc');
         $ours->appendChild($recDesc);
 
         $this->assertEquals($recDesc,$ours->getRecipientDescription());
@@ -485,7 +486,7 @@ public function testEPPPurposeElement(): void{
         $document = EPPDocumentHelper::createEPPDocument();
 
         /**@var EPPPurposeElement $purpose*/
-        $purpose = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','purpose');
+        $purpose = $document->createElementNS(EPPNamespaces::EPP_1_0,'purpose');
         $this->assertInstanceOf(EPPPurposeElement::class,$purpose);
 
         $this->assertNull($purpose->getAdministration());
@@ -493,25 +494,25 @@ public function testEPPPurposeElement(): void{
         $this->assertNull($purpose->getOther());
         $this->assertNull($purpose->getProvisioning());
 
-        $admin = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','admin');
+        $admin = $document->createElementNS(EPPNamespaces::EPP_1_0,'admin');
         $purpose->appendChild($admin);
 
         $this->assertEquals($admin,$purpose->getAdministration());
         $this->assertInstanceOf(EPPAdministrationElement::class,$admin);
 
-        $contact = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','contact');
+        $contact = $document->createElementNS(EPPNamespaces::EPP_1_0,'contact');
         $purpose->appendChild($contact);
 
         $this->assertEquals($contact,$purpose->getContact());
         $this->assertInstanceOf(EPPContactElement::class,$contact);
 
-        $other = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','other');
+        $other = $document->createElementNS(EPPNamespaces::EPP_1_0,'other');
         $purpose->appendChild($other);
 
         $this->assertEquals($other,$purpose->getOther());
         $this->assertInstanceOf(EPPOtherElement::class,$other);
 
-        $prov = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','prov');
+        $prov = $document->createElementNS(EPPNamespaces::EPP_1_0,'prov');
         $purpose->appendChild($prov);
 
         $this->assertEquals($prov,$purpose->getProvisioning());
@@ -522,7 +523,7 @@ public function testEPPRecipientElement(): void{
         $document = EPPDocumentHelper::createEPPDocument();
 
         /**@var EPPRecipientElement $recipient*/
-        $recipient = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','recipient');
+        $recipient = $document->createElementNS(EPPNamespaces::EPP_1_0,'recipient');
         $this->assertInstanceOf(EPPRecipientElement::class,$recipient);
 
         $this->assertNull($recipient->getOther());
@@ -531,31 +532,31 @@ public function testEPPRecipientElement(): void{
         $this->assertNull($recipient->getSame());
         $this->assertNull($recipient->getUnrelated());
 
-        $other = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','other');
+        $other = $document->createElementNS(EPPNamespaces::EPP_1_0,'other');
         $recipient->appendChild($other);
 
         $this->assertEquals($other,$recipient->getOther());
         $this->assertInstanceOf(EPPOtherElement::class,$other);
 
-        $ours = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','ours');
+        $ours = $document->createElementNS(EPPNamespaces::EPP_1_0,'ours');
         $recipient->appendChild($ours);
 
         $this->assertEquals($ours,$recipient->getOurs()[0]);
         $this->assertInstanceOf(EPPOursElement::class,$ours);
 
-        $public = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','public');
+        $public = $document->createElementNS(EPPNamespaces::EPP_1_0,'public');
         $recipient->appendChild($public);
 
         $this->assertEquals($public,$recipient->getPublic());
         $this->assertInstanceOf(EPPPublicElement::class,$public);
 
-        $same = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','same');
+        $same = $document->createElementNS(EPPNamespaces::EPP_1_0,'same');
         $recipient->appendChild($same);
 
         $this->assertEquals($same,$recipient->getSame());
         $this->assertInstanceOf(EPPSameElement::class,$same);
 
-        $unrelated = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','unrelated');
+        $unrelated = $document->createElementNS(EPPNamespaces::EPP_1_0,'unrelated');
         $recipient->appendChild($unrelated);
 
         $this->assertEquals($unrelated,$recipient->getUnrelated());
@@ -566,7 +567,7 @@ public function testEPPResponseElement(): void{
         $document = EPPDocumentHelper::createEPPDocument();
 
         /**@var EPPResponseElement $response*/
-        $response = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','response');
+        $response = $document->createElementNS(EPPNamespaces::EPP_1_0,'response');
         $this->assertInstanceOf(EPPResponseElement::class,$response);
 
         $this->assertEmpty($response->getResult());
@@ -575,31 +576,31 @@ public function testEPPResponseElement(): void{
         $this->assertNull($response->getExtension());
         $this->assertNull($response->getTransactionID());
 
-        $result = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','result');
+        $result = $document->createElementNS(EPPNamespaces::EPP_1_0,'result');
         $response->appendChild($result);
 
         $this->assertEquals($result,$response->getResult()[0]);
         $this->assertInstanceOf(EPPResultElement::class,$result);
 
-        $msgQ = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','msgQ');
+        $msgQ = $document->createElementNS(EPPNamespaces::EPP_1_0,'msgQ');
         $response->appendChild($msgQ);
 
         $this->assertEquals($msgQ,$response->getMessageQueue());
         $this->assertInstanceOf(EPPMessageQueueElement::class,$msgQ);
 
-        $resData = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','resData');
+        $resData = $document->createElementNS(EPPNamespaces::EPP_1_0,'resData');
         $response->appendChild($resData);
 
         $this->assertEquals($resData,$response->getResponseData());
         $this->assertInstanceOf(EPPResponseDataElement::class,$resData);
 
-        $extension = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','extension');
+        $extension = $document->createElementNS(EPPNamespaces::EPP_1_0,'extension');
         $response->appendChild($extension);
 
         $this->assertEquals($extension,$response->getExtension());
         $this->assertInstanceOf(EPPExtensionElement::class,$extension);
 
-        $trID = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','trID');
+        $trID = $document->createElementNS(EPPNamespaces::EPP_1_0,'trID');
         $response->appendChild($trID);
 
         $this->assertEquals($trID,$response->getTransactionID());
@@ -610,26 +611,26 @@ public function testEPPResultElement(): void{
         $document = EPPDocumentHelper::createEPPDocument();
 
         /**@var EPPResultElement $result*/
-        $result = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','result');
+        $result = $document->createElementNS(EPPNamespaces::EPP_1_0,'result');
         $this->assertInstanceOf(EPPResultElement::class,$result);
 
         $this->assertNull($result->getMessage());
         $this->assertEmpty($result->getValue());
         $this->assertEmpty($result->getExtensionValue());
 
-        $msg = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','msg');
+        $msg = $document->createElementNS(EPPNamespaces::EPP_1_0,'msg');
         $result->appendChild($msg);
 
         $this->assertEquals($msg,$result->getMessage());
         $this->assertInstanceOf(EPPMessageElement::class,$msg);
 
-        $value = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','value');
+        $value = $document->createElementNS(EPPNamespaces::EPP_1_0,'value');
         $result->appendChild($value);
 
         $this->assertEquals($value,$result->getValue()[0]);
         $this->assertInstanceOf(EPPValueElement::class,$value);
 
-        $extValue = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','extValue');
+        $extValue = $document->createElementNS(EPPNamespaces::EPP_1_0,'extValue');
         $result->appendChild($extValue);
 
         $this->assertEquals($extValue,$result->getExtensionValue()[0]);
@@ -640,7 +641,7 @@ public function testEPPRetentionElement(): void{
         $document = EPPDocumentHelper::createEPPDocument();
 
         /**@var EPPRetentionElement $retention*/
-        $retention = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','retention');
+        $retention = $document->createElementNS(EPPNamespaces::EPP_1_0,'retention');
         $this->assertInstanceOf(EPPRetentionElement::class,$retention);
 
         $this->assertNull($retention->getBusiness());
@@ -649,31 +650,31 @@ public function testEPPRetentionElement(): void{
         $this->assertNull($retention->getNone());
         $this->assertNull($retention->getStated());
 
-        $business = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','business');
+        $business = $document->createElementNS(EPPNamespaces::EPP_1_0,'business');
         $retention->appendChild($business);
 
         $this->assertEquals($business,$retention->getBusiness());
         $this->assertInstanceOf(EPPBusinessElement::class,$business);
 
-        $indefinite = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','indefinite');
+        $indefinite = $document->createElementNS(EPPNamespaces::EPP_1_0,'indefinite');
         $retention->appendChild($indefinite);
 
         $this->assertEquals($indefinite,$retention->getIndefinite());
         $this->assertInstanceOf(EPPIndefiniteElement::class,$indefinite);
 
-        $legal = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','legal');
+        $legal = $document->createElementNS(EPPNamespaces::EPP_1_0,'legal');
         $retention->appendChild($legal);
 
         $this->assertEquals($legal,$retention->getLegal());
         $this->assertInstanceOf(EPPLegalElement::class,$legal);
 
-        $none = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','none');
+        $none = $document->createElementNS(EPPNamespaces::EPP_1_0,'none');
         $retention->appendChild($none);
 
         $this->assertEquals($none,$retention->getNone());
         $this->assertInstanceOf(EPPNoneElement::class,$none);
 
-        $stated = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','stated');
+        $stated = $document->createElementNS(EPPNamespaces::EPP_1_0,'stated');
         $retention->appendChild($stated);
 
         $this->assertEquals($stated,$retention->getStated());
@@ -684,12 +685,12 @@ public function testEPPServiceExtensionElement(): void{
         $document = EPPDocumentHelper::createEPPDocument();
 
         /**@var EPPServiceExtensionElement $svcExtension*/
-        $svcExtension = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','svcExtension');
+        $svcExtension = $document->createElementNS(EPPNamespaces::EPP_1_0,'svcExtension');
         $this->assertInstanceOf(EPPServiceExtensionElement::class,$svcExtension);
 
         $this->assertEmpty($svcExtension->getExtensionURI());
 
-        $extURI = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','extURI');
+        $extURI = $document->createElementNS(EPPNamespaces::EPP_1_0,'extURI');
         $svcExtension->appendChild($extURI);
 
         $this->assertEquals($extURI,$svcExtension->getExtensionURI()[0]);
@@ -700,7 +701,7 @@ public function testEPPServiceMenuElement(): void{
         $document = EPPDocumentHelper::createEPPDocument();
 
         /**@var EPPServiceMenuElement $svcMenu*/
-        $svcMenu = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','svcMenu');
+        $svcMenu = $document->createElementNS(EPPNamespaces::EPP_1_0,'svcMenu');
         $this->assertInstanceOf(EPPServiceMenuElement::class,$svcMenu);
 
         $this->assertEmpty($svcMenu->getVersion());
@@ -708,25 +709,25 @@ public function testEPPServiceMenuElement(): void{
         $this->assertEmpty($svcMenu->getObjectURI());
         $this->assertNull($svcMenu->getServiceExtension());
 
-        $version = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','version');
+        $version = $document->createElementNS(EPPNamespaces::EPP_1_0,'version');
         $svcMenu->appendChild($version);
 
         $this->assertEquals($version,$svcMenu->getVersion()[0]);
         $this->assertInstanceOf(EPPVersionElement::class,$version);
 
-        $lang = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','lang');
+        $lang = $document->createElementNS(EPPNamespaces::EPP_1_0,'lang');
         $svcMenu->appendChild($lang);
 
         $this->assertEquals($lang,$svcMenu->getLanguage()[0]);
         $this->assertInstanceOf(EPPLanguageElement::class,$lang);
 
-        $objURI = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','objURI');
+        $objURI = $document->createElementNS(EPPNamespaces::EPP_1_0,'objURI');
         $svcMenu->appendChild($objURI);
 
         $this->assertEquals($objURI,$svcMenu->getObjectURI()[0]);
         $this->assertInstanceOf(EPPObjectUriElement::class,$objURI);
 
-        $svcExtension = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','svcExtension');
+        $svcExtension = $document->createElementNS(EPPNamespaces::EPP_1_0,'svcExtension');
         $svcMenu->appendChild($svcExtension);
 
         $this->assertEquals($svcExtension,$svcMenu->getServiceExtension());
@@ -737,19 +738,19 @@ public function testEPPServicesElement(): void{
         $document = EPPDocumentHelper::createEPPDocument();
 
         /**@var EPPServicesElement $svcs*/
-        $svcs = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','svcs');
+        $svcs = $document->createElementNS(EPPNamespaces::EPP_1_0,'svcs');
         $this->assertInstanceOf(EPPServicesElement::class,$svcs);
 
         $this->assertEmpty($svcs->getObjectURI());
         $this->assertNull($svcs->getServiceExtension());
 
-        $objURI = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','objURI');
+        $objURI = $document->createElementNS(EPPNamespaces::EPP_1_0,'objURI');
         $svcs->appendChild($objURI);
 
         $this->assertEquals($objURI,$svcs->getObjectURI()[0]);
         $this->assertInstanceOf(EPPObjectUriElement::class,$objURI);
 
-        $svcExtension = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','svcExtension');
+        $svcExtension = $document->createElementNS(EPPNamespaces::EPP_1_0,'svcExtension');
         $svcs->appendChild($svcExtension);
 
         $this->assertEquals($svcExtension,$svcs->getServiceExtension());
@@ -760,26 +761,26 @@ public function testEPPStatementElement(): void{
         $document = EPPDocumentHelper::createEPPDocument();
 
         /**@var EPPStatementElement $statement*/
-        $statement = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','statement');
+        $statement = $document->createElementNS(EPPNamespaces::EPP_1_0,'statement');
         $this->assertInstanceOf(EPPStatementElement::class,$statement);
 
         $this->assertNull($statement->getPurpose());
         $this->assertNull($statement->getRecipient());
         $this->assertNull($statement->getRetention());
 
-        $purpose = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','purpose');
+        $purpose = $document->createElementNS(EPPNamespaces::EPP_1_0,'purpose');
         $statement->appendChild($purpose);
 
         $this->assertEquals($purpose,$statement->getPurpose());
         $this->assertInstanceOf(EPPPurposeElement::class,$purpose);
 
-        $recipient = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','recipient');
+        $recipient = $document->createElementNS(EPPNamespaces::EPP_1_0,'recipient');
         $statement->appendChild($recipient);
 
         $this->assertEquals($recipient,$statement->getRecipient());
         $this->assertInstanceOf(EPPRecipientElement::class,$recipient);
 
-        $retention = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','retention');
+        $retention = $document->createElementNS(EPPNamespaces::EPP_1_0,'retention');
         $statement->appendChild($retention);
 
         $this->assertEquals($retention,$statement->getRetention());
@@ -790,19 +791,19 @@ public function testEPPTransactionIdElement(): void{
         $document = EPPDocumentHelper::createEPPDocument();
 
         /**@var EPPTransactionIdElement $trID*/
-        $trID = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','trID');
+        $trID = $document->createElementNS(EPPNamespaces::EPP_1_0,'trID');
         $this->assertInstanceOf(EPPTransactionIdElement::class,$trID);
 
         $this->assertNull($trID->getClientTransactionID());
         $this->assertNull($trID->getServerTransactionID());
 
-        $clTRID = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','clTRID');
+        $clTRID = $document->createElementNS(EPPNamespaces::EPP_1_0,'clTRID');
         $trID->appendChild($clTRID);
 
         $this->assertEquals($clTRID,$trID->getClientTransactionID());
         $this->assertInstanceOf(EPPClientTransactionIdElement::class,$clTRID);
 
-        $svTRID = $document->createElementNS('urn:ietf:params:xml:ns:epp-1.0','svTRID');
+        $svTRID = $document->createElementNS(EPPNamespaces::EPP_1_0,'svTRID');
         $trID->appendChild($svTRID);
 
         $this->assertEquals($svTRID,$trID->getServerTransactionID());