MetadataCollectorTest::docBlocksProvider() - Code Metrics - Inspection of "Merge pull request #2 from kejwmen/new-parser-test..." - Majkl578/doctrine-annotations - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — new-parser-ast-metadata ( 6127e0...5a4a16 )

by Michael

created 2018-10-23 01:42 UTC

MetadataCollectorTest::docBlocksProvider() A

↳ Parent: MetadataCollectorTest

Complexity

Conditions	4
Paths	1

Size

Total Lines	80
Code Lines	49

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	49
dl	0
loc	80
rs	9.1127
c	0
b	0
f	0
cc	4
nc	1
nop	0

How to fix Long Method

<?php

declare(strict_types=1);

namespace Doctrine\Tests\Annotations\Metadata;

use Doctrine\Annotations\Metadata\AnnotationMetadata;
use Doctrine\Annotations\Metadata\AnnotationTarget;
use Doctrine\Annotations\Metadata\Assembler\AnnotationMetadataAssembler;
use Doctrine\Annotations\Metadata\MetadataCollection;
use Doctrine\Annotations\Metadata\MetadataCollector;
use Doctrine\Annotations\Parser\Ast\Annotation;
use Doctrine\Annotations\Parser\Ast\Annotations;
use Doctrine\Annotations\Parser\Ast\Parameter\UnnamedParameter;
use Doctrine\Annotations\Parser\Ast\Parameters;
use Doctrine\Annotations\Parser\Ast\Reference;
use Doctrine\Annotations\Parser\Scope;
use Doctrine\Tests\Annotations\Assembler\Acceptor\AlwaysAcceptingAcceptor;
use Doctrine\Tests\Annotations\Parser\Reference\IdentifierPassingReferenceResolver;
use Doctrine\Tests\Annotations\Parser\ScopeMother;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

final class MetadataCollectorTest extends TestCase
{
    /** @var AnnotationMetadataAssembler|MockObject */
    private $assembler;

    /** @var MetadataCollector */
    private $collector;

    protected function setUp() : void
    {
        $this->assembler = $this->createMock(AnnotationMetadataAssembler::class);
        $this->collector = new MetadataCollector(
            $this->assembler,
            new AlwaysAcceptingAcceptor(),
            new IdentifierPassingReferenceResolver()
        );
    }

    /**
     * @param callable(AnnotationMetadataAssembler) : void $initializer
     * @param callable(AnnotationMetadata[]) : void        $asserter
     *
     * @dataProvider docBlocksProvider()
     */
    public function testMetadata(Annotations $annotations, callable $initializer, callable $asserter) : void
    {
        $initializer($this->assembler);

        $collection = new MetadataCollection();

        $this->collector->collect($annotations, ScopeMother::example(), $collection);

        $asserter($collection);
    }

    /**
     * @return string[][]|AnnotationMetadata[][][]
     */
    public function docBlocksProvider() : iterable
    {
        yield 'single without parameters' => [

            new Annotations(
                new Annotation(
                    new Reference('Foo', true),
                    new Parameters()
                )
            ),
            static function (AnnotationMetadataAssembler $assembler) : void {
                /** @var AnnotationMetadataAssembler|MockObject $assembler */
                $assembler->method('assemble')
                            method('assemble')
                    ->with(
                        self::callback(static function (Reference $reference) : bool {
                            return $reference->getIdentifier() === 'Foo' && $reference->isFullyQualified() === true;
                        }),
                        self::isInstanceOf(Scope::class)
                    )
                    ->willReturn(new AnnotationMetadata(
                        'Foo',
                        new AnnotationTarget(AnnotationTarget::TARGET_ALL),
                        false,
                        []
                    ));
            },
            static function (MetadataCollection $collection) : void {
                self::assertCount(1, $collection);
                self::assertSame('Foo', $collection['Foo']->getName());
            },
        ];
        yield 'nested' => [
            new Annotations(
                new Annotation(
                    new Reference('Foo', true),
                    new Parameters(
                        new UnnamedParameter(
                            new Annotation(
                                new Reference('Bar', false),
                                new Parameters()
                            )
                        )
                    )
                )
            ),
            static function (AnnotationMetadataAssembler $assembler) : void {
                /** @var AnnotationMetadataAssembler|MockObject $assembler */
                $assembler->method('assemble')
                    ->withConsecutive(
                        [
                            self::callback(static function (Reference $reference) : bool {
                                return $reference->getIdentifier() === 'Bar' && $reference->isFullyQualified() === false;
                            }),
                            self::isInstanceOf(Scope::class),
                        ],
                        [
                            self::callback(static function (Reference $reference) : bool {
                                return $reference->getIdentifier() === 'Foo' && $reference->isFullyQualified() === true;
                            }),
                            self::isInstanceOf(Scope::class),
                        ]
                    )
                    ->willReturnOnConsecutiveCalls(
                        new AnnotationMetadata(
                            'Bar',
                            new AnnotationTarget(AnnotationTarget::TARGET_ALL),
                            false,
                            []
                        ),
                        new AnnotationMetadata(
                            'Foo',
                            new AnnotationTarget(AnnotationTarget::TARGET_ALL),
                            false,
                            []
                        )
                    );
            },
            static function (MetadataCollection $collection) : void {
                self::assertCount(2, $collection);
                self::assertSame('Bar', $collection['Bar']->getName());
                self::assertSame('Foo', $collection['Foo']->getName());
            },
        ];
    }
}


Majkl578 / doctrine-annotations

Push — new-parser-ast-metadata ( 6127e0...5a4a16 )

MetadataCollectorTest::docBlocksProvider() A

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like