ImmutableParametersTest::testGetParamWillProxyToInternalParametersCollection() - Code Metrics - Inspection of "Feature/2.0.0" - alex-patterson-webdev/event-dispatcher - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#18)

by Alex

created 2022-03-18 19:35 UTC

testGetParamWillProxyToInternalParametersCollection() A

↳ Parent: ImmutableParametersTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	17
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	9
c	0
b	0
f	0
dl	0
loc	17
rs	9.9666
cc	1
nc	1
nop	0

<?php

declare(strict_types=1);

namespace ArpTest\EventDispatcher\Event;

use Arp\EventDispatcher\Event\ImmutableParameters;
use Arp\EventDispatcher\Event\Parameters;
use Arp\EventDispatcher\Event\ParametersInterface;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * @covers \Arp\EventDispatcher\Event\ImmutableParameters
 *
 * @author  Alex Patterson <[email protected]>
 * @package ArpTest\EventDispatcher\Event
 */
final class ImmutableParametersTest extends TestCase
{
    /**
     * @var ParametersInterface&MockObject
     */
    private $parameters;

    /**
     * Prepare the test case dependencies
     */
    public function setUp(): void
    {
        $this->parameters = $this->createMock(ParametersInterface::class);
    }

    /**
     * Assert that the class implements the ParametersInterface
     */
    public function testImplementsParametersInterface(): void
    {
        $params = new ImmutableParameters($this->parameters);

        $this->assertInstanceOf(ParametersInterface::class, $params);
    }

    /**
     * Assert that the class implements \ArrayAccess
     */
    public function testImplementsArrayAccess(): void
    {
        $params = new ImmutableParameters($this->parameters);

        $this->assertInstanceOf(\ArrayAccess::class, $params);
    }

    /**
     * Assert that parameters can be fetched via getParams() but attempts to setParams() will be ignored
     */
    public function testGetParameters(): void
    {
        $data = [
            'hello' => 123,
        ];

        $this->parameters->expects($this->exactly(2))
            ->method('getParams')
            ->willReturnOnConsecutiveCalls([], $data);

        $this->parameters->expects($this->never())->method('setParams');

        $params = new ImmutableParameters($this->parameters);

        $this->assertEmpty($params->getParams());

        // Ignore updates to set params with new data
        $params->setParams(
            [
                'foo' => 'bar',
            ]
        );

        $this->assertEquals($data, $params->getParams());
    }

    /**
     * Assert that calls to count() will proxy to the internal parameters collection
     */
    public function testCountWillReturnParameterCount(): void
    {
        $parameters = new ImmutableParameters($this->parameters);

        $this->parameters->expects($this->once())
            ->method('count')
            ->willReturn(5);

        $this->assertSame(5, $parameters->count());
    }

    /**
     * Assert that calls to isEmpty() will proxy to the internal parameters collection
     */
    public function testIsEmptyWillProxyToInternalParametersCollection(): void
    {
        $immutableParameters = new ImmutableParameters(new Parameters([]));

        $this->assertTrue($immutableParameters->isEmpty());

        $immutableParameters = new ImmutableParameters(
            new Parameters(
                [
                    'foo' => 123,
                ]
            )
        );

        $this->assertFalse($immutableParameters->isEmpty());
    }

    /**
     * Assert that calls to hasParam() will proxy to the internal parameters collection
     */
    public function testHasParamWillProxyToInternalParametersCollection(): void
    {
        $immutableParameters = new ImmutableParameters(
            new Parameters(
                [
                    'foo' => 123,
                    'bar' => true,
                ]
            )
        );

        $this->assertTrue($immutableParameters->hasParam('foo'));
        $this->assertTrue($immutableParameters->hasParam('bar'));
        $this->assertFalse($immutableParameters->hasParam('baz'));
    }

    /**
     * Assert that calls to getParam() will proxy to the internal parameters collection
     */
    public function testGetParamWillProxyToInternalParametersCollection(): void
    {
        $immutableParameters = new ImmutableParameters(
            new Parameters(
                [
                    'foo' => 456,
                    'bar' => 'Hello World!',
                ]
            )
        );

        $this->assertSame(456, $immutableParameters->getParam('foo'));
        $this->assertSame('Hello World!', $immutableParameters->getParam('bar'));

        $this->assertNull($immutableParameters->getParam('baz'));
        $this->assertFalse($immutableParameters->getParam('baz', false));
        $this->assertSame(123, $immutableParameters->getParam('test', 123));
    }

    /**
     * Assert that calls to removeParam() will NOT modify the internal parameters
     */
    public function testRemoveParamWillReturnFalse(): void
    {
        $params = ['test' => 123];

        $immutableParameters = new ImmutableParameters(new Parameters($params));

        $this->assertFalse($immutableParameters->removeParam('test'));
        $this->assertSame($params, $immutableParameters->getParams());
    }

    /**
     * Assert that calls to getKeys() will return the keys of the internal parameters collection
     */
    public function testGetKeysWillProxyToInternalParametersCollection(): void
    {
        $params = [
            'foo' => 'Hello',
            'bar' => 'test',
            'baz' => 123,
        ];

        $immutableParameters = new ImmutableParameters(new Parameters($params));

        $this->assertSame(array_keys($params), $immutableParameters->getKeys());
    }

    /**
     * Assert that calls to getValues() will return the values of the internal parameters collection
     */
    public function testGetValuesWillProxyToInternalParametersCollection(): void
    {
        $params = [
            'foo' => 'Hello',
            'bar' => 'test',
            'baz' => 123,
        ];

        $immutableParameters = new ImmutableParameters(new Parameters($params));

        $this->assertSame(array_values($params), $immutableParameters->getValues());
    }

    /**
     * Assert that calls to getValues() will return the values of the internal parameters collection
     */
    public function testGetIteratorWillProxyToInternalParametersCollection(): void
    {
        $iterator = new \ArrayIterator(
            [
                'foo' => 'Hello',
                'bar' => 'test',
                'baz' => 123,
            ]
        );

        $this->parameters->expects($this->once())
            ->method('getIterator')
            ->willReturn($iterator);

        $immutableParameters = new ImmutableParameters($this->parameters);

        $this->assertSame($iterator, $immutableParameters->getIterator());
    }

    /**
     * Assert that calls to offsetExists() will test the keys of the internal parameters collection
     */
    public function testOffsetExistsWillProxyToInternalParametersCollection(): void
    {
        $params = [
            'foo' => 'Hello',
            'bar' => 'test',
            'baz' => 123,
        ];

        $immutableParameters = new ImmutableParameters(new Parameters($params));

        $this->assertTrue(isset($immutableParameters['foo']));
        $this->assertTrue(isset($immutableParameters['bar']));
        $this->assertFalse(isset($immutableParameters['test']));
    }

    /**
     * Assert that calls to offsetExists() will test the keys of the internal parameters collection
     */
    public function testOffsetGetWillProxyToInternalParametersCollection(): void
    {
        $params = [
            'foo' => 'testing',
            'bar' => 999,
            'baz' => 3.14,
        ];

        $immutableParameters = new ImmutableParameters(new Parameters($params));

        $this->assertSame($params['foo'], $immutableParameters['foo']);
        $this->assertSame($params['bar'], $immutableParameters['bar']);
        $this->assertSame($params['baz'], $immutableParameters['baz']);
        $this->assertNull($immutableParameters['test']);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace ArpTest\EventDispatcher\Event;
6
7			use Arp\EventDispatcher\Event\ImmutableParameters;
8			use Arp\EventDispatcher\Event\Parameters;
9			use Arp\EventDispatcher\Event\ParametersInterface;
10			use PHPUnit\Framework\MockObject\MockObject;
11			use PHPUnit\Framework\TestCase;
12
13			/**
14			* @covers \Arp\EventDispatcher\Event\ImmutableParameters
15			*
16			* @author Alex Patterson <[email protected]>
17			* @package ArpTest\EventDispatcher\Event
18			*/
19			final class ImmutableParametersTest extends TestCase
20			{
21			/**
22			* @var ParametersInterface&MockObject
23			*/
24			private $parameters;
25
26			/**
27			* Prepare the test case dependencies
28			*/
29			public function setUp(): void
30			{
31			$this->parameters = $this->createMock(ParametersInterface::class);
32			}
33
34			/**
35			* Assert that the class implements the ParametersInterface
36			*/
37			public function testImplementsParametersInterface(): void
38			{
39			$params = new ImmutableParameters($this->parameters);
40
41			$this->assertInstanceOf(ParametersInterface::class, $params);
42			}
43
44			/**
45			* Assert that the class implements \ArrayAccess
46			*/
47			public function testImplementsArrayAccess(): void
48			{
49			$params = new ImmutableParameters($this->parameters);
50
51			$this->assertInstanceOf(\ArrayAccess::class, $params);
52			}
53
54			/**
55			* Assert that parameters can be fetched via getParams() but attempts to setParams() will be ignored
56			*/
57			public function testGetParameters(): void
58			{
59			$data = [
60			'hello' => 123,
61			];
62
63			$this->parameters->expects($this->exactly(2))
64			->method('getParams')
65			->willReturnOnConsecutiveCalls([], $data);
66
67			$this->parameters->expects($this->never())->method('setParams');
68
69			$params = new ImmutableParameters($this->parameters);
70
71			$this->assertEmpty($params->getParams());
72
73			// Ignore updates to set params with new data
74			$params->setParams(
75			[
76			'foo' => 'bar',
77			]
78			);
79
80			$this->assertEquals($data, $params->getParams());
81			}
82
83			/**
84			* Assert that calls to count() will proxy to the internal parameters collection
85			*/
86			public function testCountWillReturnParameterCount(): void
87			{
88			$parameters = new ImmutableParameters($this->parameters);
89
90			$this->parameters->expects($this->once())
91			->method('count')
92			->willReturn(5);
93
94			$this->assertSame(5, $parameters->count());
95			}
96
97			/**
98			* Assert that calls to isEmpty() will proxy to the internal parameters collection
99			*/
100			public function testIsEmptyWillProxyToInternalParametersCollection(): void
101			{
102			$immutableParameters = new ImmutableParameters(new Parameters([]));
103
104			$this->assertTrue($immutableParameters->isEmpty());
105
106			$immutableParameters = new ImmutableParameters(
107			new Parameters(
108			[
109			'foo' => 123,
110			]
111			)
112			);
113
114			$this->assertFalse($immutableParameters->isEmpty());
115			}
116
117			/**
118			* Assert that calls to hasParam() will proxy to the internal parameters collection
119			*/
120			public function testHasParamWillProxyToInternalParametersCollection(): void
121			{
122			$immutableParameters = new ImmutableParameters(
123			new Parameters(
124			[
125			'foo' => 123,
126			'bar' => true,
127			]
128			)
129			);
130
131			$this->assertTrue($immutableParameters->hasParam('foo'));
132			$this->assertTrue($immutableParameters->hasParam('bar'));
133			$this->assertFalse($immutableParameters->hasParam('baz'));
134			}
135
136			/**
137			* Assert that calls to getParam() will proxy to the internal parameters collection
138			*/
139			public function testGetParamWillProxyToInternalParametersCollection(): void
140			{
141			$immutableParameters = new ImmutableParameters(
142			new Parameters(
143			[
144			'foo' => 456,
145			'bar' => 'Hello World!',
146			]
147			)
148			);
149
150			$this->assertSame(456, $immutableParameters->getParam('foo'));
151			$this->assertSame('Hello World!', $immutableParameters->getParam('bar'));
152
153			$this->assertNull($immutableParameters->getParam('baz'));
154			$this->assertFalse($immutableParameters->getParam('baz', false));
155			$this->assertSame(123, $immutableParameters->getParam('test', 123));
156			}
157
158			/**
159			* Assert that calls to removeParam() will NOT modify the internal parameters
160			*/
161			public function testRemoveParamWillReturnFalse(): void
162			{
163			$params = ['test' => 123];
164
165			$immutableParameters = new ImmutableParameters(new Parameters($params));
166
167			$this->assertFalse($immutableParameters->removeParam('test'));
168			$this->assertSame($params, $immutableParameters->getParams());
169			}
170
171			/**
172			* Assert that calls to getKeys() will return the keys of the internal parameters collection
173			*/
174			public function testGetKeysWillProxyToInternalParametersCollection(): void
175			{
176			$params = [
177			'foo' => 'Hello',
178			'bar' => 'test',
179			'baz' => 123,
180			];
181
182			$immutableParameters = new ImmutableParameters(new Parameters($params));
183
184			$this->assertSame(array_keys($params), $immutableParameters->getKeys());
185			}
186
187			/**
188			* Assert that calls to getValues() will return the values of the internal parameters collection
189			*/
190			public function testGetValuesWillProxyToInternalParametersCollection(): void
191			{
192			$params = [
193			'foo' => 'Hello',
194			'bar' => 'test',
195			'baz' => 123,
196			];
197
198			$immutableParameters = new ImmutableParameters(new Parameters($params));
199
200			$this->assertSame(array_values($params), $immutableParameters->getValues());
201			}
202
203			/**
204			* Assert that calls to getValues() will return the values of the internal parameters collection
205			*/
206			public function testGetIteratorWillProxyToInternalParametersCollection(): void
207			{
208			$iterator = new \ArrayIterator(
209			[
210			'foo' => 'Hello',
211			'bar' => 'test',
212			'baz' => 123,
213			]
214			);
215
216			$this->parameters->expects($this->once())
217			->method('getIterator')
218			->willReturn($iterator);
219
220			$immutableParameters = new ImmutableParameters($this->parameters);
221
222			$this->assertSame($iterator, $immutableParameters->getIterator());
223			}
224
225			/**
226			* Assert that calls to offsetExists() will test the keys of the internal parameters collection
227			*/
228			public function testOffsetExistsWillProxyToInternalParametersCollection(): void
229			{
230			$params = [
231			'foo' => 'Hello',
232			'bar' => 'test',
233			'baz' => 123,
234			];
235
236			$immutableParameters = new ImmutableParameters(new Parameters($params));
237
238			$this->assertTrue(isset($immutableParameters['foo']));
239			$this->assertTrue(isset($immutableParameters['bar']));
240			$this->assertFalse(isset($immutableParameters['test']));
241			}
242
243			/**
244			* Assert that calls to offsetExists() will test the keys of the internal parameters collection
245			*/
246			public function testOffsetGetWillProxyToInternalParametersCollection(): void
247			{
248			$params = [
249			'foo' => 'testing',
250			'bar' => 999,
251			'baz' => 3.14,
252			];
253
254			$immutableParameters = new ImmutableParameters(new Parameters($params));
255
256			$this->assertSame($params['foo'], $immutableParameters['foo']);
257			$this->assertSame($params['bar'], $immutableParameters['bar']);
258			$this->assertSame($params['baz'], $immutableParameters['baz']);
259			$this->assertNull($immutableParameters['test']);
260			}
261			}
262

alex-patterson-webdev / event-dispatcher

Pull Request — master (#18)

testGetParamWillProxyToInternalParametersCollection() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like