LazyLoadingGhostFactoryTest::testWillTryAutoGeneration() - 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

LazyLoadingGhostFactoryTest::testWillTryAutoGeneration() B

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	57
rs	8.9381
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\LazyLoadingGhostFactory;
use ProxyManager\Generator\ClassGenerator;
use ProxyManager\Generator\Util\UniqueIdentifierGenerator;
use ProxyManager\GeneratorStrategy\GeneratorStrategyInterface;
use ProxyManager\Inflector\ClassNameInflectorInterface;
use ProxyManager\Signature\ClassSignatureGeneratorInterface;
use ProxyManager\Signature\SignatureCheckerInterface;
use ProxyManagerTest\Assert;
use ProxyManagerTestAsset\LazyLoadingMock;

/**
 * Tests for {@see \ProxyManager\Factory\LazyLoadingGhostFactory}
 *
 * @group Coverage
 */
final class LazyLoadingGhostFactoryTest extends TestCase
{
    /** @var ClassNameInflectorInterface&MockObject */
    protected ClassNameInflectorInterface $inflector;


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

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

    /** @var Configuration&MockObject */
    protected Configuration $config;

    /**
     * {@inheritDoc}
     */
    protected function setUp() : void
    {
        $this->config                  = $this->createMock(Configuration::class);
        $this->inflector               = $this->createMock(ClassNameInflectorInterface::class);
        $this->signatureChecker        = $this->createMock(SignatureCheckerInterface::class);
        $this->classSignatureGenerator = $this->createMock(ClassSignatureGeneratorInterface::class);

        $this
            ->config
            ->method('getClassNameInflector')
            ->willReturn($this->inflector);

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

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

    /**
     * {@inheritDoc}
     *
     * @covers \ProxyManager\Factory\LazyLoadingGhostFactory::__construct
     */
    public static function testWithOptionalFactory() : void
    {
        $factory = new LazyLoadingGhostFactory();

        $configuration = Assert::readAttribute($factory, 'configuration');

        self::assertNotEmpty($configuration);
        self::assertInstanceOf(Configuration::class, $configuration);
    }

    /**
     * {@inheritDoc}
     *
     * @covers \ProxyManager\Factory\LazyLoadingGhostFactory::__construct
     * @covers \ProxyManager\Factory\LazyLoadingGhostFactory::createProxy
     */
    public function testWillSkipAutoGeneration() : void
    {
        $className = UniqueIdentifierGenerator::getIdentifier('foo');

        $this
            ->inflector
            ->expects(self::once())
            ->method('getProxyClassName')
            ->with($className)
            ->willReturn(LazyLoadingMock::class);

        $factory     = new LazyLoadingGhostFactory($this->config);
        $initializer = static function () : void {
        };
        /** @var LazyLoadingMock $proxy */
        $proxy = $factory->createProxy($className, $initializer);

        self::assertInstanceOf(LazyLoadingMock::class, $proxy);
        self::assertSame($initializer, $proxy->initializer);
    }

    /**
     * {@inheritDoc}
     *
     * @covers \ProxyManager\Factory\LazyLoadingGhostFactory::__construct
     * @covers \ProxyManager\Factory\LazyLoadingGhostFactory::createProxy
     * @covers \ProxyManager\Factory\LazyLoadingGhostFactory::getGenerator
     *
     * NOTE: serious mocking going on in here (a class is generated on-the-fly) - careful
     */
    public function testWillTryAutoGeneration() : void
    {
        $className      = UniqueIdentifierGenerator::getIdentifier('foo');
        $proxyClassName = UniqueIdentifierGenerator::getIdentifier('bar');
        $generator      = $this->createMock(GeneratorStrategyInterface::class);
        $autoloader     = $this->createMock(AutoloaderInterface::class);

        $this->config->method('getGeneratorStrategy')->willReturn($generator);
        $this->config->method('getProxyAutoloader')->willReturn($autoloader);

        $generator
            ->expects(self::once())
            ->method('generate')
            ->with(
                self::callback(
                    static function (ClassGenerator $targetClass) use ($proxyClassName) : bool {
                        return $targetClass->getName() === $proxyClassName;
                    }
                )
            );

        // simulate autoloading
        $autoloader
            ->expects(self::once())
            ->method('__invoke')
            ->with($proxyClassName)
            ->willReturnCallback(static function () use ($proxyClassName) : bool {
                eval('class ' . $proxyClassName . ' extends \\ProxyManagerTestAsset\\LazyLoadingMock {}');

                return true;
            });

        $this
            ->inflector
            ->expects(self::once())
            ->method('getProxyClassName')
            ->with($className)
            ->willReturn($proxyClassName);

        $this
            ->inflector
            ->expects(self::once())
            ->method('getUserClassName')
            ->with($className)
            ->willReturn(LazyLoadingMock::class);

        $this->signatureChecker->expects(self::atLeastOnce())->method('checkSignature');
        $this->classSignatureGenerator->expects(self::once())->method('addSignature')->will(self::returnArgument(0));

        $factory     = new LazyLoadingGhostFactory($this->config);
        $initializer = static function () : void {
        };
        /** @var LazyLoadingMock $proxy */
        $proxy = $factory->createProxy($className, $initializer);

        self::assertSame($initializer, $proxy->initializer);
    }
}


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\LazyLoadingGhostFactory;
12			use ProxyManager\Generator\ClassGenerator;
13			use ProxyManager\Generator\Util\UniqueIdentifierGenerator;
14			use ProxyManager\GeneratorStrategy\GeneratorStrategyInterface;
15			use ProxyManager\Inflector\ClassNameInflectorInterface;
16			use ProxyManager\Signature\ClassSignatureGeneratorInterface;
17			use ProxyManager\Signature\SignatureCheckerInterface;
18			use ProxyManagerTest\Assert;
19			use ProxyManagerTestAsset\LazyLoadingMock;
20
21			/**
22			* Tests for {@see \ProxyManager\Factory\LazyLoadingGhostFactory}
23			*
24			* @group Coverage
25			*/
26			final class LazyLoadingGhostFactoryTest extends TestCase
27			{
28			/** @var ClassNameInflectorInterface&MockObject */
29			protected ClassNameInflectorInterface $inflector;
			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...
30
31			/** @var SignatureCheckerInterface&MockObject */
32			protected SignatureCheckerInterface $signatureChecker;
33
34			/** @var ClassSignatureGeneratorInterface&MockObject */
35			private ClassSignatureGeneratorInterface $classSignatureGenerator;
36
37			/** @var Configuration&MockObject */
38			protected Configuration $config;
39
40			/**
41			* {@inheritDoc}
42			*/
43			protected function setUp() : void
44			{
45			$this->config = $this->createMock(Configuration::class);
46			$this->inflector = $this->createMock(ClassNameInflectorInterface::class);
47			$this->signatureChecker = $this->createMock(SignatureCheckerInterface::class);
48			$this->classSignatureGenerator = $this->createMock(ClassSignatureGeneratorInterface::class);
49
50			$this
51			->config
52			->method('getClassNameInflector')
53			->willReturn($this->inflector);
54
55			$this
56			->config
57			->method('getSignatureChecker')
58			->willReturn($this->signatureChecker);
59
60			$this
61			->config
62			->method('getClassSignatureGenerator')
63			->willReturn($this->classSignatureGenerator);
64			}
65
66			/**
67			* {@inheritDoc}
68			*
69			* @covers \ProxyManager\Factory\LazyLoadingGhostFactory::__construct
70			*/
71			public static function testWithOptionalFactory() : void
72			{
73			$factory = new LazyLoadingGhostFactory();
74
75			$configuration = Assert::readAttribute($factory, 'configuration');
76
77			self::assertNotEmpty($configuration);
78			self::assertInstanceOf(Configuration::class, $configuration);
79			}
80
81			/**
82			* {@inheritDoc}
83			*
84			* @covers \ProxyManager\Factory\LazyLoadingGhostFactory::__construct
85			* @covers \ProxyManager\Factory\LazyLoadingGhostFactory::createProxy
86			*/
87			public function testWillSkipAutoGeneration() : void
88			{
89			$className = UniqueIdentifierGenerator::getIdentifier('foo');
90
91			$this
92			->inflector
93			->expects(self::once())
94			->method('getProxyClassName')
95			->with($className)
96			->willReturn(LazyLoadingMock::class);
97
98			$factory = new LazyLoadingGhostFactory($this->config);
99			$initializer = static function () : void {
100			};
101			/** @var LazyLoadingMock $proxy */
102			$proxy = $factory->createProxy($className, $initializer);
103
104			self::assertInstanceOf(LazyLoadingMock::class, $proxy);
105			self::assertSame($initializer, $proxy->initializer);
106			}
107
108			/**
109			* {@inheritDoc}
110			*
111			* @covers \ProxyManager\Factory\LazyLoadingGhostFactory::__construct
112			* @covers \ProxyManager\Factory\LazyLoadingGhostFactory::createProxy
113			* @covers \ProxyManager\Factory\LazyLoadingGhostFactory::getGenerator
114			*
115			* NOTE: serious mocking going on in here (a class is generated on-the-fly) - careful
116			*/
117			public function testWillTryAutoGeneration() : void
118			{
119			$className = UniqueIdentifierGenerator::getIdentifier('foo');
120			$proxyClassName = UniqueIdentifierGenerator::getIdentifier('bar');
121			$generator = $this->createMock(GeneratorStrategyInterface::class);
122			$autoloader = $this->createMock(AutoloaderInterface::class);
123
124			$this->config->method('getGeneratorStrategy')->willReturn($generator);
125			$this->config->method('getProxyAutoloader')->willReturn($autoloader);
126
127			$generator
128			->expects(self::once())
129			->method('generate')
130			->with(
131			self::callback(
132			static function (ClassGenerator $targetClass) use ($proxyClassName) : bool {
133			return $targetClass->getName() === $proxyClassName;
134			}
135			)
136			);
137
138			// simulate autoloading
139			$autoloader
140			->expects(self::once())
141			->method('__invoke')
142			->with($proxyClassName)
143			->willReturnCallback(static function () use ($proxyClassName) : bool {
144			eval('class ' . $proxyClassName . ' extends \\ProxyManagerTestAsset\\LazyLoadingMock {}');
145
146			return true;
147			});
148
149			$this
150			->inflector
151			->expects(self::once())
152			->method('getProxyClassName')
153			->with($className)
154			->willReturn($proxyClassName);
155
156			$this
157			->inflector
158			->expects(self::once())
159			->method('getUserClassName')
160			->with($className)
161			->willReturn(LazyLoadingMock::class);
162
163			$this->signatureChecker->expects(self::atLeastOnce())->method('checkSignature');
164			$this->classSignatureGenerator->expects(self::once())->method('addSignature')->will(self::returnArgument(0));
165
166			$factory = new LazyLoadingGhostFactory($this->config);
167			$initializer = static function () : void {
168			};
169			/** @var LazyLoadingMock $proxy */
170			$proxy = $factory->createProxy($className, $initializer);
171
172			self::assertSame($initializer, $proxy->initializer);
173			}
174			}
175

Ocramius / ProxyManager

Push — master ( 3be072...ba2d3a )

LazyLoadingGhostFactoryTest::testWillTryAutoGeneration() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like