# Integration tests on Symfony with Testcontainers

*Disclaimer: I'm not a divine entity. What I say is not an absolute truth. Don't be afraid to question even the world, because it might be wrong, not you.*

Today isn't a secret for nobody the importance of automated tests for keeping quality and integrity of your software and normally we talk much about unit tests, but, today, we will focus more in integration tests into [Symfony](https://symfony.com/) Framework.

### I have no patience, show me the code!

Okay okay! If you have no patience for reading the article, I have a test project with the implementation of this article in link below.

[https://github.com/joubertredrat/symfony-testcontainers](https://github.com/joubertredrat/symfony-testcontainers)

### Symfony Framework and integration tests

Today [Symfony](https://symfony.com/) Framework is one of most mature and stable frameworks in [PHP](https://www.php.net) universe and it have various good implemented solutions, as integration tests for example. But, personally I always thought that although is easy to do integration tests itself, to provide external dependencies for test It wasn't always so easy, as databases for example.

Even with a solutions like [Docker](https://www.docker.com/), I still realized necessity to provide the external dependencies in a way for the tests, but, exists a very interesting solution that can make this step much easier, the [Testcontainers](https://testcontainers.com/).

### Testcontainers

[Testcontainers](https://testcontainers.com/) is an open source framework that let you provide in a easy way any external dependency that you need using [Docker](https://www.docker.com/), as databases, message broker, cache system, or ever dependency in container.

The big advantages of [Testcontainers](https://testcontainers.com/) in relation to [Docker](https://www.docker.com/) compose or other way of container orchestration is you can code the provisioning of container, and today already have support to [Golang](https://go.dev/), [Java](https://dev.java/), [.NET](https://dotnet.microsoft.com/), [Node.js](https://nodejs.org), [Python](https://www.python.org/), [Rust](https://www.rust-lang.org), various other languages and of course, [PHP](https://www.php.net) too!

My first contact with [Testcontainers](https://testcontainers.com/) was in a project in [Golang](https://go.dev/) and I liked so much the facility of provisioning [MongoDB](https://www.mongodb.com/) container to do the repository tests and after that, I decided to do same thing in my personal project in [PHP](https://www.php.net) using [Symfony](https://symfony.com/) Framework.

### Symfony + Testcontainers = ❤️

One of biggest advantages of [Symfony](https://symfony.com/) is the support to do tests integrated with [PHPUnit](https://phpunit.de) and with a functional kernel to do the bootstrap necessary for the tests.

Although [Testcontainers](https://testcontainers.com/) have support to [PHP](https://www.php.net), their implementation is recent and you can view it at [https://github.com/testcontainers/testcontainers-php](https://github.com/testcontainers/testcontainers-php).

Below we have a implementation of [MySQL](https://www.mysql.com/) 8.0 container, that is a external dependency of this project, and the boot of [Symfony](https://symfony.com/) kernel, creation of database and schema.

```php
class IntegrationTestCase extends KernelTestCase
{
    protected static ?MySQLContainer $container = null;

    public static function setUpBeforeClass(): void
    {
        parent::setUpBeforeClass();

        if (!static::$container) {
            static::$container = MySQLContainer::make('8.0', 'password');
            static::$container->withPort('19306', '3306');
            static::$container->run();

            $kernel = self::bootKernel();
            $container = $kernel->getContainer();

            $application = new Application($kernel);
            $application->setAutoExit(false);

            $application->run(
                new ArrayInput(['command' => 'doctrine:database:create', '--if-not-exists' => true])
            );

            $entityManager = $container->get('doctrine')->getManager();
            $metadata = $entityManager->getMetadataFactory()->getAllMetadata();
            $schemaTool = new SchemaTool($entityManager);
            $schemaTool->dropSchema($metadata);
            $schemaTool->createSchema($metadata);
        }
    }

    public static function tearDownAfterClass(): void
    {
        parent::tearDownAfterClass();

        if (static::$container instanceof MySQLContainer) {
            static::$container->remove();
        }
    }
```

With this, we have the basis class for the classes that will execute the tests itself, as example below.

```php
class UserRepositoryTest extends IntegrationTestCase
{
    public function testSave(): void
    {
        $user = new User();
        $user->setName('John Doe');
        $user->setEmail('john@doe.local');

        $repo = $this->getRepository();
        $repo->save($user, true);

        self::assertNotNull($user->getId());
        self::assertIsInt($user->getId());
        self::assertTrue($user->getId() > 0);
    }

    public function testGetByEmail(): void
    {
        $user = new User();
        $user->setName('John Doe');
        $user->setEmail('john2@doe.local');

        $repo = $this->getRepository();
        $userNotFound = $repo->getByEmail($user->getEmail());
        self::assertNull($userNotFound);

        $repo->save($user, true);
        $userFound = $repo->getByEmail($user->getEmail());

        self::assertEquals($user->getEmail(), $userFound->getEmail());
    }

    protected function tearDown(): void
    {
        parent::tearDown();

        $connection = $this
            ->getContainer()
            ->get('doctrine')
            ->getManager()
            ->getConnection()
        ;
        $connection->executeStatement('TRUNCATE TABLE users');
    }

    protected function getRepository(): UserRepository
    {
        return $this->getContainer()->get(UserRepository::class);
    }
}
```

When running suite of tests, you can view that tests will execute slowly compared with unit tests of tests with just mocked behaviors, but this is normal, because during this process, [Testcontainers](https://testcontainers.com/) is provisioning the container that you defined to use in tests.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1724941514944/5e2096d2-e937-4ecc-8964-83c26ee5dd2a.png align="center")

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1724941522389/c9eca5f9-7938-44a0-a7cb-532299aff6a3.png align="center")

Finally, with this facility, can be possible to do crazy things, like 100% of coverage. Don't believe it? You can see for yourself at [https://joubertredrat.github.io/symfony-testcontainers](https://joubertredrat.github.io/symfony-testcontainers).

**UPDATE 12/11:** At start, in examples above I used `setUpBeforeClass()` and `tearDownAfterClass()` for control the operating state of container for tests, but, after I discovered that these methods executes in each new test classes, and we don't want this.

Because of this, I've fixed the project for using Extensions and Subscribers from [PHPUnit](https://phpunit.de/) in 11 version, and this solved the issue, making that container starts before and stop after all suit of tests.

Depending of [PHPUnit](https://phpunit.de/) version you're using, can be necessary use a different approach.

That's it, see you next!