DatabaseResetter::dropAndCreateDatabase() - Code Metrics - Inspection of "Add option to use doctrine migrations to reset dat..." - zenstruck/foundry - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#145)

by Kevin

created 2021-03-23 14:45 UTC

DatabaseResetter::dropAndCreateDatabase() A

↳ Parent: DatabaseResetter

Complexity

Conditions	3
Paths	3

Size

Total Lines	14
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	10
CRAP Score	3

Importance

Changes

Metric	Value
eloc	7
c	0
b	0
f	0
dl	0
loc	14
ccs	10
cts	10
cp	1
rs	10
cc	3
nc	3
nop	2
crap	3

<?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;
use Zenstruck\Foundry\Factory;

/**
 * @internal
 *
 * @author Kevin Bond <[email protected]>
 */
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 isResetUsingMigrations(): bool
    {
        return 'migrate' === ($_SERVER['FOUNDRY_RESET_MODE'] ?? null);
    }

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

        self::dropAndCreateDatabase($application, $registry);
        self::dropAndCreateDatabase($application, /** @scrutinizer ignore-type */ $registry);
        self::createSchema($application, $registry);
        self::createSchema($application, /** @scrutinizer ignore-type */ $registry);

        self::$hasBeenReset = true;
    }

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

        self::dropSchema($application, $registry);
        self::dropSchema($application, /** @scrutinizer ignore-type */ $registry);
        self::createSchema($application, $registry);
        self::createSchema($application, /** @scrutinizer ignore-type */ $registry);
    }

    private static function dropAndCreateDatabase(Application $application, ManagerRegistry $registry): void
    {
        foreach (self::connectionsToReset($registry) as $connection) {
            $dropParams = ['--connection' => $connection, '--force' => true];

            if ('sqlite' !== $registry->getConnection($connection)->getDatabasePlatform()->getName()) {
                // sqlite does not support "--if-exists" (ref: https://github.com/doctrine/dbal/pull/2402)
                $dropParams['--if-exists'] = true;
            }

            self::runCommand($application, 'doctrine:database:drop', $dropParams);

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

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

        if (!Factory::isBooted()) {
            TestState::bootFromContainer($application->getKernel()->getContainer());
        }

        TestState::flushGlobalState();
    }

    private static function dropSchema(Application $application, ManagerRegistry $registry): void
    {
        if (self::isResetUsingMigrations()) {
            self::dropAndCreateDatabase($application, $registry);

            return;
        }

        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()];
    }
}


zenstruck / foundry

Pull Request — master (#145)

DatabaseResetter::dropAndCreateDatabase() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like