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

Passed

Pull Request — master (#4)

by Alex

created 2021-04-28 22:38 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\Exception\FilterException;
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 query filter can be applied with the provided $criteria
     *
     * @param array<mixed> $criteria
     *
     * @dataProvider getFilterWillApplyFilteringData
     *
     * @throws FilterException
     */
    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<mixed>
     */
    abstract public function getFilterWillApplyFilteringData(): array;

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

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