GridSpec::it_can_have_field_definitions() - Code Metrics - Inspection of "Update changelog for 1.0.2 release" - pamil/Sylius - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 1.0-release-1.0.2 ( 4bf3c2 )

by Kamil

created 2017-10-27 11:07 UTC

GridSpec::it_can_have_field_definitions() A

↳ Parent: GridSpec

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	7
rs	9.4285
c	0
b	0
f	0
nc	1
cc	1
eloc	4
nop	1

<?php

/*
 * This file is part of the Sylius package.
 *
 * (c) Paweł Jędrzejewski
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace spec\Sylius\Component\Grid\Definition;

use PhpSpec\ObjectBehavior;
use Sylius\Component\Grid\Definition\Action;
use Sylius\Component\Grid\Definition\ActionGroup;
use Sylius\Component\Grid\Definition\Field;
use Sylius\Component\Grid\Definition\Filter;

final class GridSpec extends ObjectBehavior
{
    function let(): void
    {
        $this->beConstructedThrough('fromCodeAndDriverConfiguration', ['sylius_admin_tax_category', 'doctrine/orm', [
            'resource' => 'sylius.tax_category',
            'method' => 'createByCodeQueryBuilder',
            'arguments' => ['$code'],
        ]]);
    }

    function it_has_code(): void
    {
        $this->getCode()->shouldReturn('sylius_admin_tax_category');
    }

    function it_has_driver(): void
    {
        $this->getDriver()->shouldReturn('doctrine/orm');
    }

    function it_has_driver_configuration(): void
    {
        $this->getDriverConfiguration()->shouldReturn([
            'resource' => 'sylius.tax_category',
            'method' => 'createByCodeQueryBuilder',
            'arguments' => ['$code'],
        ]);
    }

    function its_driver_configuration_is_mutable(): void
    {
        $this->setDriverConfiguration(['foo' => 'bar']);
        $this->getDriverConfiguration()->shouldReturn(['foo' => 'bar']);
    }

    function it_has_empty_sorting_configuration_by_default(): void
    {
        $this->getSorting()->shouldReturn([]);
    }

    function it_can_have_sorting_configuration(): void
    {
        $this->setSorting(['name' => 'asc']);
        $this->getSorting()->shouldReturn(['name' => 'asc']);
    }

    function it_has_no_pagination_limits_by_default(): void
    {
        $this->getLimits()->shouldReturn([]);
    }

    function its_pagination_limits_can_be_configured(): void
    {
        $this->setLimits([20, 50, 100]);
        $this->getLimits()->shouldReturn([20, 50, 100]);
    }

    function it_does_not_have_any_fields_by_default(): void
    {
        $this->getFields()->shouldReturn([]);
    }

    function it_can_have_field_definitions(Field $field): void
    {
        $field->getName()->willReturn('description');

        $this->addField($field);
        $this->getField('description')->shouldReturn($field);
    }

    function it_cannot_have_two_fields_with_the_same_name(Field $firstField, Field $secondField): void
    {
        $firstField->getName()->willReturn('created_at');
        $secondField->getName()->willReturn('created_at');

        $this->addField($firstField);

        $this
            ->shouldThrow(\InvalidArgumentException::class)
            ->during('addField', [$secondField])
        ;
    }

    function it_knows_if_field_with_given_name_already_exists(Field $field): void
    {
        $field->getName()->willReturn('enabled');
        $this->addField($field);

        $this->hasField('enabled')->shouldReturn(true);
        $this->hasField('parent')->shouldReturn(false);
    }

    function it_can_remove_field(Field $field): void
    {
        $field->getName()->willReturn('enabled');
        $this->addField($field);

        $this->removeField('enabled');
        $this->hasField('enabled')->shouldReturn(false);
    }

    function it_can_replace_field(Field $firstField, Field $secondField): void
    {
        $firstField->getName()->willReturn('enabled');
        $secondField->getName()->willReturn('enabled');
        $this->addField($firstField);

        $this->setField($secondField);
        $this->getField('enabled')->shouldReturn($secondField);
    }

    function it_can_return_fields(Field $firstField, Field $secondField): void
    {
        $firstField->getName()->willReturn('first');
        $secondField->getName()->willReturn('second');
        $this->addField($firstField);
        $this->addField($secondField);

        $this->getFields()->shouldHaveCount(2);
    }

    function it_can_return_only_enabled_fields(Field $firstField, Field $secondField): void
    {
        $firstField->getName()->willReturn('first');
        $firstField->isEnabled()->willReturn(true);
        $secondField->getName()->willReturn('second');
        $secondField->isEnabled()->willReturn(false);
        $this->addField($firstField);
        $this->addField($secondField);

        $this->getEnabledFields()->shouldHaveCount(1);
    }

    function it_does_not_have_any_action_groups_by_default(): void
    {
        $this->getActionGroups()->shouldReturn([]);
    }

    function it_can_have_action_group_definitions(ActionGroup $actionGroup): void
    {
        $actionGroup->getName()->willReturn('default');

        $this->addActionGroup($actionGroup);
        $this->getActionGroup('default')->shouldReturn($actionGroup);
    }

    function it_cannot_have_two_action_groups_with_the_same_name(ActionGroup $firstActionGroup, ActionGroup $secondActionGroup): void
    {
        $firstActionGroup->getName()->willReturn('row');
        $secondActionGroup->getName()->willReturn('row');

        $this->addActionGroup($firstActionGroup);

        $this
            ->shouldThrow(\InvalidArgumentException::class)
            ->during('addActionGroup', [$secondActionGroup])
        ;
    }

    function it_knows_if_action_group_with_given_name_already_exists(ActionGroup $actionGroup): void
    {
        $actionGroup->getName()->willReturn('row');
        $this->addActionGroup($actionGroup);

        $this->hasActionGroup('row')->shouldReturn(true);
        $this->hasActionGroup('default')->shouldReturn(false);
    }

    function it_can_remove_action_group(ActionGroup $actionGroup): void
    {
        $actionGroup->getName()->willReturn('row');
        $this->addActionGroup($actionGroup);

        $this->removeActionGroup('row');
        $this->hasActionGroup('row')->shouldReturn(false);
    }

    function it_can_replace_action_group(ActionGroup $firstActionGroup, ActionGroup $secondActionGroup): void
    {
        $firstActionGroup->getName()->willReturn('row');
        $secondActionGroup->getName()->willReturn('row');
        $this->addActionGroup($firstActionGroup);

        $this->setActionGroup($secondActionGroup);
        $this->getActionGroup('row')->shouldReturn($secondActionGroup);
    }

    function it_returns_actions_for_given_group(ActionGroup $actionGroup, Action $action): void
    {
        $actionGroup->getName()->willReturn('row');
        $actionGroup->getActions()->willReturn([$action]);
        $this->addActionGroup($actionGroup);

        $this->getActions('row')->shouldReturn([$action]);
    }

    function it_returns_only_enabled_actions_for_given_group(
        ActionGroup $actionGroup,
        Action $firstAction,
        Action $secondAction
    ): void {
        $firstAction->isEnabled()->willReturn(true);
        $secondAction->isEnabled()->willReturn(false);
        $actionGroup->getName()->willReturn('row');
        $actionGroup->getActions()->willReturn([$firstAction, $secondAction]);
        $this->addActionGroup($actionGroup);

        $this->getEnabledActions('row')->shouldReturn([$firstAction]);
    }

    function it_does_not_have_any_filters_by_default(): void
    {
        $this->getFilters()->shouldReturn([]);
    }

    function it_can_have_filter_definitions(Filter $filter): void
    {
        $filter->getName()->willReturn('enabled');

        $this->addFilter($filter);
        $this->getFilter('enabled')->shouldReturn($filter);
    }

    function it_cannot_have_two_filters_with_the_same_name(Filter $firstFilter, Filter $secondFilter): void
    {
        $firstFilter->getName()->willReturn('created_at');
        $secondFilter->getName()->willReturn('created_at');

        $this->addFilter($firstFilter);

        $this
            ->shouldThrow(\InvalidArgumentException::class)
            ->during('addFilter', [$secondFilter])
        ;
    }

    function it_knows_if_filter_with_given_name_already_exists(Filter $filter): void
    {
        $filter->getName()->willReturn('enabled');
        $this->addFilter($filter);

        $this->hasFilter('enabled')->shouldReturn(true);
        $this->hasFilter('created_at')->shouldReturn(false);
    }

    function it_can_remove_filter(Filter $filter): void
    {
        $filter->getName()->willReturn('enabled');
        $this->addFilter($filter);

        $this->removeFilter('enabled');
        $this->hasFilter('enabled')->shouldReturn(false);
    }

    function it_can_replace_filter(Filter $firstFilter, Filter $secondFilter): void
    {
        $firstFilter->getName()->willReturn('enabled');
        $secondFilter->getName()->willReturn('enabled');
        $this->addFilter($firstFilter);

        $this->setFilter($secondFilter);
        $this->getFilter('enabled')->shouldReturn($secondFilter);
    }

    function it_can_return_filters(Filter $firstFilter, Filter $secondFilter): void
    {
        $firstFilter->getName()->willReturn('first');
        $secondFilter->getName()->willReturn('second');
        $this->addFilter($firstFilter);
        $this->addFilter($secondFilter);

        $this->getFilters()->shouldHaveCount(2);
    }

    function it_can_return_only_enabled_filters(Filter $firstFilter, Filter $secondFilter): void
    {
        $firstFilter->getName()->willReturn('first');
        $firstFilter->isEnabled()->willReturn(true);
        $secondFilter->getName()->willReturn('second');
        $secondFilter->isEnabled()->willReturn(false);
        $this->addFilter($firstFilter);
        $this->addFilter($secondFilter);

        $this->getEnabledFilters()->shouldHaveCount(1);
    }
}


1			<?php
2
3			/*
4			* This file is part of the Sylius package.
5			*
6			* (c) Paweł Jędrzejewski
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			declare(strict_types=1);
13
14			namespace spec\Sylius\Component\Grid\Definition;
15
16			use PhpSpec\ObjectBehavior;
17			use Sylius\Component\Grid\Definition\Action;
18			use Sylius\Component\Grid\Definition\ActionGroup;
19			use Sylius\Component\Grid\Definition\Field;
20			use Sylius\Component\Grid\Definition\Filter;
21
22			final class GridSpec extends ObjectBehavior
23			{
24			function let(): void
25			{
26			$this->beConstructedThrough('fromCodeAndDriverConfiguration', ['sylius_admin_tax_category', 'doctrine/orm', [
27			'resource' => 'sylius.tax_category',
28			'method' => 'createByCodeQueryBuilder',
29			'arguments' => ['$code'],
30			]]);
31			}
32
33			function it_has_code(): void
34			{
35			$this->getCode()->shouldReturn('sylius_admin_tax_category');
36			}
37
38			function it_has_driver(): void
39			{
40			$this->getDriver()->shouldReturn('doctrine/orm');
41			}
42
43			function it_has_driver_configuration(): void
44			{
45			$this->getDriverConfiguration()->shouldReturn([
46			'resource' => 'sylius.tax_category',
47			'method' => 'createByCodeQueryBuilder',
48			'arguments' => ['$code'],
49			]);
50			}
51
52			function its_driver_configuration_is_mutable(): void
53			{
54			$this->setDriverConfiguration(['foo' => 'bar']);
55			$this->getDriverConfiguration()->shouldReturn(['foo' => 'bar']);
56			}
57
58			function it_has_empty_sorting_configuration_by_default(): void
59			{
60			$this->getSorting()->shouldReturn([]);
61			}
62
63			function it_can_have_sorting_configuration(): void
64			{
65			$this->setSorting(['name' => 'asc']);
66			$this->getSorting()->shouldReturn(['name' => 'asc']);
67			}
68
69			function it_has_no_pagination_limits_by_default(): void
70			{
71			$this->getLimits()->shouldReturn([]);
72			}
73
74			function its_pagination_limits_can_be_configured(): void
75			{
76			$this->setLimits([20, 50, 100]);
77			$this->getLimits()->shouldReturn([20, 50, 100]);
78			}
79
80			function it_does_not_have_any_fields_by_default(): void
81			{
82			$this->getFields()->shouldReturn([]);
83			}
84
85			function it_can_have_field_definitions(Field $field): void
86			{
87			$field->getName()->willReturn('description');
88
89			$this->addField($field);
90			$this->getField('description')->shouldReturn($field);
91			}
92
93			function it_cannot_have_two_fields_with_the_same_name(Field $firstField, Field $secondField): void
94			{
95			$firstField->getName()->willReturn('created_at');
96			$secondField->getName()->willReturn('created_at');
97
98			$this->addField($firstField);
99
100			$this
101			->shouldThrow(\InvalidArgumentException::class)
102			->during('addField', [$secondField])
103			;
104			}
105
106			function it_knows_if_field_with_given_name_already_exists(Field $field): void
107			{
108			$field->getName()->willReturn('enabled');
109			$this->addField($field);
110
111			$this->hasField('enabled')->shouldReturn(true);
112			$this->hasField('parent')->shouldReturn(false);
113			}
114
115			function it_can_remove_field(Field $field): void
116			{
117			$field->getName()->willReturn('enabled');
118			$this->addField($field);
119
120			$this->removeField('enabled');
121			$this->hasField('enabled')->shouldReturn(false);
122			}
123
124			function it_can_replace_field(Field $firstField, Field $secondField): void
125			{
126			$firstField->getName()->willReturn('enabled');
127			$secondField->getName()->willReturn('enabled');
128			$this->addField($firstField);
129
130			$this->setField($secondField);
131			$this->getField('enabled')->shouldReturn($secondField);
132			}
133
134			function it_can_return_fields(Field $firstField, Field $secondField): void
135			{
136			$firstField->getName()->willReturn('first');
137			$secondField->getName()->willReturn('second');
138			$this->addField($firstField);
139			$this->addField($secondField);
140
141			$this->getFields()->shouldHaveCount(2);
142			}
143
144			function it_can_return_only_enabled_fields(Field $firstField, Field $secondField): void
145			{
146			$firstField->getName()->willReturn('first');
147			$firstField->isEnabled()->willReturn(true);
148			$secondField->getName()->willReturn('second');
149			$secondField->isEnabled()->willReturn(false);
150			$this->addField($firstField);
151			$this->addField($secondField);
152
153			$this->getEnabledFields()->shouldHaveCount(1);
154			}
155
156			function it_does_not_have_any_action_groups_by_default(): void
157			{
158			$this->getActionGroups()->shouldReturn([]);
159			}
160
161			function it_can_have_action_group_definitions(ActionGroup $actionGroup): void
162			{
163			$actionGroup->getName()->willReturn('default');
164
165			$this->addActionGroup($actionGroup);
166			$this->getActionGroup('default')->shouldReturn($actionGroup);
167			}
168
169			function it_cannot_have_two_action_groups_with_the_same_name(ActionGroup $firstActionGroup, ActionGroup $secondActionGroup): void
170			{
171			$firstActionGroup->getName()->willReturn('row');
172			$secondActionGroup->getName()->willReturn('row');
173
174			$this->addActionGroup($firstActionGroup);
175
176			$this
177			->shouldThrow(\InvalidArgumentException::class)
178			->during('addActionGroup', [$secondActionGroup])
179			;
180			}
181
182			function it_knows_if_action_group_with_given_name_already_exists(ActionGroup $actionGroup): void
183			{
184			$actionGroup->getName()->willReturn('row');
185			$this->addActionGroup($actionGroup);
186
187			$this->hasActionGroup('row')->shouldReturn(true);
188			$this->hasActionGroup('default')->shouldReturn(false);
189			}
190
191			function it_can_remove_action_group(ActionGroup $actionGroup): void
192			{
193			$actionGroup->getName()->willReturn('row');
194			$this->addActionGroup($actionGroup);
195
196			$this->removeActionGroup('row');
197			$this->hasActionGroup('row')->shouldReturn(false);
198			}
199
200			function it_can_replace_action_group(ActionGroup $firstActionGroup, ActionGroup $secondActionGroup): void
201			{
202			$firstActionGroup->getName()->willReturn('row');
203			$secondActionGroup->getName()->willReturn('row');
204			$this->addActionGroup($firstActionGroup);
205
206			$this->setActionGroup($secondActionGroup);
207			$this->getActionGroup('row')->shouldReturn($secondActionGroup);
208			}
209
210			function it_returns_actions_for_given_group(ActionGroup $actionGroup, Action $action): void
211			{
212			$actionGroup->getName()->willReturn('row');
213			$actionGroup->getActions()->willReturn([$action]);
214			$this->addActionGroup($actionGroup);
215
216			$this->getActions('row')->shouldReturn([$action]);
217			}
218
219			function it_returns_only_enabled_actions_for_given_group(
220			ActionGroup $actionGroup,
221			Action $firstAction,
222			Action $secondAction
223			): void {
224			$firstAction->isEnabled()->willReturn(true);
225			$secondAction->isEnabled()->willReturn(false);
226			$actionGroup->getName()->willReturn('row');
227			$actionGroup->getActions()->willReturn([$firstAction, $secondAction]);
228			$this->addActionGroup($actionGroup);
229
230			$this->getEnabledActions('row')->shouldReturn([$firstAction]);
231			}
232
233			function it_does_not_have_any_filters_by_default(): void
234			{
235			$this->getFilters()->shouldReturn([]);
236			}
237
238			function it_can_have_filter_definitions(Filter $filter): void
239			{
240			$filter->getName()->willReturn('enabled');
241
242			$this->addFilter($filter);
243			$this->getFilter('enabled')->shouldReturn($filter);
244			}
245
246			function it_cannot_have_two_filters_with_the_same_name(Filter $firstFilter, Filter $secondFilter): void
247			{
248			$firstFilter->getName()->willReturn('created_at');
249			$secondFilter->getName()->willReturn('created_at');
250
251			$this->addFilter($firstFilter);
252
253			$this
254			->shouldThrow(\InvalidArgumentException::class)
255			->during('addFilter', [$secondFilter])
256			;
257			}
258
259			function it_knows_if_filter_with_given_name_already_exists(Filter $filter): void
260			{
261			$filter->getName()->willReturn('enabled');
262			$this->addFilter($filter);
263
264			$this->hasFilter('enabled')->shouldReturn(true);
265			$this->hasFilter('created_at')->shouldReturn(false);
266			}
267
268			function it_can_remove_filter(Filter $filter): void
269			{
270			$filter->getName()->willReturn('enabled');
271			$this->addFilter($filter);
272
273			$this->removeFilter('enabled');
274			$this->hasFilter('enabled')->shouldReturn(false);
275			}
276
277			function it_can_replace_filter(Filter $firstFilter, Filter $secondFilter): void
278			{
279			$firstFilter->getName()->willReturn('enabled');
280			$secondFilter->getName()->willReturn('enabled');
281			$this->addFilter($firstFilter);
282
283			$this->setFilter($secondFilter);
284			$this->getFilter('enabled')->shouldReturn($secondFilter);
285			}
286
287			function it_can_return_filters(Filter $firstFilter, Filter $secondFilter): void
288			{
289			$firstFilter->getName()->willReturn('first');
290			$secondFilter->getName()->willReturn('second');
291			$this->addFilter($firstFilter);
292			$this->addFilter($secondFilter);
293
294			$this->getFilters()->shouldHaveCount(2);
295			}
296
297			function it_can_return_only_enabled_filters(Filter $firstFilter, Filter $secondFilter): void
298			{
299			$firstFilter->getName()->willReturn('first');
300			$firstFilter->isEnabled()->willReturn(true);
301			$secondFilter->getName()->willReturn('second');
302			$secondFilter->isEnabled()->willReturn(false);
303			$this->addFilter($firstFilter);
304			$this->addFilter($secondFilter);
305
306			$this->getEnabledFilters()->shouldHaveCount(1);
307			}
308			}
309

pamil / Sylius

Push — 1.0-release-1.0.2 ( 4bf3c2 )

GridSpec::it_can_have_field_definitions() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like