Doctrine\Tests\Annotations\Parser\Reference\StaticReferenceResolverTest

Complexity

Total Complexity

5

Size/Duplication

Total Lines	68
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	testResolvesResolvableExamples()	0	5	1
A	setUp()	0	3	1
A	notResolvableExamples()	0	13	1
A	testResolvesNotResolvableExamplesAndThrows()	0	5	1
A	resolvableExamples()	0	16	1

<?php

declare(strict_types=1);

namespace Doctrine\Tests\Annotations\Parser\Reference;

use Doctrine\Annotations\Annotation\Required;
use Doctrine\Annotations\Annotation\Target;
use Doctrine\Annotations\Parser\Ast\Reference;
use Doctrine\Annotations\Parser\Reference\Exception\ReferenceNotResolvable;
use Doctrine\Annotations\Parser\Reference\StaticReferenceResolver;
use Doctrine\Annotations\Parser\Scope;
use Doctrine\Tests\Annotations\Parser\ScopeMother;
use PHPUnit\Framework\TestCase;

class StaticReferenceResolverTest extends TestCase
{
    /** @var StaticReferenceResolver */
    private $resolver;

    public function setUp() : void
    {
        $this->resolver = new StaticReferenceResolver();
    }

    /**
     * @dataProvider resolvableExamples
     */
    public function testResolvesResolvableExamples(Reference $reference, Scope $scope, string $expected) : void
    {
        $result = $this->resolver->resolve($reference, $scope);

        $this->assertSame($expected, $result);
    }

    /**
     * @return mixed[]
     */
    public function resolvableExamples() : iterable
    {
        yield 'FCQN' => [

The expression yield 'FCQN' => array(new Doctrine\Annotations\Parser\Ast\Reference(self::class, true), Doctrine\Tests\Annotations\Parser\ScopeMother::withImports(array('this' => self::class)), self::class) returns the type Generator which is incompatible with the documented return type array<mixed,mixed>.

            new Reference(self::class, true),
            ScopeMother::withImports([
                'this' => self::class,
            ]),
            self::class,
        ];

        yield 'aliased' => [
            new Reference('foo', false),
            ScopeMother::withImports([
                'foo' => Target::class,
            ]),
            Target::class,
        ];
    }

    /**
     * @dataProvider notResolvableExamples
     */
    public function testResolvesNotResolvableExamplesAndThrows(Reference $reference, Scope $scope) : void
    {
        $this->expectException(ReferenceNotResolvable::class);

        $this->resolver->resolve($reference, $scope);
    }

    /**
     * @return mixed[]
     */
    public function notResolvableExamples() : iterable
    {
        yield 'unknown FQCN' => [

The expression yield 'unknown FQCN' => array(new Doctrine\Annotations\Parser\Ast\Reference(Doctrine\Annotations\Annotation\Target::class, true), Doctrine\Tests\Annotations\Parser\ScopeMother::withImports(array('that' => Doctrine\Annotations\Annotation\Required::class))) returns the type Generator which is incompatible with the documented return type array<mixed,mixed>.

            new Reference(Target::class, true),
            ScopeMother::withImports([
                'that' => Required::class,
            ]),
        ];

        yield 'without alias' => [
            new Reference('foo', false),
            ScopeMother::withImports([
                'bar' => Target::class,
            ]),
        ];
    }
}