DoctrineMigrationsExtensionTest::testFullConfig() - Code Metrics - Inspection of "[WIP] Add support for doctrine/migrations 3.0" - doctrine/DoctrineMigrationsBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#278)

by Asmir
created 2019-12-14 18:34 UTC
DoctrineMigrationsExtensionTest::testFullConfig() A

↳ Parent: DoctrineMigrationsExtensionTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	60
Code Lines	39
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
eloc	39
c	0
b	0
f	0
dl	0
loc	60
rs	9.296
cc	1
nc	1
nop	0
How to fix Long Method

<?php

declare(strict_types=1);

namespace Doctrine\Bundle\MigrationsBundle\Tests\DependencyInjection;

use Doctrine\Bundle\MigrationsBundle\DependencyInjection\DoctrineMigrationsExtension;
use Doctrine\Bundle\MigrationsBundle\Tests\Fixtures\CustomEntityManager;
use Doctrine\DBAL\Connection;
use Doctrine\Migrations\Configuration\Configuration;
use Doctrine\Migrations\DependencyFactory;
use Doctrine\Migrations\Metadata\Storage\TableMetadataStorageConfiguration;
use InvalidArgumentException;
use PHPUnit\Framework\TestCase;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
use function sys_get_temp_dir;

class DoctrineMigrationsExtensionTest extends TestCase
{
    public function testFullConfig() : void
    {
        $container = $this->getContainer();
        $extension = new DoctrineMigrationsExtension();

        $config = [
            'name' => 'Doctrine Sandbox Migrations',
            'storage' => [
                'table_storage' => [
                    'table_name'                 => 'doctrine_migration_versions_test',
                    'version_column_name'        => 'doctrine_migration_column_test',
                    'version_column_length'      => 2000,
                    'executed_at_column_name'    => 'doctrine_migration_executed_at_column_test',
                    'execution_time_column_name' => 'doctrine_migration_execution_time_column_test',
                ],
            ],

            'migrations_paths' => [
                'DoctrineMigrationsTest' => 'a',
                'DoctrineMigrationsTest2' => 'b',
            ],

            'migrations' => ['Foo', 'Bar'],

            'organize_migrations' => 'BY_YEAR_AND_MONTH',

            'all_or_nothing'            => true,
            'check_database_platform'   => true,
        ];

        $extension->load(['doctrine_migrations' => $config], $container);

        $container->getDefinition('doctrine.migrations.configuration')->setPublic(true);
        $container->compile();
        /**
         * @var $config Configuration
         */
        $config = $container->get('doctrine.migrations.configuration');

        self::isInstanceOf(Configuration::class, $config);
              isInstanceOf(Configuration::class, $config);
        self::assertSame('Doctrine Sandbox Migrations', $config->getName());
        self::assertSame([
            'DoctrineMigrationsTest' => 'a',
            'DoctrineMigrationsTest2' => 'b',

        ], $config->getMigrationDirectories());

        self::assertSame(['Foo', 'Bar'], $config->getMigrationClasses());
        self::assertSame(true, $config->isAllOrNothing());
        self::assertSame(true, $config->isDatabasePlatformChecked());
        self::assertSame(true, $config->areMigrationsOrganizedByYearAndMonth());

        $storage = $config->getMetadataStorageConfiguration();
        self::assertInstanceOf(TableMetadataStorageConfiguration::class, $storage);

        self::assertSame('doctrine_migration_versions_test', $storage->getTableName());
        self::assertSame('doctrine_migration_column_test', $storage->getVersionColumnName());
        self::assertSame(2000, $storage->getVersionColumnLength());
        self::assertSame('doctrine_migration_execution_time_column_test', $storage->getExecutionTimeColumnName());
        self::assertSame('doctrine_migration_executed_at_column_test', $storage->getExecutedAtColumnName());
    }

    public function testCustomSorter() : void
    {
        $container = $this->getContainer();
        $extension = new DoctrineMigrationsExtension();

        $config = [
            'migrations_paths' => ['DoctrineMigrationsTest' => 'a'],

            'sorter' => 'my_sorter',

        ];

        $extension->load(['doctrine_migrations' => $config], $container);

        $container->getDefinition('doctrine.migrations.di')->setPublic(true);

        $conn = $this->createMock(Connection::class);
        $container->set('doctrine.dbal.default_connection', $conn);

        $sorter = new class(){
            public function __invoke() : void
            {
            }
        };
        $container->set('my_sorter', $sorter);

        $container->compile();
        /**
         * @var $di DependencyFactory
         */
        $di = $container->get('doctrine.migrations.di');

        self::isInstanceOf(DependencyFactory::class, $di);
              isInstanceOf(DependencyFactory::class, $di);
        self::assertSame($sorter, $di->getSorter());
    }

    public function testCustomConnection() : void
    {
        $container = $this->getContainer();
        $extension = new DoctrineMigrationsExtension();

        $config = [
            'connection' => 'custom',
            'migrations_paths' => ['DoctrineMigrationsTest' => 'a'],

        ];

        $extension->load(['doctrine_migrations' => $config], $container);

        $container->getDefinition('doctrine.migrations.di')->setPublic(true);

        $conn = $this->createMock(Connection::class);
        $container->set('doctrine.dbal.custom_connection', $conn);

        $container->compile();
        /**
         * @var $di DependencyFactory
         */
        $di = $container->get('doctrine.migrations.di');

        self::isInstanceOf(DependencyFactory::class, $di);
              isInstanceOf(DependencyFactory::class, $di);
        self::assertSame($conn, $di->getConnection());
    }

    public function testCustomEntityManager() : void
    {
        $container = $this->getContainer();
        $extension = new DoctrineMigrationsExtension();

        $config = [
            'em' => 'custom',
            'migrations_paths' => ['DoctrineMigrationsTest' => 'a'],
        ];

        $em = new Definition(CustomEntityManager::class);
        $container->setDefinition('doctrine.orm.custom_entity_manager', $em);

        $extension->load(['doctrine_migrations' => $config], $container);

        $container->getDefinition('doctrine.migrations.di')->setPublic(true);

        $container->compile();
        /**
         * @var $di DependencyFactory
         */
        $di = $container->get('doctrine.migrations.di');

        self::isInstanceOf(DependencyFactory::class, $di);
              isInstanceOf(DependencyFactory::class, $di);
        $em = $di->getEntityManager();
        self::assertInstanceOf(CustomEntityManager::class, $em);
        self::assertInstanceOf(CustomEntityManager::class, $di->getConnection()->getEm());
        self::assertInstanceOf(CustomEntityManager::class, $di->getConnection()->/** @scrutinizer ignore-call */ getEm());
        self::assertSame($em, $di->getConnection()->getEm());
    }

    public function testCanNotSpecifyBothEmAndConnection() : void
    {
        $this->expectExceptionMessage('You can not specify both "connection" and "em" in the DoctrineMigrationsBundle configurations');
        $this->expectException(InvalidArgumentException::class);
        $container = $this->getContainer();
        $extension = new DoctrineMigrationsExtension();

        $config = [
            'em' => 'custom',
            'connection' => 'custom',
        ];

        $extension->load(['doctrine_migrations' => $config], $container);

        $container->getDefinition('doctrine.migrations.di')->setPublic(true);

        $container->compile();
    }

    private function getContainer() : ContainerBuilder
    {
        return new ContainerBuilder(new ParameterBag([
            'kernel.debug' => false,
            'kernel.bundles' => [],
            'kernel.cache_dir' => sys_get_temp_dir(),
            'kernel.environment' => 'test',
            'kernel.root_dir' => __DIR__ . '/../../', // src dir
        ]));
    }
}

doctrine / DoctrineMigrationsBundle

Pull Request — master (#278)

DoctrineMigrationsExtensionTest::testFullConfig() A

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like
