ContainerHydratorTest - Code Metrics - Inspection of "Initial commit" - pinepain/league-container-extras - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 9f0086...167a19 )

by Bogdan

created 2016-10-04 21:55 UTC

ContainerHydratorTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	290
Duplicated Lines	42.07 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

Metric	Value
wmc	15
lcom	1
cbo	5
dl	122
loc	290
rs	10
c	0
b	0
f	0

How to fix Duplicated Code

<?php

/*
  +----------------------------------------------------------------------+
  | This file is part of the pinepain/container-extras PHP library.      |
  |                                                                      |
  | Copyright (c) 2015-2016 Bogdan Padalko <[email protected]>          |
  |                                                                      |
  | Licensed under the MIT license: http://opensource.org/licenses/MIT   |
  |                                                                      |
  | For the full copyright and license information, please view the      |
  | LICENSE file that was distributed with this source or visit          |
  | http://opensource.org/licenses/MIT                                   |
  +----------------------------------------------------------------------+
*/

/* Based on League\Container\Test\ContainerTest
 * v1.x class (https://github.com/thephpleague/container/blob/1.x/tests/ContainerTest.php)
 * which is authored by Phil Bennett (https://github.com/philipobenito)
 * and other contributors (https://github.com/thephpleague/container/contributors).
 */


namespace Pinepain\Container\Extras\Tests;


use League\Container\ContainerInterface;
use League\Container\Definition\ClassDefinition;
use League\Container\Definition\DefinitionInterface;
use Pinepain\Container\Extras\ContainerHydrator;
use stdClass;


class ContainerHydratorTest extends \PHPUnit_Framework_TestCase
{
    protected $configArray = [
        'League\Container\Test\Asset\Foo' => [
            'class'     => 'League\Container\Test\Asset\Foo',
            'arguments' => ['League\Container\Test\Asset\Bar'],
            'methods'   => [
                'injectBaz' => ['League\Container\Test\Asset\Baz'],
            ],
        ],
        'League\Container\Test\Asset\Bar' => [
            'definition' => 'League\Container\Test\Asset\Bar',
            'arguments'  => ['League\Container\Test\Asset\Baz'],
        ],
        'League\Container\Test\Asset\Baz' => 'League\Container\Test\Asset\Baz',
    ];

    public function testPopulateWithEmpty()
    {
        $loader = new ContainerHydrator();

        $config = [];

        $container = $this->getContainerMock();

        $container->expects($this->never())->method('add');

        $loader->populate($container, $config);
    }

    public function testPopulateWithTraversable()
    {
        $loader = new ContainerHydrator();

        /** @var \Iterator | \PHPUnit_Framework_MockObject_MockObject $config */
        $config = $this->getMockBuilder('\Iterator')->getMockForAbstractClass();

        $container = $this->getContainerMock();

        $container->expects($this->never())->method('add');

        $loader->populate($container, $config);
    }

    /**
     * @expectedException \InvalidArgumentException
     * @expectedExceptionMessage You can only load definitions from an array or an object that implements Traversable
     *                           interface.
     */
    public function testPopulateFromNotArrayNorTraversable()
    {
        $loader = new ContainerHydrator();

        $container = $this->getContainerMock();

        $loader->populate($container, new stdClass());
    }

    public function testAddingScalar()
    {
        $loader = new ContainerHydrator();

        $config = [
            'key' => 'value',
        ];

        $container = $this->getContainerMock();

        $container->expects($this->once())
                  ->method('add')
                  ->with('key', 'value', false);

        $loader->populate($container, $config);
    }

    public function testAddingConcrete()
    {
        $loader = new ContainerHydrator();

        $config = [
            'TestInterface' => null,
        ];

        $container = $this->getContainerMock();

        $container->expects($this->once())
                  ->method('add')
                  ->with('TestInterface', null, false);

        $loader->populate($container, $config);
    }

    public function testSharingConcrete()
    {
        $loader = new ContainerHydrator();

        $config = [
            'TestInterface' => [
                'share' => true,
            ],
        ];

        $container = $this->getContainerMock();

        $container->expects($this->once())
                  ->method('add')
                  ->with('TestInterface', null, true);

        $loader->populate($container, $config);
    }

    public function testAddingAlias()
    {
        $loader = new ContainerHydrator();

        $config = [
            'TestInterface' => 'Test',
        ];

        $container = $this->getContainerMock();

        $container->expects($this->once())
                  ->method('add')
                  ->with('TestInterface', 'Test', false);

        $loader->populate($container, $config);
    }

    public function testAddingShared()
    {
        $loader = new ContainerHydrator();

        $config = [
            'TestInterface' => [
                'class' => 'Test',
                'share' => true,
            ],
        ];

        $container = $this->getContainerMock();

        $container->expects($this->once())
                  ->method('add')
                  ->with('TestInterface', 'Test', true);

        $loader->populate($container, $config);
    }

    public function testAddingAliasWithArgument()
    {
        $loader = new ContainerHydrator();

        $config = [
            'TestInterface' => [
                'class'     => 'TestWithArguments',
                'arguments' => ['test', 'arguments'],
            ],
        ];

        $container = $this->getContainerMock();

        $definition = $this->getDefinitionMock();

        $definition->expects($this->once())
                   ->method('withArguments')
                   ->with(['test', 'arguments'])
                   ->willReturn($definition);

        $container->expects($this->once())
                  ->method('add')
                  ->with('TestInterface', 'TestWithArguments', false)
                  ->willReturn($definition);

        $loader->populate($container, $config);
    }


    public function testAddingAliasWithMethodCalls()
    {
        $loader = new ContainerHydrator();

        $config = [
            'TestInterface' => [
                'class'   => 'TestWithMethodCalls',
                'methods' => [
                    'setValue' => ['test value'],
                ],
            ],
        ];

        $container = $this->getContainerMock();

        $definition = $this->getClassDefinitionMock();

        $definition->expects($this->once())
                   ->method('withMethodCalls')
                   ->with(['setValue' => ['test value']])
                   ->willReturn($definition);

        $container->expects($this->once())
                  ->method('add')
                  ->with('TestInterface', 'TestWithMethodCalls', false)
                  ->willReturn($definition);

        $loader->populate($container, $config);
    }

    public function testAddingAliasWithArgumentsAndMethodCalls()
    {
        $loader = new ContainerHydrator();

        $config = [
            'TestInterface' => [
                'class'     => 'TestWithArgumentsAndMethodCalls',
                'arguments' => ['test', 'arguments'],
                'methods'   => [
                    'setValue' => ['test value'],
                ],
            ],
        ];

        $container = $this->getContainerMock();

        $definition = $this->getClassDefinitionMock();

        $definition->expects($this->once())
                   ->method('withArguments')
                   ->with(['test', 'arguments'])
                   ->willReturn($definition);

        $definition->expects($this->once())
                   ->method('withMethodCalls')
                   ->with(['setValue' => ['test value']])
                   ->willReturn($definition);

        $container->expects($this->once())
                  ->method('add')
                  ->with('TestInterface', 'TestWithArgumentsAndMethodCalls', false)
                  ->willReturn($definition);

        $loader->populate($container, $config);
    }

    public function testAddDefinition()
    {
        $loader = new ContainerHydrator();

        $definition = $this->getClassDefinitionMock();

        $config = [
            'TestInterface' => [
                'definition' => $definition,
            ],
        ];

        $container = $this->getContainerMock();

        $container->expects($this->once())
                  ->method('add')
                  ->with('TestInterface', $definition, false);

        $loader->populate($container, $config);
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject | ContainerInterface
     */
    public function getContainerMock()
    {
        return $this->getMockBuilder('\League\Container\ContainerInterface')->getMockForAbstractClass();
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject | DefinitionInterface
     */
    public function getDefinitionMock()
    {
        return $this->getMockBuilder('\League\Container\Definition\DefinitionInterface')->getMockForAbstractClass();
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject | ClassDefinition
     */
    public function getClassDefinitionMock()
    {
        return $this->getMockBuilder('\League\Container\Definition\ClassDefinition')
                    ->disableOriginalConstructor()
                    ->getMock();
    }
}


1			<?php
2
3			/*
4			+----------------------------------------------------------------------+
5			\| This file is part of the pinepain/container-extras PHP library. \|
6			\| \|
7			\| Copyright (c) 2015-2016 Bogdan Padalko <[email protected]> \|
8			\| \|
9			\| Licensed under the MIT license: http://opensource.org/licenses/MIT \|
10			\| \|
11			\| For the full copyright and license information, please view the \|
12			\| LICENSE file that was distributed with this source or visit \|
13			\| http://opensource.org/licenses/MIT \|
14			+----------------------------------------------------------------------+
15			*/
16
17			/* Based on League\Container\Test\ContainerTest
18			* v1.x class (https://github.com/thephpleague/container/blob/1.x/tests/ContainerTest.php)
19			* which is authored by Phil Bennett (https://github.com/philipobenito)
20			* and other contributors (https://github.com/thephpleague/container/contributors).
21			*/
22
23
24			namespace Pinepain\Container\Extras\Tests;
25
26
27			use League\Container\ContainerInterface;
28			use League\Container\Definition\ClassDefinition;
29			use League\Container\Definition\DefinitionInterface;
30			use Pinepain\Container\Extras\ContainerHydrator;
31			use stdClass;
32
33
34			class ContainerHydratorTest extends \PHPUnit_Framework_TestCase
35			{
36			protected $configArray = [
37			'League\Container\Test\Asset\Foo' => [
38			'class' => 'League\Container\Test\Asset\Foo',
39			'arguments' => ['League\Container\Test\Asset\Bar'],
40			'methods' => [
41			'injectBaz' => ['League\Container\Test\Asset\Baz'],
42			],
43			],
44			'League\Container\Test\Asset\Bar' => [
45			'definition' => 'League\Container\Test\Asset\Bar',
46			'arguments' => ['League\Container\Test\Asset\Baz'],
47			],
48			'League\Container\Test\Asset\Baz' => 'League\Container\Test\Asset\Baz',
49			];
50
51			public function testPopulateWithEmpty()
52			{
53			$loader = new ContainerHydrator();
54
55			$config = [];
56
57			$container = $this->getContainerMock();
58
59			$container->expects($this->never())->method('add');
60
61			$loader->populate($container, $config);
62			}
63
64			public function testPopulateWithTraversable()
65			{
66			$loader = new ContainerHydrator();
67
68			/** @var \Iterator \| \PHPUnit_Framework_MockObject_MockObject $config */
69			$config = $this->getMockBuilder('\Iterator')->getMockForAbstractClass();
70
71			$container = $this->getContainerMock();
72
73			$container->expects($this->never())->method('add');
74
75			$loader->populate($container, $config);
76			}
77
78			/**
79			* @expectedException \InvalidArgumentException
80			* @expectedExceptionMessage You can only load definitions from an array or an object that implements Traversable
81			* interface.
82			*/
83			public function testPopulateFromNotArrayNorTraversable()
84			{
85			$loader = new ContainerHydrator();
86
87			$container = $this->getContainerMock();
88
89			$loader->populate($container, new stdClass());
90			}
91
92			public function testAddingScalar()
93			{
94			$loader = new ContainerHydrator();
95
96			$config = [
97			'key' => 'value',
98			];
99
100			$container = $this->getContainerMock();
101
102			$container->expects($this->once())
103			->method('add')
104			->with('key', 'value', false);
105
106			$loader->populate($container, $config);
107			}
108
109			public function testAddingConcrete()
110			{
111			$loader = new ContainerHydrator();
112
113			$config = [
114			'TestInterface' => null,
115			];
116
117			$container = $this->getContainerMock();
118
119			$container->expects($this->once())
120			->method('add')
121			->with('TestInterface', null, false);
122
123			$loader->populate($container, $config);
124			}
125
126			public function testSharingConcrete()
127			{
128			$loader = new ContainerHydrator();
129
130			$config = [
131			'TestInterface' => [
132			'share' => true,
133			],
134			];
135
136			$container = $this->getContainerMock();
137
138			$container->expects($this->once())
139			->method('add')
140			->with('TestInterface', null, true);
141
142			$loader->populate($container, $config);
143			}
144
145			public function testAddingAlias()
146			{
147			$loader = new ContainerHydrator();
148
149			$config = [
150			'TestInterface' => 'Test',
151			];
152
153			$container = $this->getContainerMock();
154
155			$container->expects($this->once())
156			->method('add')
157			->with('TestInterface', 'Test', false);
158
159			$loader->populate($container, $config);
160			}
161
162			public function testAddingShared()
163			{
164			$loader = new ContainerHydrator();
165
166			$config = [
167			'TestInterface' => [
168			'class' => 'Test',
169			'share' => true,
170			],
171			];
172
173			$container = $this->getContainerMock();
174
175			$container->expects($this->once())
176			->method('add')
177			->with('TestInterface', 'Test', true);
178
179			$loader->populate($container, $config);
180			}
181
182			public function testAddingAliasWithArgument()
183			{
184			$loader = new ContainerHydrator();
185
186			$config = [
187			'TestInterface' => [
188			'class' => 'TestWithArguments',
189			'arguments' => ['test', 'arguments'],
190			],
191			];
192
193			$container = $this->getContainerMock();
194
195			$definition = $this->getDefinitionMock();
196
197			$definition->expects($this->once())
198			->method('withArguments')
199			->with(['test', 'arguments'])
200			->willReturn($definition);
201
202			$container->expects($this->once())
203			->method('add')
204			->with('TestInterface', 'TestWithArguments', false)
205			->willReturn($definition);
206
207			$loader->populate($container, $config);
208			}
209
210
211			public function testAddingAliasWithMethodCalls()
212			{
213			$loader = new ContainerHydrator();
214
215			$config = [
216			'TestInterface' => [
217			'class' => 'TestWithMethodCalls',
218			'methods' => [
219			'setValue' => ['test value'],
220			],
221			],
222			];
223
224			$container = $this->getContainerMock();
225
226			$definition = $this->getClassDefinitionMock();
227
228			$definition->expects($this->once())
229			->method('withMethodCalls')
230			->with(['setValue' => ['test value']])
231			->willReturn($definition);
232
233			$container->expects($this->once())
234			->method('add')
235			->with('TestInterface', 'TestWithMethodCalls', false)
236			->willReturn($definition);
237
238			$loader->populate($container, $config);
239			}
240
241			public function testAddingAliasWithArgumentsAndMethodCalls()
242			{
243			$loader = new ContainerHydrator();
244
245			$config = [
246			'TestInterface' => [
247			'class' => 'TestWithArgumentsAndMethodCalls',
248			'arguments' => ['test', 'arguments'],
249			'methods' => [
250			'setValue' => ['test value'],
251			],
252			],
253			];
254
255			$container = $this->getContainerMock();
256
257			$definition = $this->getClassDefinitionMock();
258
259			$definition->expects($this->once())
260			->method('withArguments')
261			->with(['test', 'arguments'])
262			->willReturn($definition);
263
264			$definition->expects($this->once())
265			->method('withMethodCalls')
266			->with(['setValue' => ['test value']])
267			->willReturn($definition);
268
269			$container->expects($this->once())
270			->method('add')
271			->with('TestInterface', 'TestWithArgumentsAndMethodCalls', false)
272			->willReturn($definition);
273
274			$loader->populate($container, $config);
275			}
276
277			public function testAddDefinition()
278			{
279			$loader = new ContainerHydrator();
280
281			$definition = $this->getClassDefinitionMock();
282
283			$config = [
284			'TestInterface' => [
285			'definition' => $definition,
286			],
287			];
288
289			$container = $this->getContainerMock();
290
291			$container->expects($this->once())
292			->method('add')
293			->with('TestInterface', $definition, false);
294
295			$loader->populate($container, $config);
296			}
297
298			/**
299			* @return \PHPUnit_Framework_MockObject_MockObject \| ContainerInterface
300			*/
301			public function getContainerMock()
302			{
303			return $this->getMockBuilder('\League\Container\ContainerInterface')->getMockForAbstractClass();
304			}
305
306			/**
307			* @return \PHPUnit_Framework_MockObject_MockObject \| DefinitionInterface
308			*/
309			public function getDefinitionMock()
310			{
311			return $this->getMockBuilder('\League\Container\Definition\DefinitionInterface')->getMockForAbstractClass();
312			}
313
314			/**
315			* @return \PHPUnit_Framework_MockObject_MockObject \| ClassDefinition
316			*/
317			public function getClassDefinitionMock()
318			{
319			return $this->getMockBuilder('\League\Container\Definition\ClassDefinition')
320			->disableOriginalConstructor()
321			->getMock();
322			}
323			}
324

pinepain / league-container-extras

Push — master ( 9f0086...167a19 )

ContainerHydratorTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like