StaticClassMapSourceLocatorTest::testAcceptsEmptySet() - Code Metrics - Inspection of "Merge pull request #122 from Roave/chore/dependenc..." - Roave/BackwardCompatibilityCheck - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 4eb33b...9d87b5 )

by Marco

created 2019-06-08 13:29 UTC

testAcceptsEmptySet() A

↳ Parent: StaticClassMapSourceLocatorTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	4
nc	1
nop	0
dl	0
loc	7
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace RoaveTest\BackwardCompatibility\SourceLocator;

use InvalidArgumentException;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Roave\BackwardCompatibility\SourceLocator\StaticClassMapSourceLocator;
use Roave\BetterReflection\Identifier\Identifier;
use Roave\BetterReflection\Identifier\IdentifierType;
use Roave\BetterReflection\Reflection\Reflection;
use Roave\BetterReflection\Reflector\Reflector;
use Roave\BetterReflection\SourceLocator\Ast\Locator;
use Roave\BetterReflection\SourceLocator\Located\LocatedSource;
use function Safe\file_get_contents;

/**
 * @covers \Roave\BackwardCompatibility\SourceLocator\StaticClassMapSourceLocator
 */
final class StaticClassMapSourceLocatorTest extends TestCase
{
    /** @var Locator&MockObject */
    private $astLocator;

    /** @var Reflector&MockObject */
    private $reflector;

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

        $this->astLocator = $this->createMock(Locator::class);
        $this->reflector  = $this->createMock(Reflector::class);
    }

    public function testRejectsEmptyKeys() : void
    {
        $this->expectException(InvalidArgumentException::class);

        new StaticClassMapSourceLocator(
            ['' => __FILE__],
            $this->astLocator
        );
    }

    public function testRejectsEmptyStringFiles() : void
    {
        $this->expectException(InvalidArgumentException::class);

        new StaticClassMapSourceLocator(
            ['foo' => ''],
            $this->astLocator
        );
    }

    public function testAcceptsEmptySet() : void
    {
        $locator = new StaticClassMapSourceLocator([], $this->astLocator);

        self::assertNull($locator->locateIdentifier(
            $this->reflector,
            new Identifier(self::class, new IdentifierType(IdentifierType::IDENTIFIER_CLASS))
        ));
    }

    /**
     * @dataProvider thisClassPossiblePaths
     */
    public function testWillLocateThisClass(string $thisClassFilePath) : void
    {
        $locator    = new StaticClassMapSourceLocator([self::class => $thisClassFilePath], $this->astLocator);
        $reflection = $this->createMock(Reflection::class);

        $this
            ->astLocator
            ->expects(self::once())
              expects(self::once())
            ->method('findReflection')
            ->with($this->reflector, self::callback(static function (LocatedSource $source) : bool {
            ->with($this->reflector, self::/** @scrutinizer ignore-call */ callback(static function (LocatedSource $source) : bool {
                self::assertSame(file_get_contents(__FILE__), $source->getSource());
                self::assertSame(/** @scrutinizer ignore-type */ file_get_contents(__FILE__), $source->getSource());
                self::assertSame(__FILE__, $source->getFileName());
                self::assertNull($source->getExtensionName());
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {

                return true;
            }))
            ->willReturn($reflection);

        self::assertSame($reflection, $locator->locateIdentifier(
              assertSame($reflection, $locator->locateIdentifier(
            $this->reflector,
            new Identifier(self::class, new IdentifierType(IdentifierType::IDENTIFIER_CLASS))
        ));
    }

    /** @return array<int, array<int, string>> */
    public static function thisClassPossiblePaths() : array
    {
        return [
            [__FILE__],
            [__DIR__ . '/../SourceLocator/StaticClassMapSourceLocatorTest.php'],
        ];
    }

    public function testWillNotLocateUnknownClass() : void
    {
        $locator = new StaticClassMapSourceLocator([self::class => __FILE__], $this->astLocator);

        $this
            ->astLocator
            ->expects(self::never())
            ->expects(self::/** @scrutinizer ignore-call */ never())
            ->method('findReflection');

        self::assertNull($locator->locateIdentifier(
            $this->reflector,
            new Identifier('Unknown\\ClassName', new IdentifierType(IdentifierType::IDENTIFIER_CLASS))
        ));
    }

    public function testWillNotLocateFunctions() : void
    {
        $locator = new StaticClassMapSourceLocator([self::class => __FILE__], $this->astLocator);

        $this
            ->astLocator
            ->expects(self::never())
            ->method('findReflection');

        self::assertNull($locator->locateIdentifier(
            $this->reflector,
            new Identifier(self::class, new IdentifierType(IdentifierType::IDENTIFIER_FUNCTION))
        ));
    }
}


Roave / BackwardCompatibilityCheck

Push — master ( 4eb33b...9d87b5 )

testAcceptsEmptySet() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like