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

Test Failed

Pull Request — master (#4)

by Alex

created 2021-03-07 00:42 UTC

testFilterWillApplyFiltering() A

↳ Parent: AbstractComparisonTest

Complexity

Conditions	5
Paths	16

Size

Total Lines	57
Code Lines	38

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	5
eloc	38
c	1
b	0
f	0
nc	16
nop	1
dl	0
loc	57
rs	9.0008

How to fix Long Method

<?php

declare(strict_types=1);

namespace ArpTest\DoctrineQueryFilter\Filter;

use Arp\DoctrineQueryFilter\Constant\WhereType;
use Arp\DoctrineQueryFilter\Filter\FilterInterface;
use Doctrine\ORM\Query\Expr;
use PHPUnit\Framework\MockObject\MockObject;

/**
 * @author  Alex Patterson <[email protected]>
 * @package ArpTest\DoctrineQueryFilter\Filter
 */
abstract class AbstractComparisonTest extends AbstractFilterTest
{
    /**
     * @var FilterInterface
     */
    protected FilterInterface $filter;

    /**
     * @var string
     */
    protected string $filterClassName;

    /**
     * @var string
     */
    protected string $expressionMethodName;

    /**
     * @var string
     */
    protected string $expressionSymbol;

    /**
     * Prepare the test case dependencies
     */
    public function setUp(): void
    {
        parent::setUp();

        $this->filter = new $this->filterClassName($this->queryFilterManager, $this->typecaster);
    }

    /**
     * Assert that the filter implements FilterInterface
     */
    public function testImplementsFilterInterface(): void
    {
        $this->assertInstanceOf(FilterInterface::class, $this->filter);
    }

    /**
     * Assert that the IsGreaterThan query filter can be applied with the provided $criteria
     *
     * @param array $criteria
     *
     * @dataProvider getFilterWillApplyFilteringData
     */
    public function testFilterWillApplyFiltering(array $criteria): void
    {
        $fieldName = $criteria['field'] ?? 'testFieldName';
        $alias = $criteria['alias'] ?? 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 $comparisonExpr */
        $comparisonExpr = $this->createMock(Expr\Comparison::class);

        if (null === $alias) {
            $alias = 'entity';
            $this->queryBuilder->expects($this->once())
                ->method('getRootAlias')
                ->willReturn($alias);
        }

        $expressionString = $this->getExpressionString($fieldName, $alias, $criteria);

        $expr->expects($this->once())
            ->method($this->expressionMethodName)
            ->willReturn($comparisonExpr);

        $comparisonExpr->expects($this->once())
            ->method('__toString')
            ->willReturn($expressionString);

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

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

        if (array_key_exists('value', $criteria)) {
            $this->typecaster->expects($this->once())
                ->method('typecast')
                ->with($this->metadata, $fieldName, $criteria['value'])
                ->willReturn($criteria['value']);

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

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

    /**
     * @return array
     */
    abstract public function getFilterWillApplyFilteringData(): array;

    /**
     * @param string      $fieldName
     * @param string|null $alias
     * @param array       $criteria
     *
     * @return string
     */
    protected function getExpressionString(string $fieldName, ?string $alias, array $criteria): string
    {
        $expressionString = $alias . '.' . $fieldName . ' ' . $this->expressionSymbol;
        if (array_key_exists('value', $criteria)) {
            $expressionString .= ' :param_name';
        }
        return $expressionString;
    }
}


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\FilterInterface;
9			use Doctrine\ORM\Query\Expr;
10			use PHPUnit\Framework\MockObject\MockObject;
11
12			/**
13			* @author Alex Patterson <[email protected]>
14			* @package ArpTest\DoctrineQueryFilter\Filter
15			*/
16			abstract class AbstractComparisonTest extends AbstractFilterTest
17			{
18			/**
19			* @var FilterInterface
20			*/
21			protected FilterInterface $filter;
22
23			/**
24			* @var string
25			*/
26			protected string $filterClassName;
27
28			/**
29			* @var string
30			*/
31			protected string $expressionMethodName;
32
33			/**
34			* @var string
35			*/
36			protected string $expressionSymbol;
37
38			/**
39			* Prepare the test case dependencies
40			*/
41			public function setUp(): void
42			{
43			parent::setUp();
44
45			$this->filter = new $this->filterClassName($this->queryFilterManager, $this->typecaster);
46			}
47
48			/**
49			* Assert that the filter implements FilterInterface
50			*/
51			public function testImplementsFilterInterface(): void
52			{
53			$this->assertInstanceOf(FilterInterface::class, $this->filter);
54			}
55
56			/**
57			* Assert that the IsGreaterThan query filter can be applied with the provided $criteria
58			*
59			* @param array $criteria
60			*
61			* @dataProvider getFilterWillApplyFilteringData
62			*/
63			public function testFilterWillApplyFiltering(array $criteria): void
64			{
65			$fieldName = $criteria['field'] ?? 'testFieldName';
66			$alias = $criteria['alias'] ?? null;
67
68			$this->metadata->expects($this->once())
69			->method('hasField')
70			->with($fieldName)
71			->willReturn(true);
72
73			/** @var Expr\|MockObject $expr */
74			$expr = $this->createMock(Expr::class);
75
76			$this->queryBuilder->expects($this->once())
77			->method('expr')
78			->willReturn($expr);
79
80			/** @var Expr\Comparison\|MockObject $comparisonExpr */
81			$comparisonExpr = $this->createMock(Expr\Comparison::class);
82
83			if (null === $alias) {
84			$alias = 'entity';
85			$this->queryBuilder->expects($this->once())
86			->method('getRootAlias')
87			->willReturn($alias);
88			}
89
90			$expressionString = $this->getExpressionString($fieldName, $alias, $criteria);
91
92			$expr->expects($this->once())
93			->method($this->expressionMethodName)
94			->willReturn($comparisonExpr);
95
96			$comparisonExpr->expects($this->once())
97			->method('__toString')
98			->willReturn($expressionString);
99
100			$methodName = (!isset($criteria['where']) \|\| WhereType::AND === $criteria['where'])
101			? 'andWhere'
102			: 'orWhere';
103
104			$this->queryBuilder->expects($this->once())->method($methodName);
105
106			if (array_key_exists('value', $criteria)) {
107			$this->typecaster->expects($this->once())
108			->method('typecast')
109			->with($this->metadata, $fieldName, $criteria['value'])
110			->willReturn($criteria['value']);
111
112			$this->queryBuilder->expects($this->once())
113			->method('setParameter')
114			->with($this->callback(static function ($argument) {
115			return is_string($argument);
116			}), $criteria['value']);
117			}
118
119			$this->filter->filter($this->queryBuilder, $this->metadata, $criteria);
120			}
121
122			/**
123			* @return array
124			*/
125			abstract public function getFilterWillApplyFilteringData(): array;
126
127			/**
128			* @param string $fieldName
129			* @param string\|null $alias
130			* @param array $criteria
131			*
132			* @return string
133			*/
134			protected function getExpressionString(string $fieldName, ?string $alias, array $criteria): string
135			{
136			$expressionString = $alias . '.' . $fieldName . ' ' . $this->expressionSymbol;
137			if (array_key_exists('value', $criteria)) {
138			$expressionString .= ' :param_name';
139			}
140			return $expressionString;
141			}
142			}
143

alex-patterson-webdev / doctrine-query-filter

Pull Request — master (#4)

testFilterWillApplyFiltering() A

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like