ComposerRequireCheckerTest\DefinedSymbolsLocator\LocateDefinedSymbolsFromASTRootsTest

Complexity

Total Complexity

9

Size/Duplication

Total Lines	116
Duplicated Lines	0 %

Importance

Changes	6
Bugs	0	Features	4

9 Methods

Rating	Name	Duplication	Size	Complexity
A	testBasicLocateDefineCalls()	0	13	1
A	testBasicLocateFunctions()	0	14	1
A	testBasicLocateTrait()	0	15	1
A	testBasicLocateClass()	0	15	1
A	setUp()	0	5	1
A	testNoRoots()	0	5	1
A	testBasicDoNotLocateNamespacedDefineCalls()	0	13	1
A	locate()	0	3	1
A	testBasicLocateAnonymous()	0	10	1

<?php

namespace ComposerRequireCheckerTest\DefinedSymbolsLocator;

use ArrayObject;
use ComposerRequireChecker\DefinedSymbolsLocator\LocateDefinedSymbolsFromASTRoots;
use PhpParser\Node\Arg;
use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Name;
use PhpParser\Node\Scalar\String_;
use PhpParser\Node\Stmt\Class_;
use PhpParser\Node\Stmt\Function_;
use PhpParser\Node\Stmt\Trait_;
use PHPUnit\Framework\TestCase;

/**
 * @covers \ComposerRequireChecker\DefinedSymbolsLocator\LocateDefinedSymbolsFromASTRoots
 */
final class LocateDefinedSymbolsFromASTRootsTest extends TestCase
{
    /** @var LocateDefinedSymbolsFromASTRoots */
    private $locator;

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

        $this->locator = new LocateDefinedSymbolsFromASTRoots();
    }

    public function testNoRoots(): void
    {
        $symbols = $this->locate([]);

        $this->assertCount(0, $symbols);
    }

    public function testBasicLocateClass(): void
    {
        $roots = [
            new Class_('MyClassA'), new Class_('MyClassB'),
            new Class_('MyClassC'),
        ];

        $symbols = $this->locate([$roots]);

        $this->assertIsArray($symbols);
        $this->assertCount(3, $symbols);

        $this->assertContains('MyClassA', $symbols);
        $this->assertContains('MyClassB', $symbols);
        $this->assertContains('MyClassC', $symbols);
    }

    public function testBasicLocateFunctions(): void
    {
        $roots = [
            new Function_('myFunctionA'),
            new Class_('myFunctionB'),
        ];

        $symbols = $this->locate([$roots]);

        $this->assertIsArray($symbols);
        $this->assertCount(2, $symbols);

        $this->assertContains('myFunctionA', $symbols);
        $this->assertContains('myFunctionB', $symbols);
    }

    public function testBasicLocateTrait(): void
    {
        $roots = [
            new Trait_('MyTraitA'), new Trait_('MyTraitB'),
            new Trait_('MyTraitC'),
        ];

        $symbols = $this->locate([$roots]);

        $this->assertIsArray($symbols);
        $this->assertCount(3, $symbols);

        $this->assertContains('MyTraitA', $symbols);
        $this->assertContains('MyTraitB', $symbols);
        $this->assertContains('MyTraitC', $symbols);
    }

    public function testBasicLocateAnonymous(): void
    {
        $roots = [
            new Class_(null),
        ];

        $symbols = $this->locate([$roots]);

        $this->assertIsArray($symbols);
        $this->assertCount(0, $symbols);
    }

    public function testBasicLocateDefineCalls(): void
    {
        $roots = [
            new FuncCall(new Name('define'), [
                new Arg(new String_('CONST_NAME')),
                new Arg(new String_('CONST_VALUE')),
            ])
        ];

        $symbols = $this->locate([$roots]);

        $this->assertIsArray($symbols);
        $this->assertCount(1, $symbols);

    }

Function closing brace must go on the next line following the body; found 1 blank lines before brace

    public function testBasicDoNotLocateNamespacedDefineCalls(): void
    {
        $roots = [
            new FuncCall(new Name('define', ['namespacedName' => new Name\FullyQualified('Foo\define')]), [
                new Arg(new String_('NO_CONST')),
                new Arg(new String_('NO_SOMETHING')),
            ])
        ];

        $symbols = $this->locate([$roots]);

        $this->assertIsArray($symbols);
        $this->assertCount(0, $symbols);

    }

Function closing brace must go on the next line following the body; found 1 blank lines before brace

    private function locate(array $roots): array
    {
        return ($this->locator)(new ArrayObject($roots));
    }
}