ComposerRequireCheckerTest\NodeVisitor\DefinedSymbolCollectorFunctionalTest

Complexity

Total Complexity

9

Size/Duplication

Total Lines	99
Duplicated Lines	9.09 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	9	9	1
A	testWillCollectSymbolsDefinedInThisFile()	0	9	1
A	testWillCollectFunctionDefinition()	0	9	1
A	testWillCollectNamespacedFunctionDefinition()	0	9	1
A	testWillCollectConstDefinition()	0	9	1
A	testWillCollectNamespacedConstDefinition()	0	9	1
A	traverseStringAST()	0	4	1
A	traverseClassAST()	0	8	1
A	assertSameCollectedSymbols()	0	4	1

<?php

namespace ComposerRequireCheckerTest\NodeVisitor;

use ComposerRequireChecker\NodeVisitor\DefinedSymbolCollector;
use PhpParser\Node;
use PhpParser\NodeTraverser;
use PhpParser\NodeTraverserInterface;
use PhpParser\NodeVisitor\NameResolver;
use PhpParser\Parser;
use PhpParser\ParserFactory;
use PHPUnit\Framework\TestCase;

/**
 * @coversNothing
 *
 * @group functional
 */
final class DefinedSymbolCollectorFunctionalTest extends TestCase
{
    /**
     * @var DefinedSymbolCollector
     */
    private $collector;

    /**
     * @var Parser
     */
    private $parser;

    /**
     * @var NodeTraverserInterface
     */
    private $traverser;

    /**
     * {@inheritDoc}
     */
    protected function setUp()

This method seems to be duplicated in your project.

    {
        $this->collector = new DefinedSymbolCollector();
        $this->parser    = (new ParserFactory())->create(ParserFactory::PREFER_PHP7);
        $this->traverser = new NodeTraverser();

        $this->traverser->addVisitor(new NameResolver());
        $this->traverser->addVisitor($this->collector);
    }

    public function testWillCollectSymbolsDefinedInThisFile()
    {
        $this->traverseClassAST(self::class);

        self::assertSameCollectedSymbols(
            ['ComposerRequireCheckerTest\NodeVisitor\DefinedSymbolCollectorFunctionalTest'],
            $this->collector->getDefinedSymbols()
        );
    }

    public function testWillCollectFunctionDefinition()
    {
        $this->traverseStringAST('function foo() {}');

        self::assertSameCollectedSymbols(
            ['foo'],
            $this->collector->getDefinedSymbols()
        );
    }

    public function testWillCollectNamespacedFunctionDefinition()
    {
        $this->traverseStringAST('namespace Foo; function foo() {}');

        self::assertSameCollectedSymbols(
            ['Foo\foo'],
            $this->collector->getDefinedSymbols()
        );
    }

    public function testWillCollectConstDefinition()
    {
        $this->traverseStringAST('const foo = "bar", baz = "tab";');

        self::assertSameCollectedSymbols(
            ['foo', 'baz'],
            $this->collector->getDefinedSymbols()
        );
    }

    public function testWillCollectNamespacedConstDefinition()
    {
        $this->traverseStringAST('namespace Foo; const foo = "bar", baz = "tab";');

        self::assertSameCollectedSymbols(
            ['Foo\foo', 'Foo\baz'],
            $this->collector->getDefinedSymbols()
        );
    }

    private function traverseStringAST(string $phpSource) : array
    {
        return $this->traverser->traverse($this->parser->parse('<?php ' . $phpSource));

It seems like $this->parser->parse('<?php ' . $phpSource) targeting PhpParser\Parser::parse() can also be of type null; however, PhpParser\NodeTraverserInterface::traverse() does only seem to accept array<integer,object<PhpParser\Node>>, maybe add an additional type check?

    }

    private function traverseClassAST(string $className) : array
    {
        return $this->traverser->traverse(
            $this->parser->parse(

It seems like $this->parser->parse(file_get_contents((new \ReflectionClass($className))->getFileName())) targeting PhpParser\Parser::parse() can also be of type null; however, PhpParser\NodeTraverserInterface::traverse() does only seem to accept array<integer,object<PhpParser\Node>>, maybe add an additional type check?

                file_get_contents((new \ReflectionClass($className))->getFileName())
            )
        );
    }

    private static function assertSameCollectedSymbols(array $expected, array $actual)
    {
        self::assertSame(array_diff($expected, $actual), array_diff($actual, $expected));
    }
}