AbterPhp\Framework\Navigation\NavigationTest

Complexity

Total Complexity

21

Size/Duplication

Total Lines	221
Duplicated Lines	0 %

Importance

Changes	5
Bugs	0	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	testDefaultGetExtended()	0	9	1
A	setUp()	0	5	1
A	testOffsetSetCanUseWeightIfNeeded()	0	12	1
A	testToStringWithOptionalsModified()	0	9	1
A	testSetContentReturnsSelfIfContentIsNull()	0	7	1
A	testGetWrapperReturnsLastLestWrapper()	0	12	1
A	testOffsetUnSetCanUseWeightIfNeeded()	0	10	1
A	testRenderDisplaysItemsInProperOrder()	0	19	2
A	testOffsetGetCanUseWeightIfNeeded()	0	7	1
A	testCount()	0	8	1
A	testDefaultToString()	0	9	1
A	testOffsetSetThrowsExceptionOnInvalidOffset()	0	10	1
A	testForeach()	0	8	2
A	testSetTranslatorSetsTranslatorOnNodes()	0	19	1
A	testGetWrapperReturnsNullByDefault()	0	7	1
A	createNavigation()	0	14	3
A	testSetContent()	0	8	1

<?php

declare(strict_types=1);

namespace AbterPhp\Framework\Navigation;

use AbterPhp\Framework\Html\Helper\Attributes;
use AbterPhp\Framework\Html\ITag;
use AbterPhp\Framework\Html\Tag;
use AbterPhp\Framework\I18n\ITranslator;
use Casbin\Enforcer;
use InvalidArgumentException;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class NavigationTest extends TestCase
{
    protected const INTENTS    = ['bar', 'baz'];
    protected const ATTRIBUTES = ['data-quix' => ['quix']];
    protected const RESOURCE   = 'quint';

    /** @var Enforcer|MockObject */
    protected $enforcerMock;

    public function setUp(): void
    {
        parent::setUp();

        $this->enforcerMock = $this->createMock(Enforcer::class);
    }

    public function testDefaultGetExtended(): void
    {
        $sut = new Navigation();

        $expectedResult = [$sut->getPrefix(), $sut->getPostfix()];

        $actualResult = $sut->getExtendedNodes();

        $this->assertSame($expectedResult, $actualResult);
    }

    public function testSetContent(): void
    {
        $this->expectException(\LogicException::class);

        $sut = new Navigation();

        /** @scrutinizer ignore-deprecated */
        $sut->setContent('');
    }

    public function testSetContentReturnsSelfIfContentIsNull(): void
    {
        $sut = new Navigation();

        $actualResult = $sut->setContent(null);

        $this->assertSame($sut, $actualResult);
    }

    public function testDefaultToString(): void
    {
        $expectedResult = '<ul></ul>';

        $sut = new Navigation();

        $actualResult = (string)$sut;

        $this->assertSame($expectedResult, $actualResult);
    }

    public function testToStringWithOptionalsModified(): void
    {
        $sut = new Navigation();

        $sut->setWrapper(new Tag('YYY', [], null, 'foo'));
        $sut->getPrefix()->setContent(new Tag('XXX', [], null, 'bar'));
        $sut->getPostfix()->setContent(new Tag('ZZZ', [], null, 'baz'));

        $this->assertSame('<bar>XXX</bar><foo><ul></ul></foo><baz>ZZZ</baz>', (string)$sut);
    }

    public function testRenderDisplaysItemsInProperOrder(): void
    {
        $rawItems   = [new Item('AAA'), new Item('BBB'), new Item('CCC'), new Item('DDD')];
        $items      = [
            100 => [$rawItems[0], $rawItems[1]],
            50  => [$rawItems[2]],
            75  => [$rawItems[3]],
        ];
        $attributes = Attributes::fromArray(static::ATTRIBUTES);

        $sut = new Navigation(static::INTENTS, $attributes);

        foreach ($items as $weight => $itemsByWeight) {
            $sut->addWithWeight($weight, ...$itemsByWeight);
        }

        $rendered = (string)$sut;

        $this->assertMatchesRegularExpression('/^\s*\<ul.*CCC.*DDD.*AAA.*BBB.*\<\/ul\>\s*$/Ums', $rendered);
    }

    public function testGetWrapperReturnsNullByDefault(): void
    {
        $sut = new Navigation();

        $actualResult = $sut->getWrapper();

        $this->assertNull($actualResult);
    }

    public function testGetWrapperReturnsLastLestWrapper(): void
    {
        $sut = new Navigation();

        /** @var ITag $tagMock */
        $tagMock = $this->createMock(ITag::class);

        $sut->setWrapper($tagMock);

        $actualResult = $sut->getWrapper();

        $this->assertSame($tagMock, $actualResult);
    }

    public function testSetTranslatorSetsTranslatorOnNodes(): void
    {
        $sut = new Navigation();

        /** @var ITranslator $translatorMock */
        $translatorMock = $this->createMock(ITranslator::class);

        /** @var Item|MockObject $itemMock */
        $itemMock = $this->createMock(Item::class);

        $itemMock
            ->expects($this->atLeastOnce())
            ->method('setTranslator')
            ->with($translatorMock)
            ->willReturn($sut);

        $sut[] = $itemMock;

        $sut->setTranslator($translatorMock);
    }

    public function testOffsetSetThrowsExceptionOnInvalidOffset(): void
    {
        $this->expectException(InvalidArgumentException::class);

        $sut = new Navigation();

        /** @var Item|MockObject $itemMock */
        $itemMock = $this->createMock(Item::class);

        $sut[1] = $itemMock;
    }

    public function testOffsetSetCanUseWeightIfNeeded(): void
    {
        $sut = $this->createNavigation();

        $itemMock = $this->createMock(Item::class);
        $itemMock->expects($this->any())->method('__toString')->willReturn('!');
        $sut[4] = $itemMock;

        $expectedResult = "<ul>ax\nay\naz\nbx\n!\nbz</ul>";
        $actualResult   = (string)$sut;

        $this->assertEquals($expectedResult, $actualResult);
    }

    public function testOffsetUnSetCanUseWeightIfNeeded(): void
    {
        $sut = $this->createNavigation();

        unset($sut[4]);

        $expectedResult = "<ul>ax\nay\naz\nbx\nbz</ul>";
        $actualResult   = (string)$sut;

        $this->assertEquals($expectedResult, $actualResult);
    }

    public function testOffsetGetCanUseWeightIfNeeded(): void
    {
        $sut            = $this->createNavigation();
        $expectedResult = "by";
        $actualResult   = (string)$sut[4];

        $this->assertEquals($expectedResult, $actualResult);
    }

    public function testCount(): void
    {
        $sut = $this->createNavigation();

        $expectedResult = 6;
        $actualResult   = count($sut);

        $this->assertEquals($expectedResult, $actualResult);
    }

    public function testForeach(): void
    {
        $sut = $this->createNavigation();

        $expectedResults = ['ax', 'ay', 'az', 'bx', 'by', 'bz'];

        foreach ($sut as $key => $item) {
            $this->assertEquals($expectedResults[$key], (string)$item);
        }
    }

    /**
     * @param array|string[] $weightGroups
     * @param array|string[] $itemGroups
     *
     * @return Navigation
     */
    protected function createNavigation(
        array $weightGroups = ['a', 'b'],
        array $itemGroups = ['x', 'y', 'z']
    ): Navigation {
        $sut = new Navigation();
        foreach ($weightGroups as $w) {
            foreach ($itemGroups as $n) {
                $itemMock = $this->createMock(Item::class);
                $itemMock->expects($this->any())->method('__toString')->willReturn("$w$n");
                $sut->addWithWeight(ord($w) - ord('a'), $itemMock);
            }
        }

        return $sut;
    }
}