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

RemoteObjectFactoryTest::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\RemoteObject\AdapterInterface;
use ProxyManager\Factory\RemoteObjectFactory;
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 ProxyManagerTestAsset\BaseInterface;
use ProxyManagerTestAsset\RemoteProxy\RemoteObjectMock;
use stdClass;

/**
 * Tests for {@see \ProxyManager\Factory\RemoteObjectFactory}
 *
 * @group Coverage
 */
final class RemoteObjectFactoryTest 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\RemoteObjectFactory::__construct
     * @covers \ProxyManager\Factory\RemoteObjectFactory::createProxy
     * @covers \ProxyManager\Factory\RemoteObjectFactory::getGenerator
     */
    public function testWillSkipAutoGeneration() : void
    {
        $this
            ->inflector
            ->expects(self::once())
            ->method('getProxyClassName')
            ->with(BaseInterface::class)
            ->willReturn(RemoteObjectMock::class);

        /** @var AdapterInterface&MockObject $adapter */
        $adapter = $this->createMock(AdapterInterface::class);
        $factory = new RemoteObjectFactory($adapter, $this->config);
        /** @var stdClass|RemoteObjectMock $proxy */
        $proxy = $factory->createProxy(BaseInterface::class);

        self::assertInstanceOf(RemoteObjectMock::class, $proxy);
    }

    /**
     * {@inheritDoc}
     *
     * @covers \ProxyManager\Factory\RemoteObjectFactory::__construct
     * @covers \ProxyManager\Factory\RemoteObjectFactory::createProxy
     * @covers \ProxyManager\Factory\RemoteObjectFactory::getGenerator
     *
     * NOTE: serious mocking going on in here (a class is generated on-the-fly) - careful
     */
    public function testWillTryAutoGeneration() : void
    {
        $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 . ' implements \ProxyManager\Proxy\RemoteObjectInterface {'
                    . 'public static function staticProxyConstructor() : self { return new static(); }'
                    . '}'
                );

                return true;
            });

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

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

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

        /** @var AdapterInterface $adapter */
        $adapter = $this->createMock(AdapterInterface::class);
        $factory = new RemoteObjectFactory($adapter, $this->config);
        $factory->createProxy(BaseInterface::class);
    }
}


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\RemoteObject\AdapterInterface;
12			use ProxyManager\Factory\RemoteObjectFactory;
13			use ProxyManager\Generator\ClassGenerator;
14			use ProxyManager\Generator\Util\UniqueIdentifierGenerator;
15			use ProxyManager\GeneratorStrategy\GeneratorStrategyInterface;
16			use ProxyManager\Inflector\ClassNameInflectorInterface;
17			use ProxyManager\Signature\ClassSignatureGeneratorInterface;
18			use ProxyManager\Signature\SignatureCheckerInterface;
19			use ProxyManagerTestAsset\BaseInterface;
20			use ProxyManagerTestAsset\RemoteProxy\RemoteObjectMock;
21			use stdClass;
22
23			/**
24			* Tests for {@see \ProxyManager\Factory\RemoteObjectFactory}
25			*
26			* @group Coverage
27			*/
28			final class RemoteObjectFactoryTest 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\RemoteObjectFactory::__construct
72			* @covers \ProxyManager\Factory\RemoteObjectFactory::createProxy
73			* @covers \ProxyManager\Factory\RemoteObjectFactory::getGenerator
74			*/
75			public function testWillSkipAutoGeneration() : void
76			{
77			$this
78			->inflector
79			->expects(self::once())
80			->method('getProxyClassName')
81			->with(BaseInterface::class)
82			->willReturn(RemoteObjectMock::class);
83
84			/** @var AdapterInterface&MockObject $adapter */
85			$adapter = $this->createMock(AdapterInterface::class);
86			$factory = new RemoteObjectFactory($adapter, $this->config);
87			/** @var stdClass\|RemoteObjectMock $proxy */
88			$proxy = $factory->createProxy(BaseInterface::class);
89
90			self::assertInstanceOf(RemoteObjectMock::class, $proxy);
91			}
92
93			/**
94			* {@inheritDoc}
95			*
96			* @covers \ProxyManager\Factory\RemoteObjectFactory::__construct
97			* @covers \ProxyManager\Factory\RemoteObjectFactory::createProxy
98			* @covers \ProxyManager\Factory\RemoteObjectFactory::getGenerator
99			*
100			* NOTE: serious mocking going on in here (a class is generated on-the-fly) - careful
101			*/
102			public function testWillTryAutoGeneration() : void
103			{
104			$proxyClassName = UniqueIdentifierGenerator::getIdentifier('bar');
105			$generator = $this->createMock(GeneratorStrategyInterface::class);
106			$autoloader = $this->createMock(AutoloaderInterface::class);
107
108			$this->config->method('getGeneratorStrategy')->willReturn($generator);
109			$this->config->method('getProxyAutoloader')->willReturn($autoloader);
110
111			$generator
112			->expects(self::once())
113			->method('generate')
114			->with(
115			self::callback(
116			static function (ClassGenerator $targetClass) use ($proxyClassName) : bool {
117			return $targetClass->getName() === $proxyClassName;
118			}
119			)
120			);
121
122			// simulate autoloading
123			$autoloader
124			->expects(self::once())
125			->method('__invoke')
126			->with($proxyClassName)
127			->willReturnCallback(static function () use ($proxyClassName) : bool {
128			eval(
129			'class ' . $proxyClassName . ' implements \ProxyManager\Proxy\RemoteObjectInterface {'
130			. 'public static function staticProxyConstructor() : self { return new static(); }'
131			. '}'
132			);
133
134			return true;
135			});
136
137			$this
138			->inflector
139			->expects(self::once())
140			->method('getProxyClassName')
141			->with(BaseInterface::class)
142			->willReturn($proxyClassName);
143
144			$this
145			->inflector
146			->expects(self::once())
147			->method('getUserClassName')
148			->with(BaseInterface::class)
149			->willReturn('stdClass');
150
151			$this->signatureChecker->expects(self::atLeastOnce())->method('checkSignature');
152			$this->classSignatureGenerator->expects(self::once())->method('addSignature')->will(self::returnArgument(0));
153
154			/** @var AdapterInterface $adapter */
155			$adapter = $this->createMock(AdapterInterface::class);
156			$factory = new RemoteObjectFactory($adapter, $this->config);
157			$factory->createProxy(BaseInterface::class);
158			}
159			}
160

Ocramius / ProxyManager

Push — master ( 3be072...ba2d3a )

RemoteObjectFactoryTest::testWillTryAutoGeneration() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like