Issues in MokaMockingStrategyTestCase.php - New Issues - Inspection of "Merge pull request #17 from facile-it/feature/plug..." - facile-it/moka - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 77f1a4...b8ad13 )

by Angelo

created 2017-06-26 10:07 UTC

src/Moka/Tests/MokaMockingStrategyTestCase.php (2 issues)

Showing only issues like (Show All)

Check for mismatching type of a variable.

Bug Minor

Alberto Villa 2

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 Moka\Tests;

use Moka\Exception\InvalidArgumentException;
use Moka\Factory\StubFactory;
use Moka\Strategy\MockingStrategyInterface;
use Moka\Stub\StubSet;
use PHPUnit\Framework\TestCase;
use Tests\AbstractTestClass;
use Tests\BarTestClass;
use Tests\FooTestClass;
use Tests\TestInterface;

abstract class MokaMockingStrategyTestCase extends TestCase
{
    /**
     * @var MockingStrategyInterface
     */
    protected $strategy;

    /**
     * @var object
     */
    protected $mock;

    /**
     * @var StubSet
     */
    protected $stubs;

    /**
     * @var string
     */
    private $className;

    /**
     * @var array
     */
    private $methodsWithValues = [];

    private $methodName;

    final public function testGetMockTypeSuccess()
    {
        $this->assertInternalType('string', $this->strategy->getMockType());
    }

    final public function testBuildClassSuccess()
    {
        $this->assertInstanceOf($this->strategy->getMockType(), $this->mock);
    }

    final public function testBuildInterfaceSuccess()
    {
        $mock = $this->strategy->build(TestInterface::class);

        $this->assertInstanceOf($this->strategy->getMockType(), $mock);
    }

    final public function testBuildAbstractClassSuccess()
    {
        $mock = $this->strategy->build(AbstractTestClass::class);

        $this->assertInstanceOf($this->strategy->getMockType(), $mock);
    }

    final public function testDecorateFailure()
    {
        $this->expectException(InvalidArgumentException::class);

        $this->strategy->decorate(new \stdClass(), $this->stubs);
    }

    final public function testDecorateWrongTypeHintFailure()
    {
        $this->strategy->decorate($this->mock, StubFactory::fromArray([

            'getSelf' => mt_rand()
        ]));

        $this->expectException(\TypeError::class);
        $this->strategy->get($this->mock)->getSelf();
    }

    final public function testDecorateSingleCallSuccess()
    {
        $this->assertSame($this->methodsWithValues['isTrue'], $this->strategy->get($this->mock)->isTrue());

        $this->expectException(\Exception::class);
        $this->expectExceptionMessage($this->methodsWithValues['throwException']->getMessage());
        $this->strategy->get($this->mock)->throwException();
    }

    final public function testDecorateMultipleCallsSuccess()
    {
        $this->assertSame($this->methodsWithValues['getInt'], $this->strategy->get($this->mock)->getInt());
        $this->assertSame($this->methodsWithValues['getInt'], $this->strategy->get($this->mock)->getInt());
    }

    final public function testDecorateOverriddenCallsFailure()
    {
        $this->strategy->decorate($this->mock, StubFactory::fromArray([

            'getInt' => mt_rand(),
            'throwException' => mt_rand()
        ]));

        $this->assertSame($this->methodsWithValues['getInt'], $this->strategy->get($this->mock)->getInt());
        $this->assertSame($this->methodsWithValues['getInt'], $this->strategy->get($this->mock)->getInt());

        $this->expectException(\Exception::class);
        $this->expectExceptionMessage($this->methodsWithValues['throwException']->getMessage());
        $this->strategy->get($this->mock)->throwException();
    }

    final public function testDecorateCallWithArgumentSuccess()
    {
        $this->assertSame($this->methodsWithValues['withArgument'], $this->strategy->get($this->mock)->withArgument(mt_rand()));
    }

    final public function testDecorateCallWithMissingArgumentFailure()
    {
        $this->expectException(\Error::class);

        $this->strategy->get($this->mock)->withArgument();
    }

    final public function testDecorateCallWithWrongArgumentFailure()
    {
        $this->expectException(\TypeError::class);

        $this->strategy->get($this->mock)->withArgument('string');
    }

    final public function testGetSuccess()
    {
        $this->assertInstanceOf($this->className, $this->strategy->get($this->mock));
    }

    final public function testGetFailure()
    {
        $this->expectException(InvalidArgumentException::class);

        $this->strategy->get(new \stdClass());
    }

    public function testMethodForward()
    {
        if (!$this->methodName) {
            return;
        }

        try {
            $this->strategy->build(\stdClass::class)->{$this->methodName}();
            $this->assertTrue(true);
        } catch (\Error $e) {
            $this->assertEquals(0, preg_match('/^Call to undefined method/', $e->getMessage()));
        }
    }

    protected function setUp()
    {
        $this->className = [
            FooTestClass::class,
            BarTestClass::class
        ][random_int(0, 1)];

        $this->methodsWithValues = [
            'isTrue' => !!random_int(0, 1),
            'getInt' => mt_rand(),
            'withArgument' => mt_rand(),
            'throwException' => new \Exception('' . mt_rand())
        ];

        $this->mock = $this->strategy->build($this->className);

        // Mocking a StubSet is way too difficult.
        $this->stubs = StubFactory::fromArray($this->methodsWithValues);

        $this->strategy->decorate($this->mock, $this->stubs);
    }

    final protected function setStrategy(MockingStrategyInterface $strategy)
    {
        $this->strategy = $strategy;
    }

    final protected function setMethodName(string $methodName)
    {
        $this->methodName = $methodName;
    }

    final protected function getRandomFQCN()
    {
        return 'foo_' . rand();
    }
}


1			<?php
2			declare(strict_types=1);
3
4			namespace Moka\Tests;
5
6			use Moka\Exception\InvalidArgumentException;
7			use Moka\Factory\StubFactory;
8			use Moka\Strategy\MockingStrategyInterface;
9			use Moka\Stub\StubSet;
10			use PHPUnit\Framework\TestCase;
11			use Tests\AbstractTestClass;
12			use Tests\BarTestClass;
13			use Tests\FooTestClass;
14			use Tests\TestInterface;
15
16			abstract class MokaMockingStrategyTestCase extends TestCase
17			{
18			/**
19			* @var MockingStrategyInterface
20			*/
21			protected $strategy;
22
23			/**
24			* @var object
25			*/
26			protected $mock;
27
28			/**
29			* @var StubSet
30			*/
31			protected $stubs;
32
33			/**
34			* @var string
35			*/
36			private $className;
37
38			/**
39			* @var array
40			*/
41			private $methodsWithValues = [];
42
43			private $methodName;
44
45			final public function testGetMockTypeSuccess()
46			{
47			$this->assertInternalType('string', $this->strategy->getMockType());
48			}
49
50			final public function testBuildClassSuccess()
51			{
52			$this->assertInstanceOf($this->strategy->getMockType(), $this->mock);
53			}
54
55			final public function testBuildInterfaceSuccess()
56			{
57			$mock = $this->strategy->build(TestInterface::class);
58
59			$this->assertInstanceOf($this->strategy->getMockType(), $mock);
60			}
61
62			final public function testBuildAbstractClassSuccess()
63			{
64			$mock = $this->strategy->build(AbstractTestClass::class);
65
66			$this->assertInstanceOf($this->strategy->getMockType(), $mock);
67			}
68
69			final public function testDecorateFailure()
70			{
71			$this->expectException(InvalidArgumentException::class);
72
73			$this->strategy->decorate(new \stdClass(), $this->stubs);
74			}
75
76			final public function testDecorateWrongTypeHintFailure()
77			{
78			$this->strategy->decorate($this->mock, StubFactory::fromArray([
			0 ignored issues – show Bug introduced 2017-06-26 10:05 UTC by Report Bug Copy Issue Report Show Similar Issues like this It seems like `\Moka\Factory\StubFactor...getSelf' => mt_rand()))` targeting `Moka\Factory\StubFactory::fromArray()` can also be of type `array<integer,object<Moka\Stub\Stub>>`; however, `Moka\Strategy\MockingStrategyInterface::decorate()` does only seem to accept `object<Moka\Stub\StubSet>`, maybe add an additional type check? This check looks at variables that are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
79			'getSelf' => mt_rand()
80			]));
81
82			$this->expectException(\TypeError::class);
83			$this->strategy->get($this->mock)->getSelf();
84			}
85
86			final public function testDecorateSingleCallSuccess()
87			{
88			$this->assertSame($this->methodsWithValues['isTrue'], $this->strategy->get($this->mock)->isTrue());
89
90			$this->expectException(\Exception::class);
91			$this->expectExceptionMessage($this->methodsWithValues['throwException']->getMessage());
92			$this->strategy->get($this->mock)->throwException();
93			}
94
95			final public function testDecorateMultipleCallsSuccess()
96			{
97			$this->assertSame($this->methodsWithValues['getInt'], $this->strategy->get($this->mock)->getInt());
98			$this->assertSame($this->methodsWithValues['getInt'], $this->strategy->get($this->mock)->getInt());
99			}
100
101			final public function testDecorateOverriddenCallsFailure()
102			{
103			$this->strategy->decorate($this->mock, StubFactory::fromArray([
			0 ignored issues – show Bug introduced 2017-06-26 10:05 UTC by Report Bug Copy Issue Report Show Similar Issues like this It seems like `\Moka\Factory\StubFactor...ception' => mt_rand()))` targeting `Moka\Factory\StubFactory::fromArray()` can also be of type `array<integer,object<Moka\Stub\Stub>>`; however, `Moka\Strategy\MockingStrategyInterface::decorate()` does only seem to accept `object<Moka\Stub\StubSet>`, maybe add an additional type check? This check looks at variables that are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
104			'getInt' => mt_rand(),
105			'throwException' => mt_rand()
106			]));
107
108			$this->assertSame($this->methodsWithValues['getInt'], $this->strategy->get($this->mock)->getInt());
109			$this->assertSame($this->methodsWithValues['getInt'], $this->strategy->get($this->mock)->getInt());
110
111			$this->expectException(\Exception::class);
112			$this->expectExceptionMessage($this->methodsWithValues['throwException']->getMessage());
113			$this->strategy->get($this->mock)->throwException();
114			}
115
116			final public function testDecorateCallWithArgumentSuccess()
117			{
118			$this->assertSame($this->methodsWithValues['withArgument'], $this->strategy->get($this->mock)->withArgument(mt_rand()));
119			}
120
121			final public function testDecorateCallWithMissingArgumentFailure()
122			{
123			$this->expectException(\Error::class);
124
125			$this->strategy->get($this->mock)->withArgument();
126			}
127
128			final public function testDecorateCallWithWrongArgumentFailure()
129			{
130			$this->expectException(\TypeError::class);
131
132			$this->strategy->get($this->mock)->withArgument('string');
133			}
134
135			final public function testGetSuccess()
136			{
137			$this->assertInstanceOf($this->className, $this->strategy->get($this->mock));
138			}
139
140			final public function testGetFailure()
141			{
142			$this->expectException(InvalidArgumentException::class);
143
144			$this->strategy->get(new \stdClass());
145			}
146
147			public function testMethodForward()
148			{
149			if (!$this->methodName) {
150			return;
151			}
152
153			try {
154			$this->strategy->build(\stdClass::class)->{$this->methodName}();
155			$this->assertTrue(true);
156			} catch (\Error $e) {
157			$this->assertEquals(0, preg_match('/^Call to undefined method/', $e->getMessage()));
158			}
159			}
160
161			protected function setUp()
162			{
163			$this->className = [
164			FooTestClass::class,
165			BarTestClass::class
166			][random_int(0, 1)];
167
168			$this->methodsWithValues = [
169			'isTrue' => !!random_int(0, 1),
170			'getInt' => mt_rand(),
171			'withArgument' => mt_rand(),
172			'throwException' => new \Exception('' . mt_rand())
173			];
174
175			$this->mock = $this->strategy->build($this->className);
176
177			// Mocking a StubSet is way too difficult.
178			$this->stubs = StubFactory::fromArray($this->methodsWithValues);
179
180			$this->strategy->decorate($this->mock, $this->stubs);
181			}
182
183			final protected function setStrategy(MockingStrategyInterface $strategy)
184			{
185			$this->strategy = $strategy;
186			}
187
188			final protected function setMethodName(string $methodName)
189			{
190			$this->methodName = $methodName;
191			}
192
193			final protected function getRandomFQCN()
194			{
195			return 'foo_' . rand();
196			}
197			}
198

facile-it / moka

Push — master ( 77f1a4...b8ad13 )

src/Moka/Tests/MokaMockingStrategyTestCase.php (2 issues)

Showing only issues like (Show All)

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like