LazyLoadingValueHolderFactoryTest::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

LazyLoadingValueHolderFactoryTest::testWillTryAutoGeneration() B

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	61
rs	8.8509
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\LazyLoadingValueHolderFactory;
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\EmptyClass;
use ProxyManagerTestAsset\LazyLoadingMock;
use function get_class;

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


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

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

    /** @var Configuration&MockObject */
    private 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\LazyLoadingValueHolderFactory::__construct
     */
    public static function testWithOptionalFactory() : void
    {
        $factory = new LazyLoadingValueHolderFactory();

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

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

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

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

        $factory     = new LazyLoadingValueHolderFactory($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\LazyLoadingValueHolderFactory::__construct
     * @covers \ProxyManager\Factory\LazyLoadingValueHolderFactory::createProxy
     * @covers \ProxyManager\Factory\LazyLoadingValueHolderFactory::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')->will(self::returnValue($generator));
        $this->config->method('getProxyAutoloader')->will(self::returnValue($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(EmptyClass::class);

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

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

        /** @noinspection UnnecessaryAssertionInspection */
        self::assertInstanceOf($proxyClassName, $proxy);

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

Ocramius / ProxyManager

Push — master ( 3be072...ba2d3a )

LazyLoadingValueHolderFactoryTest::testWillTryAutoGeneration() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like