ComposerRequireCheckerTest\ASTLocator\LocateASTFromFilesTest

Complexity

Total Complexity

7

Size/Duplication

Total Lines	80
Duplicated Lines	0 %

Importance

Changes	4
Bugs	0	Features	1

7 Methods

Rating	Name	Duplication	Size	Complexity
A	locate()	0	3	1
A	testDoNotFailOnParseErrorWithErrorHandler()	0	12	1
A	testFailOnParseErrorWithNullReturn()	0	16	1
A	testLocate()	0	10	1
A	createFile()	0	3	1
A	setUp()	0	6	1
A	testFailOnParseError()	0	8	1

<?php

namespace ComposerRequireCheckerTest\ASTLocator;

use ArrayObject;
use ComposerRequireChecker\ASTLocator\LocateASTFromFiles;
use org\bovigo\vfs\vfsStream;
use org\bovigo\vfs\vfsStreamDirectory;
use PhpParser\Error;
use PhpParser\ErrorHandler\Collecting;
use PhpParser\Lexer;
use PhpParser\Parser\Php7;
use PHPUnit\Framework\TestCase;
use RuntimeException;

/**
 * @covers \ComposerRequireChecker\ASTLocator\LocateASTFromFiles
 */
final class LocateASTFromFilesTest extends TestCase
{
    /** @var LocateASTFromFiles */
    private $locator;
    /** @var vfsStreamDirectory */
    private $root;

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

        $this->locator = new LocateASTFromFiles(new Php7(new Lexer()), null);
        $this->root = vfsStream::setup();
    }

    public function testLocate(): void
    {
        $files = [
            $this->createFile('MyClassA', '<?php class MyClassA {}'),
            $this->createFile('MyClassB', '<?php class MyClassB {}'),
        ];

        $roots = $this->locate($files);

        $this->assertCount(2, $roots);
    }

    public function testFailOnParseError(): void
    {
        $this->expectException(Error::class);
        $files = [
            $this->createFile('MyBadCode', '<?php this causes a parse error'),
        ];

        $this->locate($files);
    }

    public function testDoNotFailOnParseErrorWithErrorHandler(): void
    {
        $collectingErrorHandler = new Collecting();
        $this->locator = new LocateASTFromFiles(new Php7(new Lexer()), $collectingErrorHandler);
        $files = [
            $this->createFile('MyBadCode', '<?php this causes a parse error'),
        ];

        $roots = $this->locate($files);
        $this->assertCount(1, $roots); // one file should be parsed (partially)
        $this->assertTrue($collectingErrorHandler->hasErrors());
        $this->assertCount(1, $collectingErrorHandler->getErrors()); //should have one parse error
    }

    public function testFailOnParseErrorWithNullReturn(): void
    {
        $this->expectException(RuntimeException::class);

        $parserMock = $this->createMock(Php7::class);
        $parserMock->method('parse')->willReturn(null);

        $this->locator = new LocateASTFromFiles($parserMock, null);
        $files = [
            $this->createFile(
                'MyBadCode',
                'this content is not relevant because the parser is mocked and always returns null'
            ),
        ];

        $this->locate($files);
    }

    private function createFile(string $path, string $content = null): string
    {
        return vfsStream::newFile($path)->at($this->root)->setContent($content)->url();
    }

    /**
     * @param string[] $files
     */
    private function locate(array $files): array
    {
        return iterator_to_array(($this->locator)(new ArrayObject($files)));
    }
}