GridSpec::it_can_replace_action_group() - Code Metrics - Inspection of "Provide a failing test case for handling absolute..." - pamil/Sylius - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — theme/path-package ( f6cab5 )

by Kamil

created 2017-07-17 14:26 UTC

GridSpec::it_can_replace_action_group() A

↳ Parent: GridSpec

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	9
rs	9.6666
c	0
b	0
f	0
cc	1
eloc	6
nc	1
nop	2

<?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.
 */

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;
use Sylius\Component\Grid\Definition\Grid;

/**
 * @author Paweł Jędrzejewski <[email protected]>
 */
final class GridSpec extends ObjectBehavior
{
    function let()
    {
        $this->beConstructedThrough('fromCodeAndDriverConfiguration', ['sylius_admin_tax_category', 'doctrine/orm', [
            'resource' => 'sylius.tax_category',
            'method' => 'createByCodeQueryBuilder',
            'arguments' => ['$code']
        ]]);
    }

    function it_is_initializable()
    {
        $this->shouldHaveType(Grid::class);
    }

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

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

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

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

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

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

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

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

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

    function it_can_have_field_definitions(Field $field)
    {
        $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)
    {
        $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)
    {
        $field->getName()->willReturn('enabled');
        $this->addField($field);

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

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

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

    function it_can_replace_field(Field $firstField, Field $secondField)
    {
        $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)
    {
        $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)
    {
        $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()
    {
        $this->getActionGroups()->shouldReturn([]);
    }

    function it_can_have_action_group_definitions(ActionGroup $actionGroup)
    {
        $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)
    {
        $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)
    {
        $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)
    {
        $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)
    {
        $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)
    {
        $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
    ) {
        $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()
    {
        $this->getFilters()->shouldReturn([]);
    }

    function it_can_have_filter_definitions(Filter $filter)
    {
        $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)
    {
        $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)
    {
        $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)
    {
        $filter->getName()->willReturn('enabled');
        $this->addFilter($filter);

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

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

pamil / Sylius

Push — theme/path-package ( f6cab5 )

GridSpec::it_can_replace_action_group() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like