QueryServiceTest::testExecuteWillPrepareAndExecuteQuery() - Code Metrics - Inspection of "Feature/0.0.2" - alex-patterson-webdev/doctrine-entity-repository - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#5)

by Alex
created 2020-06-17 13:09 UTC
testExecuteWillPrepareAndExecuteQuery() B

↳ Parent: QueryServiceTest
Complexity

Conditions	7
Paths	32
Size

Total Lines	40
Code Lines	24
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	24
c	1
b	0
f	0
dl	0
loc	40
rs	8.6026
cc	7
nc	32
nop	1
<?php

declare(strict_types=1);

namespace ArpTest\DoctrineEntityRepository\Query;

use Arp\DoctrineEntityRepository\Constant\QueryServiceOption;
use Arp\DoctrineEntityRepository\Query\Exception\QueryServiceException;
use Arp\DoctrineEntityRepository\Query\QueryService;
use Arp\DoctrineEntityRepository\Query\QueryServiceInterface;
use Arp\Entity\EntityInterface;
use Doctrine\ORM\AbstractQuery;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\Query;
use Doctrine\ORM\QueryBuilder;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Psr\Log\LoggerInterface;

/**
 * @author  Alex Patterson <[email protected]>
 * @package ArpTest\DoctrineEntityRepository\Query
 */
final class QueryServiceTest extends TestCase
{
    /**
     * @var string
     */
    private $entityName;

    /**
     * @var EntityManagerInterface|MockObject
     */
    private $entityManager;

    /**
     * @var LoggerInterface|MockObject
     */
    private $logger;

    /**
     * Setup the test case dependencies.
     */
    public function setUp(): void
    {
        $this->entityName = EntityInterface::class;

        $this->entityManager = $this->getMockForAbstractClass(EntityManagerInterface::class);

        $this->logger = $this->getMockForAbstractClass(LoggerInterface::class);
    }

    /**
     * Assert that the QueryService implements QueryServiceInterface
     *
     * @covers \Arp\DoctrineEntityRepository\Query\QueryService::__construct
     */
    public function testImplementsQueryServiceInterface(): void
    {
        $queryService = new QueryService($this->entityName, $this->entityManager, $this->logger);

        $this->assertInstanceOf(QueryServiceInterface::class, $queryService);
    }

    /**
     * Assert that a query builder is returned without an alias.
     *
     * @covers \Arp\DoctrineEntityRepository\Query\QueryService::createQueryBuilder
     */
    public function testCreateQueryBuilderWillReturnQueryBuilderWithoutAlias(): void
    {
        $queryService = new QueryService($this->entityName, $this->entityManager, $this->logger);

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

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

        $queryBuilder->expects($this->never())->method('select');
        $queryBuilder->expects($this->never())->method('from');

        $this->assertInstanceOf(QueryBuilder::class, $queryService->createQueryBuilder());
    }

    /**
     * Assert that a query builder is returned with the provided $alias
     *
     * @covers \Arp\DoctrineEntityRepository\Query\QueryService::createQueryBuilder
     */
    public function testCreateQueryBuilderWillReturnQueryBuilderWithAlias(): void
    {
        $queryService = new QueryService($this->entityName, $this->entityManager, $this->logger);

        $alias = 'foo';

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

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

        $queryBuilder->expects($this->once())
            ->method('select')
            ->with($alias)
            ->willReturn($queryBuilder);

        $queryBuilder->expects($this->once())
            ->method('from')
            ->with($this->entityName, $alias);

        $this->assertInstanceOf(QueryBuilder::class, $queryService->createQueryBuilder($alias));
    }

    /**
     * Assert that if we provide a invalid query object to execute() a QueryServiceException will be thrown.
     *
     * @covers \Arp\DoctrineEntityRepository\Query\QueryService::execute
     *
     * @throws QueryServiceException
     */
    public function testExecuteWillThrowQueryServiceExceptionIfProvidedInvalidQuery(): void
    {
        $queryService = new QueryService($this->entityName, $this->entityManager, $this->logger);

        $invalidQuery = new \stdClass();

        $this->expectException(QueryServiceException::class);
        $this->expectExceptionMessage(
            sprintf(
                'Query provided must be of type \'%s\'; \'%s\' provided in \'%s::%s\'.',
                AbstractQuery::class,
                (is_object($invalidQuery) ? get_class($invalidQuery) : gettype($invalidQuery)),
                QueryService::class,
                'execute'
            )
        );

        $queryService->execute($invalidQuery);
        $queryService->execute(/** @scrutinizer ignore-type */ $invalidQuery);
    }

    /**
     * Assert that a query object provided to execute will be prepared with the provided options and then executed.
     *
     * @param array $options  The optional query options to assert get set on the query when being prepared.
     *
     * @covers \Arp\DoctrineEntityRepository\Query\QueryService::execute
     * @covers \Arp\DoctrineEntityRepository\Query\QueryService::prepareQuery
     *
     * @dataProvider getExecuteWillPrepareAndExecuteQueryData
     * @throws QueryServiceException
     */
    public function testExecuteWillPrepareAndExecuteQuery(array $options = []): void
    {
        $queryService = new QueryService($this->entityName, $this->entityManager, $this->logger);

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

        if (array_key_exists('params', $options)) {
            $query->expects($this->once())
                ->method('setParameters')
                ->with($options['params']);
        }

        if (array_key_exists(QueryServiceOption::HYDRATION_MODE, $options)) {
            $query->expects($this->once())
                ->method('setHydrationMode')
                ->with($options[QueryServiceOption::HYDRATION_MODE]);
        }

        if (array_key_exists('hydration_cache_profile', $options)) {
            $query->expects($this->once())
                ->method('setHydrationCacheProfile')
                ->with($options['hydration_cache_profile']);
        }

        if (array_key_exists('result_set_mapping', $options)) {
            $query->expects($this->once())
                ->method('setResultSetMapping')
                ->with($options['result_set_mapping']);
        }

        if (!empty($options[QueryServiceOption::DQL]) && $query instanceof Query) {
            $query->expects($this->once())
                ->method('setDQL')
                ->with($options[QueryServiceOption::DQL]);
        }

        $query->expects($this->once())->method('execute')->willReturn([]);

        $queryService->execute($query, $options);
    }

    /**
     * @return array|\array[][]
     */
    public function getExecuteWillPrepareAndExecuteQueryData(): array
    {
        return [
            // Empty options
            [
                [],
            ],

            // Set parameters
            [
                [
                    'params' => [
                        'foo' => 'bar',
                        'baz' => 123,
                    ]
                ],
            ],

            // Hydration Mode
            [
                [
                    QueryServiceOption::HYDRATION_MODE => Query::HYDRATE_ARRAY,
                ]
            ],
        ];
    }
}

alex-patterson-webdev / doctrine-entity-repository

Pull Request — master (#5)

testExecuteWillPrepareAndExecuteQuery() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
