Issues in BaseFieldDescriptionTest.php - New Issues - Inspection of "Removed annotations chapter from docs" - sonata-project/SonataAdminBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 3.x ( b75183...b1c847 )

by Oskar

created 2019-02-22 09:42 UTC

tests/Admin/BaseFieldDescriptionTest.php (3 issues)

Labels

Unused Code 3

Severity

Minor 3

Gocha Ossinkine 3

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

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

use PHPUnit\Framework\TestCase;
use Sonata\AdminBundle\Admin\AdminInterface;
use Sonata\AdminBundle\Admin\BaseFieldDescription;
use Sonata\AdminBundle\Exception\NoValueException;
use Sonata\AdminBundle\Tests\Fixtures\Admin\FieldDescription;
use Sonata\AdminBundle\Tests\Fixtures\Entity\Foo;
use Sonata\AdminBundle\Tests\Fixtures\Entity\FooBoolean;
use Sonata\AdminBundle\Tests\Fixtures\Entity\FooCall;

class BaseFieldDescriptionTest extends TestCase
{
    public function testSetName(): void
    {
        $description = new FieldDescription();
        $description->setName('foo');

        $this->assertSame('foo', $description->getFieldName());
        $this->assertSame('foo', $description->getName());
    }

    public function testOptions(): void
    {
        $description = new FieldDescription();
        $description->setOption('foo', 'bar');

        $this->assertNull($description->getOption('bar'));
        $this->assertSame('bar', $description->getOption('foo'));

        $description->mergeOptions(['settings' => ['value_1', 'value_2']]);
        $description->mergeOptions(['settings' => ['value_1', 'value_3']]);

        $this->assertSame(['value_1', 'value_2', 'value_1', 'value_3'], $description->getOption('settings'));

        $description->mergeOption('settings', ['value_4']);
        $this->assertSame(['value_1', 'value_2', 'value_1', 'value_3', 'value_4'], $description->getOption('settings'));

        $description->mergeOption('bar', ['hello']);

        $this->assertCount(1, $description->getOption('bar'));

        $description->setOption('label', 'trucmuche');
        $this->assertSame('trucmuche', $description->getLabel());
        $this->assertNull($description->getTemplate());
        $description->setOptions(['type' => 'integer', 'template' => 'foo.twig.html', 'help' => 'fooHelp']);

        $this->assertSame('integer', $description->getType());
        $this->assertSame('foo.twig.html', $description->getTemplate());
        $this->assertSame('fooHelp', $description->getHelp());

        $this->assertCount(2, $description->getOptions());

        $description->setHelp('Please enter an integer');
        $this->assertSame('Please enter an integer', $description->getHelp());

        $description->setMappingType('int');
        $this->assertSame('int', $description->getMappingType());

        $this->assertSame('short_object_description_placeholder', $description->getOption('placeholder'));
        $description->setOptions(['placeholder' => false]);
        $this->assertFalse($description->getOption('placeholder'));

        $description->setOption('sortable', false);
        $this->assertFalse($description->isSortable());

        $description->setOption('sortable', 'field_name');
        $this->assertTrue($description->isSortable());
    }

    public function testAdmin(): void
    {
        $description = new FieldDescription();

        $admin = $this->getMockForAbstractClass(AdminInterface::class);
        $description->setAdmin($admin);
        $this->isInstanceOf(AdminInterface::class, $description->getAdmin());


        $associationAdmin = $this->getMockForAbstractClass(AdminInterface::class);
        $associationAdmin->expects($this->once())->method('setParentFieldDescription');

        $this->assertFalse($description->hasAssociationAdmin());
        $description->setAssociationAdmin($associationAdmin);
        $this->assertTrue($description->hasAssociationAdmin());
        $this->isInstanceOf(AdminInterface::class, $description->getAssociationAdmin());


        $parent = $this->getMockForAbstractClass(AdminInterface::class);
        $description->setParent($parent);
        $this->isInstanceOf(AdminInterface::class, $description->getParent());

    }

    public function testGetValue(): void
    {
        $description = new FieldDescription();
        $description->setOption('code', 'getFoo');

        $mock = $this->getMockBuilder('stdClass')
            ->setMethods(['getFoo'])
            ->getMock();
        $mock->expects($this->once())->method('getFoo')->will($this->returnValue(42));

        $this->assertSame(42, $description->getFieldValue($mock, 'fake'));

        /*
         * Test with One parameter int
         */
        $arg1 = 38;
        $oneParameter = [$arg1];
        $description1 = new FieldDescription();
        $description1->setOption('code', 'getWithOneParameter');
        $description1->setOption('parameters', $oneParameter);

        $mock1 = $this->getMockBuilder('stdClass')
            ->setMethods(['getWithOneParameter'])
            ->getMock();
        $returnValue1 = $arg1 + 2;
        $mock1->expects($this->once())->method('getWithOneParameter')->with($this->equalTo($arg1))->will($this->returnValue($returnValue1));

        $this->assertSame(40, $description1->getFieldValue($mock1, 'fake'));

        /*
         * Test with Two parameters int
         */
        $arg2 = 4;
        $twoParameters = [$arg1, $arg2];
        $description2 = new FieldDescription();
        $description2->setOption('code', 'getWithTwoParameters');
        $description2->setOption('parameters', $twoParameters);

        $mock2 = $this->getMockBuilder('stdClass')
            ->setMethods(['getWithTwoParameters'])
            ->getMock();
        $returnValue2 = $arg1 + $arg2;
        $mock2->expects($this->any())->method('getWithTwoParameters')->with($this->equalTo($arg1), $this->equalTo($arg2))->will($this->returnValue($returnValue2));
        $this->assertSame(42, $description2->getFieldValue($mock2, 'fake'));

        /*
         * Test with underscored attribute name
         */
        foreach (['getFake', 'isFake', 'hasFake'] as $method) {
            $description3 = new FieldDescription();
            $mock3 = $this->getMockBuilder('stdClass')
                ->setMethods([$method])
                ->getMock();

            $mock3->expects($this->once())->method($method)->will($this->returnValue(42));
            $this->assertSame(42, $description3->getFieldValue($mock3, '_fake'));
        }

        $mock4 = $this->getMockBuilder('MockedTestObject')
            ->setMethods(['myMethod'])
            ->getMock();
        $mock4->expects($this->once())
            ->method('myMethod')
            ->will($this->returnValue('myMethodValue'));

        $description4 = new FieldDescription();
        $description4->setOption('code', 'myMethod');

        $this->assertSame($description4->getFieldValue($mock4, null), 'myMethodValue');
    }

    public function testGetValueNoValueException(): void
    {
        $this->expectException(\Sonata\AdminBundle\Exception\NoValueException::class);

        $description = new FieldDescription();
        $mock = $this->getMockBuilder('stdClass')
            ->setMethods(['getFoo'])
            ->getMock();

        $description->getFieldValue($mock, 'fake');
    }

    /**
     * @doesNotPerformAssertions
     */
    public function testGetVirtualValue(): void
    {
        $description = new FieldDescription();
        $mock = $this->getMockBuilder('stdClass')
            ->setMethods(['getFoo'])
            ->getMock();

        $description->setOption('virtual_field', true);
        $description->getFieldValue($mock, 'fake');
    }

    public function testExceptionOnNonArrayOption(): void
    {
        $this->expectException(\RuntimeException::class);

        $description = new FieldDescription();
        $description->setOption('bar', 'hello');
        $description->mergeOption('bar', ['exception']);
    }

    public function testGetTranslationDomain(): void
    {
        $description = new FieldDescription();

        $admin = $this->createMock(AdminInterface::class);
        $description->setAdmin($admin);

        $admin->expects($this->once())
            ->method('getTranslationDomain')
            ->will($this->returnValue('AdminDomain'));

        $this->assertSame('AdminDomain', $description->getTranslationDomain());

        $admin->expects($this->never())
            ->method('getTranslationDomain');
        $description->setOption('translation_domain', 'ExtensionDomain');
        $this->assertSame('ExtensionDomain', $description->getTranslationDomain());
    }

    /**
     * @group legacy
     */
    public function testCamelize(): void
    {
        $this->assertSame('FooBar', BaseFieldDescription::camelize('foo_bar'));
        $this->assertSame('FooBar', BaseFieldDescription::camelize('foo bar'));
        $this->assertSame('FOoBar', BaseFieldDescription::camelize('fOo bar'));
    }

    public function testGetInaccessibleValue(): void
    {
        $quux = 'quuX';
        $foo = new Foo();
        $foo->setQuux($quux);
        $ro = new \ReflectionObject($foo);
        $rm = $ro->getMethod('getQuux');
        $rm->setAccessible(true);
        $this->assertSame($quux, $rm->invokeArgs($foo, []));

        $description = new FieldDescription();

        $this->expectException(NoValueException::class);
        $description->getFieldValue($foo, 'quux');
    }

    public function testGetFieldValue(): void
    {
        $foo = new Foo();
        $foo->setBar('Bar');

        $description = new FieldDescription();
        $this->assertSame('Bar', $description->getFieldValue($foo, 'bar'));
        $foo->setBar('baR');
        $this->assertSame('baR', $description->getFieldValue($foo, 'bar'));

        $foo->qux = 'Qux';
        $this->assertSame('Qux', $description->getFieldValue($foo, 'qux'));
        $foo->qux = 'quX';
        $this->assertSame('quX', $description->getFieldValue($foo, 'qux'));

        $foo = new FooBoolean();
        $foo->setBar(true);
        $foo->setBaz(false);

        $description = new FieldDescription();
        $this->assertTrue($description->getFieldValue($foo, 'bar'));
        $this->assertFalse($description->getFieldValue($foo, 'baz'));

        $this->expectException(NoValueException::class);
        $description->getFieldValue($foo, 'inexistantMethod');
    }

    public function testGetFieldValueWithCodeOption(): void
    {
        $foo = new Foo();
        $foo->setBaz('Baz');

        $description = new FieldDescription();

        $description->setOption('code', 'getBaz');
        $this->assertSame('Baz', $description->getFieldValue($foo, 'inexistantMethod'));

        $description->setOption('code', 'inexistantMethod');
        $this->expectException(NoValueException::class);
        $description->getFieldValue($foo, 'inexistantMethod');
    }

    public function testGetFieldValueMagicCall(): void
    {
        $parameters = ['foo', 'bar'];
        $foo = new FooCall();

        $description = new FieldDescription();
        $description->setOption('parameters', $parameters);
        $this->assertSame(['inexistantMethod', $parameters], $description->getFieldValue($foo, 'inexistantMethod'));

        // repeating to cover retrieving cached getter
        $this->assertSame(['inexistantMethod', $parameters], $description->getFieldValue($foo, 'inexistantMethod'));
    }

    public function testGetFieldValueWithNullObject(): void
    {
        $foo = null;
        $description = new FieldDescription();
        $this->assertNull($description->getFieldValue($foo, 'bar'));
    }
}


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\Admin;
15
16			use PHPUnit\Framework\TestCase;
17			use Sonata\AdminBundle\Admin\AdminInterface;
18			use Sonata\AdminBundle\Admin\BaseFieldDescription;
19			use Sonata\AdminBundle\Exception\NoValueException;
20			use Sonata\AdminBundle\Tests\Fixtures\Admin\FieldDescription;
21			use Sonata\AdminBundle\Tests\Fixtures\Entity\Foo;
22			use Sonata\AdminBundle\Tests\Fixtures\Entity\FooBoolean;
23			use Sonata\AdminBundle\Tests\Fixtures\Entity\FooCall;
24
25			class BaseFieldDescriptionTest extends TestCase
26			{
27			public function testSetName(): void
28			{
29			$description = new FieldDescription();
30			$description->setName('foo');
31
32			$this->assertSame('foo', $description->getFieldName());
33			$this->assertSame('foo', $description->getName());
34			}
35
36			public function testOptions(): void
37			{
38			$description = new FieldDescription();
39			$description->setOption('foo', 'bar');
40
41			$this->assertNull($description->getOption('bar'));
42			$this->assertSame('bar', $description->getOption('foo'));
43
44			$description->mergeOptions(['settings' => ['value_1', 'value_2']]);
45			$description->mergeOptions(['settings' => ['value_1', 'value_3']]);
46
47			$this->assertSame(['value_1', 'value_2', 'value_1', 'value_3'], $description->getOption('settings'));
48
49			$description->mergeOption('settings', ['value_4']);
50			$this->assertSame(['value_1', 'value_2', 'value_1', 'value_3', 'value_4'], $description->getOption('settings'));
51
52			$description->mergeOption('bar', ['hello']);
53
54			$this->assertCount(1, $description->getOption('bar'));
55
56			$description->setOption('label', 'trucmuche');
57			$this->assertSame('trucmuche', $description->getLabel());
58			$this->assertNull($description->getTemplate());
59			$description->setOptions(['type' => 'integer', 'template' => 'foo.twig.html', 'help' => 'fooHelp']);
60
61			$this->assertSame('integer', $description->getType());
62			$this->assertSame('foo.twig.html', $description->getTemplate());
63			$this->assertSame('fooHelp', $description->getHelp());
64
65			$this->assertCount(2, $description->getOptions());
66
67			$description->setHelp('Please enter an integer');
68			$this->assertSame('Please enter an integer', $description->getHelp());
69
70			$description->setMappingType('int');
71			$this->assertSame('int', $description->getMappingType());
72
73			$this->assertSame('short_object_description_placeholder', $description->getOption('placeholder'));
74			$description->setOptions(['placeholder' => false]);
75			$this->assertFalse($description->getOption('placeholder'));
76
77			$description->setOption('sortable', false);
78			$this->assertFalse($description->isSortable());
79
80			$description->setOption('sortable', 'field_name');
81			$this->assertTrue($description->isSortable());
82			}
83
84			public function testAdmin(): void
85			{
86			$description = new FieldDescription();
87
88			$admin = $this->getMockForAbstractClass(AdminInterface::class);
89			$description->setAdmin($admin);
90			$this->isInstanceOf(AdminInterface::class, $description->getAdmin());
			0 ignored issues – show Unused Code introduced 2019-02-09 11:04 UTC by Report Bug Copy Issue Report Show Similar Issues like this The call to `BaseFieldDescriptionTest::isInstanceOf()` has too many arguments starting with `$description->getAdmin()`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
91
92			$associationAdmin = $this->getMockForAbstractClass(AdminInterface::class);
93			$associationAdmin->expects($this->once())->method('setParentFieldDescription');
94
95			$this->assertFalse($description->hasAssociationAdmin());
96			$description->setAssociationAdmin($associationAdmin);
97			$this->assertTrue($description->hasAssociationAdmin());
98			$this->isInstanceOf(AdminInterface::class, $description->getAssociationAdmin());
			0 ignored issues – show Unused Code introduced 2019-02-09 11:04 UTC by Report Bug Copy Issue Report Show Similar Issues like this The call to `BaseFieldDescriptionTest::isInstanceOf()` has too many arguments starting with `$description->getAssociationAdmin()`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
99
100			$parent = $this->getMockForAbstractClass(AdminInterface::class);
101			$description->setParent($parent);
102			$this->isInstanceOf(AdminInterface::class, $description->getParent());
			0 ignored issues – show Unused Code introduced 2019-02-09 11:04 UTC by Report Bug Copy Issue Report Show Similar Issues like this The call to `BaseFieldDescriptionTest::isInstanceOf()` has too many arguments starting with `$description->getParent()`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
103			}
104
105			public function testGetValue(): void
106			{
107			$description = new FieldDescription();
108			$description->setOption('code', 'getFoo');
109
110			$mock = $this->getMockBuilder('stdClass')
111			->setMethods(['getFoo'])
112			->getMock();
113			$mock->expects($this->once())->method('getFoo')->will($this->returnValue(42));
114
115			$this->assertSame(42, $description->getFieldValue($mock, 'fake'));
116
117			/*
118			* Test with One parameter int
119			*/
120			$arg1 = 38;
121			$oneParameter = [$arg1];
122			$description1 = new FieldDescription();
123			$description1->setOption('code', 'getWithOneParameter');
124			$description1->setOption('parameters', $oneParameter);
125
126			$mock1 = $this->getMockBuilder('stdClass')
127			->setMethods(['getWithOneParameter'])
128			->getMock();
129			$returnValue1 = $arg1 + 2;
130			$mock1->expects($this->once())->method('getWithOneParameter')->with($this->equalTo($arg1))->will($this->returnValue($returnValue1));
131
132			$this->assertSame(40, $description1->getFieldValue($mock1, 'fake'));
133
134			/*
135			* Test with Two parameters int
136			*/
137			$arg2 = 4;
138			$twoParameters = [$arg1, $arg2];
139			$description2 = new FieldDescription();
140			$description2->setOption('code', 'getWithTwoParameters');
141			$description2->setOption('parameters', $twoParameters);
142
143			$mock2 = $this->getMockBuilder('stdClass')
144			->setMethods(['getWithTwoParameters'])
145			->getMock();
146			$returnValue2 = $arg1 + $arg2;
147			$mock2->expects($this->any())->method('getWithTwoParameters')->with($this->equalTo($arg1), $this->equalTo($arg2))->will($this->returnValue($returnValue2));
148			$this->assertSame(42, $description2->getFieldValue($mock2, 'fake'));
149
150			/*
151			* Test with underscored attribute name
152			*/
153			foreach (['getFake', 'isFake', 'hasFake'] as $method) {
154			$description3 = new FieldDescription();
155			$mock3 = $this->getMockBuilder('stdClass')
156			->setMethods([$method])
157			->getMock();
158
159			$mock3->expects($this->once())->method($method)->will($this->returnValue(42));
160			$this->assertSame(42, $description3->getFieldValue($mock3, '_fake'));
161			}
162
163			$mock4 = $this->getMockBuilder('MockedTestObject')
164			->setMethods(['myMethod'])
165			->getMock();
166			$mock4->expects($this->once())
167			->method('myMethod')
168			->will($this->returnValue('myMethodValue'));
169
170			$description4 = new FieldDescription();
171			$description4->setOption('code', 'myMethod');
172
173			$this->assertSame($description4->getFieldValue($mock4, null), 'myMethodValue');
174			}
175
176			public function testGetValueNoValueException(): void
177			{
178			$this->expectException(\Sonata\AdminBundle\Exception\NoValueException::class);
179
180			$description = new FieldDescription();
181			$mock = $this->getMockBuilder('stdClass')
182			->setMethods(['getFoo'])
183			->getMock();
184
185			$description->getFieldValue($mock, 'fake');
186			}
187
188			/**
189			* @doesNotPerformAssertions
190			*/
191			public function testGetVirtualValue(): void
192			{
193			$description = new FieldDescription();
194			$mock = $this->getMockBuilder('stdClass')
195			->setMethods(['getFoo'])
196			->getMock();
197
198			$description->setOption('virtual_field', true);
199			$description->getFieldValue($mock, 'fake');
200			}
201
202			public function testExceptionOnNonArrayOption(): void
203			{
204			$this->expectException(\RuntimeException::class);
205
206			$description = new FieldDescription();
207			$description->setOption('bar', 'hello');
208			$description->mergeOption('bar', ['exception']);
209			}
210
211			public function testGetTranslationDomain(): void
212			{
213			$description = new FieldDescription();
214
215			$admin = $this->createMock(AdminInterface::class);
216			$description->setAdmin($admin);
217
218			$admin->expects($this->once())
219			->method('getTranslationDomain')
220			->will($this->returnValue('AdminDomain'));
221
222			$this->assertSame('AdminDomain', $description->getTranslationDomain());
223
224			$admin->expects($this->never())
225			->method('getTranslationDomain');
226			$description->setOption('translation_domain', 'ExtensionDomain');
227			$this->assertSame('ExtensionDomain', $description->getTranslationDomain());
228			}
229
230			/**
231			* @group legacy
232			*/
233			public function testCamelize(): void
234			{
235			$this->assertSame('FooBar', BaseFieldDescription::camelize('foo_bar'));
236			$this->assertSame('FooBar', BaseFieldDescription::camelize('foo bar'));
237			$this->assertSame('FOoBar', BaseFieldDescription::camelize('fOo bar'));
238			}
239
240			public function testGetInaccessibleValue(): void
241			{
242			$quux = 'quuX';
243			$foo = new Foo();
244			$foo->setQuux($quux);
245			$ro = new \ReflectionObject($foo);
246			$rm = $ro->getMethod('getQuux');
247			$rm->setAccessible(true);
248			$this->assertSame($quux, $rm->invokeArgs($foo, []));
249
250			$description = new FieldDescription();
251
252			$this->expectException(NoValueException::class);
253			$description->getFieldValue($foo, 'quux');
254			}
255
256			public function testGetFieldValue(): void
257			{
258			$foo = new Foo();
259			$foo->setBar('Bar');
260
261			$description = new FieldDescription();
262			$this->assertSame('Bar', $description->getFieldValue($foo, 'bar'));
263			$foo->setBar('baR');
264			$this->assertSame('baR', $description->getFieldValue($foo, 'bar'));
265
266			$foo->qux = 'Qux';
267			$this->assertSame('Qux', $description->getFieldValue($foo, 'qux'));
268			$foo->qux = 'quX';
269			$this->assertSame('quX', $description->getFieldValue($foo, 'qux'));
270
271			$foo = new FooBoolean();
272			$foo->setBar(true);
273			$foo->setBaz(false);
274
275			$description = new FieldDescription();
276			$this->assertTrue($description->getFieldValue($foo, 'bar'));
277			$this->assertFalse($description->getFieldValue($foo, 'baz'));
278
279			$this->expectException(NoValueException::class);
280			$description->getFieldValue($foo, 'inexistantMethod');
281			}
282
283			public function testGetFieldValueWithCodeOption(): void
284			{
285			$foo = new Foo();
286			$foo->setBaz('Baz');
287
288			$description = new FieldDescription();
289
290			$description->setOption('code', 'getBaz');
291			$this->assertSame('Baz', $description->getFieldValue($foo, 'inexistantMethod'));
292
293			$description->setOption('code', 'inexistantMethod');
294			$this->expectException(NoValueException::class);
295			$description->getFieldValue($foo, 'inexistantMethod');
296			}
297
298			public function testGetFieldValueMagicCall(): void
299			{
300			$parameters = ['foo', 'bar'];
301			$foo = new FooCall();
302
303			$description = new FieldDescription();
304			$description->setOption('parameters', $parameters);
305			$this->assertSame(['inexistantMethod', $parameters], $description->getFieldValue($foo, 'inexistantMethod'));
306
307			// repeating to cover retrieving cached getter
308			$this->assertSame(['inexistantMethod', $parameters], $description->getFieldValue($foo, 'inexistantMethod'));
309			}
310
311			public function testGetFieldValueWithNullObject(): void
312			{
313			$foo = null;
314			$description = new FieldDescription();
315			$this->assertNull($description->getFieldValue($foo, 'bar'));
316			}
317			}
318

sonata-project / SonataAdminBundle

Push — 3.x ( b75183...b1c847 )

tests/Admin/BaseFieldDescriptionTest.php (3 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like