Tests - increase code coverage

tests/Utilities/DateTest.php

@@ -13,6 +13,7 @@ use DateTime;
 use Generator;
 use Meritoo\Common\Exception\Date\UnknownDatePartTypeException;
 use Meritoo\Common\Test\Base\BaseTestCase;
+use Meritoo\Common\Type\DatePeriod;
 use Meritoo\Common\Utilities\Date;
 
 /**
@@ -506,6 +507,35 @@ class DateTest extends BaseTestCase
         self::assertTrue($randomDate >= $intervalMinDate && $randomDate <= $intervalMaxDate);
     }
 
+    /**
+     * @param mixed $period Empty value, e.g. ""
+     * @dataProvider provideEmptyValue
+     */
+    public function testGetDatesForPeriodUsingEmptyPeriod($period)
+    {
+        self::assertNull(Date::getDatesForPeriod($period));
+    }
+
+    /**
+     * @param int $period Incorrect period to verify
+     * @dataProvider provideIncorrectPeriod
+     */
+    public function testGetDatesForPeriodUsingIncorrectPeriod($period)
+    {
+        self::assertNull(Date::getDatesForPeriod($period));
+    }
+
+    /**
+     * @param int        $period   The period, type of period. One of DatePeriod class constants, e.g. DatePeriod::LAST_WEEK.
+     * @param DatePeriod $expected Expected start and end date for given period
+     *
+     * @dataProvider provideCorrectPeriod
+     */
+    public function testGetDatesForPeriod($period, DatePeriod $expected)
+    {
+        self::assertEquals($expected, Date::getDatesForPeriod($period));
+    }
+
     /**
      * Provides incorrect invalidCount of DateTime
      *
@@ -758,4 +788,112 @@ class DateTest extends BaseTestCase
             50,
         ];
     }
+
+    /**
+     * Provides incorrect period
+     *
+     * @return Generator
+     */
+    public function provideIncorrectPeriod()
+    {
+        yield[-1];
+        yield[0];
+        yield[10];
+    }
+
+    /**
+     * Provides correct period
+     *
+     * @return Generator
+     */
+    public function provideCorrectPeriod()
+    {
+        yield[
+            DatePeriod::LAST_WEEK,
+            new DatePeriod(
+                (new DateTime('this week'))->sub(new DateInterval('P7D'))->setTime(0, 0, 0),
+                (new DateTime('this week'))->sub(new DateInterval('P1D'))->setTime(23, 59, 59)
+            ),
+        ];
+
+        yield[
+            DatePeriod::THIS_WEEK,
+            new DatePeriod(
+                (new DateTime('this week'))->setTime(0, 0, 0),
+                (new DateTime('this week'))->add(new DateInterval('P6D'))->setTime(23, 59, 59)
+            ),
+        ];
+
+        yield[
+            DatePeriod::NEXT_WEEK,
+            new DatePeriod(
+                (new DateTime('this week'))->add(new DateInterval('P7D'))->setTime(0, 0, 0),
+                (new DateTime('this week'))->add(new DateInterval('P7D'))->add(new DateInterval('P6D'))->setTime(23, 59, 59)
+            ),
+        ];
+
+        yield[
+            DatePeriod::LAST_MONTH,
+            new DatePeriod(
+                (new DateTime('first day of last month'))->setTime(0, 0, 0),
+                (new DateTime('last day of last month'))->setTime(23, 59, 59)
+            ),
+        ];
+
+        yield[
+            DatePeriod::THIS_MONTH,
+            new DatePeriod(
+                Date::getDatesForPeriod(DatePeriod::LAST_MONTH)
+                    ->getEndDate()
+                    ->add(new DateInterval('P1D'))
+                    ->setTime(0, 0, 0),
+                Date::getDatesForPeriod(DatePeriod::NEXT_MONTH)
+                    ->getStartDate()
+                    ->sub(new DateInterval('P1D'))
+                    ->setTime(23, 59, 59)
+            ),
+        ];
+
+        yield[
+            DatePeriod::NEXT_MONTH,
+            new DatePeriod(
+                (new DateTime('first day of next month'))->setTime(0, 0, 0),
+                (new DateTime('last day of next month'))->setTime(23, 59, 59)
+            ),
+        ];
+
+        $lastYearStart = (new DateTime())->modify('-1 year');
+        $lastYearEnd = (new DateTime())->modify('-1 year');
+        $year = $lastYearStart->format('Y');
+
+        yield[
+            DatePeriod::LAST_YEAR,
+            new DatePeriod(
+                $lastYearStart->setDate($year, 1, 1)->setTime(0, 0, 0),
+                $lastYearEnd->setDate($year, 12, 31)->setTime(23, 59, 59)
+            ),
+        ];
+
+        $year = (new DateTime())->format('Y');
+
+        yield[
+            DatePeriod::THIS_YEAR,
+            new DatePeriod(
+                (new DateTime())->setDate($year, 1, 1)->setTime(0, 0, 0),
+                (new DateTime())->setDate($year, 12, 31)->setTime(23, 59, 59)
+            ),
+        ];
+
+        $nextYearStart = (new DateTime())->modify('1 year');
+        $nextYearEnd = (new DateTime())->modify('1 year');
+        $year = $nextYearStart->format('Y');
+
+        yield[
+            DatePeriod::NEXT_YEAR,
+            new DatePeriod(
+                $nextYearStart->setDate($year, 1, 1)->setTime(0, 0, 0),
+                $nextYearEnd->setDate($year, 12, 31)->setTime(23, 59, 59)
+            ),
+        ];
+    }
 }

tests/Utilities/QueryBuilderUtilityTest.php

@@ -0,0 +1,341 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Utilities;
+
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\ORM\EntityManager;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Query\Expr;
+use Doctrine\ORM\Query\Parameter;
+use Doctrine\ORM\QueryBuilder;
+use Generator;
+use Meritoo\Common\Test\Base\BaseTestCase;
+use Meritoo\Common\Utilities\QueryBuilderUtility;
+
+/**
+ * Test case of the useful methods for query builder (the Doctrine's QueryBuilder class)
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class QueryBuilderUtilityTest extends BaseTestCase
+{
+    public function testConstructor()
+    {
+        static::assertHasNoConstructor(QueryBuilderUtility::class);
+    }
+
+    /**
+     * @param QueryBuilder $queryBuilder The query builder to retrieve root alias
+     * @param null|string  $rootAlias    Expected root alias of given query builder
+     *
+     * @dataProvider provideQueryBuilderAndRootAlias
+     */
+    public function testGetRootAlias(QueryBuilder $queryBuilder, $rootAlias)
+    {
+        static::assertSame($rootAlias, QueryBuilderUtility::getRootAlias($queryBuilder));
+    }
+
+    /**
+     * @param QueryBuilder $queryBuilder  The query builder to verify
+     * @param string       $propertyName  Name of property that maybe is joined
+     * @param null|string  $propertyAlias Expected alias of given property joined in given query builder
+     *
+     * @dataProvider provideQueryBuilderAndPropertyAlias
+     */
+    public function testGetJoinedPropertyAlias(QueryBuilder $queryBuilder, $propertyName, $propertyAlias)
+    {
+        static::assertSame($propertyAlias, QueryBuilderUtility::getJoinedPropertyAlias($queryBuilder, $propertyName));
+    }
+
+    public function testSetCriteriaWithoutCriteria()
+    {
+        $entityManager = $this->getMock(EntityManagerInterface::class);
+        $queryBuilder = new QueryBuilder($entityManager);
+        $newQueryBuilder = QueryBuilderUtility::setCriteria($queryBuilder);
+
+        static::assertSame($queryBuilder, $newQueryBuilder);
+        static::assertCount(0, $newQueryBuilder->getParameters());
+        static::assertNull($newQueryBuilder->getDQLPart('where'));
+    }
+
+    public function testSetCriteriaWithoutAlias()
+    {
+        $criteria = [
+            'lorem' => 11,
+            'ipsum' => 22,
+        ];
+
+        $entityManager = $this->getMock(EntityManagerInterface::class);
+        $queryBuilder = new QueryBuilder($entityManager);
+        $newQueryBuilder = QueryBuilderUtility::setCriteria($queryBuilder, $criteria);
+
+        static::assertSame($queryBuilder, $newQueryBuilder);
+        static::assertCount(count($criteria), $newQueryBuilder->getParameters());
+        static::assertNotNull($newQueryBuilder->getDQLPart('where'));
+    }
+
+    /**
+     * @param QueryBuilder $queryBuilder The query builder
+     * @param array        $criteria     The criteria used in WHERE clause
+     *
+     * @dataProvider provideQueryBuilderAndCriteria
+     */
+    public function testSetCriteria(QueryBuilder $queryBuilder, array $criteria)
+    {
+        $newQueryBuilder = QueryBuilderUtility::setCriteria($queryBuilder, $criteria);
+        $criteriaCount = count($criteria);
+        $nullsCount = 0;
+
+        /*
+         * I have to verify count/amount of NULLs and decrease $criteriaCount, because for null parameter is not added
+         */
+        array_walk($criteria, function ($value) use (&$nullsCount) {
+            if (null === $value) {
+                ++$nullsCount;
+            }
+        });
+
+        static::assertSame($queryBuilder, $newQueryBuilder);
+        static::assertCount($criteriaCount - $nullsCount, $newQueryBuilder->getParameters());
+        static::assertNotNull($newQueryBuilder->getDQLPart('where'));
+    }
+
+    public function testDeleteEntitiesWithoutFlush()
+    {
+        $methods = [
+            'remove',
+            'flush',
+        ];
+
+        $entityManager = $this->getMock(EntityManager::class, $methods, [], '', false);
+        $entities1 = [];
+
+        $entities2 = [
+            new \stdClass(),
+        ];
+
+        static::assertFalse(QueryBuilderUtility::deleteEntities($entityManager, $entities1, false));
+        static::assertTrue(QueryBuilderUtility::deleteEntities($entityManager, $entities2, false));
+    }
+
+    public function testDeleteEntities()
+    {
+        $methods = [
+            'remove',
+            'flush',
+        ];
+
+        $entityManager = $this->getMock(EntityManager::class, $methods, [], '', false);
+        $entities1 = [];
+
+        $entities2 = [
+            new \stdClass(),
+        ];
+
+        static::assertFalse(QueryBuilderUtility::deleteEntities($entityManager, $entities1));
+        static::assertTrue(QueryBuilderUtility::deleteEntities($entityManager, $entities2));
+    }
+
+    /**
+     * @param QueryBuilder          $queryBuilder The query builder
+     * @param array|ArrayCollection $parameters   Parameters to add. Collection of Doctrine\ORM\Query\Parameter
+     *                                            instances or an array with key-value pairs.
+     *
+     * @dataProvider provideQueryBuilderAndParameters
+     */
+    public function testAddParameters(QueryBuilder $queryBuilder, $parameters)
+    {
+        $newQueryBuilder = QueryBuilderUtility::addParameters($queryBuilder, $parameters);
+
+        static::assertSame($queryBuilder, $newQueryBuilder);
+        static::assertCount(count($parameters), $newQueryBuilder->getParameters());
+    }
+
+    /**
+     * Provides query builder to retrieve root alias and expected root alias
+     *
+     * @return Generator
+     */
+    public function provideQueryBuilderAndRootAlias()
+    {
+        $entityManager = $this->getMock(EntityManagerInterface::class);
+
+        yield[
+            new QueryBuilder($entityManager),
+            null,
+        ];
+
+        yield[
+            (new QueryBuilder($entityManager))->from('lorem_ipsum', 'lm'),
+            'lm',
+        ];
+
+        yield[
+            (new QueryBuilder($entityManager))
+                ->from('lorem', 'l')
+                ->leftJoin('l.ipsum', 'i'),
+            'l',
+        ];
+    }
+
+    /**
+     * Provides query builder, name of property and expected alias of given property
+     *
+     * @return Generator
+     */
+    public function provideQueryBuilderAndPropertyAlias()
+    {
+        $entityManager = $this->getMock(EntityManagerInterface::class);
+
+        yield[
+            new QueryBuilder($entityManager),
+            '',
+            null,
+        ];
+
+        yield[
+            new QueryBuilder($entityManager),
+            'lorem',
+            null,
+        ];
+
+        yield[
+            (new QueryBuilder($entityManager))->from('lorem_ipsum', 'lm'),
+            'lm',
+            null,
+        ];
+
+        yield[
+            (new QueryBuilder($entityManager))
+                ->from('lorem', 'l')
+                ->leftJoin('l.ipsum', 'i'),
+            'ipsum',
+            'i',
+        ];
+
+        yield[
+            (new QueryBuilder($entityManager))
+                ->from('lorem', 'l')
+                ->leftJoin('l.ipsum', 'i')
+                ->innerJoin('i.dolor', 'd'),
+            'ipsum1',
+            null,
+        ];
+
+        yield[
+            (new QueryBuilder($entityManager))
+                ->from('lorem', 'l')
+                ->leftJoin('l.ipsum', 'i')
+                ->innerJoin('i.dolor', 'd'),
+            'ipsum',
+            'i',
+        ];
+
+        yield[
+            (new QueryBuilder($entityManager))
+                ->from('lorem', 'l')
+                ->leftJoin('l.ipsum', 'i')
+                ->innerJoin('i.dolor', 'd'),
+            'dolor',
+            'd',
+        ];
+    }
+
+    /**
+     * Provides query builder and criteria used in WHERE clause
+     *
+     * @return Generator
+     */
+    public function provideQueryBuilderAndCriteria()
+    {
+        $entityManager = $this->getMock(EntityManager::class, ['getExpressionBuilder'], [], '', false);
+
+        $entityManager
+            ->expects(static::any())
+            ->method('getExpressionBuilder')
+            ->willReturn(new Expr());
+
+        yield[
+            (new QueryBuilder($entityManager))->from('lorem_ipsum', 'lm'),
+            [
+                'lorem' => 11,
+                'ipsum' => 22,
+                'dolor' => null,
+            ],
+        ];
+
+        yield[
+            (new QueryBuilder($entityManager))->from('lorem_ipsum', 'lm'),
+            [
+                'lorem' => [
+                    11,
+                    '>=',
+                ],
+                'ipsum' => [
+                    22,
+                    '<',
+                ],
+                'dolor' => null,
+            ],
+        ];
+    }
+
+    /**
+     * Provides query builder and parameters to add to given query builder
+     *
+     * @return Generator
+     */
+    public function provideQueryBuilderAndParameters()
+    {
+        $entityManager = $this->getMock(EntityManagerInterface::class);
+
+        yield[
+            new QueryBuilder($entityManager),
+            [],
+        ];
+
+        yield[
+            new QueryBuilder($entityManager),
+            new ArrayCollection(),
+        ];
+
+        yield[
+            new QueryBuilder($entityManager),
+            [
+                'lorem' => 11,
+                'ipsum' => 22,
+            ],
+        ];
+
+        yield[
+            new QueryBuilder($entityManager),
+            new ArrayCollection([
+                'lorem' => 11,
+                'ipsum' => 22,
+            ]),
+        ];
+
+        yield[
+            new QueryBuilder($entityManager),
+            [
+                new Parameter('lorem', 11),
+                new Parameter('ipsum', 22),
+            ],
+        ];
+
+        yield[
+            new QueryBuilder($entityManager),
+            new ArrayCollection([
+                new Parameter('lorem', 11),
+                new Parameter('ipsum', 22),
+            ]),
+        ];
+    }
+}

tests/Utilities/Reflection/B.php

@@ -15,7 +15,7 @@ namespace Meritoo\Common\Test\Utilities\Reflection;
  * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
  * @copyright Meritoo.pl
  */
-class B extends A
+class B extends A implements I
 {
     protected $name = 'Lorem Ipsum';
 

tests/Utilities/Reflection/H.php

@@ -0,0 +1,27 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Utilities\Reflection;
+
+/**
+ * The H class.
+ * Used for testing the Reflection class.
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class H
+{
+    const DOLOR = 'sit';
+
+    const LOREM = 'ipsum';
+
+    const MAX_USERS = 5;
+
+    const MIN_USERS = 2;
+}

tests/Utilities/Reflection/I.php

@@ -0,0 +1,20 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Utilities\Reflection;
+
+/**
+ * The H interface.
+ * Used for testing the Reflection class.
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+interface I
+{
+}

tests/Utilities/ReflectionTest.php

@@ -22,6 +22,8 @@ use Meritoo\Common\Test\Utilities\Reflection\D;
 use Meritoo\Common\Test\Utilities\Reflection\E;
 use Meritoo\Common\Test\Utilities\Reflection\F;
 use Meritoo\Common\Test\Utilities\Reflection\G;
+use Meritoo\Common\Test\Utilities\Reflection\H;
+use Meritoo\Common\Test\Utilities\Reflection\I;
 use Meritoo\Common\Utilities\Reflection;
 use ReflectionProperty;
 
@@ -379,6 +381,99 @@ class ReflectionTest extends BaseTestCase
         self::assertEquals($expected, Reflection::getPropertyValues($collection, 'gInstance.firstName', true));
     }
 
+    public function testGetMaxNumberConstantUsingClassWithoutConstants()
+    {
+        static::assertNull(Reflection::getMaxNumberConstant(A::class));
+    }
+
+    public function testGetMaxNumberConstant()
+    {
+        static::assertEquals(5, Reflection::getMaxNumberConstant(H::class));
+    }
+
+    public function testHasMethodUsingClassWithoutMethod()
+    {
+        static::assertFalse(Reflection::hasMethod(A::class, 'getUser'));
+    }
+
+    public function testHasMethod()
+    {
+        static::assertTrue(Reflection::hasMethod(A::class, 'getCount'));
+    }
+
+    public function testHasPropertyUsingClassWithoutProperty()
+    {
+        static::assertFalse(Reflection::hasProperty(A::class, 'users'));
+    }
+
+    public function testHasProperty()
+    {
+        static::assertTrue(Reflection::hasProperty(A::class, 'count'));
+    }
+
+    public function testHasConstantUsingClassWithoutConstant()
+    {
+        static::assertFalse(Reflection::hasConstant(H::class, 'users'));
+    }
+
+    public function testHasConstant()
+    {
+        static::assertTrue(Reflection::hasConstant(H::class, 'LOREM'));
+    }
+
+    public function testGetConstantValueUsingClassWithoutConstant()
+    {
+        static::assertNull(Reflection::getConstantValue(H::class, 'users'));
+    }
+
+    public function testGetConstantValue()
+    {
+        static::assertEquals(H::LOREM, Reflection::getConstantValue(H::class, 'LOREM'));
+    }
+
+    public function testIsInterfaceImplementedUsingClassWithoutInterface()
+    {
+        static::assertFalse(Reflection::isInterfaceImplemented(A::class, I::class));
+    }
+
+    public function testIsInterfaceImplemented()
+    {
+        static::assertTrue(Reflection::isInterfaceImplemented(B::class, I::class));
+    }
+
+    public function testIsChildOfClassUsingClassWithoutChildClass()
+    {
+        static::assertFalse(Reflection::isChildOfClass(A::class, B::class));
+    }
+
+    public function testIsChildOfClass()
+    {
+        static::assertTrue(Reflection::isChildOfClass(B::class, A::class));
+    }
+
+    public function testGetPropertyUsingClassWithoutProperty()
+    {
+        static::assertNull(Reflection::getProperty(A::class, 'lorem'));
+    }
+
+    public function testGetPropertyUsingClassWithPrivateProperty()
+    {
+        $property = Reflection::getProperty(A::class, 'count', ReflectionProperty::IS_PRIVATE);
+
+        static::assertInstanceOf(ReflectionProperty::class, $property);
+        static::assertTrue($property->isPrivate());
+        static::assertEquals('count', $property->getName());
+    }
+
+    public function testGetPropertyUsingClassWithProtectedProperty()
+    {
+        $property = Reflection::getProperty(B::class, 'name', ReflectionProperty::IS_PROTECTED);
+
+        static::assertInstanceOf(ReflectionProperty::class, $property);
+        static::assertTrue($property->isProtected());
+        static::assertEquals('name', $property->getName());
+    }
+
     /**
      * Provides invalid class and trait
      *