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 (1 issue)

Labels

Severity

Minor 1

Alberto Villa 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 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);
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}

        $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([
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([
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);
			0 ignored issues – show Documentation 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...his->methodsWithValues)` can also be of type `array<integer,object<Moka\Stub\Stub>>`. However, the property `$stubs` is declared as type `object<Moka\Stub\StubSet>`. Maybe add an additional type check? Our type inference engine has found a suspicous assignment of a value to a property. This check raises an issue when a value that can be of a mixed type is assigned to a property that is type hinted more strictly. For example, imagine you have a variable `$accountId` that can either hold an Id object or false (if there is no account id yet). Your code now assigns that value to the `id` property of an instance of the `Account` class. This class holds a proper account, so the id value must no longer be false. Either this assignment is in error or a type check should be added for that assignment. class Id { public $id; public function __construct($id) { $this->id = $id; } } class Account { /** @var Id $id */ public $id; } $account_id = false; if (starsAreRight()) { $account_id = new Id(42); } $account = new Account(); if ($account instanceof Id) { $account->id = $account_id; } Loading history...
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 (1 issue)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like