GridSpec::it_has_code() - Code Metrics - Inspection of "Move the `CONTRIBUTING.md` to `docs` directory" - pamil/Sylius - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 1.0-contributing ( e0062d )

by Kamil

created 2017-09-26 09:07 UTC

GridSpec::it_has_code() A

↳ Parent: GridSpec

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
nc	1
cc	1
eloc	2
nop	0

<?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;

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

pamil / Sylius

Push — 1.0-contributing ( e0062d )

GridSpec::it_has_code() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like