TraceableSpec::let() - Code Metrics - KnpLabs/DictionaryBundle - Measure and Improve Code Quality continuously with Scrutinizer

TraceableSpec::let() A
last analyzed 2025-06-12 06:14 UTC

↳ Parent: TraceableSpec
Complexity

Conditions	1
Paths	1
Size

Total Lines	10
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	5
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	10
rs	10
<?php

declare(strict_types=1);

namespace spec\Knp\DictionaryBundle\Dictionary;

use Knp\DictionaryBundle\DataCollector\DictionaryDataCollector;
use Knp\DictionaryBundle\Dictionary;
use Knp\DictionaryBundle\Dictionary\Simple;
use Knp\DictionaryBundle\Dictionary\Traceable;
use PhpSpec\ObjectBehavior;
use Webmozart\Assert\Assert;

final class TraceableSpec extends ObjectBehavior
{
    /**
     * @var DictionaryDataCollector
     */
    private $collector;

    function let()
    {
        $dictionary = new Simple('name', [
            'foo' => 'bar',
            'baz' => null,
        ]);

        $this->collector = new DictionaryDataCollector();

        $this->beConstructedWith($dictionary, $this->collector);
    }

    function it_is_initializable()

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

    function it_is_a_dictionary()
    {
        $this->shouldImplement(Dictionary::class);
    }

    function it_has_a_name()
    {
        Assert::isEmpty(iterator_to_array($this->collector->getDictionaries()));

        $this->getName()->shouldReturn('name');
               getName()->shouldReturn('name');

        Assert::isEmpty(iterator_to_array($this->collector->getDictionaries()));
    }

    function it_traces_keys()
    {
        Assert::isEmpty(iterator_to_array($this->collector->getDictionaries()));

        $this->getKeys()->shouldReturn(['foo', 'baz']);
               getKeys()->shouldReturn(['foo', 'baz']);

        Assert::eq(
            iterator_to_array($this->collector->getDictionaries()),
            [
                'name' => [
                    [
                        'key'   => 'foo',
                        'value' => 'bar',
                    ],
                    [
                        'key'   => 'baz',
                        'value' => null,
                    ],
                ],
            ]
        );
    }

    function it_traces_values()
    {
        Assert::isEmpty(iterator_to_array($this->collector->getDictionaries()));

        $this->getValues()->shouldReturn(['foo' => 'bar', 'baz' => null]);
               getValues()->shouldReturn(['foo' => 'bar', 'baz' => null]);

        Assert::eq(
            iterator_to_array($this->collector->getDictionaries()),
            [
                'name' => [
                    [
                        'key'   => 'foo',
                        'value' => 'bar',
                    ],
                    [
                        'key'   => 'baz',
                        'value' => null,
                    ],
                ],
            ],
        );
    }

    function it_traces_values_get()
    {
        Assert::isEmpty(iterator_to_array($this->collector->getDictionaries()));

        $this['foo']->shouldReturn('bar');

        Assert::eq(
            iterator_to_array($this->collector->getDictionaries()),
            [
                'name' => [
                    [
                        'key'   => 'foo',
                        'value' => 'bar',
                    ],
                    [
                        'key'   => 'baz',
                        'value' => null,
                    ],
                ],
            ]
        );
    }

    function it_traces_value_set()
    {
        Assert::isEmpty(iterator_to_array($this->collector->getDictionaries()));

        $this['yo'] = 'lo';

        Assert::eq(
            iterator_to_array($this->collector->getDictionaries()),
            [
                'name' => [
                    [
                        'key'   => 'foo',
                        'value' => 'bar',
                    ],
                    [
                        'key'   => 'baz',
                        'value' => null,
                    ],
                    [
                        'key'   => 'yo',
                        'value' => 'lo',
                    ],
                ],
            ]
        );
    }

    function it_traces_value_unset()
    {
        Assert::isEmpty(iterator_to_array($this->collector->getDictionaries()));

        unset($this['foo']);

        Assert::eq(
            iterator_to_array($this->collector->getDictionaries()),
            [
                'name' => [
                    [
                        'key'   => 'baz',
                        'value' => null,
                    ],
                ],
            ]
        );
    }

    function it_traces_key_exists()
    {
        Assert::isEmpty(iterator_to_array($this->collector->getDictionaries()));

        $this->shouldHaveKey('baz');

        Assert::eq(
            iterator_to_array($this->collector->getDictionaries()),
            [
                'name' => [
                    [
                        'key'   => 'foo',
                        'value' => 'bar',
                    ],
                    [
                        'key'   => 'baz',
                        'value' => null,
                    ],
                ],
            ]
        );
    }

    function it_trace_iteration()
    {
        Assert::isEmpty(iterator_to_array($this->collector->getDictionaries()));

        $this->shouldIterateLike([
            'foo' => 'bar',
            'baz' => null,
        ]);

        Assert::eq(
            iterator_to_array($this->collector->getDictionaries()),
            [
                'name' => [
                    [
                        'key'   => 'foo',
                        'value' => 'bar',
                    ],
                    [
                        'key'   => 'baz',
                        'value' => null,
                    ],
                ],
            ]
        );
    }

    function it_delegates_the_count_to_the_other_dictionary()
    {
        $this->count()->shouldReturn(2);
               count()->shouldReturn(2);
    }
}

KnpLabs / DictionaryBundle

TraceableSpec::let() A last analyzed 2025-06-12 06:14 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

TraceableSpec::let() A
last analyzed 2025-06-12 06:14 UTC
