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 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

Symfony Framework and integration tests

Today Symfony Framework is one of most mature and stable frameworks in PHP 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, 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.

Testcontainers

Testcontainers is an open source framework that let you provide in a easy way any external dependency that you need using Docker, as databases, message broker, cache system, or ever dependency in container.

The big advantages of Testcontainers in relation to Docker compose or other way of container orchestration is you can code the provisioning of container, and today already have support to Golang, Java, .NET, Node.js, Python, Rust, various other languages and of course, PHP too!

My first contact with Testcontainers was in a project in Golang and I liked so much the facility of provisioning MongoDB container to do the repository tests and after that, I decided to do same thing in my personal project in PHP using Symfony Framework.

Symfony + Testcontainers = ❤️

One of biggest advantages of Symfony is the support to do tests integrated with PHPUnit and with a functional kernel to do the bootstrap necessary for the tests.

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

Below we have a implementation of MySQL 8.0 container, that is a external dependency of this project, and the boot of Symfony kernel, creation of database and schema.

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.

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 is provisioning the container that you defined to use in tests.

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.

That's it, see you next!