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

Passed

Pull Request — master (#19)

by Alex

created 2023-05-08 00:19 UTC

ImmutableParametersTest::testGetParameters() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	24
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	11
c	1
b	0
f	0
dl	0
loc	24
rs	9.9
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
 */
final class ImmutableParametersTest extends TestCase
{
    private ParametersInterface&MockObject $parameters;


    public function setUp(): void
    {
        $this->parameters = $this->createMock(ParametersInterface::class);
    }

    public function testImplementsParametersInterface(): void
    {
        $params = new ImmutableParameters($this->parameters);

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

    public function testImplementsArrayAccess(): void
    {
        $params = new ImmutableParameters($this->parameters);

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

    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());
    }

    public function testCountWillReturnParameterCount(): void
    {
        $parameters = new ImmutableParameters($this->parameters);

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

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

    public function testIsEmptyWillProxyToInternalParametersCollection(): void
    {
        $immutableParameters = new ImmutableParameters(new Parameters([]));

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

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

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

    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'));
    }

    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));
    }

    public function testRemoveParamWillReturnFalse(): void
    {
        $params = ['test' => 123];

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

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

    public function testGetKeysWillProxyToInternalParametersCollection(): void
    {
        $params = [
            'foo' => 'Hello',
            'bar' => 'test',
            'baz' => 123,
        ];

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

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

    public function testGetValuesWillProxyToInternalParametersCollection(): void
    {
        $params = [
            'foo' => 'Hello',
            'bar' => 'test',
            'baz' => 123,
        ];

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

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

    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());
    }

    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']));
    }

    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']);
    }

    public function testSetParamPerformsNoModifications(): void
    {
        $data = [
            'foo' => 123,
            'bar' => 'test',
        ];

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

        $this->assertSame($data, $params->getParams());

        $params->setParam('foo', true);
        $params->setParam('baz', 'Testing setter');

        $this->assertSame(123, $params->getParam('foo'));
        $this->assertFalse($params->hasParam('baz'));
        $this->assertSame($data, $params->getParams());
    }

    public function testOffsetSetParamPerformsNoModifications(): void
    {
        $data = [
            'foo' => 456,
            'bar' => 'test123',
        ];

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

        $this->assertSame($data, $params->getParams());

        $params->offsetSet('foo', true);
        $params->offsetSet('baz', 'Testing setter');

        $this->assertSame(456, $params->getParam('foo'));
        $this->assertFalse($params->hasParam('baz'));
        $this->assertSame($data, $params->getParams());
    }

    public function testRemoveParamsWillPerformsNoModifications(): void
    {
        $data = [
            'foo' => 123,
            'bar' => 'test',
            'baz' => true,
        ];

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

        $params->removeParams(['foo', 'baz']);
        $params->removeParams(['baz']);

        $this->assertTrue($params->hasParam('foo'));
        $this->assertSame($data, $params->getParams());
    }

    public function testOffsetUnsetWillPerformsNoModifications(): void
    {
        $data = [
            'foo' => 123,
            'bar' => 'test',
            'baz' => true,
        ];

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

        $params->offsetUnset('foo');
        $params->offsetUnset('baz');

        $this->assertTrue($params->hasParam('foo'));
        $this->assertTrue($params->hasParam('baz'));
        $this->assertSame($data, $params->getParams());
    }
}


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			final class ImmutableParametersTest extends TestCase
17			{
18			private ParametersInterface&MockObject $parameters;
			0 ignored issues – show Bug introduced 2023-05-08 00:21 UTC by Report Bug Copy Issue Report A parse error occurred: Syntax error, unexpected '&', expecting T_VARIABLE on line 18 at column 31 Loading history...
19
20			public function setUp(): void
21			{
22			$this->parameters = $this->createMock(ParametersInterface::class);
23			}
24
25			public function testImplementsParametersInterface(): void
26			{
27			$params = new ImmutableParameters($this->parameters);
28
29			$this->assertInstanceOf(ParametersInterface::class, $params);
30			}
31
32			public function testImplementsArrayAccess(): void
33			{
34			$params = new ImmutableParameters($this->parameters);
35
36			$this->assertInstanceOf(\ArrayAccess::class, $params);
37			}
38
39			public function testGetParameters(): void
40			{
41			$data = [
42			'hello' => 123,
43			];
44
45			$this->parameters->expects($this->exactly(2))
46			->method('getParams')
47			->willReturnOnConsecutiveCalls([], $data);
48
49			$this->parameters->expects($this->never())->method('setParams');
50
51			$params = new ImmutableParameters($this->parameters);
52
53			$this->assertEmpty($params->getParams());
54
55			// Ignore updates to set params with new data
56			$params->setParams(
57			[
58			'foo' => 'bar',
59			]
60			);
61
62			$this->assertEquals($data, $params->getParams());
63			}
64
65			public function testCountWillReturnParameterCount(): void
66			{
67			$parameters = new ImmutableParameters($this->parameters);
68
69			$this->parameters->expects($this->once())
70			->method('count')
71			->willReturn(5);
72
73			$this->assertSame(5, $parameters->count());
74			}
75
76			public function testIsEmptyWillProxyToInternalParametersCollection(): void
77			{
78			$immutableParameters = new ImmutableParameters(new Parameters([]));
79
80			$this->assertTrue($immutableParameters->isEmpty());
81
82			$immutableParameters = new ImmutableParameters(
83			new Parameters(
84			[
85			'foo' => 123,
86			]
87			)
88			);
89
90			$this->assertFalse($immutableParameters->isEmpty());
91			}
92
93			public function testHasParamWillProxyToInternalParametersCollection(): void
94			{
95			$immutableParameters = new ImmutableParameters(
96			new Parameters(
97			[
98			'foo' => 123,
99			'bar' => true,
100			]
101			)
102			);
103
104			$this->assertTrue($immutableParameters->hasParam('foo'));
105			$this->assertTrue($immutableParameters->hasParam('bar'));
106			$this->assertFalse($immutableParameters->hasParam('baz'));
107			}
108
109			public function testGetParamWillProxyToInternalParametersCollection(): void
110			{
111			$immutableParameters = new ImmutableParameters(
112			new Parameters(
113			[
114			'foo' => 456,
115			'bar' => 'Hello World!',
116			]
117			)
118			);
119
120			$this->assertSame(456, $immutableParameters->getParam('foo'));
121			$this->assertSame('Hello World!', $immutableParameters->getParam('bar'));
122
123			$this->assertNull($immutableParameters->getParam('baz'));
124			$this->assertFalse($immutableParameters->getParam('baz', false));
125			$this->assertSame(123, $immutableParameters->getParam('test', 123));
126			}
127
128			public function testRemoveParamWillReturnFalse(): void
129			{
130			$params = ['test' => 123];
131
132			$immutableParameters = new ImmutableParameters(new Parameters($params));
133
134			$this->assertFalse($immutableParameters->removeParam('test'));
135			$this->assertSame($params, $immutableParameters->getParams());
136			}
137
138			public function testGetKeysWillProxyToInternalParametersCollection(): void
139			{
140			$params = [
141			'foo' => 'Hello',
142			'bar' => 'test',
143			'baz' => 123,
144			];
145
146			$immutableParameters = new ImmutableParameters(new Parameters($params));
147
148			$this->assertSame(array_keys($params), $immutableParameters->getKeys());
149			}
150
151			public function testGetValuesWillProxyToInternalParametersCollection(): void
152			{
153			$params = [
154			'foo' => 'Hello',
155			'bar' => 'test',
156			'baz' => 123,
157			];
158
159			$immutableParameters = new ImmutableParameters(new Parameters($params));
160
161			$this->assertSame(array_values($params), $immutableParameters->getValues());
162			}
163
164			public function testGetIteratorWillProxyToInternalParametersCollection(): void
165			{
166			$iterator = new \ArrayIterator(
167			[
168			'foo' => 'Hello',
169			'bar' => 'test',
170			'baz' => 123,
171			]
172			);
173
174			$this->parameters->expects($this->once())
175			->method('getIterator')
176			->willReturn($iterator);
177
178			$immutableParameters = new ImmutableParameters($this->parameters);
179
180			$this->assertSame($iterator, $immutableParameters->getIterator());
181			}
182
183			public function testOffsetExistsWillProxyToInternalParametersCollection(): void
184			{
185			$params = [
186			'foo' => 'Hello',
187			'bar' => 'test',
188			'baz' => 123,
189			];
190
191			$immutableParameters = new ImmutableParameters(new Parameters($params));
192
193			$this->assertTrue(isset($immutableParameters['foo']));
194			$this->assertTrue(isset($immutableParameters['bar']));
195			$this->assertFalse(isset($immutableParameters['test']));
196			}
197
198			public function testOffsetGetWillProxyToInternalParametersCollection(): void
199			{
200			$params = [
201			'foo' => 'testing',
202			'bar' => 999,
203			'baz' => 3.14,
204			];
205
206			$immutableParameters = new ImmutableParameters(new Parameters($params));
207
208			$this->assertSame($params['foo'], $immutableParameters['foo']);
209			$this->assertSame($params['bar'], $immutableParameters['bar']);
210			$this->assertSame($params['baz'], $immutableParameters['baz']);
211			$this->assertNull($immutableParameters['test']);
212			}
213
214			public function testSetParamPerformsNoModifications(): void
215			{
216			$data = [
217			'foo' => 123,
218			'bar' => 'test',
219			];
220
221			$params = new ImmutableParameters(new Parameters($data));
222
223			$this->assertSame($data, $params->getParams());
224
225			$params->setParam('foo', true);
226			$params->setParam('baz', 'Testing setter');
227
228			$this->assertSame(123, $params->getParam('foo'));
229			$this->assertFalse($params->hasParam('baz'));
230			$this->assertSame($data, $params->getParams());
231			}
232
233			public function testOffsetSetParamPerformsNoModifications(): void
234			{
235			$data = [
236			'foo' => 456,
237			'bar' => 'test123',
238			];
239
240			$params = new ImmutableParameters(new Parameters($data));
241
242			$this->assertSame($data, $params->getParams());
243
244			$params->offsetSet('foo', true);
245			$params->offsetSet('baz', 'Testing setter');
246
247			$this->assertSame(456, $params->getParam('foo'));
248			$this->assertFalse($params->hasParam('baz'));
249			$this->assertSame($data, $params->getParams());
250			}
251
252			public function testRemoveParamsWillPerformsNoModifications(): void
253			{
254			$data = [
255			'foo' => 123,
256			'bar' => 'test',
257			'baz' => true,
258			];
259
260			$params = new ImmutableParameters(new Parameters($data));
261
262			$params->removeParams(['foo', 'baz']);
263			$params->removeParams(['baz']);
264
265			$this->assertTrue($params->hasParam('foo'));
266			$this->assertSame($data, $params->getParams());
267			}
268
269			public function testOffsetUnsetWillPerformsNoModifications(): void
270			{
271			$data = [
272			'foo' => 123,
273			'bar' => 'test',
274			'baz' => true,
275			];
276
277			$params = new ImmutableParameters(new Parameters($data));
278
279			$params->offsetUnset('foo');
280			$params->offsetUnset('baz');
281
282			$this->assertTrue($params->hasParam('foo'));
283			$this->assertTrue($params->hasParam('baz'));
284			$this->assertSame($data, $params->getParams());
285			}
286			}
287

alex-patterson-webdev / event-dispatcher

Pull Request — master (#19)

ImmutableParametersTest::testGetParameters() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like