AbterPhp\Framework\TestCase\Html\NodeTestCase

Complexity

Total Complexity

12

Size/Duplication

Total Lines	155
Duplicated Lines	0 %

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	toStringCanReturnTranslatedContentProvider()	0	6	1
A	testDefaultToString()	0	5	1
A	testToStringReturnsRawContentByDefault()	0	5	1
A	testToStringCanReturnTranslatedContent()	0	9	1
A	testAddIntent()	0	13	1
A	testSetContentFailure()	0	7	1
A	setContentFailureProvider()	0	4	1
A	testCreateFailure()	0	5	1
A	testIsMatch()	0	8	1
A	toStringReturnsRawContentByDefaultProvider()	0	4	1
A	testHasIntent()	0	11	1
A	createNode()	0	3	1

<?php

declare(strict_types=1);

namespace AbterPhp\Framework\TestCase\Html;

use AbterPhp\Framework\Html\INode;
use AbterPhp\Framework\Html\Node;
use AbterPhp\Framework\TestDouble\I18n\MockTranslatorFactory;
use PHPUnit\Framework\TestCase;

abstract class NodeTestCase extends TestCase
{
    /**
     * @return array
     */
    public function setContentFailureProvider(): array
    {
        return [
            [new \stdClass()],
        ];
    }

    /**
     * @dataProvider setContentFailureProvider
     *
     * @param mixed $content
     */
    public function testCreateFailure($content)
    {
        $this->expectException(\InvalidArgumentException::class);

        $this->createNode($content);
    }

    /**
     * @dataProvider setContentFailureProvider
     *
     * @param mixed $content
     */
    public function testSetContentFailure($content)
    {
        $this->expectException(\InvalidArgumentException::class);

        $sut = $this->createNode();

        $sut->setContent($content);
    }

    public function testDefaultToString()
    {
        $sut = $this->createNode();

        $this->assertSame('', (string)$sut);
    }

    /**
     * @return array
     */
    public function toStringReturnsRawContentByDefaultProvider(): array
    {
        return [
            'string' => ['foo', 'foo'],
        ];
    }

    /**
     * @dataProvider toStringReturnsRawContentByDefaultProvider
     *
     * @param mixed  $rawContent
     * @param string $expectedResult
     */
    public function testToStringReturnsRawContentByDefault($rawContent, string $expectedResult)
    {
        $sut = $this->createNode($rawContent);

        $this->assertStringContainsString($expectedResult, (string)$sut);
    }

    /**
     * @return array
     */
    public function toStringCanReturnTranslatedContentProvider(): array
    {
        $translations = ['foo' => 'bar'];

        return [
            'string' => ['foo', $translations, 'bar'],
        ];
    }

    /**
     * @dataProvider toStringCanReturnTranslatedContentProvider
     *
     * @param mixed $rawContent
     * @param string $expectedResult
     */
    public function testToStringCanReturnTranslatedContent($rawContent, array $translations, string $expectedResult)
    {
        $translatorMock = MockTranslatorFactory::createSimpleTranslator($this, $translations);

        $sut = $this->createNode($rawContent);

        $sut->setTranslator($translatorMock);

        $this->assertStringContainsString($expectedResult, (string)$sut);
    }

    /**
     * @return array
     */
    abstract public function isMatchProvider(): array;

    /**
     * @dataProvider isMatchProvider
     *
     * @param string|null $className
     * @param string[]    $intents
     * @param int|null    $expectedResult
     */
    public function testIsMatch(?string $className, array $intents, bool $expectedResult)
    {
        $sut = $this->createNode();
        $sut->setIntent('foo', 'bar');

        $actualResult = $sut->isMatch($className, ...$intents);

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

    public function testAddIntent()
    {
        $intent0 = 'foo';
        $intent1 = 'bar';

        $sut = $this->createNode();

        $sut->addIntent($intent0);
        $sut->addIntent($intent1);

        $intents = $sut->getIntents();

        $this->assertSame([$intent0, $intent1], $intents);
    }

    public function testHasIntent()
    {
        $intent0 = 'foo';
        $intent1 = 'bar';

        $sut = $this->createNode();

        $sut->addIntent($intent0);
        $sut->addIntent($intent1);

        $this->assertTrue($sut->hasIntent($intent0));
    }

    /**
     * @param INode|string|null $content
     *
     * @return Node
     */
    private function createNode($content = null): INode
    {
        return new Node($content);
    }
}