anonymous//Tests/DependencyInjection/DoctrineMigrationsExtensionTest.php$0 - 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-20 09:12 UTC

ensionTest.php$0 A

↳ Parent: DoctrineMigrationsExtensionTest.php$0 ➔ testCustomSorter()

Complexity

Total Complexity

Size/Duplication

Total Lines	3
Duplicated Lines	0 %

Importance

Changes

Metric	Value
wmc	1
c	0
b	0
f	0
dl	0
loc	3
rs	10

<?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,
        ];

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

        $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			$conn = $this->createMock(Connection::class);
56			$container->set('doctrine.dbal.default_connection', $conn);
57
58			$extension->load(['doctrine_migrations' => $config], $container);
59
60			$container->getDefinition('doctrine.migrations.configuration')->setPublic(true);
61			$container->compile();
62
63			$config = $container->get('doctrine.migrations.configuration');
64
65			self::assertInstanceOf(Configuration::class, $config);
66			self::assertSame('Doctrine Sandbox Migrations', $config->getName());
67			self::assertSame([
68			'DoctrineMigrationsTest' => 'a',
69			'DoctrineMigrationsTest2' => 'b',
70
71			], $config->getMigrationDirectories());
72
73			self::assertSame(['Foo', 'Bar'], $config->getMigrationClasses());
74			self::assertTrue($config->isAllOrNothing());
75			self::assertTrue($config->isDatabasePlatformChecked());
76			self::assertTrue($config->areMigrationsOrganizedByYearAndMonth());
77
78			$storage = $config->getMetadataStorageConfiguration();
79			self::assertInstanceOf(TableMetadataStorageConfiguration::class, $storage);
80
81			self::assertSame('doctrine_migration_versions_test', $storage->getTableName());
82			self::assertSame('doctrine_migration_column_test', $storage->getVersionColumnName());
83			self::assertSame(2000, $storage->getVersionColumnLength());
84			self::assertSame('doctrine_migration_execution_time_column_test', $storage->getExecutionTimeColumnName());
85			self::assertSame('doctrine_migration_executed_at_column_test', $storage->getExecutedAtColumnName());
86			}
87
88			public function testCustomSorter() : void
89			{
90			$container = $this->getContainer();
91			$extension = new DoctrineMigrationsExtension();
92
93			$config = ['sorter' => 'my_sorter'];
94
95			$extension->load(['doctrine_migrations' => $config], $container);
96
97			$container->getDefinition('doctrine.migrations.di')->setPublic(true);
98
99			$conn = $this->createMock(Connection::class);
100			$container->set('doctrine.dbal.default_connection', $conn);
101
102			$sorter = new class(){
103			public function __invoke() : void
104			{
105			}
106			};
107			$container->set('my_sorter', $sorter);
108
109			$container->compile();
110
111			$di = $container->get('doctrine.migrations.di');
112			self::assertInstanceOf(DependencyFactory::class, $di);
113			self::assertSame($sorter, $di->getSorter());
114			}
115
116			public function testCustomConnection() : void
117			{
118			$container = $this->getContainer();
119			$extension = new DoctrineMigrationsExtension();
120
121			$config = ['connection' => 'custom'];
122
123			$extension->load(['doctrine_migrations' => $config], $container);
124
125			$container->getDefinition('doctrine.migrations.di')->setPublic(true);
126
127			$conn = $this->createMock(Connection::class);
128			$container->set('doctrine.dbal.custom_connection', $conn);
129
130			$container->compile();
131
132			$di = $container->get('doctrine.migrations.di');
133			self::assertInstanceOf(DependencyFactory::class, $di);
134			self::assertSame($conn, $di->getConnection());
135			}
136
137			public function testCustomEntityManager() : void
138			{
139			$container = $this->getContainer();
140			$extension = new DoctrineMigrationsExtension();
141
142			$config = ['em' => 'custom'];
143
144			$em = new Definition(CustomEntityManager::class);
145			$container->setDefinition('doctrine.orm.custom_entity_manager', $em);
146
147			$extension->load(['doctrine_migrations' => $config], $container);
148
149			$container->getDefinition('doctrine.migrations.di')->setPublic(true);
150
151			$container->compile();
152
153			$di = $container->get('doctrine.migrations.di');
154			self::assertInstanceOf(DependencyFactory::class, $di);
155
156			$em = $di->getEntityManager();
157			self::assertInstanceOf(CustomEntityManager::class, $em);
158
159			assert(method_exists($di->getConnection(), 'getEm'));
160			self::assertInstanceOf(CustomEntityManager::class, $di->getConnection()->getEm());
161			self::assertSame($em, $di->getConnection()->getEm());
162			}
163
164			public function testCustomMetadataStorage() : void
165			{
166			$container = $this->getContainer();
167			$extension = new DoctrineMigrationsExtension();
168
169			$config = [
170			'storage' => ['id' => 'mock_storage_service'],
171			];
172
173			$mockStorage = $this->createMock(MetadataStorage::class);
174			$container->set('mock_storage_service', $mockStorage);
175
176			$conn = $this->createMock(Connection::class);
177			$container->set('doctrine.dbal.default_connection', $conn);
178
179			$extension->load(['doctrine_migrations' => $config], $container);
180
181			$container->getDefinition('doctrine.migrations.di')->setPublic(true);
182
183			$container->compile();
184
185			$di = $container->get('doctrine.migrations.di');
186			self::assertInstanceOf(DependencyFactory::class, $di);
187			self::assertSame($mockStorage, $di->getMetadataStorage());
188			}
189
190			public function testCanNotSpecifyBothEmAndConnection() : void
191			{
192			$this->expectExceptionMessage('You can not specify both "connection" and "em" in the DoctrineMigrationsBundle configurations');
193			$this->expectException(InvalidArgumentException::class);
194			$container = $this->getContainer();
195			$extension = new DoctrineMigrationsExtension();
196
197			$config = [
198			'em' => 'custom',
199			'connection' => 'custom',
200			];
201
202			$extension->load(['doctrine_migrations' => $config], $container);
203
204			$container->getDefinition('doctrine.migrations.di')->setPublic(true);
205
206			$container->compile();
207			}
208
209			private function getContainer() : ContainerBuilder
210			{
211			return new ContainerBuilder(new ParameterBag([
212			'kernel.debug' => false,
213			'kernel.bundles' => [],
214			'kernel.cache_dir' => sys_get_temp_dir(),
215			'kernel.environment' => 'test',
216			'kernel.root_dir' => __DIR__ . '/../../', // src dir
217			]));
218			}
219			}
220

doctrine / DoctrineMigrationsBundle

Pull Request — master (#278)

ensionTest.php$0 A

Complexity

Size/Duplication

Importance

Duplication Side-by-Side

Filter issues like