IsNotEqualTest::testFilterWillApplyIsNotEqualFiltering() - Code Metrics - Inspection of "Feature/0.2.0" - alex-patterson-webdev/doctrine-query-filter - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#2)

by Alex

created 2021-02-27 16:26 UTC

testFilterWillApplyIsNotEqualFiltering() A

↳ Parent: IsNotEqualTest

Complexity

Conditions	4
Paths	8

Size

Total Lines	53
Code Lines	36

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	36
c	1
b	0
f	0
dl	0
loc	53
rs	9.344
cc	4
nc	8
nop	0

How to fix Long Method

<?php

declare(strict_types=1);

namespace ArpTest\DoctrineQueryFilter\Filter;

use Arp\DoctrineQueryFilter\Constant\WhereType;
use Arp\DoctrineQueryFilter\Filter\Exception\InvalidArgumentException;
use Arp\DoctrineQueryFilter\Filter\FilterInterface;
use Arp\DoctrineQueryFilter\Filter\IsNotEqual;
use Arp\DoctrineQueryFilter\Metadata\MetadataInterface;
use Arp\DoctrineQueryFilter\QueryBuilderInterface;
use Arp\DoctrineQueryFilter\QueryFilterManager;
use Doctrine\ORM\Query\Expr;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * @covers \Arp\DoctrineQueryFilter\Filter\IsNotEqual
 *
 * @author  Alex Patterson <[email protected]>
 * @package ArpTest\DoctrineQueryFilter\Filter
 */
final class IsNotEqualTest extends TestCase
{
    /**
     * @var QueryFilterManager|MockObject
     */
    private $queryFilterManager;

    /**
     * @var MetadataInterface|MockObject
     */
    private $metadata;

    /**
     * @var QueryBuilderInterface|MockObject
     */
    private $queryBuilder;

    /**
     * Prepare the test case dependencies
     */
    public function setUp(): void
    {
        $this->queryFilterManager = $this->createMock(QueryFilterManager::class);

        $this->metadata = $this->createMock(MetadataInterface::class);

        $this->queryBuilder = $this->createMock(QueryBuilderInterface::class);
    }

    /**
     * Assert that IsEqual implement FilterInterface
     */
    public function testImplementsFilterInterface(): void
    {
        $filter = new IsNotEqual($this->queryFilterManager);

        $this->assertInstanceOf(FilterInterface::class, $filter);
    }

    /**
     * @throws InvalidArgumentException
     */
    public function testFilterWillThrowInvalidArgumentExceptionIfTheRequiredFieldNameCriteriaIsMissing(): void
    {
        $filter = new IsNotEqual($this->queryFilterManager);

        $criteria = [
            // No field 'name' will raise exception
        ];

        $this->expectException(InvalidArgumentException::class);
        $this->expectExceptionMessage(
            sprintf('The required \'field\' criteria value is missing for filter \'%s\'', IsNotEqual::class)
        );

        $filter->filter($this->queryBuilder, $this->metadata, $criteria);
    }

    /**
     * Assert that the IsNotEqual query filter can be applied with the provided $criteria
     *
     * @throws InvalidArgumentException
     */
    public function testFilterWillApplyIsNotEqualFiltering(): void
    {
        $filter = new IsNotEqual($this->queryFilterManager);

        $fieldName = 'FieldNameTest';
        $criteria = [
            'field'  => $fieldName,
            'alias'  => 'test',
            'where'  => WhereType::AND,
            'value'  => 123,
            'format' => null,
        ];

        $this->metadata->expects($this->once())
            ->method('hasField')
            ->with($fieldName)
            ->willReturn(true);

        /** @var Expr|MockObject $expr */
        $expr = $this->createMock(Expr::class);

        $this->queryBuilder->expects($this->once())
            ->method('expr')
            ->willReturn($expr);

        /** @var Expr\Comparison|MockObject $neq */
        $neq = $this->createMock(Expr\Comparison::class);

        $isNotEqualString = $criteria['alias'] . '.' . $fieldName . '!=' . ':param_name';
        $expr->expects($this->once())
            ->method('neq')
            ->with($criteria['alias'] . '.' . $fieldName, $this->stringStartsWith(':'))
            ->willReturn($neq);

        $neq->expects($this->once())
            ->method('__toString')
            ->willReturn($isNotEqualString);

        $methodName = (!isset($criteria['where']) || WhereType::AND === $criteria['where'])
            ? 'andWhere'
            : 'orWhere';

        $this->queryBuilder->expects($this->once())->method($methodName);

        if (array_key_exists('value', $criteria)) {
            $this->queryBuilder->expects($this->once())
                ->method('setParameter')
                ->with($this->callback(static function ($argument) {
                    return is_string($argument);
                }), $criteria['value']);
        }

        $filter->filter($this->queryBuilder, $this->metadata, $criteria);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace ArpTest\DoctrineQueryFilter\Filter;
6
7			use Arp\DoctrineQueryFilter\Constant\WhereType;
8			use Arp\DoctrineQueryFilter\Filter\Exception\InvalidArgumentException;
9			use Arp\DoctrineQueryFilter\Filter\FilterInterface;
10			use Arp\DoctrineQueryFilter\Filter\IsNotEqual;
11			use Arp\DoctrineQueryFilter\Metadata\MetadataInterface;
12			use Arp\DoctrineQueryFilter\QueryBuilderInterface;
13			use Arp\DoctrineQueryFilter\QueryFilterManager;
14			use Doctrine\ORM\Query\Expr;
15			use PHPUnit\Framework\MockObject\MockObject;
16			use PHPUnit\Framework\TestCase;
17
18			/**
19			* @covers \Arp\DoctrineQueryFilter\Filter\IsNotEqual
20			*
21			* @author Alex Patterson <[email protected]>
22			* @package ArpTest\DoctrineQueryFilter\Filter
23			*/
24			final class IsNotEqualTest extends TestCase
25			{
26			/**
27			* @var QueryFilterManager\|MockObject
28			*/
29			private $queryFilterManager;
30
31			/**
32			* @var MetadataInterface\|MockObject
33			*/
34			private $metadata;
35
36			/**
37			* @var QueryBuilderInterface\|MockObject
38			*/
39			private $queryBuilder;
40
41			/**
42			* Prepare the test case dependencies
43			*/
44			public function setUp(): void
45			{
46			$this->queryFilterManager = $this->createMock(QueryFilterManager::class);
47
48			$this->metadata = $this->createMock(MetadataInterface::class);
49
50			$this->queryBuilder = $this->createMock(QueryBuilderInterface::class);
51			}
52
53			/**
54			* Assert that IsEqual implement FilterInterface
55			*/
56			public function testImplementsFilterInterface(): void
57			{
58			$filter = new IsNotEqual($this->queryFilterManager);
59
60			$this->assertInstanceOf(FilterInterface::class, $filter);
61			}
62
63			/**
64			* @throws InvalidArgumentException
65			*/
66			public function testFilterWillThrowInvalidArgumentExceptionIfTheRequiredFieldNameCriteriaIsMissing(): void
67			{
68			$filter = new IsNotEqual($this->queryFilterManager);
69
70			$criteria = [
71			// No field 'name' will raise exception
72			];
73
74			$this->expectException(InvalidArgumentException::class);
75			$this->expectExceptionMessage(
76			sprintf('The required \'field\' criteria value is missing for filter \'%s\'', IsNotEqual::class)
77			);
78
79			$filter->filter($this->queryBuilder, $this->metadata, $criteria);
80			}
81
82			/**
83			* Assert that the IsNotEqual query filter can be applied with the provided $criteria
84			*
85			* @throws InvalidArgumentException
86			*/
87			public function testFilterWillApplyIsNotEqualFiltering(): void
88			{
89			$filter = new IsNotEqual($this->queryFilterManager);
90
91			$fieldName = 'FieldNameTest';
92			$criteria = [
93			'field' => $fieldName,
94			'alias' => 'test',
95			'where' => WhereType::AND,
96			'value' => 123,
97			'format' => null,
98			];
99
100			$this->metadata->expects($this->once())
101			->method('hasField')
102			->with($fieldName)
103			->willReturn(true);
104
105			/** @var Expr\|MockObject $expr */
106			$expr = $this->createMock(Expr::class);
107
108			$this->queryBuilder->expects($this->once())
109			->method('expr')
110			->willReturn($expr);
111
112			/** @var Expr\Comparison\|MockObject $neq */
113			$neq = $this->createMock(Expr\Comparison::class);
114
115			$isNotEqualString = $criteria['alias'] . '.' . $fieldName . '!=' . ':param_name';
116			$expr->expects($this->once())
117			->method('neq')
118			->with($criteria['alias'] . '.' . $fieldName, $this->stringStartsWith(':'))
119			->willReturn($neq);
120
121			$neq->expects($this->once())
122			->method('__toString')
123			->willReturn($isNotEqualString);
124
125			$methodName = (!isset($criteria['where']) \|\| WhereType::AND === $criteria['where'])
126			? 'andWhere'
127			: 'orWhere';
128
129			$this->queryBuilder->expects($this->once())->method($methodName);
130
131			if (array_key_exists('value', $criteria)) {
132			$this->queryBuilder->expects($this->once())
133			->method('setParameter')
134			->with($this->callback(static function ($argument) {
135			return is_string($argument);
136			}), $criteria['value']);
137			}
138
139			$filter->filter($this->queryBuilder, $this->metadata, $criteria);
140			}
141			}
142

alex-patterson-webdev / doctrine-query-filter

Pull Request — master (#2)

testFilterWillApplyIsNotEqualFiltering() A

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like