UnitTestCase::getObjectWithMockedArguments() - Code Metrics - Inspection of "fixes bugs in ranking system, improves memory mana..." - tfboe/fm-lib - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 916c4f...7f572e )

by Benedikt

created 2018-06-13 13:27 UTC

UnitTestCase::getObjectWithMockedArguments() A

↳ Parent: UnitTestCase

Complexity

Conditions	2
Paths	2

Size

Total Lines	11
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	11
c	0
b	0
f	0
rs	9.4285
cc	2
eloc	7
nc	2
nop	2

<?php
declare(strict_types=1);
/**
 * Created by PhpStorm.
 * User: benedikt
 * Date: 1/6/18
 * Time: 7:08 PM
 */

namespace Tfboe\FmLib\TestHelpers;

use Doctrine\ORM\AbstractQuery;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\QueryBuilder;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * Class UnitTestCase
 * @package Tfboe\FmLib\TestHelpers
 */
abstract class UnitTestCase extends TestCase
{
  use ReflectionMethods;
  use OnlyTestLogging;

//<editor-fold desc="Protected Methods">

  /**
   * Creates a stub with a given set of stubbed methods, which will return the given results
   * @param string $class the class name
   * @param array $methodResults a dictionary mapping method names to results of this methods
   * @return MockObject the configured stub
   */
  protected function createStub(string $class, array $methodResults): MockObject
  {
    $entity = $this->createMock($class);
    foreach ($methodResults as $method => $result) {
      $entity->method($method)->willReturn($result);
    }
    return $entity;
  }

  /**
   * Creates an empty mock with a getId method
   * @param string $class the class to mock
   * @param string $entityId the id to assign
   * @param string $getterMethod the name of the getter method
   * @return \PHPUnit\Framework\MockObject\MockObject the mocked instance
   */
  protected function createStubWithId(string $class, $entityId = "entity-id", $getterMethod = 'getId')
  {
    return $this->createStub($class, [$getterMethod => $entityId]);
  }

  /**
   * Gets a mock for an entity manager which creates a query builder which will return a query which will return the
   * given result.
   * @param array $result the result array the query should return
   * @param string|null $expectedQuery the expected query if set
   * @param string[] $otherMockedMethods list of other methods to mock
   * @return MockObject the mocked entity manager
   */
  protected function getEntityManagerMockForQuery(array $result, ?string $expectedQuery = null,
                                                  array $otherMockedMethods = [], $amount = 1)
  {
    $entityManager = $this->getMockForAbstractClass(EntityManager::class, [], '',
      false, true, true, array_merge($otherMockedMethods, ['createQueryBuilder']));

    $entityManager->expects(static::exactly($amount))->method('createQueryBuilder')->willReturnCallback(
      function () use ($entityManager, $result, $expectedQuery) {
        $queryBuilder = $this->getMockForAbstractClass(QueryBuilder::class, [$entityManager],
          '', true, true, true, ['getQuery']);
        $query = $this->createMock(AbstractQuery::class);
        $query->expects(static::once())->method('getResult')->willReturn($result);
        if ($expectedQuery !== null) {
          $queryBuilder->expects(static::once())->method('getQuery')->willReturnCallback(
            function () use ($queryBuilder, $query, $expectedQuery) {
              /** @var QueryBuilder $queryBuilder */
              self::assertEquals($expectedQuery, $queryBuilder->getDQL());
              return $query;
            });
        } else {
          $queryBuilder->expects(static::once())->method('getQuery')->willReturn($query);
        }
        return $queryBuilder;
      }
    );
    return $entityManager;
  }

  /** @noinspection PhpDocMissingThrowsInspection */
  /**
   * Gets a mock class (with full implementation). The given arguments are used for the arguments for the constructor.
   * If too less arguments are given mocks are created for the rest of the constructor arguments.
   * @param string $className the class to mock
   * @param array $arguments the arguments to use for the constructor
   * @param string[] $mockedMethods the methods to mock in the class
   * @return MockObject the mocked object
   */
  protected final function getMockWithMockedArguments(string $className, array $arguments = [],

                                                      array $mockedMethods = []): MockObject
  {
    /** @noinspection PhpUnhandledExceptionInspection */
    $reflection = new \ReflectionClass($className);
    $params = $reflection->getConstructor()->getParameters();
    $allArguments = $arguments;
    for ($i = count($arguments); $i < count($params); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
      $allArguments[] = $this->createMock($params[$i]->getClass()->name);
    }
    return $this->getMockForAbstractClass($className, $allArguments, '', true, true, true, $mockedMethods);
  }

  /** @noinspection PhpDocMissingThrowsInspection */
  /**
   * Gets a new instance of the given class. The given arguments are used for the arguments for the constructor.
   * If too less arguments are given mocks are created for the rest of the constructor arguments.
   * @param string $className the class for which to create an instance
   * @param array $arguments the arguments to use for the constructor
   * @return mixed an instance of the given class
   */
  protected final function getObjectWithMockedArguments($className, array $arguments = [])

  {
    /** @noinspection PhpUnhandledExceptionInspection */
    $reflection = new \ReflectionClass($className);
    $params = $reflection->getConstructor()->getParameters();
    $allArguments = $arguments;
    for ($i = count($arguments); $i < count($params); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
      $allArguments[$i] = $this->createMock($params[$i]->getClass()->name);
    }
    return new $className(...$allArguments);
  }

  public function tearDown()
  {
    parent::tearDown();
  }
//</editor-fold desc="Protected Methods">
}

1			<?php
2			declare(strict_types=1);
3			/**
4			* Created by PhpStorm.
5			* User: benedikt
6			* Date: 1/6/18
7			* Time: 7:08 PM
8			*/
9
10			namespace Tfboe\FmLib\TestHelpers;
11
12			use Doctrine\ORM\AbstractQuery;
13			use Doctrine\ORM\EntityManager;
14			use Doctrine\ORM\QueryBuilder;
15			use PHPUnit\Framework\MockObject\MockObject;
16			use PHPUnit\Framework\TestCase;
17
18			/**
19			* Class UnitTestCase
20			* @package Tfboe\FmLib\TestHelpers
21			*/
22			abstract class UnitTestCase extends TestCase
23			{
24			use ReflectionMethods;
25			use OnlyTestLogging;
26
27			//<editor-fold desc="Protected Methods">
28
29			/**
30			* Creates a stub with a given set of stubbed methods, which will return the given results
31			* @param string $class the class name
32			* @param array $methodResults a dictionary mapping method names to results of this methods
33			* @return MockObject the configured stub
34			*/
35			protected function createStub(string $class, array $methodResults): MockObject
36			{
37			$entity = $this->createMock($class);
38			foreach ($methodResults as $method => $result) {
39			$entity->method($method)->willReturn($result);
40			}
41			return $entity;
42			}
43
44			/**
45			* Creates an empty mock with a getId method
46			* @param string $class the class to mock
47			* @param string $entityId the id to assign
48			* @param string $getterMethod the name of the getter method
49			* @return \PHPUnit\Framework\MockObject\MockObject the mocked instance
50			*/
51			protected function createStubWithId(string $class, $entityId = "entity-id", $getterMethod = 'getId')
52			{
53			return $this->createStub($class, [$getterMethod => $entityId]);
54			}
55
56			/**
57			* Gets a mock for an entity manager which creates a query builder which will return a query which will return the
58			* given result.
59			* @param array $result the result array the query should return
60			* @param string\|null $expectedQuery the expected query if set
61			* @param string[] $otherMockedMethods list of other methods to mock
62			* @return MockObject the mocked entity manager
63			*/
64			protected function getEntityManagerMockForQuery(array $result, ?string $expectedQuery = null,
65			array $otherMockedMethods = [], $amount = 1)
66			{
67			$entityManager = $this->getMockForAbstractClass(EntityManager::class, [], '',
68			false, true, true, array_merge($otherMockedMethods, ['createQueryBuilder']));
69
70			$entityManager->expects(static::exactly($amount))->method('createQueryBuilder')->willReturnCallback(
71			function () use ($entityManager, $result, $expectedQuery) {
72			$queryBuilder = $this->getMockForAbstractClass(QueryBuilder::class, [$entityManager],
73			'', true, true, true, ['getQuery']);
74			$query = $this->createMock(AbstractQuery::class);
75			$query->expects(static::once())->method('getResult')->willReturn($result);
76			if ($expectedQuery !== null) {
77			$queryBuilder->expects(static::once())->method('getQuery')->willReturnCallback(
78			function () use ($queryBuilder, $query, $expectedQuery) {
79			/** @var QueryBuilder $queryBuilder */
80			self::assertEquals($expectedQuery, $queryBuilder->getDQL());
81			return $query;
82			});
83			} else {
84			$queryBuilder->expects(static::once())->method('getQuery')->willReturn($query);
85			}
86			return $queryBuilder;
87			}
88			);
89			return $entityManager;
90			}
91
92			/** @noinspection PhpDocMissingThrowsInspection */
93			/**
94			* Gets a mock class (with full implementation). The given arguments are used for the arguments for the constructor.
95			* If too less arguments are given mocks are created for the rest of the constructor arguments.
96			* @param string $className the class to mock
97			* @param array $arguments the arguments to use for the constructor
98			* @param string[] $mockedMethods the methods to mock in the class
99			* @return MockObject the mocked object
100			*/
101			protected final function getMockWithMockedArguments(string $className, array $arguments = [],
			0 ignored issues – show Coding Style introduced 2018-01-27 11:04 UTC by Report Bug Copy Issue Report As per PSR2, `final` should precede the visibility keyword. Loading history...
102			array $mockedMethods = []): MockObject
103			{
104			/** @noinspection PhpUnhandledExceptionInspection */
105			$reflection = new \ReflectionClass($className);
106			$params = $reflection->getConstructor()->getParameters();
107			$allArguments = $arguments;
108			for ($i = count($arguments); $i < count($params); $i++) {
			0 ignored issues – show Performance Best Practice introduced 2018-01-27 10:52 UTC by Report Bug Copy Issue Report It seems like you are calling the size function `count()` as part of the test condition. You might want to compute the size beforehand, and not on each iteration. If the size of the collection does not change during the iteration, it is generally a good practice to compute it beforehand, and not on each iteration: for ($i=0; $i<count($array); $i++) { // calls count() on each iteration } // Better for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once } Loading history...
109			$allArguments[] = $this->createMock($params[$i]->getClass()->name);
110			}
111			return $this->getMockForAbstractClass($className, $allArguments, '', true, true, true, $mockedMethods);
112			}
113
114			/** @noinspection PhpDocMissingThrowsInspection */
115			/**
116			* Gets a new instance of the given class. The given arguments are used for the arguments for the constructor.
117			* If too less arguments are given mocks are created for the rest of the constructor arguments.
118			* @param string $className the class for which to create an instance
119			* @param array $arguments the arguments to use for the constructor
120			* @return mixed an instance of the given class
121			*/
122			protected final function getObjectWithMockedArguments($className, array $arguments = [])
			0 ignored issues – show Coding Style introduced 2018-01-27 11:04 UTC by Report Bug Copy Issue Report As per PSR2, `final` should precede the visibility keyword. Loading history...
123			{
124			/** @noinspection PhpUnhandledExceptionInspection */
125			$reflection = new \ReflectionClass($className);
126			$params = $reflection->getConstructor()->getParameters();
127			$allArguments = $arguments;
128			for ($i = count($arguments); $i < count($params); $i++) {
			0 ignored issues – show Performance Best Practice introduced 2018-01-27 10:52 UTC by Report Bug Copy Issue Report It seems like you are calling the size function `count()` as part of the test condition. You might want to compute the size beforehand, and not on each iteration. If the size of the collection does not change during the iteration, it is generally a good practice to compute it beforehand, and not on each iteration: for ($i=0; $i<count($array); $i++) { // calls count() on each iteration } // Better for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once } Loading history...
129			$allArguments[$i] = $this->createMock($params[$i]->getClass()->name);
130			}
131			return new $className(...$allArguments);
132			}
133
134			public function tearDown()
135			{
136			parent::tearDown();
137			}
138			//</editor-fold desc="Protected Methods">
139			}

tfboe / fm-lib

Push — master ( 916c4f...7f572e )

UnitTestCase::getObjectWithMockedArguments() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like