ApiGen\Parser\Tests\Elements\NamespaceSorterTest

Complexity

Total Complexity

8

Size/Duplication

Total Lines	87
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	6	1
A	testSort()	0	9	1
A	testSortNoneOnly()	0	6	1
A	testIsNoneOnly()	0	5	1
A	testAddMissingParentNamespaces()	0	12	1
A	testAddMissingElementTypes()	0	14	1
A	testCompareNamespaces()	0	7	1
A	getCompareNamespacesData()	0	7	1

<?php declare(strict_types=1);

namespace ApiGen\Parser\Tests\Elements;

use ApiGen\Contracts\Configuration\ConfigurationInterface;
use ApiGen\Contracts\Parser\Elements\NamespaceSorterInterface;
use ApiGen\Parser\Elements\Elements;
use ApiGen\Parser\Elements\NamespaceSorter;
use ApiGen\Tests\MethodInvoker;
use PHPUnit\Framework\Assert;
use PHPUnit\Framework\TestCase;

final class NamespaceSorterTest extends TestCase
{
    /**
     * @var NamespaceSorterInterface
     */
    private $namespaceSorter;

    protected function setUp(): void
    {
        $configurationMock = $this->createMock(ConfigurationInterface::class);

        $this->namespaceSorter = new NamespaceSorter(new Elements, $configurationMock);

The call to NamespaceSorter::__construct() has too many arguments starting with $configurationMock.

    }

    public function testSort(): void
    {
        $groups = ['OneGroup' => [], 'OtherGroup' => [], 'OneMoreGroup' => []];
        $sortedGroups = $this->namespaceSorter->sort($groups);
        $this->assertCount(3, $sortedGroups);
        $this->assertArrayHasKey('OneGroup', $sortedGroups);
        $this->assertArrayHasKey('OtherGroup', $sortedGroups);
        $this->assertArrayHasKey('OneMoreGroup', $sortedGroups);
    }

    public function testSortNoneOnly(): void
    {
        $groups = ['None' => []];
        $sortedGroups = $this->namespaceSorter->sort($groups);
        $this->assertSame([], $sortedGroups);
    }

    public function testIsNoneOnly(): void
    {
        $groups['None'] = true;

$groups was never initialized. Although not strictly required by PHP, it is generally a good practice to add $groups = array(); before regardless.

        $this->assertTrue(MethodInvoker::callMethodOnObject($this->namespaceSorter, 'isNoneOnly', [$groups]));
    }

    public function testAddMissingParentNamespaces(): void
    {
        $this->assertNull(Assert::getObjectAttribute($this->namespaceSorter, 'namespaces'));
        MethodInvoker::callMethodOnObject(
            $this->namespaceSorter, 'addMissingParentNamespaces', ['Some\Group\Name']
        );

        $groups = Assert::getObjectAttribute($this->namespaceSorter, 'namespaces');
        $this->assertArrayHasKey('Some\Group\Name', $groups);
        $this->assertArrayHasKey('Some\Group', $groups);
        $this->assertArrayHasKey('Some', $groups);
    }

    public function testAddMissingElementTypes(): void
    {
        MethodInvoker::callMethodOnObject($this->namespaceSorter, 'addMissingElementTypes', ['Some\Group']);
        $groups = Assert::getObjectAttribute($this->namespaceSorter, 'namespaces');
        $this->assertArrayHasKey('Some\Group', $groups);

        $someGroup = $groups['Some\Group'];
        $this->assertArrayHasKey('classes', $someGroup);
        $this->assertArrayHasKey('constants', $someGroup);
        $this->assertArrayHasKey('exceptions', $someGroup);
        $this->assertArrayHasKey('functions', $someGroup);
        $this->assertArrayHasKey('interfaces', $someGroup);
        $this->assertArrayHasKey('traits', $someGroup);
    }

    /**
     * @dataProvider getCompareNamespacesData()
     */
    public function testCompareNamespaces(string $one, string $two, int $expected): void
    {
        $this->assertSame(
            $expected,
            MethodInvoker::callMethodOnObject($this->namespaceSorter, 'compareNamespaceNames', [$one, $two])
        );
    }

    /**
     * @return mixed[]
     */
    public function getCompareNamespacesData(): array
    {
        return [
            ['GroupOne', 'OtherGroup', -8],
            ['One', 'Two', -5],
        ];
    }
}