Copied shared filed from Codeception and module-soap

Naktibalda · Naktibalda · commit 8e9f7d826590 · 2022-03-11T11:28:11.000+02:00
diff --git a/composer.json b/composer.json
@@ -13,7 +13,10 @@
     ],
     "homepage": "https://codeception.com/",
     "require": {
-        "php": "^8.0"
+        "php": "^8.0",
+        "ext-dom": "*",
+        "codeception/lib-web": "^1.0",
+        "symfony/css-selector": ">=4.4.24 <7.0"
     },
     "require-dev": {
         "phpunit/phpunit": "^9.5 | ^10.0"
diff --git a/src/Util/Soap.php b/src/Util/Soap.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Codeception\Util;
+
+/**
+ * This class is left for BC compatibility.
+ * Most of its contents moved to parent
+ *
+ * Class Soap
+ * @package Codeception\Util
+ */
+class Soap extends Xml
+{
+    public static function request(): XmlBuilder
+    {
+        return new XmlBuilder();
+    }
+
+    public static function response(): XmlBuilder
+    {
+        return new XmlBuilder();
+    }
+}
diff --git a/src/Util/Xml.php b/src/Util/Xml.php
@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Codeception\Util;
+
+use DOMDocument;
+use DOMElement;
+use DOMNode;
+
+use function is_array;
+
+class Xml
+{
+    public static function arrayToXml(DOMDocument $xml, DOMNode $domNode, array $array = []): DOMDocument
+    {
+        foreach ($array as $el => $val) {
+            if (is_array($val)) {
+                self::arrayToXml($xml, $domNode->$el, $val);
+            } else {
+                $domNode->appendChild($xml->createElement($el, $val));
+            }
+        }
+        return $xml;
+    }
+
+    public static function toXml(DOMDocument|DOMElement|XmlBuilder|string|null $xml): DOMDocument
+    {
+        if ($xml instanceof XmlBuilder) {
+            return $xml->getDom();
+        }
+        if ($xml instanceof DOMDocument) {
+            return $xml;
+        }
+        $dom = new DOMDocument();
+        $dom->preserveWhiteSpace = false;
+        if ($xml instanceof DOMNode) {
+            $xml = $dom->importNode($xml, true);
+            $dom->appendChild($xml);
+            return $dom;
+        }
+
+        if (is_array($xml)) {
+            return self::arrayToXml($dom, $dom, $xml);
+        }
+        if (!empty($xml)) {
+            $dom->loadXML($xml);
+        }
+        return $dom;
+    }
+
+    public static function build(): XmlBuilder
+    {
+        return new XmlBuilder();
+    }
+}
diff --git a/src/Util/XmlBuilder.php b/src/Util/XmlBuilder.php
@@ -0,0 +1,154 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Codeception\Util;
+
+use DOMDocument;
+use DOMElement;
+use Exception;
+
+/**
+ * That's a pretty simple yet powerful class to build XML structures in jQuery-like style.
+ * With no XML line actually written!
+ * Uses DOM extension to manipulate XML data.
+ *
+ * ```php
+ * <?php
+ * $xml = new \Codeception\Util\XmlBuilder();
+ * $xml->users
+ *    ->user
+ *        ->val(1)
+ *        ->email
+ *            ->val('davert@mail.ua')
+ *            ->attr('valid','true')
+ *            ->parent()
+ *        ->cart
+ *            ->attr('empty','false')
+ *            ->items
+ *                ->item
+ *                    ->val('useful item');
+ *                ->parents('user')
+ *        ->active
+ *            ->val(1);
+ * echo $xml;
+ * ```
+ *
+ * This will produce this XML
+ *
+ * ```xml
+ * <?xml version="1.0"?>
+ * <users>
+ *    <user>
+ *        1
+ *        <email valid="true">davert@mail.ua</email>
+ *        <cart empty="false">
+ *            <items>
+ *                <item>useful item</item>
+ *            </items>
+ *        </cart>
+ *        <active>1</active>
+ *    </user>
+ * </users>
+ * ```
+ *
+ * ### Usage
+ *
+ * Builder uses chained calls. So each call to builder returns a builder object.
+ * Except for `getDom` and `__toString` methods.
+ *
+ *  * `$xml->node` - create new xml node and go inside of it.
+ *  * `$xml->node->val('value')` - sets the inner value of node
+ *  * `$xml->attr('name','value')` - set the attribute of node
+ *  * `$xml->parent()` - go back to parent node.
+ *  * `$xml->parents('user')` - go back through all parents to `user` node.
+ *
+ * Export:
+ *
+ *  * `$xml->getDom` - get a DOMDocument object
+ *  * `$xml->__toString` - get a string representation of XML.
+ *
+ * [Source code](https://github.com/Codeception/Codeception/blob/5.0/src/Codeception/Util/XmlBuilder.php)
+ */
+class XmlBuilder
+{
+    protected DOMDocument $dom;
+
+    protected DOMElement|DOMDocument $currentNode;
+
+    public function __construct()
+    {
+        $this->dom = new DOMDocument();
+        $this->currentNode = $this->dom;
+    }
+
+    /**
+     * Appends child node
+     */
+    public function __get(string $tag): XmlBuilder
+    {
+        $domElement = $this->dom->createElement($tag);
+        $this->currentNode->appendChild($domElement);
+        $this->currentNode = $domElement;
+        return $this;
+    }
+
+    public function val($val): self
+    {
+        $this->currentNode->nodeValue = $val;
+        return $this;
+    }
+
+    /**
+     * Sets attribute for current node
+     */
+    public function attr(string $attr, string $val): self
+    {
+        $this->currentNode->setAttribute($attr, $val);
+        return $this;
+    }
+
+    /**
+     * Traverses to parent
+     */
+    public function parent(): self
+    {
+        $this->currentNode = $this->currentNode->parentNode;
+        return $this;
+    }
+
+    /**
+     * Traverses to parent with $name
+     *
+     * @throws Exception
+     */
+    public function parents(string $tag): self
+    {
+        $traverseNode = $this->currentNode;
+        $elFound = false;
+        while ($traverseNode->parentNode) {
+            $traverseNode = $traverseNode->parentNode;
+            if ($traverseNode->tagName === $tag) {
+                $this->currentNode = $traverseNode;
+                $elFound = true;
+                break;
+            }
+        }
+
+        if (!$elFound) {
+            throw new Exception("Parent {$tag} not found in XML");
+        }
+
+        return $this;
+    }
+
+    public function __toString(): string
+    {
+        return $this->dom->saveXML();
+    }
+
+    public function getDom(): DOMDocument
+    {
+        return $this->dom;
+    }
+}
diff --git a/src/Util/XmlStructure.php b/src/Util/XmlStructure.php
@@ -0,0 +1,83 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Codeception\Util;
+
+use Codeception\Exception\ElementNotFound;
+use Codeception\Exception\MalformedLocatorException;
+use Codeception\Util\Soap as SoapXmlUtil;
+use DOMDocument;
+use DOMNode;
+use DOMXPath;
+use Symfony\Component\CssSelector\CssSelectorConverter;
+
+class XmlStructure
+{
+    protected DOMDocument|DOMNode $xml;
+
+    public function __construct($xml)
+    {
+        $this->xml = SoapXmlUtil::toXml($xml);
+    }
+
+    public function matchesXpath(string $xpath): bool
+    {
+        $domXpath = new DOMXPath($this->xml);
+        $res = $domXpath->query($xpath);
+        if ($res === false) {
+            throw new MalformedLocatorException($xpath);
+        }
+        return $res->length > 0;
+    }
+
+    public function matchElement(string $cssOrXPath): ?DOMNode
+    {
+        $domXpath = new DOMXpath($this->xml);
+        $selector = (new CssSelectorConverter())->toXPath($cssOrXPath);
+        $els = $domXpath->query($selector);
+        if ($els) {
+            return $els->item(0);
+        }
+        $els = $domXpath->query($cssOrXPath);
+        if ($els->length !== 0) {
+            return $els->item(0);
+        }
+        throw new ElementNotFound($cssOrXPath);
+    }
+
+    public function matchXmlStructure($xml): bool
+    {
+        $xml = SoapXmlUtil::toXml($xml);
+        $root = $xml->firstChild;
+        $els = $this->xml->getElementsByTagName($root->nodeName);
+        if (empty($els)) {
+            throw new ElementNotFound($root->nodeName, 'Element');
+        }
+
+        $matches = false;
+        foreach ($els as $node) {
+            $matches |= $this->matchForNode($root, $node);
+        }
+        return $matches;
+    }
+
+    protected function matchForNode($schema, $xml): bool
+    {
+        foreach ($schema->childNodes as $node1) {
+            $matched = false;
+            foreach ($xml->childNodes as $node2) {
+                if ($node1->nodeName == $node2->nodeName) {
+                    $matched = $this->matchForNode($node1, $node2);
+                    if ($matched) {
+                        break;
+                    }
+                }
+            }
+            if (!$matched) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
