AbstractBaseFactoryTest::testGeneratesClass() - Code Metrics - Inspection of "Merge pull request #453 from Ocramius/feature/bump..." - Ocramius/ProxyManager - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3be072...ba2d3a )

by Marco

created 2019-03-20 14:52 UTC

AbstractBaseFactoryTest::testGeneratesClass() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	53
rs	9.0254
c	0
b	0
f	0
cc	1
nc	1
nop	0

How to fix Long Method

<?php

declare(strict_types=1);

namespace ProxyManagerTest\Factory;

use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use ProxyManager\Autoloader\AutoloaderInterface;
use ProxyManager\Configuration;
use ProxyManager\Factory\AbstractBaseFactory;
use ProxyManager\Generator\Util\UniqueIdentifierGenerator;
use ProxyManager\GeneratorStrategy\GeneratorStrategyInterface;
use ProxyManager\Inflector\ClassNameInflectorInterface;
use ProxyManager\ProxyGenerator\ProxyGeneratorInterface;
use ProxyManager\Signature\ClassSignatureGeneratorInterface;
use ProxyManager\Signature\SignatureCheckerInterface;
use ReflectionClass;
use ReflectionMethod;
use stdClass;
use Zend\Code\Generator\ClassGenerator;
use function class_exists;

/**
 * Tests for {@see \ProxyManager\Factory\AbstractBaseFactory}
 *
 * @covers \ProxyManager\Factory\AbstractBaseFactory
 * @group Coverage
 */
final class AbstractBaseFactoryTest extends TestCase
{
    /**
     * Note: we mock the class in order to assert on the abstract method usage
     *
     * @var AbstractBaseFactory|MockObject
     */
    private AbstractBaseFactory $factory;


    /** @var ProxyGeneratorInterface&MockObject */
    private ProxyGeneratorInterface $generator;

    /** @var ClassNameInflectorInterface&MockObject */
    private ClassNameInflectorInterface $classNameInflector;

    /** @var GeneratorStrategyInterface&MockObject */
    private GeneratorStrategyInterface $generatorStrategy;

    /** @var AutoloaderInterface&MockObject */
    private AutoloaderInterface $proxyAutoloader;

    /** @var SignatureCheckerInterface&MockObject */
    private SignatureCheckerInterface $signatureChecker;

    /** @var ClassSignatureGeneratorInterface&MockObject */
    private ClassSignatureGeneratorInterface $classSignatureGenerator;

    /**
     * {@inheritDoc}
     */
    protected function setUp() : void
    {
        $configuration                 = $this->createMock(Configuration::class);
        $this->generator               = $this->createMock(ProxyGeneratorInterface::class);
        $this->classNameInflector      = $this->createMock(ClassNameInflectorInterface::class);
        $this->generatorStrategy       = $this->createMock(GeneratorStrategyInterface::class);
        $this->proxyAutoloader         = $this->createMock(AutoloaderInterface::class);
        $this->signatureChecker        = $this->createMock(SignatureCheckerInterface::class);
        $this->classSignatureGenerator = $this->createMock(ClassSignatureGeneratorInterface::class);

        $configuration
            ->method('getClassNameInflector')
            ->willReturn($this->classNameInflector);

        $configuration
            ->method('getGeneratorStrategy')
            ->willReturn($this->generatorStrategy);

        $configuration
            ->method('getProxyAutoloader')
            ->willReturn($this->proxyAutoloader);

        $configuration
            ->method('getSignatureChecker')
            ->willReturn($this->signatureChecker);

        $configuration
            ->method('getClassSignatureGenerator')
            ->willReturn($this->classSignatureGenerator);

        $this
            ->classNameInflector
            ->method('getUserClassName')
            ->willReturn('stdClass');

        $this->factory = $this->getMockForAbstractClass(AbstractBaseFactory::class, [$configuration]);

        $this->factory->method('getGenerator')->willReturn($this->generator);
    }

    public function testGeneratesClass() : void
    {
        $generateProxy = new ReflectionMethod($this->factory, 'generateProxy');

        $generateProxy->setAccessible(true);
        $generatedClass = UniqueIdentifierGenerator::getIdentifier('fooBar');

        $this
            ->classNameInflector
            ->method('getProxyClassName')
            ->with('stdClass')
            ->willReturn($generatedClass);

        $this
            ->generatorStrategy
            ->expects(self::once())
            ->method('generate')
            ->with(self::isInstanceOf(ClassGenerator::class));
        $this
            ->proxyAutoloader
            ->expects(self::once())
            ->method('__invoke')
            ->with($generatedClass)
            ->will(self::returnCallback(static function ($className) : bool {
                eval('class ' . $className . ' {}');

                return true;
            }));

        $this->signatureChecker->expects(self::atLeastOnce())->method('checkSignature');
        $this->classSignatureGenerator->expects(self::once())->method('addSignature')->will(self::returnArgument(0));
        $this
            ->generator
            ->expects(self::once())
            ->method('generate')
            ->with(
                self::callback(static function (ReflectionClass $reflectionClass) : bool {
                    return $reflectionClass->getName() === 'stdClass';
                }),
                self::isInstanceOf(ClassGenerator::class),
                ['some' => 'proxy', 'options' => 'here']
            );

        self::assertSame(
            $generatedClass,
            $generateProxy->invoke($this->factory, stdClass::class, ['some' => 'proxy', 'options' => 'here'])
        );
        self::assertTrue(class_exists($generatedClass, false));
        self::assertSame(
            $generatedClass,
            $generateProxy->invoke($this->factory, stdClass::class, ['some' => 'proxy', 'options' => 'here'])
        );
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace ProxyManagerTest\Factory;
6
7			use PHPUnit\Framework\MockObject\MockObject;
8			use PHPUnit\Framework\TestCase;
9			use ProxyManager\Autoloader\AutoloaderInterface;
10			use ProxyManager\Configuration;
11			use ProxyManager\Factory\AbstractBaseFactory;
12			use ProxyManager\Generator\Util\UniqueIdentifierGenerator;
13			use ProxyManager\GeneratorStrategy\GeneratorStrategyInterface;
14			use ProxyManager\Inflector\ClassNameInflectorInterface;
15			use ProxyManager\ProxyGenerator\ProxyGeneratorInterface;
16			use ProxyManager\Signature\ClassSignatureGeneratorInterface;
17			use ProxyManager\Signature\SignatureCheckerInterface;
18			use ReflectionClass;
19			use ReflectionMethod;
20			use stdClass;
21			use Zend\Code\Generator\ClassGenerator;
22			use function class_exists;
23
24			/**
25			* Tests for {@see \ProxyManager\Factory\AbstractBaseFactory}
26			*
27			* @covers \ProxyManager\Factory\AbstractBaseFactory
28			* @group Coverage
29			*/
30			final class AbstractBaseFactoryTest extends TestCase
31			{
32			/**
33			* Note: we mock the class in order to assert on the abstract method usage
34			*
35			* @var AbstractBaseFactory\|MockObject
36			*/
37			private AbstractBaseFactory $factory;
			0 ignored issues – show Bug introduced 2019-03-20 18:22 UTC by Report Bug Copy Issue Report This code did not parse for me. Apparently, there is an error somewhere around this line: Syntax error, unexpected T_STRING, expecting T_FUNCTION or T_CONST Loading history...
38
39			/** @var ProxyGeneratorInterface&MockObject */
40			private ProxyGeneratorInterface $generator;
41
42			/** @var ClassNameInflectorInterface&MockObject */
43			private ClassNameInflectorInterface $classNameInflector;
44
45			/** @var GeneratorStrategyInterface&MockObject */
46			private GeneratorStrategyInterface $generatorStrategy;
47
48			/** @var AutoloaderInterface&MockObject */
49			private AutoloaderInterface $proxyAutoloader;
50
51			/** @var SignatureCheckerInterface&MockObject */
52			private SignatureCheckerInterface $signatureChecker;
53
54			/** @var ClassSignatureGeneratorInterface&MockObject */
55			private ClassSignatureGeneratorInterface $classSignatureGenerator;
56
57			/**
58			* {@inheritDoc}
59			*/
60			protected function setUp() : void
61			{
62			$configuration = $this->createMock(Configuration::class);
63			$this->generator = $this->createMock(ProxyGeneratorInterface::class);
64			$this->classNameInflector = $this->createMock(ClassNameInflectorInterface::class);
65			$this->generatorStrategy = $this->createMock(GeneratorStrategyInterface::class);
66			$this->proxyAutoloader = $this->createMock(AutoloaderInterface::class);
67			$this->signatureChecker = $this->createMock(SignatureCheckerInterface::class);
68			$this->classSignatureGenerator = $this->createMock(ClassSignatureGeneratorInterface::class);
69
70			$configuration
71			->method('getClassNameInflector')
72			->willReturn($this->classNameInflector);
73
74			$configuration
75			->method('getGeneratorStrategy')
76			->willReturn($this->generatorStrategy);
77
78			$configuration
79			->method('getProxyAutoloader')
80			->willReturn($this->proxyAutoloader);
81
82			$configuration
83			->method('getSignatureChecker')
84			->willReturn($this->signatureChecker);
85
86			$configuration
87			->method('getClassSignatureGenerator')
88			->willReturn($this->classSignatureGenerator);
89
90			$this
91			->classNameInflector
92			->method('getUserClassName')
93			->willReturn('stdClass');
94
95			$this->factory = $this->getMockForAbstractClass(AbstractBaseFactory::class, [$configuration]);
96
97			$this->factory->method('getGenerator')->willReturn($this->generator);
98			}
99
100			public function testGeneratesClass() : void
101			{
102			$generateProxy = new ReflectionMethod($this->factory, 'generateProxy');
103
104			$generateProxy->setAccessible(true);
105			$generatedClass = UniqueIdentifierGenerator::getIdentifier('fooBar');
106
107			$this
108			->classNameInflector
109			->method('getProxyClassName')
110			->with('stdClass')
111			->willReturn($generatedClass);
112
113			$this
114			->generatorStrategy
115			->expects(self::once())
116			->method('generate')
117			->with(self::isInstanceOf(ClassGenerator::class));
118			$this
119			->proxyAutoloader
120			->expects(self::once())
121			->method('__invoke')
122			->with($generatedClass)
123			->will(self::returnCallback(static function ($className) : bool {
124			eval('class ' . $className . ' {}');
125
126			return true;
127			}));
128
129			$this->signatureChecker->expects(self::atLeastOnce())->method('checkSignature');
130			$this->classSignatureGenerator->expects(self::once())->method('addSignature')->will(self::returnArgument(0));
131			$this
132			->generator
133			->expects(self::once())
134			->method('generate')
135			->with(
136			self::callback(static function (ReflectionClass $reflectionClass) : bool {
137			return $reflectionClass->getName() === 'stdClass';
138			}),
139			self::isInstanceOf(ClassGenerator::class),
140			['some' => 'proxy', 'options' => 'here']
141			);
142
143			self::assertSame(
144			$generatedClass,
145			$generateProxy->invoke($this->factory, stdClass::class, ['some' => 'proxy', 'options' => 'here'])
146			);
147			self::assertTrue(class_exists($generatedClass, false));
148			self::assertSame(
149			$generatedClass,
150			$generateProxy->invoke($this->factory, stdClass::class, ['some' => 'proxy', 'options' => 'here'])
151			);
152			}
153			}
154

Ocramius / ProxyManager

Push — master ( 3be072...ba2d3a )

AbstractBaseFactoryTest::testGeneratesClass() A

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like