Rezzza\RestApiBehatExtension\Xml\XmlContext

Complexity

Total Complexity

41

Size/Duplication

Total Lines	300
Duplicated Lines	26.67 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	4
Bugs	0	Features	2

23 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	setResponseStorage()	0	4	1
A	iLoadXml()	0	4	1
A	theResponseShouldBeInXml()	0	4	1
A	theResponseShouldNotBeInXml()	0	11	3
A	theXmlElementShouldExist()	8	8	2
A	theXmlElementShouldNotExist()	7	7	2
A	theResponseXmlShouldBeEqualTo()	0	13	2
A	theXmlElementShouldBeEqualTo()	8	8	2
A	theXmlElementShouldNotBeEqualTo()	8	8	2
A	theXmlAttributeShouldExist()	9	9	2
A	theXmlAttributeShouldNotExist()	12	12	3
A	theXmlAttributeShouldBeEqualTo()	7	7	2
A	theXmlAttributeShouldNotBeEqualTo()	7	7	2
A	theXmlElementShouldHaveNChildElements()	0	14	4
A	theXmlElementShouldContain()	0	8	1
A	theXmlElementShouldNotContain()	0	8	1
A	theXmlShouldUseTheNamespace()	7	7	2
A	theXmlShouldNotUseTheNamespace()	7	7	2
A	printLastXmlResponse()	0	5	1
A	xpath()	0	6	2
A	getNamespaces()	0	4	1
A	beforeScenario()	0	5	1

<?php

namespace Rezzza\RestApiBehatExtension\Xml;

use Behat\Behat\Context\BehatContext;
use Behat\Gherkin\Node\PyStringNode;
use Rezzza\RestApiBehatExtension\Response\ResponseStorage;
use Rezzza\RestApiBehatExtension\Response\ResponseStorageAware;
use mageekguy\atoum\asserter\generator as asserter;

class XmlContext extends BehatContext implements ResponseStorageAware
{
    private $asserter;

    private $xmlStorage;

    public function __construct(asserter $asserter)
    {
        $this->asserter = $asserter;
    }

    public function setResponseStorage(ResponseStorage $responseStorage)
    {
        $this->xmlStorage = new XmlStorage($responseStorage);
    }

    /**
     * @When /^I load XML:$/
     */
    public function iLoadXml(PyStringNode $jsonContent)
    {
        $this->xmlStorage->writeRawContent($jsonContent);
    }

    /**
     * Checks that the response is correct XML
     *
     * @Then /^the response should be in XML$/
     */
    public function theResponseShouldBeInXml()
    {
        $this->xmlStorage->readXml(true);
    }

    /**
     * Checks that the response is not correct XML
     *
     * @Then /^the response should not be in XML$/
     */
    public function theResponseShouldNotBeInXml()
    {
        try {
            $this->xmlStorage->readXml(true);
        } catch (\Exception $e) {

Consider adding a comment why this CATCH block is empty.

        }

        if (!isset($e)) {
            throw new \Exception("The response is in XML");
        }
    }

    /**
     * Checks that the specified XML element exists
     *
     * @param string $element
     * @throws \Exception
     * @return \DomNodeList
     *
     * @Then /^the XML element "(?P<element>[^"]*)" should exists?$/
     */
    public function theXmlElementShouldExist($element)

This method seems to be duplicated in your project.

    {
        $elements = $this->xpath($element);
        if ($elements->length == 0) {
            throw new \Exception(sprintf("The element '%s' does not exist.", $element));
        }
        return $elements;
    }

    /**
     * Checks that the specified XML element does not exist
     *
     * @Then /^the XML element "(?P<element>[^"]*)" should not exists?$/
     */
    public function theXmlElementShouldNotExist($element)

This method seems to be duplicated in your project.

    {
        $elements = $this->xpath($element);
        if ($elements->length != 0) {
            throw new \Exception(sprintf("The element '%s' exists.", $element));
        }
    }

    /**
     * @Then /^the XML response should be equal to:$/
     */
    public function theResponseXmlShouldBeEqualTo(PyStringNode $expected)
    {
        $expected = new Xml(str_replace('\\"', '"', $expected));
        $actual   = $this->xmlStorage->readXml(false);

        if (false === $actual->isEqual($expected)) {
            throw new \Exception(sprintf(
                'The string "%s" is not equal to the response of the current page: %s',
                $expected->read(),
                $actual->read()
            ));
        }
    }

    /**
     * Checks that the specified XML element is equal to the given value
     *
     * @Then /^the XML element "(?P<element>(?:[^"]|\\")*)" should be equal to "(?P<text>[^"]*)"$/
     */
    public function theXmlElementShouldBeEqualTo($element, $text)

This method seems to be duplicated in your project.

    {
        $elements = $this->theXmlElementShouldExist($element);
        $actual = $elements->item(0)->nodeValue;
        if ($text != $actual) {
            throw new \Exception(sprintf("The element value is `%s`", $actual));
        }
    }

    /**
     * Checks that the specified XML element is not equal to the given value
     *
     * @Then /^the XML element "(?P<element>(?:[^"]|\\")*)" should not be equal to "(?P<text>[^"]*)"$/
     */
    public function theXmlElementShouldNotBeEqualTo($element, $text)

This method seems to be duplicated in your project.

    {
        $elements = $this->theXmlElementShouldExist($element);
        $actual = $elements->item(0)->nodeValue;
        if ($text == $actual) {
            throw new \Exception(sprintf("The element value is `%s`", $actual));
        }
    }

    /**
     * Checks that the XML attribute on the specified element exists
     *
     * @Then /^the XML attribute "(?P<attribute>[^"]*)" on element "(?P<element>(?:[^"]|\\")*)" should exists?$/
     */
    public function theXmlAttributeShouldExist($attribute, $element)

This method seems to be duplicated in your project.

    {
        $elements = $this->theXmlElementShouldExist("{$element}[@{$attribute}]");
        $actual = $elements->item(0)->getAttribute($attribute);
        if (empty($actual)) {
            throw new \Exception(sprintf("The attribute value is `%s`", $actual));
        }
        return $actual;
    }

    /**
     * Checks that the XML attribute on the specified element does not exist
     *
     * @Then /^the XML attribute "(?P<attribute>[^"]*)" on element "(?P<element>(?:[^"]|\\")*)" should not exists?$/
     */
    public function theXmlAttributeShouldNotExist($attribute, $element)

This method seems to be duplicated in your project.

    {
        try {
            $elements = $this->theXmlElementShouldExist("{$element}[@{$attribute}]");
            $actual = $elements->item(0)->getAttribute($attribute);
            if (!empty($actual)) {
                throw new \Exception(sprintf("The element '%s' exists and contains '%s'.", $element , $elements));
            }
        }
        catch (\Exception $e) {

Consider adding a comment why this CATCH block is empty.

        }
    }

    /**
     * Checks that the XML attribute on the specified element is equal to the given value
     *
     * @Then /^the XML attribute "(?P<attribute>[^"]*)" on element "(?P<element>(?:[^"]|\\")*)" should be equal to "(?P<text>[^"]*)"$/
     */
    public function theXmlAttributeShouldBeEqualTo($attribute, $element, $text)

This method seems to be duplicated in your project.

    {
        $actual = $this->theXmlAttributeShouldExist($attribute, $element);
        if ($text != $actual) {
            throw new \Exception(sprintf("The attribute value is `%s`", $actual));
        }
    }

    /**
     * Checks that the XML attribute on the specified element is not equal to the given value
     *
     * @Then /^the XML attribute "(?P<attribute>[^"]*)" on element "(?P<element>(?:[^"]|\\")*)" should not be equal to "(?P<text>[^"]*)"$/
     */
    public function theXmlAttributeShouldNotBeEqualTo($attribute, $element, $text)

This method seems to be duplicated in your project.

    {
        $actual = $this->theXmlAttributeShouldExist($attribute, $element);
        if ($text === $actual) {
            throw new \Exception(sprintf("The attribute value is `%s`", $actual));
        }
    }

    /**
     * Checks that the given XML element has N child element(s)
     *
     * @Then /^the XML element "(?P<element>[^"]*)" should have (?P<nth>\d+) elements?$/
     */

    public function theXmlElementShouldHaveNChildElements($element, $nth)
    {
        $elements = $this->theXmlElementShouldExist($element);
        $length = 0;
        foreach ($elements->item(0)->childNodes as $node) {
            if ($node->hasAttributes() || (trim($node->nodeValue) != '')) {
                ++$length;
            }
        }

        $this->asserter
            ->integer((int) $nth)
            ->isEqualTo($length);
    }

    /**
     * Checks that the given XML element contains the given value
     *
     * @Then /^the XML element "(?P<element>[^"]*)" should contain "(?P<text>[^"]*)"$/
     */
    public function theXmlElementShouldContain($element, $text)
    {
        $elements = $this->theXmlElementShouldExist($element);

        $this->asserter
            ->phpString($elements->item(0)->nodeValue)
            ->contains($text);
    }

    /**
     * Checks that the given XML element does not contain the given value
     *
     * @Then /^the XML element "(?P<element>[^"]*)" should not contain "(?P<text>[^"]*)"$/
     */
    public function theXmlElementShouldNotContain($element, $text)
    {
        $elements = $this->theXmlElementShouldExist($element);

        $this->asserter
            ->phpString($elements->item(0)->nodeValue)
            ->notContains($text);
    }

    /**
     * Checks that the XML uses the specified namespace
     *
     * @Then /^[Tt]he XML should use the namespace "(?P<namespace>[^"]*)"$/
     */
    public function theXmlShouldUseTheNamespace($namespace)

This method seems to be duplicated in your project.

    {
        $namespaces = $this->getNamespaces();
        if (!in_array($namespace, $namespaces)) {
            throw new \Exception(sprintf("The namespace '%s' is not used", $namespace));
        }
    }

    /**
     * Checks that the XML does not use the specified namespace
     *
     * @Then /^[Tt]he XML should not use the namespace "(?P<namespace>[^"]*)"$/
     */
    public function theXmlShouldNotUseTheNamespace($namespace)

This method seems to be duplicated in your project.

    {
        $namespaces = $this->getNamespaces();
        if (in_array($namespace, $namespaces)) {
            throw new \Exception(sprintf("The namespace '%s' is used", $namespace));
        }
    }

    /**
     * Optimistically (ignoring errors) attempt to pretty-print the last XML response
     *
     * @Then /^print last XML response$/
     */
    public function printLastXmlResponse()
    {
        $xml = $this->xmlStorage->readXml(false);
        $this->printDebug($xml->pretty());
    }

    /**
     * @param string $element
     * @return \DomNodeList
     */
    public function xpath($element)
    {
        $elements = $this->xmlStorage->readXml(false)->xpath($element);

        return ($elements === false) ? new \DOMNodeList() : $elements;
    }

    /**
     * @return array
     */
    private function getNamespaces()
    {
        return $this->xmlStorage->readXml(false)->getNamespaces();
    }

    /**
     * @BeforeScenario
     */
    public function beforeScenario()
    {
        libxml_clear_errors();
        libxml_use_internal_errors(true);
    }
}