spec\Knp\DictionaryBundle\DependencyInjection\Compiler\DictionaryBuildingPassSpec

Complexity

Total Complexity

4

Size/Duplication

Total Lines	125
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	it_builds_a_key_value_dictionary_from_the_config()	0	38	1
A	it_builds_a_value_dictionary_from_the_config()	0	38	1
A	it_is_initializable()	0	3	1
A	it_builds_a_value_as_key_dictionary_from_the_config()	0	38	1

<?php

declare(strict_types=1);

namespace spec\Knp\DictionaryBundle\DependencyInjection\Compiler;

use Assert\Assert;
use Knp\DictionaryBundle\DependencyInjection\Compiler\DictionaryBuildingPass;
use Knp\DictionaryBundle\DependencyInjection\Compiler\DictionaryRegistrationPass;
use Knp\DictionaryBundle\Dictionary;
use Knp\DictionaryBundle\Dictionary\Factory\Aggregate;
use PhpSpec\ObjectBehavior;
use Prophecy\Argument;
use Symfony\Component\DependencyInjection\ContainerBuilder;

final class DictionaryBuildingPassSpec extends ObjectBehavior
{
    function it_is_initializable()

It is generally recommended to explicitly declare the visibility for methods.

    {
        $this->shouldHaveType(DictionaryBuildingPass::class);
    }

    function it_builds_a_value_as_key_dictionary_from_the_config(ContainerBuilder $container)
    {
        $config = [
            'dictionaries' => [
                'dico1' => [
                    'type'    => Dictionary::VALUE_AS_KEY,
                    'content' => ['foo', 'bar', 'baz'],
                ],
            ],
        ];

        $container->getParameter('knp_dictionary.configuration')->willReturn($config);
        $container->setDefinition(
            'knp_dictionary.dictionary.dico1',
            Argument::that(function ($definition): bool {

Prophecy\Argument::that(function(...) { /* ... */ }) of type Prophecy\Argument\Token\CallbackToken is incompatible with the type Symfony\Component\DependencyInjection\Definition expected by parameter $definition of Symfony\Component\DependencyInjection\ContainerBuilder::setDefinition().

                Assert::that($definition->getClass())->eq(Dictionary::class);

                $factory = $definition->getFactory();

                Assert::that($factory[0]->__toString())->eq(Aggregate::class);

                Assert::that($factory[1])->eq('create');

                Assert::that($definition->getArguments())->eq([
                    'dico1',
                    [
                        'type'    => Dictionary::VALUE_AS_KEY,
                        'content' => ['foo', 'bar', 'baz'],
                    ],
                ]);

                Assert::that($definition->getTags())->eq([DictionaryRegistrationPass::TAG_DICTIONARY => [[]]]);

                return true;
            })
        )->shouldBeCalled();

The method shouldBeCalled() does not exist on Symfony\Component\DependencyInjection\Definition.

        $this->process($container);

The method process() does not exist on spec\Knp\DictionaryBundle\DependencyInjection\Compiler\DictionaryBuildingPassSpec. Since you implemented __call, consider adding a @method annotation.

    }

    function it_builds_a_value_dictionary_from_the_config(ContainerBuilder $container)
    {
        $config = [
            'dictionaries' => [
                'dico1' => [
                    'type'    => Dictionary::VALUE,
                    'content' => [2 => 'foo', 10 => 'bar', 100 => 'baz'],
                ],
            ],
        ];

        $container->getParameter('knp_dictionary.configuration')->willReturn($config);
        $container->setDefinition(
            'knp_dictionary.dictionary.dico1',
            Argument::that(function ($definition): bool {

Prophecy\Argument::that(function(...) { /* ... */ }) of type Prophecy\Argument\Token\CallbackToken is incompatible with the type Symfony\Component\DependencyInjection\Definition expected by parameter $definition of Symfony\Component\DependencyInjection\ContainerBuilder::setDefinition().

                Assert::that($definition->getClass())->eq(Dictionary::class);

                $factory = $definition->getFactory();

                Assert::that($factory[0]->__toString())->eq(Aggregate::class);

                Assert::that($factory[1])->eq('create');

                Assert::that($definition->getArguments())->eq([
                    'dico1',
                    [
                        'type'    => Dictionary::VALUE,
                        'content' => [2 => 'foo', 10 => 'bar', 100 => 'baz'],
                    ],
                ]);

                Assert::that($definition->getTags(), [DictionaryRegistrationPass::TAG_DICTIONARY => [[]]]);

                return true;
            })
        )->shouldBeCalled();

        $this->process($container);
    }

    function it_builds_a_key_value_dictionary_from_the_config(ContainerBuilder $container)
    {
        $config = [
            'dictionaries' => [
                'dico1' => [
                    'type'    => Dictionary::KEY_VALUE,
                    'content' => [2 => 'foo', 10 => 'bar', 100 => 'baz'],
                ],
            ],
        ];

        $container->getParameter('knp_dictionary.configuration')->willReturn($config);
        $container->setDefinition(
            'knp_dictionary.dictionary.dico1',
            Argument::that(function ($definition): bool {

Prophecy\Argument::that(function(...) { /* ... */ }) of type Prophecy\Argument\Token\CallbackToken is incompatible with the type Symfony\Component\DependencyInjection\Definition expected by parameter $definition of Symfony\Component\DependencyInjection\ContainerBuilder::setDefinition().

                Assert::that($definition->getClass())->eq(Dictionary::class);

                $factory = $definition->getFactory();

                Assert::that($factory[0]->__toString())->eq(Aggregate::class);

                Assert::that($factory[1])->eq('create');

                Assert::that($definition->getArguments())->eq([
                    'dico1',
                    [
                        'type'    => Dictionary::KEY_VALUE,
                        'content' => [2 => 'foo', 10 => 'bar', 100 => 'baz'],
                    ],
                ]);

                Assert::that($definition->getTags())->eq([DictionaryRegistrationPass::TAG_DICTIONARY => [[]]]);

                return true;
            })
        )->shouldBeCalled();

        $this->process($container);
    }
}