FilterTest::testExceptionOnNonDefinedFilterName() - Code Metrics - Inspection of "Narrow Filter API" - sonata-project/SonataAdminBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ece51a...a98e5a )

by Javier

created 2020-08-11 02:52 UTC

FilterTest::testExceptionOnNonDefinedFilterName() A

↳ Parent: FilterTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	13
rs	9.8333
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

declare(strict_types=1);

/*
 * This file is part of the Sonata Project package.
 *
 * (c) Thomas Rabaix <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Sonata\AdminBundle\Tests\Filter;

use PHPUnit\Framework\TestCase;
use Sonata\AdminBundle\Filter\FilterFactory;
use Sonata\AdminBundle\Tests\Fixtures\Filter\FooFilter;
use Symfony\Component\Form\Extension\Core\Type\TextType;

class FilterTest extends TestCase
{
    public function testFilter(): void
    {
        $filter = new FooFilter();

        $this->assertSame(TextType::class, $filter->getFieldType());
        $this->assertSame(['required' => false], $filter->getFieldOptions());
        $this->assertNull($filter->getLabel());

        $options = [
            'label' => 'foo',
            'field_type' => 'integer',
            'field_options' => ['required' => true],
            'field_name' => 'name',
        ];

        $filter->setOptions($options);

        $this->assertSame('foo', $filter->getOption('label'));
        $this->assertSame('foo', $filter->getLabel());

        $expected = array_merge([
            'show_filter' => null,
            'advanced_filter' => true,
            'foo' => 'bar',
        ], $options);

        $this->assertSame($expected, $filter->getOptions());
        $this->assertSame('name', $filter->getFieldName());

        $this->assertSame('default', $filter->getOption('fake', 'default'));

        $filter->setValue(42);
        $this->assertSame(42, $filter->getValue());

        $filter->setCondition('>');
        $this->assertSame('>', $filter->getCondition());
    }

    public function testGetFieldOption(): void
    {
        $filter = new FooFilter();
        $filter->initialize('name', [
            'field_options' => ['foo' => 'bar', 'baz' => 12345],
        ]);

        $this->assertSame(['foo' => 'bar', 'baz' => 12345], $filter->getFieldOptions());
        $this->assertSame('bar', $filter->getFieldOption('foo'));
        $this->assertSame(12345, $filter->getFieldOption('baz'));
    }

    public function testSetFieldOption(): void
    {
        $filter = new FooFilter();
        $this->assertSame(['required' => false], $filter->getFieldOptions());

        $filter->setFieldOption('foo', 'bar');
        $filter->setFieldOption('baz', 12345);

        $this->assertSame(['foo' => 'bar', 'baz' => 12345], $filter->getFieldOptions());
        $this->assertSame('bar', $filter->getFieldOption('foo'));
        $this->assertSame(12345, $filter->getFieldOption('baz'));
    }

    public function testInitialize(): void
    {
        $filter = new FooFilter();
        $filter->initialize('name', [
            'field_name' => 'bar',
        ]);

        $this->assertSame('name', $filter->getName());
        $this->assertSame('bar', $filter->getOption('field_name'));
        $this->assertSame('bar', $filter->getFieldName());
    }

    public function testLabel(): void
    {
        $filter = new FooFilter();
        $filter->setLabel('foo');

        $this->assertSame('foo', $filter->getLabel());
    }

    public function testExceptionOnNonDefinedFilterName(): void
    {
        $filter = new FooFilter();

        $this->expectException(\LogicException::class);
        $this->expectExceptionMessage(sprintf(
            'Seems like you didn\'t call `initialize()` on the filter `%s`. Did you create it through `%s::create()`?',
            FooFilter::class,
            FilterFactory::class
        ));

        $filter->getName();
    }

    public function testExceptionOnNonDefinedFieldName(): void
    {
        $filter = new FooFilter();
        $filter->initialize('foo');

        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage('The option `field_name` must be set for field: `foo`');

        $filter->getFieldName();
    }

    /**
     * @dataProvider isActiveData
     *
     * @param $expected
     * @param $value
     */
    public function testIsActive(bool $expected, array $value): void
    {
        $filter = new FooFilter();
        $filter->setValue($value);

        $this->assertSame($expected, $filter->isActive());
    }

    public function isActiveData(): array
    {
        return [
            [false, []],
            [false, ['value' => null]],
            [false, ['value' => '']],
            [false, ['value' => false]],
            [true, ['value' => 'active']],
        ];
    }

    public function testGetTranslationDomain(): void
    {
        $filter = new FooFilter();
        $this->assertNull($filter->getTranslationDomain());
        $filter->setOption('translation_domain', 'baz');
        $this->assertSame('baz', $filter->getTranslationDomain());
    }

    public function testGetFieldMappingException(): void
    {
        $filter = new FooFilter();
        $filter->initialize('foo');

        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage('The option `field_mapping` must be set for field: `foo`');

        $filter->getFieldMapping();
    }

    public function testGetFieldMapping(): void
    {
        $fieldMapping = [
            'fieldName' => 'username',
            'type' => 'string',
            'columnName' => 'username',
            'length' => 200,
            'unique' => true,
            'nullable' => false,
            'declared' => 'Foo\Bar\User',
        ];

        $filter = new FooFilter();
        $filter->setOption('field_mapping', $fieldMapping);
        $this->assertSame($fieldMapping, $filter->getFieldMapping());
    }

    public function testGetParentAssociationMappings(): void
    {
        $parentAssociationMapping = [
            0 => ['fieldName' => 'user',
                'targetEntity' => 'Foo\Bar\User',
                'joinColumns' => [
                    0 => [
                        'name' => 'user_id',
                        'referencedColumnName' => 'user_id',
                    ],
                ],
                'type' => 2,
                'mappedBy' => null,
            ],
        ];

        $filter = new FooFilter();
        $this->assertSame([], $filter->getParentAssociationMappings());
        $filter->setOption('parent_association_mappings', $parentAssociationMapping);
        $this->assertSame($parentAssociationMapping, $filter->getParentAssociationMappings());
    }

    public function testGetAssociationMappingException(): void
    {
        $filter = new FooFilter();
        $filter->initialize('foo');

        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage('The option `association_mapping` must be set for field: `foo`');

        $filter->getAssociationMapping();
    }

    public function testGetAssociationMapping(): void
    {
        $associationMapping = [
            'fieldName' => 'user',
            'targetEntity' => 'Foo\Bar\User',
            'joinColumns' => [
                0 => [
                    'name' => 'user_id',
                    'referencedColumnName' => 'user_id',
                ],
            ],
            'type' => 2,
            'mappedBy' => null,
        ];

        $filter = new FooFilter();
        $filter->setOption('association_mapping', $associationMapping);
        $this->assertSame($associationMapping, $filter->getAssociationMapping());
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the Sonata Project package.
7			*
8			* (c) Thomas Rabaix <[email protected]>
9			*
10			* For the full copyright and license information, please view the LICENSE
11			* file that was distributed with this source code.
12			*/
13
14			namespace Sonata\AdminBundle\Tests\Filter;
15
16			use PHPUnit\Framework\TestCase;
17			use Sonata\AdminBundle\Filter\FilterFactory;
18			use Sonata\AdminBundle\Tests\Fixtures\Filter\FooFilter;
19			use Symfony\Component\Form\Extension\Core\Type\TextType;
20
21			class FilterTest extends TestCase
22			{
23			public function testFilter(): void
24			{
25			$filter = new FooFilter();
26
27			$this->assertSame(TextType::class, $filter->getFieldType());
28			$this->assertSame(['required' => false], $filter->getFieldOptions());
29			$this->assertNull($filter->getLabel());
30
31			$options = [
32			'label' => 'foo',
33			'field_type' => 'integer',
34			'field_options' => ['required' => true],
35			'field_name' => 'name',
36			];
37
38			$filter->setOptions($options);
39
40			$this->assertSame('foo', $filter->getOption('label'));
41			$this->assertSame('foo', $filter->getLabel());
42
43			$expected = array_merge([
44			'show_filter' => null,
45			'advanced_filter' => true,
46			'foo' => 'bar',
47			], $options);
48
49			$this->assertSame($expected, $filter->getOptions());
50			$this->assertSame('name', $filter->getFieldName());
51
52			$this->assertSame('default', $filter->getOption('fake', 'default'));
53
54			$filter->setValue(42);
55			$this->assertSame(42, $filter->getValue());
56
57			$filter->setCondition('>');
58			$this->assertSame('>', $filter->getCondition());
59			}
60
61			public function testGetFieldOption(): void
62			{
63			$filter = new FooFilter();
64			$filter->initialize('name', [
65			'field_options' => ['foo' => 'bar', 'baz' => 12345],
66			]);
67
68			$this->assertSame(['foo' => 'bar', 'baz' => 12345], $filter->getFieldOptions());
69			$this->assertSame('bar', $filter->getFieldOption('foo'));
70			$this->assertSame(12345, $filter->getFieldOption('baz'));
71			}
72
73			public function testSetFieldOption(): void
74			{
75			$filter = new FooFilter();
76			$this->assertSame(['required' => false], $filter->getFieldOptions());
77
78			$filter->setFieldOption('foo', 'bar');
79			$filter->setFieldOption('baz', 12345);
80
81			$this->assertSame(['foo' => 'bar', 'baz' => 12345], $filter->getFieldOptions());
82			$this->assertSame('bar', $filter->getFieldOption('foo'));
83			$this->assertSame(12345, $filter->getFieldOption('baz'));
84			}
85
86			public function testInitialize(): void
87			{
88			$filter = new FooFilter();
89			$filter->initialize('name', [
90			'field_name' => 'bar',
91			]);
92
93			$this->assertSame('name', $filter->getName());
94			$this->assertSame('bar', $filter->getOption('field_name'));
95			$this->assertSame('bar', $filter->getFieldName());
96			}
97
98			public function testLabel(): void
99			{
100			$filter = new FooFilter();
101			$filter->setLabel('foo');
102
103			$this->assertSame('foo', $filter->getLabel());
104			}
105
106			public function testExceptionOnNonDefinedFilterName(): void
107			{
108			$filter = new FooFilter();
109
110			$this->expectException(\LogicException::class);
111			$this->expectExceptionMessage(sprintf(
112			'Seems like you didn\'t call `initialize()` on the filter `%s`. Did you create it through `%s::create()`?',
113			FooFilter::class,
114			FilterFactory::class
115			));
116
117			$filter->getName();
118			}
119
120			public function testExceptionOnNonDefinedFieldName(): void
121			{
122			$filter = new FooFilter();
123			$filter->initialize('foo');
124
125			$this->expectException(\RuntimeException::class);
126			$this->expectExceptionMessage('The option `field_name` must be set for field: `foo`');
127
128			$filter->getFieldName();
129			}
130
131			/**
132			* @dataProvider isActiveData
133			*
134			* @param $expected
135			* @param $value
136			*/
137			public function testIsActive(bool $expected, array $value): void
138			{
139			$filter = new FooFilter();
140			$filter->setValue($value);
141
142			$this->assertSame($expected, $filter->isActive());
143			}
144
145			public function isActiveData(): array
146			{
147			return [
148			[false, []],
149			[false, ['value' => null]],
150			[false, ['value' => '']],
151			[false, ['value' => false]],
152			[true, ['value' => 'active']],
153			];
154			}
155
156			public function testGetTranslationDomain(): void
157			{
158			$filter = new FooFilter();
159			$this->assertNull($filter->getTranslationDomain());
160			$filter->setOption('translation_domain', 'baz');
161			$this->assertSame('baz', $filter->getTranslationDomain());
162			}
163
164			public function testGetFieldMappingException(): void
165			{
166			$filter = new FooFilter();
167			$filter->initialize('foo');
168
169			$this->expectException(\RuntimeException::class);
170			$this->expectExceptionMessage('The option `field_mapping` must be set for field: `foo`');
171
172			$filter->getFieldMapping();
173			}
174
175			public function testGetFieldMapping(): void
176			{
177			$fieldMapping = [
178			'fieldName' => 'username',
179			'type' => 'string',
180			'columnName' => 'username',
181			'length' => 200,
182			'unique' => true,
183			'nullable' => false,
184			'declared' => 'Foo\Bar\User',
185			];
186
187			$filter = new FooFilter();
188			$filter->setOption('field_mapping', $fieldMapping);
189			$this->assertSame($fieldMapping, $filter->getFieldMapping());
190			}
191
192			public function testGetParentAssociationMappings(): void
193			{
194			$parentAssociationMapping = [
195			0 => ['fieldName' => 'user',
196			'targetEntity' => 'Foo\Bar\User',
197			'joinColumns' => [
198			0 => [
199			'name' => 'user_id',
200			'referencedColumnName' => 'user_id',
201			],
202			],
203			'type' => 2,
204			'mappedBy' => null,
205			],
206			];
207
208			$filter = new FooFilter();
209			$this->assertSame([], $filter->getParentAssociationMappings());
210			$filter->setOption('parent_association_mappings', $parentAssociationMapping);
211			$this->assertSame($parentAssociationMapping, $filter->getParentAssociationMappings());
212			}
213
214			public function testGetAssociationMappingException(): void
215			{
216			$filter = new FooFilter();
217			$filter->initialize('foo');
218
219			$this->expectException(\RuntimeException::class);
220			$this->expectExceptionMessage('The option `association_mapping` must be set for field: `foo`');
221
222			$filter->getAssociationMapping();
223			}
224
225			public function testGetAssociationMapping(): void
226			{
227			$associationMapping = [
228			'fieldName' => 'user',
229			'targetEntity' => 'Foo\Bar\User',
230			'joinColumns' => [
231			0 => [
232			'name' => 'user_id',
233			'referencedColumnName' => 'user_id',
234			],
235			],
236			'type' => 2,
237			'mappedBy' => null,
238			];
239
240			$filter = new FooFilter();
241			$filter->setOption('association_mapping', $associationMapping);
242			$this->assertSame($associationMapping, $filter->getAssociationMapping());
243			}
244			}
245

sonata-project / SonataAdminBundle

Push — master ( ece51a...a98e5a )

FilterTest::testExceptionOnNonDefinedFilterName() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like