Tests\TestModel\Instance\AlternativeNsTest

Complexity

Total Complexity

17

Size/Duplication

Total Lines	177
Duplicated Lines	0 %

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	testGetAttributeValueNsForAlternativeNs()	0	6	1
A	assertThatThereIsNoNewerNamespaceUrl()	0	6	2
A	testModifyingElementWithNewNamespaceKeepsNewNamespace()	0	7	1
A	testModifyingAttributeWithSecondAlternativeNamespaceKeepsSecondAlternativeNamespace()	0	11	1
A	testModifyingElementWithAlternativeNamespaceKeepsAlternativeNamespace()	0	11	1
A	tearDown()	0	5	1
A	testModifyingElementWithSecondAlternativeNamespaceKeepsSecondAlternativeNamespace()	0	13	1
A	testModifyingAttributeWithAlternativeNamespaceKeepsAlternativeNamespace()	0	12	1
A	testGetChildElementsByTypeForSecondAlternativeNs()	0	11	1
A	testGetUniqueChildElementByNameNsForAlternativeNs()	0	7	1
A	testModifyingAttributeWithNewNamespaceKeepsNewNamespace()	0	6	1
A	testUseExistingNamespace()	0	12	1
A	testGetChildElementsByTypeForAlternativeNs()	0	8	1
A	setUp()	0	6	1
A	testGetUniqueChildElementByNameNsForSecondAlternativeNs()	0	11	1
A	testGetAttributeValueNsForSecondAlternativeNs()	0	10	1

<?php

namespace Tests\TestModel\Instance;

use Xml\Impl\Util\StringUtil;
use Xml\ModelInstanceInterface;
use Xml\Impl\Parser\AbstractModelParser;
use Tests\TestModel\{
    Gender,
    TestModelConstants,
    TestModelParser
};
use Tests\TestModel\TestModelTest;
use Xml\Instance\ModelElementInstanceInterface;
use Xml\Impl\Instance\ModelElementInstanceImpl;

class AlternativeNsTest extends TestModelTest
{
    private const MECHANICAL_NS = "http://test.org/mechanical";
    private const YET_ANOTHER_NS = "http://test.org/yans";

    protected function setUp(): void
    {
        parent::parseModel("AlternativeNsTest");
        $modelImpl = $this->modelInstance->getModel();
        $modelImpl->declareAlternativeNamespace(self::MECHANICAL_NS, TestModelConstants::NEWER_NAMESPACE);
        $modelImpl->declareAlternativeNamespace(self::YET_ANOTHER_NS, TestModelConstants::NEWER_NAMESPACE);
    }

    protected function tearDown(): void
    {
        $modelImpl = $this->modelInstance->getModel();
        $modelImpl->undeclareAlternativeNamespace(self::MECHANICAL_NS);
        $modelImpl->undeclareAlternativeNamespace(self::YET_ANOTHER_NS);
    }

    public function testGetUniqueChildElementByNameNsForAlternativeNs(): void
    {
        $this->hedwig = $this->modelInstance->getModelElementById("hedwig");

The property hedwig does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->assertFalse(empty($this->hedwig));
        $childElementByNameNs = $this->hedwig->getUniqueChildElementByNameNs(TestModelConstants::NEWER_NAMESPACE, "wings");
        $this->assertFalse(empty($childElementByNameNs));
        $this->assertEquals("wusch", $childElementByNameNs->getTextContent());
    }

    public function testGetUniqueChildElementByNameNsForSecondAlternativeNs(): void
    {
        // given
        $donald = $this->modelInstance->getModelElementById("donald");

        // when
        $childElementByNameNs = $donald->getUniqueChildElementByNameNs(TestModelConstants::NEWER_NAMESPACE, "wings");

        // then
        $this->assertFalse(empty($childElementByNameNs));
        $this->assertEquals("flappy", $childElementByNameNs->getTextContent());
    }

    public function testGetChildElementsByTypeForAlternativeNs(): void
    {
        $birdo = $this->modelInstance->getModelElementById("birdo");
        $this->assertFalse(empty($birdo));

        $elements = $birdo->getChildElementsByType(Wings::class);
        $this->assertCount(1, $elements);
        $this->assertEquals("zisch", $elements[0]->getTextContent());
    }

    public function testGetChildElementsByTypeForSecondAlternativeNs(): void
    {
        // given
        $donald = $this->modelInstance->getModelElementById("donald");

        // when
        $elements = $donald->getChildElementsByType(Wings::class);

        // then
        $this->assertCount(1, $elements);
        $this->assertEquals("flappy", $elements[0]->getTextContent());
    }

    public function testGetAttributeValueNsForAlternativeNs(): void
    {
        $plucky = $this->modelInstance->getModelElementById("plucky");
        $this->assertFalse(empty($plucky));

        $this->assertFalse($plucky->canHaveExtendedWings());
    }

    public function testGetAttributeValueNsForSecondAlternativeNs(): void
    {
        // given
        $donald = $this->modelInstance->getModelElementById("donald");

        // when
        $extendedWings = $donald->canHaveExtendedWings();

The assignment to $extendedWings is dead and can be removed.

        // then
        $this->assertTrue($donald->canHaveExtendedWings());
    }

    public function testModifyingAttributeWithAlternativeNamespaceKeepsAlternativeNamespace(): void
    {
        $plucky = $this->modelInstance->getModelElementById("plucky");
        $this->assertFalse(empty($plucky));
        //validate old value

        $this->assertFalse($plucky->canHaveExtendedWings());
        //change it
        $plucky->setCanHaveExtendedWings(true);

        $attributeValueNs = $plucky->getAttributeValueNs(self::MECHANICAL_NS, "canHaveExtendedWings");
        $this->assertEquals("true", $attributeValueNs);
    }

    public function testModifyingAttributeWithSecondAlternativeNamespaceKeepsSecondAlternativeNamespace(): void
    {
        // given
        $donald = $this->modelInstance->getModelElementById("donald");

        // when
        $donald->setCanHaveExtendedWings(false);

        // then
        $attributeValueNs = $donald->getAttributeValueNs(self::YET_ANOTHER_NS, "canHaveExtendedWings");
        $this->assertEquals("false", $attributeValueNs);
    }

    public function testModifyingAttributeWithNewNamespaceKeepsNewNamespace(): void
    {
        $bird = $this->createBird($this->modelInstance, "waldo", Gender::MALE);
        $bird->setCanHaveExtendedWings(true);
        $attributeValueNs = $bird->getAttributeValueNs(TestModelConstants::NEWER_NAMESPACE, "canHaveExtendedWings");
        $this->assertEquals("true", $attributeValueNs);
    }

    public function testModifyingElementWithAlternativeNamespaceKeepsAlternativeNamespace(): void
    {
        $birdo = $this->modelInstance->getModelElementById("birdo");
        $this->assertFalse($birdo === null);
        $wings = $birdo->getWings();
        $this->assertFalse($wings === null);
        $wings->setTextContent("kawusch");

        $childElementsByNameNs = $birdo->getDomElement()->getChildElementsByNameNs(self::MECHANICAL_NS, "wings");
        $this->assertCount(1, $childElementsByNameNs);
        $this->assertEquals("kawusch", $childElementsByNameNs[0]->getTextContent());
    }

    public function testModifyingElementWithSecondAlternativeNamespaceKeepsSecondAlternativeNamespace(): void
    {
        // given
        $donald = $this->modelInstance->getModelElementById("donald");
        $wings = $donald->getWings();

        // when
        $wings->setTextContent("kawusch");

        // then
        $childElementsByNameNs = $donald->getDomElement()->getChildElementsByNameNs(self::YET_ANOTHER_NS, "wings");
        $this->assertCount(1, $childElementsByNameNs);
        $this->assertEquals("kawusch", $childElementsByNameNs[0]->getTextContent());
    }

    public function testModifyingElementWithNewNamespaceKeepsNewNamespace(): void
    {
        $bird = $this->createBird($this->modelInstance, "waldo", Gender::MALE);
        $bird->setWings($this->modelInstance->newInstance(Wings::class));

        $childElementsByNameNs = $bird->getDomElement()->getChildElementsByNameNs(TestModelConstants::NEWER_NAMESPACE, "wings");
        $this->assertCount(1, $childElementsByNameNs);
    }

    public function testUseExistingNamespace(): void
    {
        $this->assertThatThereIsNoNewerNamespaceUrl();
        $plucky = $this->modelInstance->getModelElementById("plucky");
        $plucky->setAttributeValueNs(self::MECHANICAL_NS, "canHaveExtendedWings", "true");

        $donald = $this->modelInstance->getModelElementById("donald");
        $donald->setAttributeValueNs(self::YET_ANOTHER_NS, "canHaveExtendedWings", "false");
        $this->assertThatThereIsNoNewerNamespaceUrl();

        $this->assertTrue($plucky->canHaveExtendedWings());
        $this->assertThatThereIsNoNewerNamespaceUrl();
    }

    protected function assertThatThereIsNoNewerNamespaceUrl(): void
    {
        $rootElement = $this->modelInstance->getDocument()->getDomSource()->documentElement;
        foreach ($rootElement->attributes as $attr) {
            $nodeValue = $attr->nodeValue;
            $this->assertFalse(TestModelConstants::NEWER_NAMESPACE == $nodeValue);
        }
    }
}