How to Test A Doctrine Repository

How to Test A Doctrine Repository

See also

The main Testing guide describes how to use and set-up a database for your automated tests. The contents of this article show ways to test your Doctrine repositories.

Mocking a Doctrine Repository in Unit Tests

Unit testing Doctrine repositories is not recommended. Repositories are meant to be tested against a real database connection. However, in case you still need to do this, look at the following example.

Suppose the class you want to test looks like this:

  1. // src/Salary/SalaryCalculator.php
  2. namespace App\Salary;
  4. use App\Entity\Employee;
  5. use Doctrine\Persistence\ObjectManager;
  7. class SalaryCalculator
  8. {
  9.     private $objectManager;
  11.     public function __construct(ObjectManager $objectManager)
  12.     {
  13.         $this->objectManager = $objectManager;
  14.     }
  16.     public function calculateTotalSalary($id)
  17.     {
  18.         $employeeRepository = $this->objectManager
  19.             ->getRepository(Employee::class);
  20.         $employee = $employeeRepository->find($id);
  22.         return $employee->getSalary() + $employee->getBonus();
  23.     }
  24. }

Since the EntityManagerInterface gets injected into the class through the constructor, you can pass a mock object within a test:

  1. // tests/Salary/SalaryCalculatorTest.php
  2. namespace App\Tests\Salary;
  4. use App\Entity\Employee;
  5. use App\Salary\SalaryCalculator;
  6. use Doctrine\Persistence\ObjectManager;
  7. use Doctrine\Persistence\ObjectRepository;
  8. use PHPUnit\Framework\TestCase;
  10. class SalaryCalculatorTest extends TestCase
  11. {
  12.     public function testCalculateTotalSalary()
  13.     {
  14.         $employee = new Employee();
  15.         $employee->setSalary(1000);
  16.         $employee->setBonus(1100);
  18.         // Now, mock the repository so it returns the mock of the employee
  19.         $employeeRepository = $this->createMock(ObjectRepository::class);
  20.         // use getMock() on PHPUnit 5.3 or below
  21.         // $employeeRepository = $this->getMock(ObjectRepository::class);
  22.         $employeeRepository->expects($this->any())
  23.             ->method('find')
  24.             ->willReturn($employee);
  26.         // Last, mock the EntityManager to return the mock of the repository
  27.         // (this is not needed if the class being tested injects the
  28.         // repository it uses instead of the entire object manager)
  29.         $objectManager = $this->createMock(ObjectManager::class);
  30.         // use getMock() on PHPUnit 5.3 or below
  31.         // $objectManager = $this->getMock(ObjectManager::class);
  32.         $objectManager->expects($this->any())
  33.             ->method('getRepository')
  34.             ->willReturn($employeeRepository);
  36.         $salaryCalculator = new SalaryCalculator($objectManager);
  37.         $this->assertEquals(2100, $salaryCalculator->calculateTotalSalary(1));
  38.     }
  39. }

In this example, you are building the mocks from the inside out, first creating the employee which gets returned by the Repository, which itself gets returned by the EntityManager. This way, no real class is involved in testing.

Functional Testing of A Doctrine Repository

In functional tests you’ll make queries to the database using the actual Doctrine repositories, instead of mocking them. To do so, get the entity manager via the service container as follows:

  1. // tests/Repository/ProductRepositoryTest.php
  2. namespace App\Tests\Repository;
  4. use App\Entity\Product;
  5. use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
  7. class ProductRepositoryTest extends KernelTestCase
  8. {
  9.     /**
  10.      * @var \Doctrine\ORM\EntityManager
  11.      */
  12.     private $entityManager;
  14.     protected function setUp()
  15.     {
  16.         $kernel = self::bootKernel();
  18.         $this->entityManager = $kernel->getContainer()
  19.             ->get('doctrine')
  20.             ->getManager();
  21.     }
  23.     public function testSearchByName()
  24.     {
  25.         $product = $this->entityManager
  26.             ->getRepository(Product::class)
  27.             ->findOneBy(['name' => 'Priceless widget'])
  28.         ;
  30.         $this->assertSame(14.50, $product->getPrice());
  31.     }
  33.     protected function tearDown()
  34.     {
  35.         parent::tearDown();
  37.         // doing this is recommended to avoid memory leaks
  38.         $this->entityManager->close();
  39.         $this->entityManager = null;
  40.     }
  41. }

This work, including the code samples, is licensed under a Creative Commons BY-SA 3.0 license.