ArpTest\DoctrineQueryFilter\Filter\AbstractComparisonTest

Complexity

Total Complexity

9

Size/Duplication

Total Lines	102
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	7	1
A	testImplementsFilterInterface()	0	3	1
A	testFilterWillApplyFiltering()	0	57	5
A	getExpressionString()	0	7	2

<?php

declare(strict_types=1);

namespace ArpTest\DoctrineQueryFilter\Filter;

use Arp\DoctrineQueryFilter\Enum\WhereType;
use Arp\DoctrineQueryFilter\Filter\Exception\FilterException;
use Arp\DoctrineQueryFilter\Filter\FilterInterface;
use Doctrine\ORM\Query\Expr;
use PHPUnit\Framework\MockObject\MockObject;

abstract class AbstractComparisonTest extends AbstractFilterTest
{
    protected FilterInterface $filter;

    protected string $filterClassName;

    protected string $expressionMethodName;

    protected string $expressionSymbol;

    public function setUp(): void
    {
        parent::setUp();

        /** @var FilterInterface $filter */
        $filter = new $this->filterClassName($this->queryFilterManager, $this->typecaster, $this->paramNameGenerator);
        $this->filter = $filter;
    }

    /**
     * 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
     *
     * @dataProvider getFilterWillApplyFilteringData
     *
     * @throws FilterException
     */
    public function testFilterWillApplyFiltering(array $criteria): void
    {
        $fieldName = $criteria['field'] ?? 'testFieldName';
        $alias = $criteria['alias'] ?? null;

        $this->metadata->expects($this->once())

The method expects() does not exist on Arp\DoctrineQueryFilter\Metadata\MetadataInterface.

            ->method('hasField')
            ->with($fieldName)
            ->willReturn(true);

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

        $this->queryBuilder->expects($this->once())

The method expects() does not exist on Arp\DoctrineQueryFilter\QueryBuilderInterface.

            ->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())

The method expects() does not exist on Arp\DoctrineQueryFilter\Metadata\TypecasterInterface.

                ->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);
    }

    abstract public function getFilterWillApplyFilteringData(): array;

    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;
    }
}