From 8bcf006e02eb3fa16be8d04244336336077f3cb6 Mon Sep 17 00:00:00 2001 From: Meritoo Date: Fri, 3 Nov 2017 21:13:47 +0100 Subject: [PATCH] Tests - increase code coverage --- src/Utilities/Date.php | 180 ++++++----- src/Utilities/QueryBuilderUtility.php | 93 ++++-- src/Utilities/Reflection.php | 4 +- tests/Utilities/DateTest.php | 138 ++++++++ tests/Utilities/QueryBuilderUtilityTest.php | 341 ++++++++++++++++++++ tests/Utilities/Reflection/B.php | 2 +- tests/Utilities/Reflection/H.php | 27 ++ tests/Utilities/Reflection/I.php | 20 ++ tests/Utilities/ReflectionTest.php | 95 ++++++ 9 files changed, 777 insertions(+), 123 deletions(-) create mode 100644 tests/Utilities/QueryBuilderUtilityTest.php create mode 100644 tests/Utilities/Reflection/H.php create mode 100644 tests/Utilities/Reflection/I.php diff --git a/src/Utilities/Date.php b/src/Utilities/Date.php index 2e95054..827e973 100644 --- a/src/Utilities/Date.php +++ b/src/Utilities/Date.php @@ -67,97 +67,105 @@ 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 DatePeriod + * @return null|DatePeriod */ public static function getDatesForPeriod($period) { - $datePeriod = null; - - if ((new DatePeriod())->isCorrectType($period)) { - $dateStart = null; - $dateEnd = null; - - switch ($period) { - case DatePeriod::LAST_WEEK: - $thisWeekStart = new DateTime('this week'); - - $dateStart = clone $thisWeekStart; - $dateEnd = clone $thisWeekStart; - - $dateStart->sub(new DateInterval('P7D')); - $dateEnd->sub(new DateInterval('P1D')); - - break; - case DatePeriod::THIS_WEEK: - $dateStart = new DateTime('this week'); - - $dateEnd = clone $dateStart; - $dateEnd->add(new DateInterval('P6D')); - - break; - case DatePeriod::NEXT_WEEK: - $dateStart = new DateTime('this week'); - $dateStart->add(new DateInterval('P7D')); - - $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::THIS_MONTH: - $lastMonth = self::getDatesForPeriod(DatePeriod::LAST_MONTH); - $nextMonth = self::getDatesForPeriod(DatePeriod::NEXT_MONTH); - - $dateStart = $lastMonth->getEndDate(); - $dateStart->add(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::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) { - $yearDifference *= -1; - } - - $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); - - break; - } - - if (null !== $dateStart && null !== $dateEnd) { - $dateStart->setTime(0, 0, 0); - $dateEnd->setTime(23, 59, 59); - - $datePeriod = new DatePeriod($dateStart, $dateEnd); - } + /* + * Type of period is incorrect? + * Nothing to do + */ + if (!(new DatePeriod())->isCorrectType($period)) { + return null; } - return $datePeriod; + $dateStart = null; + $dateEnd = null; + + switch ($period) { + case DatePeriod::LAST_WEEK: + $thisWeekStart = new DateTime('this week'); + + $dateStart = clone $thisWeekStart; + $dateEnd = clone $thisWeekStart; + + $dateStart->sub(new DateInterval('P7D')); + $dateEnd->sub(new DateInterval('P1D')); + + break; + case DatePeriod::THIS_WEEK: + $dateStart = new DateTime('this week'); + + $dateEnd = clone $dateStart; + $dateEnd->add(new DateInterval('P6D')); + + break; + case DatePeriod::NEXT_WEEK: + $dateStart = new DateTime('this week'); + $dateStart->add(new DateInterval('P7D')); + + $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::THIS_MONTH: + $lastMonth = self::getDatesForPeriod(DatePeriod::LAST_MONTH); + $nextMonth = self::getDatesForPeriod(DatePeriod::NEXT_MONTH); + + $dateStart = $lastMonth->getEndDate(); + $dateStart->add(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::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) { + $yearDifference *= -1; + } + + $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); + + break; + } + + /* + * 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); } /** diff --git a/src/Utilities/QueryBuilderUtility.php b/src/Utilities/QueryBuilderUtility.php index b645a82..294879d 100644 --- a/src/Utilities/QueryBuilderUtility.php +++ b/src/Utilities/QueryBuilderUtility.php @@ -33,6 +33,10 @@ class QueryBuilderUtility { $aliases = $queryBuilder->getRootAliases(); + /* + * No aliases? + * Nothing to do + */ if (empty($aliases)) { return null; } @@ -42,7 +46,8 @@ class QueryBuilderUtility /** * Returns alias of given property joined in given query builder - * If the join does not exist, null is returned. + * + * If there are no joins or 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 @@ -53,6 +58,10 @@ class QueryBuilderUtility { $joins = $queryBuilder->getDQLPart('join'); + /* + * No joins? + * Nothing to do + */ if (empty($joins)) { return null; } @@ -99,33 +108,43 @@ class QueryBuilderUtility */ public static function setCriteria(QueryBuilder $queryBuilder, array $criteria = [], $alias = '') { - if (!empty($criteria)) { - if (empty($alias)) { - $alias = self::getRootAlias($queryBuilder); - } + /* + * No criteria used in WHERE clause? + * Nothing to do + */ + if (empty($criteria)) { + return $queryBuilder; + } - foreach ($criteria as $column => $value) { - $compareOperator = '='; + /* + * No alias provided? + * Let's use root alias + */ + if (empty($alias)) { + $alias = self::getRootAlias($queryBuilder); + } - if (is_array($value) && !empty($value)) { - if (2 == count($value)) { - $compareOperator = $value[1]; - } + foreach ($criteria as $column => $value) { + $compareOperator = '='; - $value = $value[0]; + if (is_array($value) && !empty($value)) { + if (2 == count($value)) { + $compareOperator = $value[1]; } - $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); + $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); } return $queryBuilder; @@ -143,7 +162,7 @@ class QueryBuilderUtility public static function deleteEntities(EntityManager $entityManager, $entities, $flushDeleted = true) { /* - * No entities found? + * No entities provided? * Nothing to do */ if (empty($entities)) { @@ -169,24 +188,30 @@ class QueryBuilderUtility * Attention. Existing parameters will be overridden. * * @param QueryBuilder $queryBuilder The query builder - * @param array|ArrayCollection $parameters Parameters to add. Collection of instances of - * Doctrine\ORM\Query\Parameter class or an array with key-value pairs. + * @param array|ArrayCollection $parameters Parameters to add. Collection of Doctrine\ORM\Query\Parameter + * instances or an array with key-value pairs. * @return QueryBuilder */ public static function addParameters(QueryBuilder $queryBuilder, $parameters) { - if (!empty($parameters)) { - foreach ($parameters as $key => $parameter) { - $name = $key; - $value = $parameter; + /* + * No parameters? + * Nothing to do + */ + if (empty($parameters)) { + return $queryBuilder; + } - if ($parameter instanceof Parameter) { - $name = $parameter->getName(); - $value = $parameter->getValue(); - } + foreach ($parameters as $key => $parameter) { + $name = $key; + $value = $parameter; - $queryBuilder->setParameter($name, $value); + if ($parameter instanceof Parameter) { + $name = $parameter->getName(); + $value = $parameter->getValue(); } + + $queryBuilder->setParameter($name, $value); } return $queryBuilder; diff --git a/src/Utilities/Reflection.php b/src/Utilities/Reflection.php index 4e94900..6577d08 100644 --- a/src/Utilities/Reflection.php +++ b/src/Utilities/Reflection.php @@ -74,8 +74,8 @@ class Reflection } /** - * Returns maximum constant from all constants of given class / object. - * Values of constants should be integers. + * Returns maximum integer value of constant of given class / object. + * Constants whose values are integers are considered only. * * @param object|string $class The object or name of object's class * @return int|null diff --git a/tests/Utilities/DateTest.php b/tests/Utilities/DateTest.php index f750520..aa46b0d 100644 --- a/tests/Utilities/DateTest.php +++ b/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) + ), + ]; + } } diff --git a/tests/Utilities/QueryBuilderUtilityTest.php b/tests/Utilities/QueryBuilderUtilityTest.php new file mode 100644 index 0000000..5c5f05d --- /dev/null +++ b/tests/Utilities/QueryBuilderUtilityTest.php @@ -0,0 +1,341 @@ + + * @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), + ]), + ]; + } +} diff --git a/tests/Utilities/Reflection/B.php b/tests/Utilities/Reflection/B.php index 3366835..3c1b541 100644 --- a/tests/Utilities/Reflection/B.php +++ b/tests/Utilities/Reflection/B.php @@ -15,7 +15,7 @@ namespace Meritoo\Common\Test\Utilities\Reflection; * @author Krzysztof Niziol * @copyright Meritoo.pl */ -class B extends A +class B extends A implements I { protected $name = 'Lorem Ipsum'; diff --git a/tests/Utilities/Reflection/H.php b/tests/Utilities/Reflection/H.php new file mode 100644 index 0000000..408b900 --- /dev/null +++ b/tests/Utilities/Reflection/H.php @@ -0,0 +1,27 @@ + + * @copyright Meritoo.pl + */ +class H +{ + const DOLOR = 'sit'; + + const LOREM = 'ipsum'; + + const MAX_USERS = 5; + + const MIN_USERS = 2; +} diff --git a/tests/Utilities/Reflection/I.php b/tests/Utilities/Reflection/I.php new file mode 100644 index 0000000..794253b --- /dev/null +++ b/tests/Utilities/Reflection/I.php @@ -0,0 +1,20 @@ + + * @copyright Meritoo.pl + */ +interface I +{ +} diff --git a/tests/Utilities/ReflectionTest.php b/tests/Utilities/ReflectionTest.php index 9907779..a0ca5e4 100644 --- a/tests/Utilities/ReflectionTest.php +++ b/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 *