From 26b136d676abb878a2c024cd3e1d55dab7233691 Mon Sep 17 00:00:00 2001 From: Meritoo Date: Wed, 19 Sep 2018 23:21:40 +0200 Subject: [PATCH] Tests > increase code coverage --- src/Utilities/Repository.php | 9 +- tests/Utilities/RepositoryTest.php | 242 ++++++++++++++++++++++++++++- 2 files changed, 243 insertions(+), 8 deletions(-) diff --git a/src/Utilities/Repository.php b/src/Utilities/Repository.php index fbc8d12..32dc95c 100644 --- a/src/Utilities/Repository.php +++ b/src/Utilities/Repository.php @@ -177,10 +177,13 @@ class Repository $direction = 'ASC' ) { $alias = 'qb'; + $queryBuilder = $repository->createQueryBuilder($alias); - return $repository - ->createQueryBuilder($alias) - ->orderBy(sprintf('%s.%s', $alias, $property), $direction); + if (empty($property)) { + return $queryBuilder; + } + + return $queryBuilder->orderBy(sprintf('%s.%s', $alias, $property), $direction); } /** diff --git a/tests/Utilities/RepositoryTest.php b/tests/Utilities/RepositoryTest.php index aafeadb..0ccedd4 100644 --- a/tests/Utilities/RepositoryTest.php +++ b/tests/Utilities/RepositoryTest.php @@ -8,6 +8,10 @@ namespace Meritoo\Common\Test\Utilities; +use Doctrine\ORM\EntityManagerInterface; +use Doctrine\ORM\EntityRepository; +use Doctrine\ORM\Query\Expr\OrderBy; +use Doctrine\ORM\QueryBuilder; use Generator; use Meritoo\Common\Test\Base\BaseTestCase; use Meritoo\Common\Test\Utilities\Repository\Sortable; @@ -160,7 +164,7 @@ class RepositoryTest extends BaseTestCase /** * @param array $items Objects who have "getPosition()" and "setPosition()" methods or arrays - * @param bool $max (optional) If is set to true, maximum value is returned. Otherwise - minimum. + * @param bool $max If is set to true, maximum value is returned. Otherwise - minimum. * @param int $expected Extreme position (max or min) of given items * * @dataProvider provideArraysWithoutExtremePositionToGetExtremePosition @@ -170,12 +174,122 @@ class RepositoryTest extends BaseTestCase static::assertEquals($expected, Repository::getExtremePosition($items, $max)); } - public function testGetExtremePositionUsingObjects() + /** + * @param array $items Objects who have "getPosition()" and "setPosition()" methods or arrays + * @param bool $max If is set to true, maximum value is returned. Otherwise - minimum. + * @param int $expected Extreme position (max or min) of given items + * + * @dataProvider provideArraysWithExtremePositionToGetExtremePosition + */ + public function testGetExtremePositionUsingArraysWithExtremePosition(array $items, $max, $expected) { + static::assertEquals($expected, Repository::getExtremePosition($items, $max)); } - public function testGetEntityOrderedQueryBuilder() + /** + * @param array $items Objects who have "getPosition()" and "setPosition()" methods or arrays + * @param bool $max If is set to true, maximum value is returned. Otherwise - minimum. + * @param int $expected Extreme position (max or min) of given items + * + * @dataProvider provideObjectsWithoutExtremePositionToGetExtremePosition + */ + public function testGetExtremePositionUsingObjectsWithoutExtremePosition(array $items, $max, $expected) { + static::assertEquals($expected, Repository::getExtremePosition($items, $max)); + } + + /** + * @param array $items Objects who have "getPosition()" and "setPosition()" methods or arrays + * @param bool $max If is set to true, maximum value is returned. Otherwise - minimum. + * @param int $expected Extreme position (max or min) of given items + * + * @dataProvider provideObjectsWithExtremePositionToGetExtremePosition + */ + public function testGetExtremePositionUsingObjectsWithExtremePosition(array $items, $max, $expected) + { + static::assertEquals($expected, Repository::getExtremePosition($items, $max)); + } + + public function testGetEntityOrderedQueryBuilderUsingDefaults() + { + $entityManager = $this->getMock(EntityManagerInterface::class); + + $entityRepository = $this + ->getMockBuilder(EntityRepository::class) + ->disableOriginalConstructor() + ->setMethods([ + 'createQueryBuilder', + ]) + ->getMock(); + + $expectedQueryBuilder = new QueryBuilder($entityManager); + $expectedQueryBuilder->from('any_table_name', 'qb'); + + $entityRepository + ->expects(static::once()) + ->method('createQueryBuilder') + ->willReturn($expectedQueryBuilder); + + $queryBuilder = Repository::getEntityOrderedQueryBuilder($entityRepository); + $selectDQLPart = $queryBuilder->getDQLPart('select'); + $whereDQLPart = $queryBuilder->getDQLPart('where'); + $orderDQLPart = $queryBuilder->getDQLPart('orderBy'); + + /* @var OrderBy $orderBy */ + $orderBy = $orderDQLPart[0]; + + static::assertInstanceOf(QueryBuilder::class, $queryBuilder); + static::assertArraySubset(['qb'], $queryBuilder->getRootAliases()); + static::assertSame([], $selectDQLPart); + static::assertNull($whereDQLPart); + static::assertSame(['qb.name ASC'], $orderBy->getParts()); + } + + /** + * @param string $property Name of property used by the ORDER BY clause + * @param string $direction Direction used by the ORDER BY clause ("ASC" or "DESC") + * @param string $expectedOrderBy Expected ORDER BY clause + * + * @dataProvider providePropertyAndDirectionToGetEntityOrderedQueryBuilder + */ + public function testGetEntityOrderedQueryBuilder($property, $direction, $expectedOrderBy) + { + $entityManager = $this->getMock(EntityManagerInterface::class); + + $entityRepository = $this + ->getMockBuilder(EntityRepository::class) + ->disableOriginalConstructor() + ->setMethods([ + 'createQueryBuilder', + ]) + ->getMock(); + + $expectedQueryBuilder = new QueryBuilder($entityManager); + $expectedQueryBuilder->from('any_table_name', 'qb'); + + $entityRepository + ->expects(static::once()) + ->method('createQueryBuilder') + ->willReturn($expectedQueryBuilder); + + $queryBuilder = Repository::getEntityOrderedQueryBuilder($entityRepository, $property, $direction); + $selectDQLPart = $queryBuilder->getDQLPart('select'); + $whereDQLPart = $queryBuilder->getDQLPart('where'); + $orderDQLPart = $queryBuilder->getDQLPart('orderBy'); + + static::assertInstanceOf(QueryBuilder::class, $queryBuilder); + static::assertArraySubset(['qb'], $queryBuilder->getRootAliases()); + static::assertSame([], $selectDQLPart); + static::assertNull($whereDQLPart); + + if (empty($property)) { + static::assertSame([], $orderDQLPart); + } else { + /* @var OrderBy $orderBy */ + $orderBy = $orderDQLPart[0]; + + static::assertSame([$expectedOrderBy], $orderBy->getParts()); + } } /** @@ -581,7 +695,7 @@ class RepositoryTest extends BaseTestCase [], ], true, - 1, + 2, ]; yield[ @@ -596,7 +710,125 @@ class RepositoryTest extends BaseTestCase [], ], false, - 2, + 1, + ]; + } + + /** + * Provides objects without extreme position used to get extreme position + * + * @return Generator + */ + public function provideObjectsWithoutExtremePositionToGetExtremePosition() + { + yield[ + [], + false, + null, + ]; + + yield[ + [], + true, + null, + ]; + + yield[ + [ + new Sortable(), + new Sortable(), + new Sortable(), + ], + true, + null, + ]; + + yield[ + [ + new Sortable(), + new Sortable(), + new Sortable(), + ], + false, + null, + ]; + } + + /** + * Provides objects with extreme position used to get extreme position + * + * @return Generator + */ + public function provideObjectsWithExtremePositionToGetExtremePosition() + { + yield[ + [ + new Sortable(1), + new Sortable(2), + new Sortable(3), + ], + true, + 3, + ]; + + yield[ + [ + new Sortable(1), + new Sortable(2), + new Sortable(3), + ], + false, + 1, + ]; + } + + /** + * Provide name of property, direction and expected ORDER BY clause used to get query builder + * + * @return Generator + */ + public function providePropertyAndDirectionToGetEntityOrderedQueryBuilder() + { + yield[ + null, + null, + '', + ]; + + yield[ + '', + '', + '', + ]; + + yield[ + 'first_name', + '', + 'qb.first_name ASC', + ]; + + yield[ + 'first_name', + 'asc', + 'qb.first_name asc', + ]; + + yield[ + 'first_name', + 'ASC', + 'qb.first_name ASC', + ]; + + yield[ + 'first_name', + 'desc', + 'qb.first_name desc', + ]; + + yield[ + 'first_name', + 'DESC', + 'qb.first_name DESC', ]; } }