FailsafeContainerTest.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
namespace ‪TYPO3\CMS\Core\Tests\Unit\DependencyInjection;
 
use Prophecy\PhpUnit\ProphecyTrait;
use Prophecy\Prophecy\ObjectProphecy;
use Psr\Container\ContainerExceptionInterface;
use Psr\Container\ContainerInterface;
use Psr\Container\NotFoundExceptionInterface;
use stdClass as Service;
use ‪TYPO3\CMS\Core\DependencyInjection\FailsafeContainer as Container;
use ‪TYPO3\CMS\Core\DependencyInjection\ServiceProviderInterface;
use TYPO3\TestingFramework\Core\Unit\UnitTestCase;
 
class ‪FailsafeContainerTest extends UnitTestCase
{
    use ProphecyTrait;
 
    protected ?ObjectProphecy ‪$providerProphecy;
 
    protected function ‪setUp(): void
    {
        parent::setUp();
 
        $this->providerProphecy = $this->‪createServiceProviderProphecy();
    }
 
    protected function ‪createServiceProviderProphecy(array $extensions = [], array $factories = []): ObjectProphecy
    {
        $prophecy = $this->prophesize();
        $prophecy->willImplement(ServiceProviderInterface::class);
        $prophecy->getFactories()->willReturn($extensions);
        $prophecy->getExtensions()->willReturn($factories);
        return $prophecy;
    }
 
    public function ‪implementsInterface(): void
    {
        self::assertInstanceOf(ContainerInterface::class, new Container());
    }
 
    public function ‪withString(): void
    {
        $this->providerProphecy->getFactories()->willReturn([
            'param' => static function () {
                return 'value';
            },
        ]);
        $container = new Container([$this->providerProphecy->reveal()]);
 
        self::assertTrue($container->has('param'));
        self::assertEquals('value', $container->get('param'));
    }
 
    public function get($factory): void
    {
        $this->providerProphecy->getFactories()->willReturn([
            'service' => $factory,
        ]);
        $container = new Container([$this->providerProphecy->reveal()]);
 
        self::assertTrue($container->has('service'));
        self::assertInstanceOf(Service::class, $container->get('service'));
    }
 
    public function ‪multipleGetServicesShouldBeEqual($factory): void
    {
        $this->providerProphecy->getFactories()->willReturn([ 'service' => $factory ]);
        // A factory can also be used as extension, as it's based on the same signature
        $this->providerProphecy->getExtensions()->willReturn([ 'extension' => $factory ]);
 
        $container = new Container([$this->providerProphecy->reveal()]);
 
        $serviceOne = $container->get('service');
        $serviceTwo = $container->get('service');
 
        $extensionOne = $container->get('extension');
        $extensionTwo = $container->get('extension');
 
        self::assertSame($serviceOne, $serviceTwo);
        self::assertSame($extensionOne, $extensionTwo);
    }
 
    public function ‪passesContainerAsParameter(): void
    {
        $this->providerProphecy->getFactories()->willReturn([
            'service' => static function () {
                return new Service();
            },
            'container' => static function (ContainerInterface $container) {
                return $container;
            },
        ]);
        $container = new Container([$this->providerProphecy->reveal()]);
 
        self::assertNotSame($container, $container->get('service'));
        self::assertSame($container, $container->get('container'));
    }
 
    public function ‪nullValueEntry(): void
    {
        $this->providerProphecy->getFactories()->willReturn([
            'null' => static function () {
                return null;
            },
        ]);
        $container = new Container([$this->providerProphecy->reveal()]);
 
        self::assertTrue($container->has('null'));
        self::assertNull($container->get('null'));
    }
 
    public function ‪nullValueEntryCallsFactoryOnlyOnce(): void
    {
        $calledCount = 0;
        $factory = static function () use (&$calledCount) {
            $calledCount++;
            return null;
        };
        $this->providerProphecy->getFactories()->willReturn([
            'null' => $factory,
        ]);
        $container = new Container([$this->providerProphecy->reveal()]);
 
        self::assertTrue($container->has('null'));
        self::assertNull($container->get('null'));
        self::assertTrue($container->has('null'));
        self::assertNull($container->get('null'));
        self::assertEquals(1, $calledCount);
    }
 
    public function ‪has(): void
    {
        $this->providerProphecy->getFactories()->willReturn([
            'service' => static function () {
                return new Service();
            },
            'param' => static function () {
                return 'value';
            },
            'int' => static function () {
                return 2;
            },
            'bool' => static function () {
                return false;
            },
            'null' => static function () {
                return null;
            },
            '0' => static function () {
                return 0;
            },
        ]);
        $container = new Container([$this->providerProphecy->reveal()]);
 
        self::assertTrue($container->has('param'));
        self::assertTrue($container->has('service'));
        self::assertTrue($container->has('int'));
        self::assertTrue($container->has('bool'));
        self::assertTrue($container->has('null'));
        self::assertFalse($container->has('non_existent'));
    }
 
    public function ‪defaultEntry(): void
    {
        $default = ['param' => 'value'];
        $container = new Container([], $default);
 
        self::assertSame('value', $container->get('param'));
    }
 
    public function ‪getValidatesKeyIsPresent(): void
    {
        $container = new Container();
 
        $this->expectException(NotFoundExceptionInterface::class);
        $this->expectExceptionMessage('Container entry "foo" is not available.');
        $container->get('foo');
    }
 
    public function ‪extension($factory): void
    {
        $providerA = ‪$this->providerProphecy;
        $providerA->getFactories()->willReturn(['service' => $factory]);
 
        $providerB = $this->‪createServiceProviderProphecy();
        $providerB->getExtensions()->willReturn([
            'service' => static function (ContainerInterface $c, Service $s) {
                $s->value = 'value';
                return $s;
            },
        ]);
        $iterator = (static function () use ($providerA, $providerB): iterable {
            yield $providerA->reveal();
            yield $providerB->reveal();
        })();
        $container = new Container($iterator);
 
        self::assertSame('value', $container->get('service')->value);
    }
 
    public function ‪extendingLaterProvider($factory): void
    {
        $providerA = ‪$this->providerProphecy;
        $providerA->getFactories()->willReturn(['service' => $factory]);
 
        $providerB = $this->‪createServiceProviderProphecy();
        $providerB->getExtensions()->willReturn([
            'service' => static function (ContainerInterface $c, Service $s) {
                $s->value = 'value';
                return $s;
            },
        ]);
        $container = new Container([$providerB->reveal(), $providerA->reveal()]);
 
        self::assertSame('value', $container->get('service')->value);
    }
 
    public function ‪extendingOwnFactory($factory): void
    {
        $this->providerProphecy->getFactories()->willReturn(['service' => $factory]);
        $this->providerProphecy->getExtensions()->willReturn(
            [
                'service' => static function (ContainerInterface $c, Service $s) {
                    $s->value = 'value';
                    return $s;
                },
            ]
        );
        $container = new Container([$this->providerProphecy->reveal()]);
 
        self::assertSame('value', $container->get('service')->value);
    }
 
    public function ‪extendingNonExistingFactory(): void
    {
        $this->providerProphecy->getExtensions()->willReturn([
            'service' => static function (ContainerInterface $c, Service $s = null) {
                if ($s === null) {
                    $s = new Service();
                }
                $s->value = 'value';
                return $s;
            },
        ]);
        $container = new Container([$this->providerProphecy->reveal()]);
 
        self::assertSame('value', $container->get('service')->value);
    }
 
    public function ‪multipleExtensions($factory): void
    {
        $providerA = ‪$this->providerProphecy;
        $providerA->getFactories()->willReturn(['service' => $factory]);
 
        $providerB = $this->‪createServiceProviderProphecy();
        $providerB->getExtensions()->willReturn([
            'service' => static function (ContainerInterface $c, Service $s) {
                $s->value = '1';
                return $s;
            },
        ]);
 
        $providerC = $this->‪createServiceProviderProphecy();
        $providerC->getExtensions()->willReturn([
            'service' => static function (ContainerInterface $c, Service $s) {
                $s->value .= '2';
                return $s;
            },
        ]);
        $container = new Container([$providerA->reveal(), $providerB->reveal(), $providerC->reveal()]);
 
        self::assertSame('12', $container->get('service')->value);
    }
 
    public function ‪entryOverriding($factory): void
    {
        $providerA = ‪$this->providerProphecy;
        $providerA->getFactories()->willReturn(['service' => $factory]);
 
        $providerB = $this->‪createServiceProviderProphecy();
        $providerB->getFactories()->willReturn(['service' => static function () {
            return 'value';
        }]);
 
        $container = new Container([$providerA->reveal(), $providerB->reveal()]);
 
        self::assertNotInstanceOf(Service::class, $container->get('service'));
        self::assertEquals('value', $container->get('service'));
    }
 
    public function ‪cyclicDependency(): void
    {
        $this->providerProphecy->getFactories()->willReturn([
            'A' => static function (ContainerInterface $container) {
                return $container->get('B');
            },
            'B' => static function (ContainerInterface $container) {
                return $container->get('A');
            },
        ]);
 
        $container = new Container([$this->providerProphecy->reveal()]);
 
        $this->expectException(ContainerExceptionInterface::class);
        $this->expectExceptionMessage('Container entry "A" is part of a cyclic dependency chain.');
        $container->get('A');
    }
 
    public function ‪cyclicDependencyRetrievedTwice(): void
    {
        $this->providerProphecy->getFactories()->willReturn([
            'A' => static function (ContainerInterface $container) {
                return $container->get('B');
            },
            'B' => static function (ContainerInterface $container) {
                return $container->get('A');
            },
        ]);
 
        $container = new Container([$this->providerProphecy->reveal()]);
 
        $this->expectException(ContainerExceptionInterface::class);
        $this->expectExceptionMessage('Container entry "A" is part of a cyclic dependency chain.');
        try {
            $container->get('A');
        } catch (ContainerExceptionInterface $e) {
        }
        self::assertTrue($container->has('A'));
        $container->get('A');
    }
 
    public function ‪nullContainer(): void
    {
        $container = new Container();
        self::assertFalse($container->has('foo'));
    }
public function ‪nullContainerWithDefaultEntries(): void
    {
        $container = new Container([], ['foo' => 'bar']);
        self::assertTrue($container->has('foo'));
    }
 
    public static function ‪factory(): Service
    {
        return new Service();
    }
 
    public function ‪objectFactories(): array
    {
        return [
            [
                // Static callback
                [ self::class, 'factory'],
            ],
            [
                // Closure
                static function () {
                    return new Service();
                },
            ],
            [
                // Invokable
                new class () {
                    public function __invoke(): Service
                    {
                        return new Service();
                    }
                },
            ],
            [
                // Non static factory
                [
                    new class () {
                        public function ‪factory(): Service
                        {
                            return new Service();
                        }
                    },
                    'factory',
                ],
            ],
        ];
    }
}