composer.json - update name of this package (name of vendor, actually)

README.md

@@ -5,10 +5,22 @@ Common and useful classes, methods, exceptions etc.
 
 ## Installation
 
+In your `composer.json` add address of repository into `repositories` section:
+
+```json
+"repositories": [
+    (...)
+    {
+        "type": "vcs",
+        "url": "https://github.com/wiosna-dev/common-library"
+    }
+]
+```
+
 Run [Composer](https://getcomposer.org) to install this package in your project:
 
 ```bash
-$ composer require meritoo/common-library
+$ composer require wiosna-dev/common-library
 ```
 
 > How to install Composer: https://getcomposer.org/download

composer.json

@@ -1,8 +1,8 @@
 {
-    "name": "meritoo/common-library",
+    "name": "wiosna-dev/common-library",
     "description": "Useful classes, methods, extensions etc.",
     "license": "MIT",
-    "version": "0.0.18",
+    "version": "0.0.17",
     "authors": [
         {
             "name": "Meritoo.pl",

src/Utilities/Date.php

@@ -12,7 +12,6 @@ use DateInterval;
 use DateTime;
 use Meritoo\Common\Exception\Date\UnknownDatePartTypeException;
 use Meritoo\Common\Type\DatePartType;
-use Meritoo\Common\Type\DatePeriod;
 
 /**
  * Useful date methods
@@ -67,105 +66,97 @@ class Date
      * The dates are returned in an array with indexes 'start' and 'end'.
      *
      * @param int $period The period, type of period. One of DatePeriod class constants, e.g. DatePeriod::LAST_WEEK.
-     * @return null|DatePeriod
+     * @return DatePeriod
      */
     public static function getDatesForPeriod($period)
     {
-        /*
-         * Type of period is incorrect?
-         * Nothing to do
-         */
-        if (!(new DatePeriod())->isCorrectType($period)) {
-            return null;
-        }
+        $datePeriod = null;
 
-        $dateStart = null;
-        $dateEnd = null;
+        if (DatePeriod::isCorrectPeriod($period)) {
+            $dateStart = null;
+            $dateEnd = null;
 
-        switch ($period) {
-            case DatePeriod::LAST_WEEK:
-                $thisWeekStart = new DateTime('this week');
+            switch ($period) {
+                case DatePeriod::LAST_WEEK:
+                    $thisWeekStart = new DateTime('this week');
 
-                $dateStart = clone $thisWeekStart;
-                $dateEnd = clone $thisWeekStart;
+                    $dateStart = clone $thisWeekStart;
+                    $dateEnd = clone $thisWeekStart;
 
-                $dateStart->sub(new DateInterval('P7D'));
-                $dateEnd->sub(new DateInterval('P1D'));
+                    $dateStart->sub(new DateInterval('P7D'));
+                    $dateEnd->sub(new DateInterval('P1D'));
 
-                break;
-            case DatePeriod::THIS_WEEK:
-                $dateStart = new DateTime('this week');
+                    break;
+                case DatePeriod::THIS_WEEK:
+                    $dateStart = new DateTime('this week');
 
-                $dateEnd = clone $dateStart;
-                $dateEnd->add(new DateInterval('P6D'));
+                    $dateEnd = clone $dateStart;
+                    $dateEnd->add(new DateInterval('P6D'));
 
-                break;
-            case DatePeriod::NEXT_WEEK:
-                $dateStart = new DateTime('this week');
-                $dateStart->add(new DateInterval('P7D'));
+                    break;
+                case DatePeriod::NEXT_WEEK:
+                    $dateStart = new DateTime('this week');
+                    $dateStart->add(new DateInterval('P7D'));
 
-                $dateEnd = clone $dateStart;
-                $dateEnd->add(new DateInterval('P6D'));
+                    $dateEnd = clone $dateStart;
+                    $dateEnd->add(new DateInterval('P6D'));
 
-                break;
-            case DatePeriod::LAST_MONTH:
-                $dateStart = new DateTime('first day of last month');
-                $dateEnd = new DateTime('last day of last month');
+                    break;
+                case DatePeriod::LAST_MONTH:
+                    $dateStart = new DateTime('first day of last month');
+                    $dateEnd = new DateTime('last day of last month');
 
-                break;
-            case DatePeriod::THIS_MONTH:
-                $lastMonth = self::getDatesForPeriod(DatePeriod::LAST_MONTH);
-                $nextMonth = self::getDatesForPeriod(DatePeriod::NEXT_MONTH);
+                    break;
+                case DatePeriod::THIS_MONTH:
+                    $lastMonth = self::getDatesForPeriod(DatePeriod::LAST_MONTH);
+                    $nextMonth = self::getDatesForPeriod(DatePeriod::NEXT_MONTH);
 
-                $dateStart = $lastMonth->getEndDate();
-                $dateStart->add(new DateInterval('P1D'));
+                    $dateStart = $lastMonth->getEndDate();
+                    $dateStart->add(new DateInterval('P1D'));
 
-                $dateEnd = $nextMonth->getStartDate();
-                $dateEnd->sub(new DateInterval('P1D'));
+                    $dateEnd = $nextMonth->getStartDate();
+                    $dateEnd->sub(new DateInterval('P1D'));
 
-                break;
-            case DatePeriod::NEXT_MONTH:
-                $dateStart = new DateTime('first day of next month');
-                $dateEnd = new DateTime('last day of next month');
+                    break;
+                case DatePeriod::NEXT_MONTH:
+                    $dateStart = new DateTime('first day of next month');
+                    $dateEnd = new DateTime('last day of next month');
 
-                break;
-            case DatePeriod::LAST_YEAR:
-            case DatePeriod::THIS_YEAR:
-            case DatePeriod::NEXT_YEAR:
-                $dateStart = new DateTime();
-                $dateEnd = new DateTime();
+                    break;
+                case DatePeriod::LAST_YEAR:
+                case DatePeriod::THIS_YEAR:
+                case DatePeriod::NEXT_YEAR:
+                    $dateStart = new DateTime();
+                    $dateEnd = new DateTime();
 
-                if (DatePeriod::LAST_YEAR == $period || DatePeriod::NEXT_YEAR == $period) {
-                    $yearDifference = 1;
+                    if (DatePeriod::LAST_YEAR == $period || DatePeriod::NEXT_YEAR == $period) {
+                        $yearDifference = 1;
 
-                    if (DatePeriod::LAST_YEAR == $period) {
-                        $yearDifference *= -1;
+                        if (DatePeriod::LAST_YEAR == $period) {
+                            $yearDifference *= -1;
+                        }
+
+                        $modifyString = sprintf('%s year', $yearDifference);
+                        $dateStart->modify($modifyString);
+                        $dateEnd->modify($modifyString);
                     }
 
-                    $modifyString = sprintf('%s year', $yearDifference);
-                    $dateStart->modify($modifyString);
-                    $dateEnd->modify($modifyString);
-                }
+                    $year = $dateStart->format('Y');
+                    $dateStart->setDate($year, 1, 1);
+                    $dateEnd->setDate($year, 12, 31);
 
-                $year = $dateStart->format('Y');
-                $dateStart->setDate($year, 1, 1);
-                $dateEnd->setDate($year, 12, 31);
+                    break;
+            }
 
-                break;
+            if (null !== $dateStart && null !== $dateEnd) {
+                $dateStart->setTime(0, 0, 0);
+                $dateEnd->setTime(23, 59, 59);
+
+                $datePeriod = new DatePeriod($dateStart, $dateEnd);
+            }
         }
 
-        /*
-         * Start or end date is unknown?
-         * Nothing to do
-         */
-        if (null === $dateStart || null === $dateEnd) {
-            return null;
-        }
-
-        $dateStart->setTime(0, 0, 0);
-        $dateEnd->setTime(23, 59, 59);
-
-        return new DatePeriod($dateStart, $dateEnd);
+        return $datePeriod;
     }
 
     /**

src/Utilities/DatePeriod.php

@@ -6,11 +6,9 @@
  * file that was distributed with this source code.
  */
 
-namespace Meritoo\Common\Type;
+namespace Meritoo\Common\Utilities;
 
 use DateTime;
-use Meritoo\Common\Type\Base\BaseType;
-use Meritoo\Common\Utilities\Date;
 
 /**
  * A date's period.
@@ -19,7 +17,7 @@ use Meritoo\Common\Utilities\Date;
  * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
  * @copyright Meritoo.pl
  */
-class DatePeriod extends BaseType
+class DatePeriod
 {
     /**
      * The period constant: last month
@@ -110,6 +108,17 @@ class DatePeriod extends BaseType
         $this->endDate = $endDate;
     }
 
+    /**
+     * Returns information if given period is correct
+     *
+     * @param int $period The period to verify
+     * @return bool
+     */
+    public static function isCorrectPeriod($period)
+    {
+        return in_array($period, Reflection::getConstants(__CLASS__));
+    }
+
     /**
      * Returns formatted one of the period's date: start date or end date
      *

src/Utilities/QueryBuilderUtility.php

@@ -33,10 +33,6 @@ class QueryBuilderUtility
     {
         $aliases = $queryBuilder->getRootAliases();
 
-        /*
-         * No aliases?
-         * Nothing to do
-         */
         if (empty($aliases)) {
             return null;
         }
@@ -46,8 +42,7 @@ class QueryBuilderUtility
 
     /**
      * Returns alias of given property joined in given query builder
-     *
-     * If there are no joins or the join does not exist, null is returned.
+     * If the join does not exist, null is returned.
      * It's also information if given property is already joined in given query builder.
      *
      * @param QueryBuilder $queryBuilder The query builder to verify
@@ -58,10 +53,6 @@ class QueryBuilderUtility
     {
         $joins = $queryBuilder->getDQLPart('join');
 
-        /*
-         * No joins?
-         * Nothing to do
-         */
         if (empty($joins)) {
             return null;
         }
@@ -108,43 +99,33 @@ class QueryBuilderUtility
      */
     public static function setCriteria(QueryBuilder $queryBuilder, array $criteria = [], $alias = '')
     {
-        /*
-         * No criteria used in WHERE clause?
-         * Nothing to do
-         */
-        if (empty($criteria)) {
-            return $queryBuilder;
-        }
+        if (!empty($criteria)) {
+            if (empty($alias)) {
+                $alias = self::getRootAlias($queryBuilder);
+            }
 
-        /*
-         * No alias provided?
-         * Let's use root alias
-         */
-        if (empty($alias)) {
-            $alias = self::getRootAlias($queryBuilder);
-        }
+            foreach ($criteria as $column => $value) {
+                $compareOperator = '=';
 
-        foreach ($criteria as $column => $value) {
-            $compareOperator = '=';
+                if (is_array($value) && !empty($value)) {
+                    if (2 == count($value)) {
+                        $compareOperator = $value[1];
+                    }
 
-            if (is_array($value) && !empty($value)) {
-                if (2 == count($value)) {
-                    $compareOperator = $value[1];
+                    $value = $value[0];
                 }
 
-                $value = $value[0];
+                $predicate = sprintf('%s.%s %s :%s', $alias, $column, $compareOperator, $column);
+
+                if (null === $value) {
+                    $predicate = $queryBuilder->expr()->isNull(sprintf('%s.%s', $alias, $column));
+                    unset($criteria[$column]);
+                } else {
+                    $queryBuilder->setParameter($column, $value);
+                }
+
+                $queryBuilder = $queryBuilder->andWhere($predicate);
             }
-
-            $predicate = sprintf('%s.%s %s :%s', $alias, $column, $compareOperator, $column);
-
-            if (null === $value) {
-                $predicate = $queryBuilder->expr()->isNull(sprintf('%s.%s', $alias, $column));
-                unset($criteria[$column]);
-            } else {
-                $queryBuilder->setParameter($column, $value);
-            }
-
-            $queryBuilder = $queryBuilder->andWhere($predicate);
         }
 
         return $queryBuilder;
@@ -162,7 +143,7 @@ class QueryBuilderUtility
     public static function deleteEntities(EntityManager $entityManager, $entities, $flushDeleted = true)
     {
         /*
-         * No entities provided?
+         * No entities found?
          * Nothing to do
          */
         if (empty($entities)) {
@@ -188,30 +169,24 @@ class QueryBuilderUtility
      * Attention. Existing parameters will be overridden.
      *
      * @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.
+     * @param array|ArrayCollection $parameters   Parameters to add. Collection of instances of
+     *                                            Doctrine\ORM\Query\Parameter class or an array with key-value pairs.
      * @return QueryBuilder
      */
     public static function addParameters(QueryBuilder $queryBuilder, $parameters)
     {
-        /*
-         * No parameters?
-         * Nothing to do
-         */
-        if (empty($parameters)) {
-            return $queryBuilder;
-        }
+        if (!empty($parameters)) {
+            foreach ($parameters as $key => $parameter) {
+                $name = $key;
+                $value = $parameter;
 
-        foreach ($parameters as $key => $parameter) {
-            $name = $key;
-            $value = $parameter;
+                if ($parameter instanceof Parameter) {
+                    $name = $parameter->getName();
+                    $value = $parameter->getValue();
+                }
 
-            if ($parameter instanceof Parameter) {
-                $name = $parameter->getName();
-                $value = $parameter->getValue();
+                $queryBuilder->setParameter($name, $value);
             }
-
-            $queryBuilder->setParameter($name, $value);
         }
 
         return $queryBuilder;

src/Utilities/Reflection.php

@@ -74,8 +74,8 @@ class Reflection
     }
 
     /**
-     * Returns maximum integer value of constant of given class / object.
-     * Constants whose values are integers are considered only.
+     * Returns maximum constant from all constants of given class / object.
+     * Values of constants should be integers.
      *
      * @param object|string $class The object or name of object's class
      * @return int|null

tests/Utilities/DatePeriodTest.php

@@ -6,13 +6,13 @@
  * file that was distributed with this source code.
  */
 
-namespace Meritoo\Common\Test\Type;
+namespace Meritoo\Common\Test\Utilities;
 
 use DateTime;
 use Generator;
-use Meritoo\Common\Test\Base\BaseTypeTestCase;
-use Meritoo\Common\Type\DatePeriod;
+use Meritoo\Common\Test\Base\BaseTestCase;
 use Meritoo\Common\Type\OopVisibilityType;
+use Meritoo\Common\Utilities\DatePeriod;
 
 /**
  * Test case of date's period
@@ -20,7 +20,7 @@ use Meritoo\Common\Type\OopVisibilityType;
  * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
  * @copyright Meritoo.pl
  */
-class DatePeriodTest extends BaseTypeTestCase
+class DatePeriodTest extends BaseTestCase
 {
     public function testConstructorVisibilityAndArguments()
     {
@@ -58,6 +58,33 @@ class DatePeriodTest extends BaseTypeTestCase
         self::assertEquals($endDate, $period->getEndDate());
     }
 
+    /**
+     * @param mixed $period Empty value, e.g. ""
+     * @dataProvider provideEmptyValue
+     */
+    public function testIsCorrectPeriodEmptyPeriod($period)
+    {
+        self::assertFalse(DatePeriod::isCorrectPeriod($period));
+    }
+
+    /**
+     * @param int $period Incorrect period to verify
+     * @dataProvider provideIncorrectPeriod
+     */
+    public function testIsCorrectPeriodIncorrectPeriod($period)
+    {
+        self::assertFalse(DatePeriod::isCorrectPeriod($period));
+    }
+
+    /**
+     * @param int $period The period to verify
+     * @dataProvider providePeriod
+     */
+    public function testIsCorrectPeriod($period)
+    {
+        self::assertTrue(DatePeriod::isCorrectPeriod($period));
+    }
+
     /**
      * @param DatePeriod $period The date period to verify
      * @param string     $format Format used to format the date
@@ -115,6 +142,36 @@ class DatePeriodTest extends BaseTypeTestCase
         ];
     }
 
+    /**
+     * Provides incorrect period
+     *
+     * @return Generator
+     */
+    public function provideIncorrectPeriod()
+    {
+        yield[-1];
+        yield[0];
+        yield[10];
+    }
+
+    /**
+     * Provides period to verify
+     *
+     * @return Generator
+     */
+    public function providePeriod()
+    {
+        yield[DatePeriod::LAST_WEEK];
+        yield[DatePeriod::THIS_WEEK];
+        yield[DatePeriod::NEXT_WEEK];
+        yield[DatePeriod::LAST_MONTH];
+        yield[DatePeriod::THIS_MONTH];
+        yield[DatePeriod::NEXT_MONTH];
+        yield[DatePeriod::LAST_YEAR];
+        yield[DatePeriod::THIS_YEAR];
+        yield[DatePeriod::NEXT_YEAR];
+    }
+
     /**
      * Provides period and incorrect format of date to verify
      *
@@ -213,68 +270,4 @@ class DatePeriodTest extends BaseTypeTestCase
             '2002-02-02 00:00',
         ];
     }
-
-    /**
-     * Returns all expected types of the tested type
-     *
-     * @return array
-     */
-    protected function getAllExpectedTypes()
-    {
-        return [
-            'LAST_MONTH' => DatePeriod::LAST_MONTH,
-            'LAST_WEEK'  => DatePeriod::LAST_WEEK,
-            'LAST_YEAR'  => DatePeriod::LAST_YEAR,
-            'NEXT_MONTH' => DatePeriod::NEXT_MONTH,
-            'NEXT_WEEK'  => DatePeriod::NEXT_WEEK,
-            'NEXT_YEAR'  => DatePeriod::NEXT_YEAR,
-            'THIS_MONTH' => DatePeriod::THIS_MONTH,
-            'THIS_WEEK'  => DatePeriod::THIS_WEEK,
-            'THIS_YEAR'  => DatePeriod::THIS_YEAR,
-        ];
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    protected function getTestedTypeInstance()
-    {
-        return new DatePeriod();
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function provideTypeToVerify()
-    {
-        yield[
-            '',
-            false,
-        ];
-
-        yield[
-            -1,
-            false,
-        ];
-
-        yield[
-            true,
-            false,
-        ];
-
-        yield[
-            DatePeriod::LAST_MONTH,
-            true,
-        ];
-
-        yield[
-            DatePeriod::NEXT_WEEK,
-            true,
-        ];
-
-        yield[
-            DatePeriod::THIS_YEAR,
-            true,
-        ];
-    }
 }

tests/Utilities/DateTest.php

@@ -13,7 +13,6 @@ 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;
 
 /**
@@ -507,35 +506,6 @@ 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
      *
@@ -788,112 +758,4 @@ 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

@@ -1,341 +0,0 @@
-<?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 implements I
+class B extends A
 {
     protected $name = 'Lorem Ipsum';
 

tests/Utilities/Reflection/H.php

@@ -1,27 +0,0 @@
-<?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

@@ -1,20 +0,0 @@
-<?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,8 +22,6 @@ 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;
 
@@ -381,99 +379,6 @@ 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
      *