Cycle\ORM\Promise\Tests\ProxyPrinterTest

Complexity

Total Complexity

36

Size/Duplication

Total Lines	390
Duplicated Lines	29.74 %

Coupling/Cohesion

Components	1
Dependencies	11

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	testDeclaration()	0	27	1
A	testSameNamespace()	0	17	1
A	testDifferentNamespace()	17	17	1
A	testUseStmtsInSameNamespace()	18	18	1
A	testUseStmtsInDifferentNamespace()	19	19	1
A	fetchUseStatements()	0	15	3
A	fetchExternalDependencies()	0	16	4
A	testTraits()	7	7	1
A	testConstants()	7	7	1
A	testProperties()	0	31	3
A	testHasConstructor()	0	32	1
A	testNotContainParentConstructor()	15	15	1
A	testContainParentConstructor()	15	15	1
A	testPromiseMethods()	18	18	2
B	testInheritedMethods()	0	52	9
A	getDeclaration()	0	4	1
A	extractor()	0	6	1
A	makeProxyObject()	0	9	1
A	make()	0	4	1
A	proxyCreator()	0	7	1

<?php
declare(strict_types=1);

namespace Cycle\ORM\Promise\Tests;

use Cycle\ORM\ORMInterface;
use Cycle\ORM\Promise\Declaration\Declaration;
use Cycle\ORM\Promise\Declaration\Extractor;
use Cycle\ORM\Promise\Declaration\Structure;
use Cycle\ORM\Promise\PromiseInterface;
use Cycle\ORM\Promise\PromiseResolver;
use Cycle\ORM\Promise\ProxyPrinter;
use Cycle\ORM\Promise\Tests\Fixtures;
use Cycle\ORM\Promise\Utils;
use PhpParser\PrettyPrinter\Standard;
use PhpParser\PrettyPrinterAbstract;
use PHPUnit\Framework\TestCase;
use Spiral\Core\Container;

class ProxyPrinterTest extends TestCase
{
    public function testDeclaration(): void
    {
        $class = Fixtures\Entity::class;
        $as = 'EntityProxy' . __LINE__;

        $declaration = new Declaration(new \ReflectionClass($class), $as);
        $output = $this->make($declaration);
        $output = ltrim($output, '<?php');

        $this->assertFalse(class_exists($declaration->class->getFullName()));

        eval($output);

        $this->assertStringNotContainsString('abstract', $output);
        $this->assertStringContainsString(sprintf(
            'class %s extends %s implements %s',
            $as,
            Utils::shortName($class),
            Utils::shortName(PromiseInterface::class)
        ), $output);

        $proxy = $this->makeProxyObject($class, $declaration->class->getFullName());

        $this->assertInstanceOf($declaration->class->getFullName(), $proxy);
        $this->assertInstanceOf($class, $proxy);
        $this->assertInstanceOf(PromiseInterface::class, $proxy);
    }

    /**
     * @throws \ReflectionException
     */
    public function testSameNamespace(): void
    {
        $class = Fixtures\Entity::class;
        $as = 'EntityProxy' . __LINE__;

        $declaration = new Declaration(new \ReflectionClass($class), $as);
        $output = $this->make($declaration);
        $output = ltrim($output, '<?php');

        $this->assertFalse(class_exists($declaration->class->getFullName()));

        eval($output);

        $origReflection = new \ReflectionClass($class);
        $proxyReflection = new \ReflectionClass($declaration->class->getFullName());
        $this->assertSame($origReflection->getNamespaceName(), $proxyReflection->getNamespaceName());
    }

    /**
     * @throws \ReflectionException
     */
    public function testDifferentNamespace(): void

This method seems to be duplicated in your project.

    {
        $class = Fixtures\Entity::class;
        $as = "\EntityProxy" . __LINE__;

        $declaration = new Declaration(new \ReflectionClass($class), $as);
        $output = $this->make($declaration);
        $output = ltrim($output, '<?php');

        $this->assertFalse(class_exists($declaration->class->getFullName()));

        eval($output);

        $proxyReflection = new \ReflectionClass($declaration->class->getFullName());
        $this->assertSame('', (string)$proxyReflection->getNamespaceName());
        $this->assertStringNotContainsString('namespace ', $output);
    }

    /**
     * @throws \ReflectionException
     */
    public function testUseStmtsInSameNamespace(): void

This method seems to be duplicated in your project.

    {
        $class = Fixtures\Entity::class;
        $as = 'EntityProxy' . __LINE__;

        $declaration = new Declaration(new \ReflectionClass($class), $as);
        $output = $this->make($declaration);
        $output = ltrim($output, '<?php');

        $this->assertFalse(class_exists($declaration->class->getFullName()));

        eval($output);

        $this->assertSame($this->fetchUseStatements($output), $this->fetchExternalDependencies($declaration->class->getFullName(), [
            PromiseResolver::class,
            PromiseInterface::class
        ]));
    }

    /**
     * @throws \ReflectionException
     */
    public function testUseStmtsInDifferentNamespace(): void

This method seems to be duplicated in your project.

    {
        $class = Fixtures\Entity::class;
        $as = "\EntityProxy" . __LINE__;

        $declaration = new Declaration(new \ReflectionClass($class), $as);
        $output = $this->make($declaration);
        $output = ltrim($output, '<?php');

        $this->assertFalse(class_exists($declaration->class->getFullName()));

        eval($output);

        $this->assertSame($this->fetchUseStatements($output), $this->fetchExternalDependencies($declaration->class->getFullName(), [
            PromiseResolver::class,
            PromiseInterface::class,
            $class
        ]));
    }

    private function fetchUseStatements(string $code): array
    {
        $uses = [];
        foreach (explode("\n", $code) as $line) {
            if (mb_stripos($line, 'use') !== 0) {
                continue;
            }

            $uses[] = trim(mb_substr($line, 4), " ;\r\n");
        }

        sort($uses);

        return $uses;
    }

    /**
     * @param string $class
     * @param array  $types
     *
     * @return array
     * @throws \ReflectionException
     */
    private function fetchExternalDependencies(string $class, array $types = []): array
    {
        $reflection = new \ReflectionClass($class);

        foreach ($reflection->getConstructor()->getParameters() as $parameter) {
            if (!$parameter->hasType() || $parameter->getType()->isBuiltin()) {
                continue;
            }

            $types[] = $parameter->getType()->getName();
        }

        sort($types);

        return $types;
    }

    public function testTraits(): void

This method seems to be duplicated in your project.

    {
        $this->assertStringNotContainsString(' use ',
            $this->make(new Declaration(new \ReflectionClass(Fixtures\EntityWithoutTrait::class), 'EntityProxy' . __LINE__)));
        $this->assertStringNotContainsString(' use ',
            $this->make(new Declaration(new \ReflectionClass(Fixtures\EntityWithTrait::class), 'EntityProxy' . __LINE__)));
    }

    public function testConstants(): void

This method seems to be duplicated in your project.

    {
        $this->assertStringNotContainsString(' const ',
            $this->make(new Declaration(new \ReflectionClass(Fixtures\EntityWithoutConstants::class), 'EntityProxy' . __LINE__)));
        $this->assertStringNotContainsString(' const ',
            $this->make(new Declaration(new \ReflectionClass(Fixtures\EntityWithConstants::class), 'EntityProxy' . __LINE__)));
    }

    public function testProperties(): void
    {
        $class = Fixtures\Entity::class;
        $as = 'EntityProxy' . __LINE__;

        $declaration = new Declaration(new \ReflectionClass($class), $as);
        $output = $this->make($declaration);
        $output = ltrim($output, '<?php');

        $this->assertFalse(class_exists($declaration->class->getFullName()));

        eval($output);

        $reflection = new \ReflectionClass($declaration->class->getFullName());

        /** @var \ReflectionProperty[] $properties */
        $properties = [];
        foreach ($reflection->getProperties() as $property) {
            if ($property->getDeclaringClass()->getName() !== $declaration->class->getFullName()) {

Consider using $property->class. There is an issue with getName() and APC-enabled PHP versions.

                continue;
            }

            $properties[] = $property;
        }

        $this->assertCount(1, $properties);

$properties is of type array<integer,object<ReflectionProperty>>, but the function expects a object<Countable>|object<PHPUnit\Framework\iterable>.

        $property = $properties[0];
        $this->assertTrue($property->isPrivate());
        $this->assertFalse($property->isStatic());
        $this->assertStringContainsString('@var PromiseResolver|' . Utils::shortName($class), $property->getDocComment());
    }

    /**
     * @throws \ReflectionException
     */
    public function testHasConstructor(): void
    {
        $class = Fixtures\EntityWithoutConstructor::class;
        $as = 'EntityProxy' . __LINE__;

        $declaration = new Declaration(new \ReflectionClass($class), $as);
        $output = $this->make($declaration);
        $output = ltrim($output, '<?php');

        $this->assertFalse(class_exists($declaration->class->getFullName()));

        eval($output);

        $reflection = new \ReflectionClass($declaration->class->getFullName());
        $constructor = $reflection->getConstructor();
        $this->assertNotNull($constructor);

        $class = Fixtures\EntityWithConstructor::class;
        $as = 'EntityProxy' . __LINE__;

        $declaration = new Declaration(new \ReflectionClass($class), $as);
        $output = $this->make($declaration);
        $output = ltrim($output, '<?php');

        $this->assertFalse(class_exists($declaration->class->getFullName()));

        eval($output);

        $reflection = new \ReflectionClass($declaration->class->getFullName());
        $constructor = $reflection->getConstructor();
        $this->assertNotNull($constructor);
    }

    public function testNotContainParentConstructor(): void

This method seems to be duplicated in your project.

    {
        $class = Fixtures\EntityWithoutConstructor::class;
        $as = 'EntityProxy' . __LINE__;

        $declaration = new Declaration(new \ReflectionClass($class), $as);
        $output = $this->make($declaration);
        $output = ltrim($output, '<?php');

        $this->assertFalse(class_exists($declaration->class->getFullName()));

        eval($output);

        $this->assertStringNotContainsString('parent::__construct();', $output);
    }

    public function testContainParentConstructor(): void

This method seems to be duplicated in your project.

    {
        $class = Fixtures\EntityWithConstructor::class;
        $as = 'EntityProxy' . __LINE__;

        $declaration = new Declaration(new \ReflectionClass($class), $as);
        $output = $this->make($declaration);
        $output = ltrim($output, '<?php');

        $this->assertFalse(class_exists($declaration->class->getFullName()));

        eval($output);

        $this->assertStringContainsString('parent::__construct();', $output);
    }

    public function testPromiseMethods(): void

This method seems to be duplicated in your project.

    {
        $class = Fixtures\Entity::class;
        $as = 'EntityProxy' . __LINE__;

        $declaration = new Declaration(new \ReflectionClass($class), $as);
        $output = $this->make($declaration);
        $output = ltrim($output, '<?php');

        $this->assertFalse(class_exists($declaration->class->getFullName()));

        eval($output);

        $i = new \ReflectionClass(PromiseInterface::class);
        foreach ($i->getMethods() as $method) {
            $this->assertStringContainsString("public function {$method->getName()}()", $output);

Consider using $method->name. There is an issue with getName() and APC-enabled PHP versions.

        }
    }

//    public function testInheritedProperties(): void
//    {
//    }

    public function testInheritedMethods(): void
    {
        $class = Fixtures\ChildEntity::class;
        $as = 'EntityProxy' . __LINE__;

        $reflection = new \ReflectionClass($class);

        $declaration = new Declaration($reflection, $as);
        $output = $this->make($declaration);
        $output = ltrim($output, '<?php');

        $this->assertFalse(class_exists($declaration->class->getFullName()));

        eval($output);

        $sourceMethods = [];

        //There're only public and protected methods inside
        foreach ($reflection->getMethods() as $method) {
            $sourceMethods[$method->getName()] = $method->isPublic() ? 'public' : 'protected';

Consider using $method->name. There is an issue with getName() and APC-enabled PHP versions.

        }

        /** @var \PhpParser\Node\Stmt\ClassMethod[] $methods */
        $methods = [];
        foreach ($this->getDeclaration($class)->methods as $method) {
            $methods[$method->name->name] = $method;
        }

        foreach ($sourceMethods as $name => $accessor) {
            $this->assertArrayHasKey($name, $methods, "Proxy class does not contain expected `{$name}` method");

            if ($accessor === 'public') {
                $this->assertTrue($methods[$name]->isPublic(), "Proxied method `{$name}` expected to be public");
                $this->assertStringContainsString("public function {$name}()", $output);
            } else {
                $this->assertTrue($methods[$name]->isProtected(), "Proxied method `{$name}` expected to be protected");
                $this->assertStringContainsString("protected function {$name}()", $output);
            }
        }

        foreach ($methods as $name => $method) {
            $this->assertArrayHasKey($name, $sourceMethods, "Origin class does not contain expected `{$name}` method");

            if ($method->isPublic()) {
                $this->assertEquals('public', $sourceMethods[$name], "Proxied method `{$name}` expected to be public");
            } elseif ($method->isProtected()) {
                $this->assertEquals('protected', $sourceMethods[$name], "Proxied method `{$name}` expected to be public");
            } else {
                throw new \UnexpectedValueException("\"{$method->name->toString()}\" method not found");
            }
        }
    }

    private function getDeclaration(string $class): Structure
    {
        return $this->extractor()->extract($class);
    }

    private function extractor(): Extractor
    {
        $container = new Container();

        return $container->get(Extractor::class);
    }

    /**
     * @param string $className
     * @param string $proxyFullName
     *
     * @return object
     */
    private function makeProxyObject(string $className, string $proxyFullName)
    {
        $orm = \Mockery::mock(ORMInterface::class);

        $container = new Container();
        $container->bind(ORMInterface::class, $orm);

        return $container->make($proxyFullName, ['role' => $className, 'scope' => []]);
    }

    private function make(Declaration $declaration): string
    {
        return $this->proxyCreator()->make($declaration);
    }

    private function proxyCreator(): ProxyPrinter
    {
        $container = new Container();
        $container->bind(PrettyPrinterAbstract::class, Standard::class);

        return $container->get(ProxyPrinter::class);
    }
}