SettingsAccessTest::testConstructorWithObject() - Code Metrics - HexMakina/LeMarchand - Measure and Improve Code Quality continuously with Scrutinizer

SettingsAccessTest::testConstructorWithObject() A
last analyzed 2025-02-18 01:20 UTC

↳ Parent: SettingsAccessTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
cc	1
eloc	3
c	1
b	0
f	1
nc	1
nop	0
dl	0
loc	5
rs	10

<?php

use PHPUnit\Framework\TestCase;
use HexMakina\LeMarchand\LeMarchand;
use HexMakina\LeMarchand\Factory;
use Psr\Container\ContainerInterface;

use Psr\Container\ContainerExceptionInterface;
use Psr\Container\NotFoundExceptionInterface;


class SettingsAccessTest extends TestCase
{
    public function testConstructor()
    {
        $res = new LeMarchand(['key' => 'value']);
        $this->assertInstanceOf(LeMarchand::class, $res);
        $this->assertInstanceOf(ContainerInterface::class, $res);

        $this->assertTrue($res->has('settings.key'));
        $this->assertEquals('value', $res->get('settings.key'));
    }

    public function testEmptyConstructor()
    {
        $res = new LeMarchand([]);
        $this->assertInstanceOf(LeMarchand::class, $res);
        $this->assertInstanceOf(ContainerInterface::class, $res);

        $this->assertFalse($res->has('settings.0'));

        $this->expectException(NotFoundExceptionInterface::class);
        $res->get('settings.nothing');

        $this->assertFalse($res->has('settings.nothing'));
    }

    public function testConstructorWithNumericallyIndexedStrings()
    {
        $res = new LeMarchand(['invalid', 'key' => 'value2', ['value0', 'value1'], 'key_last' => 'value3']);
        $this->assertEquals('invalid', $res->get('settings.0'));
        $this->assertEquals('value0', $res->get('settings.1.0'));
        $this->assertEquals('value1', $res->get('settings.1.1'));

        $this->assertEquals('value2', $res->get('settings.key'));
        $this->assertEquals('value3', $res->get('settings.key_last'));
        

        $res = new LeMarchand([1]);
        $this->assertEquals(1, $res->get('settings.0'));

        $settings = [1, 2, 3, 4, 5];
        unset($settings[2]);
        $res = new LeMarchand($settings);
        $this->assertTrue($res->has('settings.0'));
        $this->assertTrue($res->has('settings.1'));
        $this->assertFalse($res->has('settings.2'));
        $this->assertTrue($res->has('settings.3'));
        $this->assertTrue($res->has('settings.4'));

        $this->assertEquals(1, $res->get('settings.0'));
        $this->assertEquals(2, $res->get('settings.1'));
        $this->assertEquals(4, $res->get('settings.3'));
        $this->assertEquals(5, $res->get('settings.4'));

        $this->expectException(NotFoundExceptionInterface::class);
        $res->get('settings.2');
        

        $res = new LeMarchand([true]);
        $this->assertEquals(true, $res->get('settings.0'));
    }

    public function testConstructorWithObject()
    {
        $res = new LeMarchand([new stdClass(), 'key' => new stdClass()]);
        $this->assertInstanceOf(stdClass::class, $res->get('settings.0'));
        $this->assertInstanceOf(stdClass::class, $res->get('settings.key'));
    }

    public function testConstructorWithBooleanValues()
    {
        $res = new LeMarchand([true, false, 'key_true' => true, 'key_false' => false]);

        $this->assertTrue($res->get('settings.0'));
        $this->assertFalse($res->get('settings.1'));

        $this->assertTrue($res->get('settings.key_true'));
        $this->assertFalse($res->get('settings.key_false'));
    }

    public function testConstructorWithNullValues()
    {
        $res = new LeMarchand(
            [
                null,
                'key' => null,
                'level' => [
                    null,
                    [
                        'key' => [
                            'value1',
                            null
                        ]
                    ]
                ]
            ]
        );

        foreach(['settings.0', 'settings.key', 'settings.level.0', 'settings.level.1.key.1'] as $lament){
            $this->expectException(NotFoundExceptionInterface::class);
            $res->get($lament);
            $this->assertFalse($res->has($lament));
        }

        $this->assertEquals('value1', $res->get('settings.level.1.key.0'));
        $this->expectException(NotFoundExceptionInterface::class);
    }

    // write a test for constructor with settings
    public function testConstructorWith5Levels()
    {
        $res = new LeMarchand($this->Settings5Levels());


        $this->assertFalse($res->has('settings.nothing'));
        $this->expectException(NotFoundExceptionInterface::class);
        $res->get('settings.nothing');


        $this->assertTrue($res->has('settings.key'));
        $this->assertEquals('value1', $res->get('settings.key'));

        $this->assertTrue($res->has('settings.2level.key'));
        $this->assertEquals('value2', $res->get('settings.2level.key'));

        $this->assertTrue($res->has('settings.3level.2level.key'));
        $this->assertEquals('value3', $res->get('settings.3level.2level.key'));

        $this->assertTrue($res->has('settings.3level.2level2.key'));
        $this->assertEquals('value4', $res->get('settings.3level.2level2.key'));

        $this->assertTrue($res->has('settings.4level.3level.2level.key'));
        $this->assertEquals('value5', $res->get('settings.4level.3level.2level.key'));

        $this->assertTrue($res->has('settings.4level.3level.2level2.key'));
        $this->assertEquals('value6', $res->get('settings.4level.3level.2level2.key'));

        $this->assertTrue($res->has('settings.5level.4level.3level.2level.key'));
        $this->assertEquals('value9', $res->get('settings.5level.4level.3level.2level.key'));

        $this->assertTrue($res->has('settings.5level.4level.3level.2level2.key'));
        $this->assertEquals('value10', $res->get('settings.5level.4level.3level.2level2.key'));

        $this->assertTrue($res->has('settings.5level.4level2.3level.2level.key'));
        $this->assertEquals('value13', $res->get('settings.5level.4level2.3level.2level.key'));

        $this->assertTrue($res->has('settings.5level.4level2.3level.2level2.key'));
        $this->assertEquals('value14', $res->get('settings.5level.4level2.3level.2level2.key'));

        $this->assertTrue($res->has('settings.5level.4level2.3level2.2level.key'));
        $this->assertEquals('value15', $res->get('settings.5level.4level2.3level2.2level.key'));

        $this->assertTrue($res->has('settings.5level.4level2.3level2.2level2.key'));
        $this->assertEquals('value16', $res->get('settings.5level.4level2.3level2.2level2.key'));
    }

    private function Settings5Levels()
    {
        return [
            'key' => 'value1',
            '2level' => [
                'key' => 'value2'
            ],
            '3level' => [
                '2level' => [
                    'key' => 'value3'
                ],
                '2level2' => [
                    'key' => 'value4'
                ]
            ],
            '4level' => [
                '3level' => [
                    '2level' => [
                        'key' => 'value5'
                    ],
                    '2level2' => [
                        'key' => 'value6'
                    ]
                ],
                '3level2' => [
                    '2level' => [
                        'key' => 'value7'
                    ],
                    '2level2' => [
                        'key' => 'value8'
                    ]
                ]
            ],
            '5level' => [
                '4level' => [
                    '3level' => [
                        '2level' => [
                            'key' => 'value9'
                        ],
                        '2level2' => [
                            'key' => 'value10'
                        ]
                    ],
                    '3level2' => [
                        '2level' => [
                            'key' => 'value11'
                        ],
                        '2level2' => [
                            'key' => 'value12'
                        ]
                    ]
                ],
                '4level2' => [
                    '3level' => [
                        '2level' => [
                            'key' => 'value13'
                        ],
                        '2level2' => [
                            'key' => 'value14'
                        ]
                    ],
                    '3level2' => [
                        '2level' => [
                            'key' => 'value15'
                        ],
                        '2level2' => [
                            'key' => 'value16'
                        ]
                    ]
                ]
            ]

        ];
    }
}


1			<?php
2
3			use PHPUnit\Framework\TestCase;
4			use HexMakina\LeMarchand\LeMarchand;
5			use HexMakina\LeMarchand\Factory;
6			use Psr\Container\ContainerInterface;
7
8			use Psr\Container\ContainerExceptionInterface;
9			use Psr\Container\NotFoundExceptionInterface;
10
11
12			class SettingsAccessTest extends TestCase
13			{
14			public function testConstructor()
15			{
16			$res = new LeMarchand(['key' => 'value']);
17			$this->assertInstanceOf(LeMarchand::class, $res);
18			$this->assertInstanceOf(ContainerInterface::class, $res);
19
20			$this->assertTrue($res->has('settings.key'));
21			$this->assertEquals('value', $res->get('settings.key'));
22			}
23
24			public function testEmptyConstructor()
25			{
26			$res = new LeMarchand([]);
27			$this->assertInstanceOf(LeMarchand::class, $res);
28			$this->assertInstanceOf(ContainerInterface::class, $res);
29
30			$this->assertFalse($res->has('settings.0'));
31
32			$this->expectException(NotFoundExceptionInterface::class);
33			$res->get('settings.nothing');
34
35			$this->assertFalse($res->has('settings.nothing'));
36			}
37
38			public function testConstructorWithNumericallyIndexedStrings()
39			{
40			$res = new LeMarchand(['invalid', 'key' => 'value2', ['value0', 'value1'], 'key_last' => 'value3']);
41			$this->assertEquals('invalid', $res->get('settings.0'));
42			$this->assertEquals('value0', $res->get('settings.1.0'));
43			$this->assertEquals('value1', $res->get('settings.1.1'));
44
45			$this->assertEquals('value2', $res->get('settings.key'));
46			$this->assertEquals('value3', $res->get('settings.key_last'));
47
48
49			$res = new LeMarchand([1]);
50			$this->assertEquals(1, $res->get('settings.0'));
51
52			$settings = [1, 2, 3, 4, 5];
53			unset($settings[2]);
54			$res = new LeMarchand($settings);
55			$this->assertTrue($res->has('settings.0'));
56			$this->assertTrue($res->has('settings.1'));
57			$this->assertFalse($res->has('settings.2'));
58			$this->assertTrue($res->has('settings.3'));
59			$this->assertTrue($res->has('settings.4'));
60
61			$this->assertEquals(1, $res->get('settings.0'));
62			$this->assertEquals(2, $res->get('settings.1'));
63			$this->assertEquals(4, $res->get('settings.3'));
64			$this->assertEquals(5, $res->get('settings.4'));
65
66			$this->expectException(NotFoundExceptionInterface::class);
67			$res->get('settings.2');
68
69
70			$res = new LeMarchand([true]);
71			$this->assertEquals(true, $res->get('settings.0'));
72			}
73
74			public function testConstructorWithObject()
75			{
76			$res = new LeMarchand([new stdClass(), 'key' => new stdClass()]);
77			$this->assertInstanceOf(stdClass::class, $res->get('settings.0'));
78			$this->assertInstanceOf(stdClass::class, $res->get('settings.key'));
79			}
80
81			public function testConstructorWithBooleanValues()
82			{
83			$res = new LeMarchand([true, false, 'key_true' => true, 'key_false' => false]);
84
85			$this->assertTrue($res->get('settings.0'));
86			$this->assertFalse($res->get('settings.1'));
87
88			$this->assertTrue($res->get('settings.key_true'));
89			$this->assertFalse($res->get('settings.key_false'));
90			}
91
92			public function testConstructorWithNullValues()
93			{
94			$res = new LeMarchand(
95			[
96			null,
97			'key' => null,
98			'level' => [
99			null,
100			[
101			'key' => [
102			'value1',
103			null
104			]
105			]
106			]
107			]
108			);
109
110			foreach(['settings.0', 'settings.key', 'settings.level.0', 'settings.level.1.key.1'] as $lament){
111			$this->expectException(NotFoundExceptionInterface::class);
112			$res->get($lament);
113			$this->assertFalse($res->has($lament));
114			}
115
116			$this->assertEquals('value1', $res->get('settings.level.1.key.0'));
117			$this->expectException(NotFoundExceptionInterface::class);
118			}
119
120			// write a test for constructor with settings
121			public function testConstructorWith5Levels()
122			{
123			$res = new LeMarchand($this->Settings5Levels());
124
125
126			$this->assertFalse($res->has('settings.nothing'));
127			$this->expectException(NotFoundExceptionInterface::class);
128			$res->get('settings.nothing');
129
130
131			$this->assertTrue($res->has('settings.key'));
132			$this->assertEquals('value1', $res->get('settings.key'));
133
134			$this->assertTrue($res->has('settings.2level.key'));
135			$this->assertEquals('value2', $res->get('settings.2level.key'));
136
137			$this->assertTrue($res->has('settings.3level.2level.key'));
138			$this->assertEquals('value3', $res->get('settings.3level.2level.key'));
139
140			$this->assertTrue($res->has('settings.3level.2level2.key'));
141			$this->assertEquals('value4', $res->get('settings.3level.2level2.key'));
142
143			$this->assertTrue($res->has('settings.4level.3level.2level.key'));
144			$this->assertEquals('value5', $res->get('settings.4level.3level.2level.key'));
145
146			$this->assertTrue($res->has('settings.4level.3level.2level2.key'));
147			$this->assertEquals('value6', $res->get('settings.4level.3level.2level2.key'));
148
149			$this->assertTrue($res->has('settings.5level.4level.3level.2level.key'));
150			$this->assertEquals('value9', $res->get('settings.5level.4level.3level.2level.key'));
151
152			$this->assertTrue($res->has('settings.5level.4level.3level.2level2.key'));
153			$this->assertEquals('value10', $res->get('settings.5level.4level.3level.2level2.key'));
154
155			$this->assertTrue($res->has('settings.5level.4level2.3level.2level.key'));
156			$this->assertEquals('value13', $res->get('settings.5level.4level2.3level.2level.key'));
157
158			$this->assertTrue($res->has('settings.5level.4level2.3level.2level2.key'));
159			$this->assertEquals('value14', $res->get('settings.5level.4level2.3level.2level2.key'));
160
161			$this->assertTrue($res->has('settings.5level.4level2.3level2.2level.key'));
162			$this->assertEquals('value15', $res->get('settings.5level.4level2.3level2.2level.key'));
163
164			$this->assertTrue($res->has('settings.5level.4level2.3level2.2level2.key'));
165			$this->assertEquals('value16', $res->get('settings.5level.4level2.3level2.2level2.key'));
166			}
167
168			private function Settings5Levels()
169			{
170			return [
171			'key' => 'value1',
172			'2level' => [
173			'key' => 'value2'
174			],
175			'3level' => [
176			'2level' => [
177			'key' => 'value3'
178			],
179			'2level2' => [
180			'key' => 'value4'
181			]
182			],
183			'4level' => [
184			'3level' => [
185			'2level' => [
186			'key' => 'value5'
187			],
188			'2level2' => [
189			'key' => 'value6'
190			]
191			],
192			'3level2' => [
193			'2level' => [
194			'key' => 'value7'
195			],
196			'2level2' => [
197			'key' => 'value8'
198			]
199			]
200			],
201			'5level' => [
202			'4level' => [
203			'3level' => [
204			'2level' => [
205			'key' => 'value9'
206			],
207			'2level2' => [
208			'key' => 'value10'
209			]
210			],
211			'3level2' => [
212			'2level' => [
213			'key' => 'value11'
214			],
215			'2level2' => [
216			'key' => 'value12'
217			]
218			]
219			],
220			'4level2' => [
221			'3level' => [
222			'2level' => [
223			'key' => 'value13'
224			],
225			'2level2' => [
226			'key' => 'value14'
227			]
228			],
229			'3level2' => [
230			'2level' => [
231			'key' => 'value15'
232			],
233			'2level2' => [
234			'key' => 'value16'
235			]
236			]
237			]
238			]
239
240			];
241			}
242			}
243

HexMakina / LeMarchand

SettingsAccessTest::testConstructorWithObject() A last analyzed 2025-02-18 01:20 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

SettingsAccessTest::testConstructorWithObject() A
last analyzed 2025-02-18 01:20 UTC