AntidotTest\Container\ContainerBuilderTest

Complexity

Total Complexity

7

Size/Duplication

Total Lines	112
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	testItShouldCreateAConfiguredContainerFromFrameworkConfigWithAnonymousFunctionFactories()	0	15	1
A	testItShouldCreateAConfiguredContainerFromFrameworkConfigWithConditionals()	0	20	1
A	testItShouldCreateAConfiguredContainerFromFrameworkConfigWithFactories()	0	13	1
A	testItShouldCreateAConfiguredContainerFromFrameworkConfig()	0	8	1
A	testItShouldCreateAConfiguredContainerFromFrameworkConfigWithComplexFactories()	0	13	1
A	testItShouldCreateAConfiguredContainerFromFrameworkConfigWithInvokables()	0	13	1
A	testItShouldCreateAConfiguredContainerFromFrameworkConfigWithAliases()	0	16	1

<?php

declare(strict_types=1);

namespace AntidotTest\Container;

use Antidot\Container\Container;
use Antidot\Container\ContainerBuilder;
use PHPUnit\Framework\TestCase;
use Psr\Container\ContainerInterface;

class ContainerBuilderTest extends TestCase
{
    public function testItShouldCreateAConfiguredContainerFromFrameworkConfig(): void
    {
        $container = ContainerBuilder::build([
            'dependencies' => [],
            'config' => []
        ]);

        $this->assertInstanceOf(Container::class, $container);
    }

    public function testItShouldCreateAConfiguredContainerFromFrameworkConfigWithInvokables(): void
    {
        $container = ContainerBuilder::build([
            'dependencies' => [
                'invokables' => [
                    \SplStack::class => \SplStack::class,
                ]
            ],
            'config' => []
        ], true);

        $this->assertInstanceOf(Container::class, $container);
        $this->assertInstanceOf(\SplStack::class, $container->get(\SplStack::class));
    }

    public function testItShouldCreateAConfiguredContainerFromFrameworkConfigWithFactories(): void
    {
        $container = ContainerBuilder::build([
            'dependencies' => [
                'factories' => [
                    'some.test.class' => SomeTestFactory::class,
                ]
            ],
            'config' => []
        ], true);

        $this->assertInstanceOf(Container::class, $container);
        $this->assertInstanceOf(SomeTestClass::class, $container->get('some.test.class'));
    }

    public function testItShouldCreateAConfiguredContainerFromFrameworkConfigWithComplexFactories(): void
    {
        $container = ContainerBuilder::build([
            'dependencies' => [
                'factories' => [
                    'some.test.class' => [SomeTestFactory::class, 'buzz'],
                ]
            ],
            'config' => []
        ], true);

        $this->assertInstanceOf(Container::class, $container);
        $this->assertInstanceOf(SomeTestClass::class, $container->get('some.test.class'));
    }

    public function testItShouldCreateAConfiguredContainerFromFrameworkConfigWithAnonymousFunctionFactories(): void
    {
        $container = ContainerBuilder::build([
            'dependencies' => [
                'factories' => [
                    'some.test.class' => function (ContainerInterface $container) {

The parameter $container is not used and could be removed.

                        return new \SplStack();
                    },
                ]
            ],
            'config' => []
        ], true);

        $this->assertInstanceOf(Container::class, $container);
        $this->assertInstanceOf(\SplStack::class, $container->get('some.test.class'));
    }

    public function testItShouldCreateAConfiguredContainerFromFrameworkConfigWithConditionals(): void
    {
        $container = ContainerBuilder::build([
            'dependencies' => [
                'conditionals' => [
                    \InvalidArgumentException::class => [
                        'class' => \InvalidArgumentException::class,
                        'arguments' => [
                            'message' => 'Oh Oh!!',
                            'code' => 0,
                            'previous' => null,
                        ]
                    ],
                ]
            ],
            'config' => []
        ], true);

        $this->assertInstanceOf(Container::class, $container);
        $this->assertInstanceOf(\InvalidArgumentException::class, $container->get(\InvalidArgumentException::class));
    }

    public function testItShouldCreateAConfiguredContainerFromFrameworkConfigWithAliases(): void
    {
        $container = ContainerBuilder::build([
            'dependencies' => [
                'invokables' => [
                    \SplStack::class => \SplStack::class,
                ],
                'aliases' => [
                    'some.alias' => \SplStack::class,
                ]
            ],
            'config' => []
        ], true);

        $this->assertInstanceOf(Container::class, $container);
        $this->assertInstanceOf(\SplStack::class, $container->get('some.alias'));
    }
}