Issues in AbstractBaseFactoryTest.php - Fixed Issues - Inspection of "Merge pull request #442 from malukenho/improve-tes..." - Ocramius/ProxyManager - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 6a6c80...a2c1e8 )

by Marco

created 2019-02-27 13:37 UTC

Factory/AbstractBaseFactoryTest.php (1 issue)

Labels

Bug 1

Severity

Major 1

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?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
 */
class AbstractBaseFactoryTest extends TestCase
{
    /**
     * Note: we mock the class in order to assert on the abstract method usage
     *
     * @var AbstractBaseFactory|MockObject
     */
    private $factory;

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

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

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

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

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

    /** @var ClassSignatureGeneratorInterface|MockObject */
    private $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
            ->expects(self::any())
            ->method('getClassNameInflector')
            ->will(self::returnValue($this->classNameInflector));

        $configuration
            ->expects(self::any())
            ->method('getGeneratorStrategy')
            ->will(self::returnValue($this->generatorStrategy));

        $configuration
            ->expects(self::any())
            ->method('getProxyAutoloader')
            ->will(self::returnValue($this->proxyAutoloader));

        $configuration
            ->expects(self::any())
            ->method('getSignatureChecker')
            ->will(self::returnValue($this->signatureChecker));

        $configuration
            ->expects(self::any())
            ->method('getClassSignatureGenerator')
            ->will(self::returnValue($this->classSignatureGenerator));

        $this
            ->classNameInflector
            ->expects(self::any())
            ->method('getUserClassName')
            ->will(self::returnValue('stdClass'));

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

        $this->factory->expects(self::any())->method('getGenerator')->will(self::returnValue($this->generator));
    }

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

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

        $this

            ->classNameInflector
            ->expects(self::any())
            ->method('getProxyClassName')
            ->with('stdClass')
            ->will(self::returnValue($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			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 $factory;
38
39			/** @var ProxyGeneratorInterface\|MockObject */
40			private $generator;
41
42			/** @var ClassNameInflectorInterface\|MockObject */
43			private $classNameInflector;
44
45			/** @var GeneratorStrategyInterface\|MockObject */
46			private $generatorStrategy;
47
48			/** @var AutoloaderInterface\|MockObject */
49			private $proxyAutoloader;
50
51			/** @var SignatureCheckerInterface\|MockObject */
52			private $signatureChecker;
53
54			/** @var ClassSignatureGeneratorInterface\|MockObject */
55			private $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			->expects(self::any())
72			->method('getClassNameInflector')
73			->will(self::returnValue($this->classNameInflector));
74
75			$configuration
76			->expects(self::any())
77			->method('getGeneratorStrategy')
78			->will(self::returnValue($this->generatorStrategy));
79
80			$configuration
81			->expects(self::any())
82			->method('getProxyAutoloader')
83			->will(self::returnValue($this->proxyAutoloader));
84
85			$configuration
86			->expects(self::any())
87			->method('getSignatureChecker')
88			->will(self::returnValue($this->signatureChecker));
89
90			$configuration
91			->expects(self::any())
92			->method('getClassSignatureGenerator')
93			->will(self::returnValue($this->classSignatureGenerator));
94
95			$this
96			->classNameInflector
97			->expects(self::any())
98			->method('getUserClassName')
99			->will(self::returnValue('stdClass'));
100
101			$this->factory = $this->getMockForAbstractClass(AbstractBaseFactory::class, [$configuration]);
102
103			$this->factory->expects(self::any())->method('getGenerator')->will(self::returnValue($this->generator));
104			}
105
106			public function testGeneratesClass() : void
107			{
108			$generateProxy = new ReflectionMethod($this->factory, 'generateProxy');
109
110			$generateProxy->setAccessible(true);
111			$generatedClass = UniqueIdentifierGenerator::getIdentifier('fooBar');
112
113			$this
			0 ignored issues – show Bug introduced 2017-05-04 11:54 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `expects()` does not seem to exist on `object<ProxyManager\Infl...NameInflectorInterface>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
114			->classNameInflector
115			->expects(self::any())
116			->method('getProxyClassName')
117			->with('stdClass')
118			->will(self::returnValue($generatedClass));
119
120			$this
121			->generatorStrategy
122			->expects(self::once())
123			->method('generate')
124			->with(self::isInstanceOf(ClassGenerator::class));
125			$this
126			->proxyAutoloader
127			->expects(self::once())
128			->method('__invoke')
129			->with($generatedClass)
130			->will(self::returnCallback(static function ($className) : bool {
131			eval('class ' . $className . ' {}');
132
133			return true;
134			}));
135
136			$this->signatureChecker->expects(self::atLeastOnce())->method('checkSignature');
137			$this->classSignatureGenerator->expects(self::once())->method('addSignature')->will(self::returnArgument(0));
138			$this
139			->generator
140			->expects(self::once())
141			->method('generate')
142			->with(
143			self::callback(static function (ReflectionClass $reflectionClass) : bool {
144			return $reflectionClass->getName() === 'stdClass';
145			}),
146			self::isInstanceOf(ClassGenerator::class),
147			['some' => 'proxy', 'options' => 'here']
148			);
149
150			self::assertSame(
151			$generatedClass,
152			$generateProxy->invoke($this->factory, stdClass::class, ['some' => 'proxy', 'options' => 'here'])
153			);
154			self::assertTrue(class_exists($generatedClass, false));
155			self::assertSame(
156			$generatedClass,
157			$generateProxy->invoke($this->factory, stdClass::class, ['some' => 'proxy', 'options' => 'here'])
158			);
159			}
160			}
161

Ocramius / ProxyManager

Push — master ( 6a6c80...a2c1e8 )

Factory/AbstractBaseFactoryTest.php (1 issue)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like