ClassContainerTest::test_without_dependencies() - Code Metrics - Inspection of "Fix factory service" - gacela-project/container - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — main (#16)

by Chema

created 2025-06-10 09:24 UTC

ClassContainerTest::test_without_dependencies() A

↳ Parent: ClassContainerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

declare(strict_types=1);

namespace GacelaTest\Unit;

use ArrayObject;
use Gacela\Container\Container;
use Gacela\Container\Exception\ContainerException;
use GacelaTest\Fake\ClassWithDependencyWithoutDependencies;
use GacelaTest\Fake\ClassWithInnerObjectDependencies;
use GacelaTest\Fake\ClassWithInterfaceDependencies;
use GacelaTest\Fake\ClassWithObjectDependencies;
use GacelaTest\Fake\ClassWithoutDependencies;
use GacelaTest\Fake\ClassWithRelationship;
use GacelaTest\Fake\Person;
use GacelaTest\Fake\PersonInterface;
use PHPUnit\Framework\TestCase;

final class ClassContainerTest extends TestCase
{
    public function test_static_create_without_dependencies(): void
    {
        $actual = Container::create(ClassWithoutDependencies::class);

        self::assertEquals(new ClassWithoutDependencies(), $actual);
    }

    public function test_static_create_class_with_inner_dependencies_without_dependencies(): void
    {
        $actual = Container::create(ClassWithDependencyWithoutDependencies::class);

        self::assertEquals(new ClassWithDependencyWithoutDependencies(new ClassWithoutDependencies()), $actual);
    }

    public function test_static_create_class_with_inner_dependencies_with_many_dependencies(): void
    {
        $actual = Container::create(ClassWithInnerObjectDependencies::class);

        self::assertEquals(new ClassWithInnerObjectDependencies(new ClassWithRelationship(new Person(), new Person())), $actual);
    }

    public function test_static_create_with_dependencies(): void
    {
        $actual = Container::create(ClassWithObjectDependencies::class);

        self::assertEquals(new ClassWithObjectDependencies(new Person()), $actual);
    }

    public function test_static_create_with_many_dependencies(): void
    {
        $actual = Container::create(ClassWithRelationship::class);

        self::assertEquals(new ClassWithRelationship(new Person(), new Person()), $actual);
    }

    public function test_without_dependencies(): void
    {
        $container = new Container();
        $actual = $container->get(ClassWithoutDependencies::class);

        self::assertEquals(new ClassWithoutDependencies(), $actual);
    }

    public function test_object_with_resolvable_dependencies(): void
    {
        $container = new Container();
        $actual = $container->get(ClassWithObjectDependencies::class);

        self::assertEquals(new ClassWithObjectDependencies(new Person()), $actual);
    }

    public function test_interface_dependency(): void
    {
        $container = new Container([
            PersonInterface::class => Person::class,
        ]);
        $actual = $container->get(ClassWithObjectDependencies::class);

        self::assertEquals(new ClassWithObjectDependencies(new Person()), $actual);
    }

    public function test_use_mapped_interface_dependency(): void
    {
        $person = new Person();
        $person->name = 'anything';

        $container = new Container([
            PersonInterface::class => $person,
        ]);
        $actual = $container->get(ClassWithInterfaceDependencies::class);

        self::assertEquals(new ClassWithInterfaceDependencies($person), $actual);
    }

    public function test_has_not_existing_class(): void
    {
        $container = new Container();
        $actual = $container->has(InexistentClass::class);

        self::assertFalse($actual);
    }

    public function test_resolve_object_from_interface(): void
    {
        $person = new Person();
        $person->name = 'person-name';

        $container = new Container([
            PersonInterface::class => $person,
        ]);
        $resolvedPerson = $container->get(PersonInterface::class);

        self::assertSame($resolvedPerson, $person);
    }

    public function test_resolve_new_object(): void
    {
        // We are registering 'PersonInterface::class', but 'Person::class' was not.
        // As result, a 'new Person()' will be resolved.
        $person = new Person();
        $person->name = 'person-name';

        $container = new Container([
            PersonInterface::class => $person,
        ]);
        $resolvedPerson = $container->get(Person::class);

        self::assertEquals($resolvedPerson, new Person()); // different objects!
    }

    public function test_interface_not_registered_returns_null(): void
    {
        $container = new Container([
            Person::class => new Person(),
        ]);
        $resolvedPerson = $container->get(PersonInterface::class);

        self::assertNull($resolvedPerson);
    }

    public function test_resolve_object_from_classname(): void
    {
        $container = new Container([
            PersonInterface::class => Person::class,
        ]);
        $resolvedPerson = $container->get(PersonInterface::class);

        self::assertEquals($resolvedPerson, new Person());
    }

    public function test_resolve_object_from_instance_in_a_callable(): void
    {
        $person = new Person();
        $person->name = 'person-name';

        $container = new Container([
            PersonInterface::class => static fn () => $person,
        ]);
        $resolvedPerson = $container->get(PersonInterface::class);

        self::assertEquals($resolvedPerson, $person);
    }

    public function test_resolve_object_from_callable_classname_in_a_callable(): void
    {
        $container = new Container([
            PersonInterface::class => static fn () => Person::class,
        ]);
        $resolvedPerson = $container->get(PersonInterface::class);

        self::assertEquals($resolvedPerson, new Person());
    }

    public function test_get_non_existing_service(): void
    {
        $container = new Container();

        self::assertNull($container->get('unknown-service_name'));
    }

    public function test_has_service(): void
    {
        $container = new Container();
        $container->set('service_name', 'value');

        self::assertTrue($container->has('service_name'));
        self::assertFalse($container->has('unknown-service_name'));
    }

    public function test_remove_existing_service(): void
    {
        $container = new Container();
        $container->set('service_name', 'value');
        $container->remove('service_name');

        self::assertNull($container->get('service_name'));
    }

    public function test_resolve_service_as_raw_string(): void
    {
        $container = new Container();
        $container->set('service_name', 'value');

        $resolvedService = $container->get('service_name');
        self::assertSame('value', $resolvedService);

        $cachedResolvedService = $container->get('service_name');
        self::assertSame('value', $cachedResolvedService);
    }

    public function test_resolve_service_as_function(): void
    {
        $container = new Container();
        $container->set('service_name', static fn () => 'value');

        $resolvedService = $container->get('service_name');
        self::assertSame('value', $resolvedService);

        $cachedResolvedService = $container->get('service_name');
        self::assertSame('value', $cachedResolvedService);
    }

    public function test_resolve_service_as_callable_class(): void
    {
        $container = new Container();
        $container->set(
            'service_name',
            new class() {
                public function __invoke(): string
                {
                    return 'value';
                }
            },
        );

        $resolvedService = $container->get('service_name');
        self::assertSame('value', $resolvedService);

        $cachedResolvedService = $container->get('service_name');
        self::assertSame('value', $cachedResolvedService);
    }

    public function test_resolve_non_factory_service_with_random(): void
    {
        $container = new Container();
        $container->set(
            'service_name',
            static fn () => 'value_' . random_int(0, PHP_INT_MAX),
        );

        self::assertSame(
            $container->get('service_name'),
            $container->get('service_name'),
        );
    }

    public function test_resolve_factory_service_with_random(): void
    {
        $container = new Container();
        $container->set(
            'service_name',
            $container->factory(
                static fn () => 'value_' . random_int(0, PHP_INT_MAX),
            ),
        );

        self::assertNotSame(
            $container->get('service_name'),
            $container->get('service_name'),
        );
    }

    public function test_extend_existing_factory_service(): void
    {
        $container = new Container();
        $container->set('n3', 3);
        $container->set(
            'service_name',
            $container->factory(
                static fn () => new ArrayObject([1, 2]),
            ),
        );

        $container->extend(
            'service_name',
            static function (ArrayObject $arrayObject, Container $container): ArrayObject {
                $arrayObject->append($container->get('n3'));

                return $arrayObject;
            },
        );

        /** @var ArrayObject $first */
        $first = $container->get('service_name');
        /** @var ArrayObject $second */
        $second = $container->get('service_name');

        self::assertEquals(new ArrayObject([1, 2, 3]), $first);
        self::assertEquals(new ArrayObject([1, 2, 3]), $second);
        self::assertNotSame($first, $second);
    }

    public function test_extend_existing_callable_service(): void
    {
        $container = new Container();
        $container->set('n3', 3);
        $container->set('service_name', static fn () => new ArrayObject([1, 2]));

        $container->extend(
            'service_name',
            static function (ArrayObject $arrayObject, Container $container) {
                $arrayObject->append($container->get('n3'));
                return $arrayObject;
            },
        );

        $container->extend(
            'service_name',
            static fn (ArrayObject $arrayObject) => $arrayObject->append(4),
        );

        /** @var ArrayObject $actual */
        $actual = $container->get('service_name');

        self::assertEquals(new ArrayObject([1, 2, 3, 4]), $actual);
    }

    public function test_set_after_extend(): void
    {
        $container = new Container();

        $container->extend(
            'service_name',
            static fn (ArrayObject $arrayObject) => $arrayObject->append(3),
        );

        $container->set('service_name', static fn () => new ArrayObject([1, 2]));

        /** @var ArrayObject $actual */
        $actual = $container->get('service_name');

        self::assertEquals(new ArrayObject([1, 2, 3]), $actual);
    }

    public function test_extend_existing_object_service(): void
    {
        $container = new Container();
        $container->set('n3', 3);
        $container->set('service_name', new ArrayObject([1, 2]));

        $container->extend(
            'service_name',
            static function (ArrayObject $arrayObject, Container $container) {
                $arrayObject->append($container->get('n3'));
                return $arrayObject;
            },
        );

        $container->extend(
            'service_name',
            static function (ArrayObject $arrayObject): void {
                $arrayObject->append(4);
            },
        );

        /** @var ArrayObject $actual */
        $actual = $container->get('service_name');

        self::assertEquals(new ArrayObject([1, 2, 3, 4]), $actual);
    }

    public function test_extend_existing_array_service(): void
    {
        $container = new Container();
        $container->set('service_name', [1, 2]);

        $container->extend(
            'service_name',
            static function (array $arrayObject): array {
                $arrayObject[] = 3;
                return $arrayObject;
            },
        );

        $container->extend(
            'service_name',
            static function (array &$arrayObject): void {
                $arrayObject[] = 4;
            },
        );

        /** @var ArrayObject $actual */
        $actual = $container->get('service_name');

        self::assertEquals([1, 2, 3, 4], $actual);
    }

    public function test_extend_non_existing_service(): void
    {
        $container = new Container();
        $container->extend('service_name', static fn () => '');

        self::assertNull($container->get('service_name'));
    }

    public function test_service_not_extendable(): void
    {
        $container = new Container();
        $container->set('service_name', 'raw string');

        $this->expectExceptionObject(ContainerException::instanceNotExtendable());
        $container->extend('service_name', static fn (string $str) => $str);
    }

    public function test_extend_existing_used_object_service_is_allowed(): void
    {
        $container = new Container();
        $container->set('service_name', new ArrayObject([1, 2]));
        $container->get('service_name'); // and get frozen

        $this->expectExceptionObject(ContainerException::frozenInstanceExtend('service_name'));

        $container->extend(
            'service_name',
            static fn (ArrayObject $arrayObject) => $arrayObject->append(3),
        );
    }

    public function test_extend_existing_used_callable_service_then_error(): void
    {
        $container = new Container();
        $container->set('service_name', static fn () => new ArrayObject([1, 2]));
        $container->get('service_name'); // and get frozen

        $this->expectExceptionObject(ContainerException::frozenInstanceExtend('service_name'));

        $container->extend(
            'service_name',
            static fn (ArrayObject $arrayObject) => $arrayObject->append(3),
        );
    }

    public function test_extend_later_existing_frozen_object_service_then_error(): void
    {
        $container = new Container();
        $container->extend(
            'service_name',
            static fn (ArrayObject $arrayObject) => $arrayObject->append(3),
        );

        $container->set('service_name', new ArrayObject([1, 2]));
        $container->get('service_name'); // and get frozen

        $this->expectExceptionObject(ContainerException::frozenInstanceExtend('service_name'));

        $container->extend(
            'service_name',
            static fn (ArrayObject $arrayObject) => $arrayObject->append(4),
        );
    }

    public function test_extend_later_existing_frozen_callable_service_then_error(): void
    {
        $container = new Container();
        $container->extend(
            'service_name',
            static fn (ArrayObject $arrayObject) => $arrayObject->append(3),
        );

        $container->set('service_name', static fn () => new ArrayObject([1, 2]));
        $container->get('service_name'); // and get frozen

        $this->expectExceptionObject(ContainerException::frozenInstanceExtend('service_name'));

        $container->extend(
            'service_name',
            static fn (ArrayObject $arrayObject) => $arrayObject->append(4),
        );
    }

    public function test_set_existing_frozen_service(): void
    {
        $container = new Container();
        $container->set('service_name', static fn () => new ArrayObject([1, 2]));
        $container->get('service_name'); // and get frozen

        $this->expectExceptionObject(ContainerException::frozenInstanceOverride('service_name'));
        $container->set('service_name', static fn () => new ArrayObject([3]));
    }

    public function test_protect_service_is_not_resolved(): void
    {
        $container = new Container();
        $service = static fn () => 'value';
        $container->set('service_name', $container->protect($service));

        self::assertSame($service, $container->get('service_name'));
    }

    public function test_protect_service_cannot_be_extended(): void
    {
        $container = new Container();
        $container->set(
            'service_name',
            $container->protect(static fn () => new ArrayObject([1, 2])),
        );

        $this->expectExceptionObject(ContainerException::instanceProtected('service_name'));

        $container->extend(
            'service_name',
            static fn (ArrayObject $arrayObject) => $arrayObject,
        );
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace GacelaTest\Unit;
6
7			use ArrayObject;
8			use Gacela\Container\Container;
9			use Gacela\Container\Exception\ContainerException;
10			use GacelaTest\Fake\ClassWithDependencyWithoutDependencies;
11			use GacelaTest\Fake\ClassWithInnerObjectDependencies;
12			use GacelaTest\Fake\ClassWithInterfaceDependencies;
13			use GacelaTest\Fake\ClassWithObjectDependencies;
14			use GacelaTest\Fake\ClassWithoutDependencies;
15			use GacelaTest\Fake\ClassWithRelationship;
16			use GacelaTest\Fake\Person;
17			use GacelaTest\Fake\PersonInterface;
18			use PHPUnit\Framework\TestCase;
19
20			final class ClassContainerTest extends TestCase
21			{
22			public function test_static_create_without_dependencies(): void
23			{
24			$actual = Container::create(ClassWithoutDependencies::class);
25
26			self::assertEquals(new ClassWithoutDependencies(), $actual);
27			}
28
29			public function test_static_create_class_with_inner_dependencies_without_dependencies(): void
30			{
31			$actual = Container::create(ClassWithDependencyWithoutDependencies::class);
32
33			self::assertEquals(new ClassWithDependencyWithoutDependencies(new ClassWithoutDependencies()), $actual);
34			}
35
36			public function test_static_create_class_with_inner_dependencies_with_many_dependencies(): void
37			{
38			$actual = Container::create(ClassWithInnerObjectDependencies::class);
39
40			self::assertEquals(new ClassWithInnerObjectDependencies(new ClassWithRelationship(new Person(), new Person())), $actual);
41			}
42
43			public function test_static_create_with_dependencies(): void
44			{
45			$actual = Container::create(ClassWithObjectDependencies::class);
46
47			self::assertEquals(new ClassWithObjectDependencies(new Person()), $actual);
48			}
49
50			public function test_static_create_with_many_dependencies(): void
51			{
52			$actual = Container::create(ClassWithRelationship::class);
53
54			self::assertEquals(new ClassWithRelationship(new Person(), new Person()), $actual);
55			}
56
57			public function test_without_dependencies(): void
58			{
59			$container = new Container();
60			$actual = $container->get(ClassWithoutDependencies::class);
61
62			self::assertEquals(new ClassWithoutDependencies(), $actual);
63			}
64
65			public function test_object_with_resolvable_dependencies(): void
66			{
67			$container = new Container();
68			$actual = $container->get(ClassWithObjectDependencies::class);
69
70			self::assertEquals(new ClassWithObjectDependencies(new Person()), $actual);
71			}
72
73			public function test_interface_dependency(): void
74			{
75			$container = new Container([
76			PersonInterface::class => Person::class,
77			]);
78			$actual = $container->get(ClassWithObjectDependencies::class);
79
80			self::assertEquals(new ClassWithObjectDependencies(new Person()), $actual);
81			}
82
83			public function test_use_mapped_interface_dependency(): void
84			{
85			$person = new Person();
86			$person->name = 'anything';
87
88			$container = new Container([
89			PersonInterface::class => $person,
90			]);
91			$actual = $container->get(ClassWithInterfaceDependencies::class);
92
93			self::assertEquals(new ClassWithInterfaceDependencies($person), $actual);
94			}
95
96			public function test_has_not_existing_class(): void
97			{
98			$container = new Container();
99			$actual = $container->has(InexistentClass::class);
100
101			self::assertFalse($actual);
102			}
103
104			public function test_resolve_object_from_interface(): void
105			{
106			$person = new Person();
107			$person->name = 'person-name';
108
109			$container = new Container([
110			PersonInterface::class => $person,
111			]);
112			$resolvedPerson = $container->get(PersonInterface::class);
113
114			self::assertSame($resolvedPerson, $person);
115			}
116
117			public function test_resolve_new_object(): void
118			{
119			// We are registering 'PersonInterface::class', but 'Person::class' was not.
120			// As result, a 'new Person()' will be resolved.
121			$person = new Person();
122			$person->name = 'person-name';
123
124			$container = new Container([
125			PersonInterface::class => $person,
126			]);
127			$resolvedPerson = $container->get(Person::class);
128
129			self::assertEquals($resolvedPerson, new Person()); // different objects!
130			}
131
132			public function test_interface_not_registered_returns_null(): void
133			{
134			$container = new Container([
135			Person::class => new Person(),
136			]);
137			$resolvedPerson = $container->get(PersonInterface::class);
138
139			self::assertNull($resolvedPerson);
140			}
141
142			public function test_resolve_object_from_classname(): void
143			{
144			$container = new Container([
145			PersonInterface::class => Person::class,
146			]);
147			$resolvedPerson = $container->get(PersonInterface::class);
148
149			self::assertEquals($resolvedPerson, new Person());
150			}
151
152			public function test_resolve_object_from_instance_in_a_callable(): void
153			{
154			$person = new Person();
155			$person->name = 'person-name';
156
157			$container = new Container([
158			PersonInterface::class => static fn () => $person,
159			]);
160			$resolvedPerson = $container->get(PersonInterface::class);
161
162			self::assertEquals($resolvedPerson, $person);
163			}
164
165			public function test_resolve_object_from_callable_classname_in_a_callable(): void
166			{
167			$container = new Container([
168			PersonInterface::class => static fn () => Person::class,
169			]);
170			$resolvedPerson = $container->get(PersonInterface::class);
171
172			self::assertEquals($resolvedPerson, new Person());
173			}
174
175			public function test_get_non_existing_service(): void
176			{
177			$container = new Container();
178
179			self::assertNull($container->get('unknown-service_name'));
180			}
181
182			public function test_has_service(): void
183			{
184			$container = new Container();
185			$container->set('service_name', 'value');
186
187			self::assertTrue($container->has('service_name'));
188			self::assertFalse($container->has('unknown-service_name'));
189			}
190
191			public function test_remove_existing_service(): void
192			{
193			$container = new Container();
194			$container->set('service_name', 'value');
195			$container->remove('service_name');
196
197			self::assertNull($container->get('service_name'));
198			}
199
200			public function test_resolve_service_as_raw_string(): void
201			{
202			$container = new Container();
203			$container->set('service_name', 'value');
204
205			$resolvedService = $container->get('service_name');
206			self::assertSame('value', $resolvedService);
207
208			$cachedResolvedService = $container->get('service_name');
209			self::assertSame('value', $cachedResolvedService);
210			}
211
212			public function test_resolve_service_as_function(): void
213			{
214			$container = new Container();
215			$container->set('service_name', static fn () => 'value');
216
217			$resolvedService = $container->get('service_name');
218			self::assertSame('value', $resolvedService);
219
220			$cachedResolvedService = $container->get('service_name');
221			self::assertSame('value', $cachedResolvedService);
222			}
223
224			public function test_resolve_service_as_callable_class(): void
225			{
226			$container = new Container();
227			$container->set(
228			'service_name',
229			new class() {
230			public function __invoke(): string
231			{
232			return 'value';
233			}
234			},
235			);
236
237			$resolvedService = $container->get('service_name');
238			self::assertSame('value', $resolvedService);
239
240			$cachedResolvedService = $container->get('service_name');
241			self::assertSame('value', $cachedResolvedService);
242			}
243
244			public function test_resolve_non_factory_service_with_random(): void
245			{
246			$container = new Container();
247			$container->set(
248			'service_name',
249			static fn () => 'value_' . random_int(0, PHP_INT_MAX),
250			);
251
252			self::assertSame(
253			$container->get('service_name'),
254			$container->get('service_name'),
255			);
256			}
257
258			public function test_resolve_factory_service_with_random(): void
259			{
260			$container = new Container();
261			$container->set(
262			'service_name',
263			$container->factory(
264			static fn () => 'value_' . random_int(0, PHP_INT_MAX),
265			),
266			);
267
268			self::assertNotSame(
269			$container->get('service_name'),
270			$container->get('service_name'),
271			);
272			}
273
274			public function test_extend_existing_factory_service(): void
275			{
276			$container = new Container();
277			$container->set('n3', 3);
278			$container->set(
279			'service_name',
280			$container->factory(
281			static fn () => new ArrayObject([1, 2]),
282			),
283			);
284
285			$container->extend(
286			'service_name',
287			static function (ArrayObject $arrayObject, Container $container): ArrayObject {
288			$arrayObject->append($container->get('n3'));
289
290			return $arrayObject;
291			},
292			);
293
294			/** @var ArrayObject $first */
295			$first = $container->get('service_name');
296			/** @var ArrayObject $second */
297			$second = $container->get('service_name');
298
299			self::assertEquals(new ArrayObject([1, 2, 3]), $first);
300			self::assertEquals(new ArrayObject([1, 2, 3]), $second);
301			self::assertNotSame($first, $second);
302			}
303
304			public function test_extend_existing_callable_service(): void
305			{
306			$container = new Container();
307			$container->set('n3', 3);
308			$container->set('service_name', static fn () => new ArrayObject([1, 2]));
309
310			$container->extend(
311			'service_name',
312			static function (ArrayObject $arrayObject, Container $container) {
313			$arrayObject->append($container->get('n3'));
314			return $arrayObject;
315			},
316			);
317
318			$container->extend(
319			'service_name',
320			static fn (ArrayObject $arrayObject) => $arrayObject->append(4),
321			);
322
323			/** @var ArrayObject $actual */
324			$actual = $container->get('service_name');
325
326			self::assertEquals(new ArrayObject([1, 2, 3, 4]), $actual);
327			}
328
329			public function test_set_after_extend(): void
330			{
331			$container = new Container();
332
333			$container->extend(
334			'service_name',
335			static fn (ArrayObject $arrayObject) => $arrayObject->append(3),
336			);
337
338			$container->set('service_name', static fn () => new ArrayObject([1, 2]));
339
340			/** @var ArrayObject $actual */
341			$actual = $container->get('service_name');
342
343			self::assertEquals(new ArrayObject([1, 2, 3]), $actual);
344			}
345
346			public function test_extend_existing_object_service(): void
347			{
348			$container = new Container();
349			$container->set('n3', 3);
350			$container->set('service_name', new ArrayObject([1, 2]));
351
352			$container->extend(
353			'service_name',
354			static function (ArrayObject $arrayObject, Container $container) {
355			$arrayObject->append($container->get('n3'));
356			return $arrayObject;
357			},
358			);
359
360			$container->extend(
361			'service_name',
362			static function (ArrayObject $arrayObject): void {
363			$arrayObject->append(4);
364			},
365			);
366
367			/** @var ArrayObject $actual */
368			$actual = $container->get('service_name');
369
370			self::assertEquals(new ArrayObject([1, 2, 3, 4]), $actual);
371			}
372
373			public function test_extend_existing_array_service(): void
374			{
375			$container = new Container();
376			$container->set('service_name', [1, 2]);
377
378			$container->extend(
379			'service_name',
380			static function (array $arrayObject): array {
381			$arrayObject[] = 3;
382			return $arrayObject;
383			},
384			);
385
386			$container->extend(
387			'service_name',
388			static function (array &$arrayObject): void {
389			$arrayObject[] = 4;
390			},
391			);
392
393			/** @var ArrayObject $actual */
394			$actual = $container->get('service_name');
395
396			self::assertEquals([1, 2, 3, 4], $actual);
397			}
398
399			public function test_extend_non_existing_service(): void
400			{
401			$container = new Container();
402			$container->extend('service_name', static fn () => '');
403
404			self::assertNull($container->get('service_name'));
405			}
406
407			public function test_service_not_extendable(): void
408			{
409			$container = new Container();
410			$container->set('service_name', 'raw string');
411
412			$this->expectExceptionObject(ContainerException::instanceNotExtendable());
413			$container->extend('service_name', static fn (string $str) => $str);
414			}
415
416			public function test_extend_existing_used_object_service_is_allowed(): void
417			{
418			$container = new Container();
419			$container->set('service_name', new ArrayObject([1, 2]));
420			$container->get('service_name'); // and get frozen
421
422			$this->expectExceptionObject(ContainerException::frozenInstanceExtend('service_name'));
423
424			$container->extend(
425			'service_name',
426			static fn (ArrayObject $arrayObject) => $arrayObject->append(3),
427			);
428			}
429
430			public function test_extend_existing_used_callable_service_then_error(): void
431			{
432			$container = new Container();
433			$container->set('service_name', static fn () => new ArrayObject([1, 2]));
434			$container->get('service_name'); // and get frozen
435
436			$this->expectExceptionObject(ContainerException::frozenInstanceExtend('service_name'));
437
438			$container->extend(
439			'service_name',
440			static fn (ArrayObject $arrayObject) => $arrayObject->append(3),
441			);
442			}
443
444			public function test_extend_later_existing_frozen_object_service_then_error(): void
445			{
446			$container = new Container();
447			$container->extend(
448			'service_name',
449			static fn (ArrayObject $arrayObject) => $arrayObject->append(3),
450			);
451
452			$container->set('service_name', new ArrayObject([1, 2]));
453			$container->get('service_name'); // and get frozen
454
455			$this->expectExceptionObject(ContainerException::frozenInstanceExtend('service_name'));
456
457			$container->extend(
458			'service_name',
459			static fn (ArrayObject $arrayObject) => $arrayObject->append(4),
460			);
461			}
462
463			public function test_extend_later_existing_frozen_callable_service_then_error(): void
464			{
465			$container = new Container();
466			$container->extend(
467			'service_name',
468			static fn (ArrayObject $arrayObject) => $arrayObject->append(3),
469			);
470
471			$container->set('service_name', static fn () => new ArrayObject([1, 2]));
472			$container->get('service_name'); // and get frozen
473
474			$this->expectExceptionObject(ContainerException::frozenInstanceExtend('service_name'));
475
476			$container->extend(
477			'service_name',
478			static fn (ArrayObject $arrayObject) => $arrayObject->append(4),
479			);
480			}
481
482			public function test_set_existing_frozen_service(): void
483			{
484			$container = new Container();
485			$container->set('service_name', static fn () => new ArrayObject([1, 2]));
486			$container->get('service_name'); // and get frozen
487
488			$this->expectExceptionObject(ContainerException::frozenInstanceOverride('service_name'));
489			$container->set('service_name', static fn () => new ArrayObject([3]));
490			}
491
492			public function test_protect_service_is_not_resolved(): void
493			{
494			$container = new Container();
495			$service = static fn () => 'value';
496			$container->set('service_name', $container->protect($service));
497
498			self::assertSame($service, $container->get('service_name'));
499			}
500
501			public function test_protect_service_cannot_be_extended(): void
502			{
503			$container = new Container();
504			$container->set(
505			'service_name',
506			$container->protect(static fn () => new ArrayObject([1, 2])),
507			);
508
509			$this->expectExceptionObject(ContainerException::instanceProtected('service_name'));
510
511			$container->extend(
512			'service_name',
513			static fn (ArrayObject $arrayObject) => $arrayObject,
514			);
515			}
516			}
517

gacela-project / container

Pull Request — main (#16)

ClassContainerTest::test_without_dependencies() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like