DoctrineMigrationsExtensionTest.php$0 ➔ testCustomConnection() - 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-15 16:39 UTC

php$0 ➔ testCustomConnection() A

↳ Parent: DoctrineMigrationsExtensionTest

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	19
rs	9.6333
cc	1

<?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\MetadataStorage;
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 assert;
use function method_exists;
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();

        $config = $container->get('doctrine.migrations.configuration');

        self::assertInstanceOf(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::assertTrue($config->isAllOrNothing());
        self::assertTrue($config->isDatabasePlatformChecked());
        self::assertTrue($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 = ['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();

        $di = $container->get('doctrine.migrations.di');
        self::assertInstanceOf(DependencyFactory::class, $di);
        self::assertSame($sorter, $di->getSorter());
    }

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

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

        $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();

        $di = $container->get('doctrine.migrations.di');
        self::assertInstanceOf(DependencyFactory::class, $di);
        self::assertSame($conn, $di->getConnection());
    }

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

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

        $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();

        $di = $container->get('doctrine.migrations.di');
        self::assertInstanceOf(DependencyFactory::class, $di);

        $em = $di->getEntityManager();
        self::assertInstanceOf(CustomEntityManager::class, $em);

        assert(method_exists($di->getConnection(), 'getEm'));
        self::assertInstanceOf(CustomEntityManager::class, $di->getConnection()->getEm());
        self::assertSame($em, $di->getConnection()->getEm());
    }

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

        $config = [
            'storage' => ['id' => 'mock_storage_service'],
        ];

        $mockStorage = $this->createMock(MetadataStorage::class);
        $container->set('mock_storage_service', $mockStorage);

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

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

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

        $container->compile();

        $di = $container->get('doctrine.migrations.di');
        self::assertInstanceOf(DependencyFactory::class, $di);
        self::assertSame($mockStorage, $di->getMetadataStorage());
    }

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


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Doctrine\Bundle\MigrationsBundle\Tests\DependencyInjection;
6
7			use Doctrine\Bundle\MigrationsBundle\DependencyInjection\DoctrineMigrationsExtension;
8			use Doctrine\Bundle\MigrationsBundle\Tests\Fixtures\CustomEntityManager;
9			use Doctrine\DBAL\Connection;
10			use Doctrine\Migrations\Configuration\Configuration;
11			use Doctrine\Migrations\DependencyFactory;
12			use Doctrine\Migrations\Metadata\Storage\MetadataStorage;
13			use Doctrine\Migrations\Metadata\Storage\TableMetadataStorageConfiguration;
14			use InvalidArgumentException;
15			use PHPUnit\Framework\TestCase;
16			use Symfony\Component\DependencyInjection\ContainerBuilder;
17			use Symfony\Component\DependencyInjection\Definition;
18			use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
19			use function assert;
20			use function method_exists;
21			use function sys_get_temp_dir;
22
23			class DoctrineMigrationsExtensionTest extends TestCase
24			{
25			public function testFullConfig() : void
26			{
27			$container = $this->getContainer();
28			$extension = new DoctrineMigrationsExtension();
29
30			$config = [
31			'name' => 'Doctrine Sandbox Migrations',
32			'storage' => [
33			'table_storage' => [
34			'table_name' => 'doctrine_migration_versions_test',
35			'version_column_name' => 'doctrine_migration_column_test',
36			'version_column_length' => 2000,
37			'executed_at_column_name' => 'doctrine_migration_executed_at_column_test',
38			'execution_time_column_name' => 'doctrine_migration_execution_time_column_test',
39			],
40			],
41
42			'migrations_paths' => [
43			'DoctrineMigrationsTest' => 'a',
44			'DoctrineMigrationsTest2' => 'b',
45			],
46
47			'migrations' => ['Foo', 'Bar'],
48
49			'organize_migrations' => 'BY_YEAR_AND_MONTH',
50
51			'all_or_nothing' => true,
52			'check_database_platform' => true,
53			];
54
55			$extension->load(['doctrine_migrations' => $config], $container);
56
57			$container->getDefinition('doctrine.migrations.configuration')->setPublic(true);
58			$container->compile();
59
60			$config = $container->get('doctrine.migrations.configuration');
61
62			self::assertInstanceOf(Configuration::class, $config);
63			self::assertSame('Doctrine Sandbox Migrations', $config->getName());
64			self::assertSame([
65			'DoctrineMigrationsTest' => 'a',
66			'DoctrineMigrationsTest2' => 'b',
67
68			], $config->getMigrationDirectories());
69
70			self::assertSame(['Foo', 'Bar'], $config->getMigrationClasses());
71			self::assertTrue($config->isAllOrNothing());
72			self::assertTrue($config->isDatabasePlatformChecked());
73			self::assertTrue($config->areMigrationsOrganizedByYearAndMonth());
74
75			$storage = $config->getMetadataStorageConfiguration();
76			self::assertInstanceOf(TableMetadataStorageConfiguration::class, $storage);
77
78			self::assertSame('doctrine_migration_versions_test', $storage->getTableName());
79			self::assertSame('doctrine_migration_column_test', $storage->getVersionColumnName());
80			self::assertSame(2000, $storage->getVersionColumnLength());
81			self::assertSame('doctrine_migration_execution_time_column_test', $storage->getExecutionTimeColumnName());
82			self::assertSame('doctrine_migration_executed_at_column_test', $storage->getExecutedAtColumnName());
83			}
84
85			public function testCustomSorter() : void
86			{
87			$container = $this->getContainer();
88			$extension = new DoctrineMigrationsExtension();
89
90			$config = ['sorter' => 'my_sorter'];
91
92			$extension->load(['doctrine_migrations' => $config], $container);
93
94			$container->getDefinition('doctrine.migrations.di')->setPublic(true);
95
96			$conn = $this->createMock(Connection::class);
97			$container->set('doctrine.dbal.default_connection', $conn);
98
99			$sorter = new class(){
100			public function __invoke() : void
101			{
102			}
103			};
104			$container->set('my_sorter', $sorter);
105
106			$container->compile();
107
108			$di = $container->get('doctrine.migrations.di');
109			self::assertInstanceOf(DependencyFactory::class, $di);
110			self::assertSame($sorter, $di->getSorter());
111			}
112
113			public function testCustomConnection() : void
114			{
115			$container = $this->getContainer();
116			$extension = new DoctrineMigrationsExtension();
117
118			$config = ['connection' => 'custom'];
119
120			$extension->load(['doctrine_migrations' => $config], $container);
121
122			$container->getDefinition('doctrine.migrations.di')->setPublic(true);
123
124			$conn = $this->createMock(Connection::class);
125			$container->set('doctrine.dbal.custom_connection', $conn);
126
127			$container->compile();
128
129			$di = $container->get('doctrine.migrations.di');
130			self::assertInstanceOf(DependencyFactory::class, $di);
131			self::assertSame($conn, $di->getConnection());
132			}
133
134			public function testCustomEntityManager() : void
135			{
136			$container = $this->getContainer();
137			$extension = new DoctrineMigrationsExtension();
138
139			$config = ['em' => 'custom'];
140
141			$em = new Definition(CustomEntityManager::class);
142			$container->setDefinition('doctrine.orm.custom_entity_manager', $em);
143
144			$extension->load(['doctrine_migrations' => $config], $container);
145
146			$container->getDefinition('doctrine.migrations.di')->setPublic(true);
147
148			$container->compile();
149
150			$di = $container->get('doctrine.migrations.di');
151			self::assertInstanceOf(DependencyFactory::class, $di);
152
153			$em = $di->getEntityManager();
154			self::assertInstanceOf(CustomEntityManager::class, $em);
155
156			assert(method_exists($di->getConnection(), 'getEm'));
157			self::assertInstanceOf(CustomEntityManager::class, $di->getConnection()->getEm());
158			self::assertSame($em, $di->getConnection()->getEm());
159			}
160
161			public function testCustomMetadataStorage() : void
162			{
163			$container = $this->getContainer();
164			$extension = new DoctrineMigrationsExtension();
165
166			$config = [
167			'storage' => ['id' => 'mock_storage_service'],
168			];
169
170			$mockStorage = $this->createMock(MetadataStorage::class);
171			$container->set('mock_storage_service', $mockStorage);
172
173			$conn = $this->createMock(Connection::class);
174			$container->set('doctrine.dbal.default_connection', $conn);
175
176			$extension->load(['doctrine_migrations' => $config], $container);
177
178			$container->getDefinition('doctrine.migrations.di')->setPublic(true);
179
180			$container->compile();
181
182			$di = $container->get('doctrine.migrations.di');
183			self::assertInstanceOf(DependencyFactory::class, $di);
184			self::assertSame($mockStorage, $di->getMetadataStorage());
185			}
186
187			public function testCanNotSpecifyBothEmAndConnection() : void
188			{
189			$this->expectExceptionMessage('You can not specify both "connection" and "em" in the DoctrineMigrationsBundle configurations');
190			$this->expectException(InvalidArgumentException::class);
191			$container = $this->getContainer();
192			$extension = new DoctrineMigrationsExtension();
193
194			$config = [
195			'em' => 'custom',
196			'connection' => 'custom',
197			];
198
199			$extension->load(['doctrine_migrations' => $config], $container);
200
201			$container->getDefinition('doctrine.migrations.di')->setPublic(true);
202
203			$container->compile();
204			}
205
206			private function getContainer() : ContainerBuilder
207			{
208			return new ContainerBuilder(new ParameterBag([
209			'kernel.debug' => false,
210			'kernel.bundles' => [],
211			'kernel.cache_dir' => sys_get_temp_dir(),
212			'kernel.environment' => 'test',
213			'kernel.root_dir' => __DIR__ . '/../../', // src dir
214			]));
215			}
216			}
217

doctrine / DoctrineMigrationsBundle

Pull Request — master (#278)

php$0 ➔ testCustomConnection() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like