Zenstruck\Foundry\Test\DatabaseResetter

Complexity

Total Complexity

18

Size/Duplication

Total Lines	108
Duplicated Lines	0 %

Test Coverage

Coverage

61.11%

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	objectManagersToReset()	0	7	2
A	runCommand()	0	9	2
A	dropSchema()	0	6	2
A	createApplication()	0	6	1
A	resetSchema()	0	7	1
A	isDAMADoctrineTestBundleEnabled()	0	3	2
A	resetDatabase()	0	20	2
A	createSchema()	0	10	2
A	connectionsToReset()	0	7	2
A	hasBeenReset()	0	7	2

<?php

namespace Zenstruck\Foundry\Test;

use DAMA\DoctrineTestBundle\Doctrine\DBAL\StaticDriver;
use Doctrine\Persistence\ManagerRegistry;
use Symfony\Bundle\FrameworkBundle\Console\Application;
use Symfony\Component\Console\Input\ArrayInput;
use Symfony\Component\Console\Output\BufferedOutput;
use Symfony\Component\HttpKernel\KernelInterface;

/**
 * @internal
 *
 * @author Kevin Bond <kevinbond@gmail.com>
 */
final class DatabaseResetter
{
    /** @var bool */
    private static $hasBeenReset = false;

    public static function hasBeenReset(): bool
    {
        if (isset($_SERVER['FOUNDRY_DISABLE_DATABASE_RESET'])) {
            return true;
        }

        return self::$hasBeenReset;
    }

    public static function isDAMADoctrineTestBundleEnabled(): bool
    {
        return \class_exists(StaticDriver::class) && StaticDriver::isKeepStaticConnections();
    }

    public static function resetDatabase(KernelInterface $kernel): void
    {
        $application = self::createApplication($kernel);
        $registry = $kernel->getContainer()->get('doctrine');

        foreach (self::connectionsToReset($registry) as $connection) {

It seems like $registry can also be of type null; however, parameter $registry of Zenstruck\Foundry\Test\DatabaseResetter::connectionsToReset() does only seem to accept Doctrine\Persistence\ManagerRegistry, maybe add an additional type check?

            self::runCommand($application, 'doctrine:database:drop', [
                '--connection' => $connection,
                '--if-exists' => true,
                '--force' => true,
            ]);

            self::runCommand($application, 'doctrine:database:create', [
                '--connection' => $connection,
            ]);
        }

        self::createSchema($application, $registry);

It seems like $registry can also be of type null; however, parameter $registry of Zenstruck\Foundry\Test\DatabaseResetter::createSchema() does only seem to accept Doctrine\Persistence\ManagerRegistry, maybe add an additional type check?

        self::$hasBeenReset = true;
    }

    public static function resetSchema(KernelInterface $kernel): void
    {
        $application = self::createApplication($kernel);
        $registry = $kernel->getContainer()->get('doctrine');

        self::dropSchema($application, $registry);

It seems like $registry can also be of type null; however, parameter $registry of Zenstruck\Foundry\Test\DatabaseResetter::dropSchema() does only seem to accept Doctrine\Persistence\ManagerRegistry, maybe add an additional type check?

        self::createSchema($application, $registry);

It seems like $registry can also be of type null; however, parameter $registry of Zenstruck\Foundry\Test\DatabaseResetter::createSchema() does only seem to accept Doctrine\Persistence\ManagerRegistry, maybe add an additional type check?

    }

    private static function createSchema(Application $application, ManagerRegistry $registry): void
    {
        foreach (self::objectManagersToReset($registry) as $manager) {
            self::runCommand($application, 'doctrine:schema:create', [
                '--em' => $manager,
            ]);
        }

        TestState::bootFromContainer($application->getKernel()->getContainer());
        TestState::flushGlobalState();
    }

    private static function dropSchema(Application $application, ManagerRegistry $registry): void
    {
        foreach (self::objectManagersToReset($registry) as $manager) {
            self::runCommand($application, 'doctrine:schema:drop', [
                '--em' => $manager,
                '--force' => true,
            ]);
        }
    }

    private static function runCommand(Application $application, string $command, array $parameters = []): void
    {
        $exit = $application->run(
            new ArrayInput(\array_merge(['command' => $command], $parameters)),
            $output = new BufferedOutput()
        );

        if (0 !== $exit) {
            throw new \RuntimeException(\sprintf('Error running "%s": %s', $command, $output->fetch()));
        }
    }

    private static function createApplication(KernelInterface $kernel): Application
    {
        $application = new Application($kernel);
        $application->setAutoExit(false);

        return $application;
    }

    private static function connectionsToReset(ManagerRegistry $registry): array
    {
        if (isset($_SERVER['FOUNDRY_RESET_CONNECTIONS'])) {
            return \explode(',', $_SERVER['FOUNDRY_RESET_CONNECTIONS']);
        }

        return [$registry->getDefaultConnectionName()];
    }

    private static function objectManagersToReset(ManagerRegistry $registry): array
    {
        if (isset($_SERVER['FOUNDRY_RESET_OBJECT_MANAGERS'])) {
            return \explode(',', $_SERVER['FOUNDRY_RESET_OBJECT_MANAGERS']);
        }

        return [$registry->getDefaultManagerName()];
    }
}