ApiGen\Parser\Tests\Reflection\ReflectionClass\AbstractReflectionClassTestCase

Complexity

Total Complexity

3

Size/Duplication

Total Lines	57
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	10	1
A	getReflectionFactory()	0	23	2

<?php declare(strict_types=1);

namespace ApiGen\Parser\Tests\Reflection\ReflectionClass;

use ApiGen\Contracts\Configuration\ConfigurationInterface;
use ApiGen\Contracts\Parser\ParserStorageInterface;
use ApiGen\Contracts\Parser\Reflection\TokenReflection\ReflectionFactoryInterface;
use ApiGen\Parser\Broker\Backend;
use ApiGen\Parser\Reflection\ReflectionClass;
use ApiGen\Parser\Reflection\TokenReflection\ReflectionFactory;
use PHPUnit\Framework\TestCase;
use ReflectionProperty;
use TokenReflection\Broker;

abstract class AbstractReflectionClassTestCase extends TestCase
{
    /**
     * @var ReflectionClass
     */
    protected $reflectionClass;

    /**
     * @var ReflectionClass
     */
    protected $reflectionClassOfParent;

    /**
     * @var ReflectionClass
     */
    protected $reflectionClassOfTrait;

    /**
     * @var ReflectionClass
     */
    protected $reflectionClassOfInterface;

    protected function setUp(): void
    {
        $backend = new Backend($this->getReflectionFactory());
        $broker = new Broker($backend);
        $broker->processDirectory(__DIR__ . '/../ReflectionClassSource');
        $this->reflectionClass = $backend->getClasses()['Project\AccessLevels'];

$backend->getClasses()['Project\\AccessLevels'] is of type object<ApiGen\Contracts\Parser\Reflection\ClassReflectionInterface>, but the property $reflectionClass was declared to be of type object<ApiGen\Parser\Reflection\ReflectionClass>. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

        $this->reflectionClassOfParent = $backend->getClasses()['Project\ParentClass'];

$backend->getClasses()['Project\\ParentClass'] is of type object<ApiGen\Contracts\Parser\Reflection\ClassReflectionInterface>, but the property $reflectionClassOfParent was declared to be of type object<ApiGen\Parser\Reflection\ReflectionClass>. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

        $this->reflectionClassOfTrait = $backend->getClasses()['Project\SomeTrait'];

$backend->getClasses()['Project\\SomeTrait'] is of type object<ApiGen\Contracts\Parser\Reflection\ClassReflectionInterface>, but the property $reflectionClassOfTrait was declared to be of type object<ApiGen\Parser\Reflection\ReflectionClass>. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

        $this->reflectionClassOfInterface = $backend->getClasses()['Project\RichInterface'];

$backend->getClasses()['Project\\RichInterface'] is of type object<ApiGen\Contracts\Parser\Reflection\ClassReflectionInterface>, but the property $reflectionClassOfInterface was declared to be of type object<ApiGen\Parser\Reflection\ReflectionClass>. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

    }

    private function getReflectionFactory(): ReflectionFactoryInterface
    {
        // @todo: use $parserStorage from DI
        $parserStorageMock = $this->createMock(ParserStorageInterface::class);
        $parserStorageMock->method('getDirectImplementersOfInterface')->willReturn([1]);
        $parserStorageMock->method('getIndirectImplementersOfInterface')->willReturn([]);
        $parserStorageMock->method('getElementsByType')->willReturnCallback(function ($arg) {
            if ($arg) {
                return [
                    'Project\AccessLevels' => $this->reflectionClass,
                    'Project\ParentClass' => $this->reflectionClassOfParent,
                    'Project\SomeTrait' => $this->reflectionClassOfTrait,
                    'Project\RichInterface' => $this->reflectionClassOfInterface
                ];
            }
        });

        $configurationMock = $this->createMock(ConfigurationInterface::class);
        $configurationMock->method('getVisibilityLevel')
            ->willReturn(ReflectionProperty::IS_PUBLIC | ReflectionProperty::IS_PROTECTED);

        return new ReflectionFactory($configurationMock, $parserStorageMock);
    }
}