DoctrineMigrationsExtensionTest::testNoConfigsAreNeeded() - Code Metrics - Inspection of "Merge pull request #316 from goetas/no-required-ns" - doctrine/DoctrineMigrationsBundle - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — master ( 521d07...1946f9 )

by Asmir

created 2020-04-24 06:21 UTC

testNoConfigsAreNeeded() A

↳ Parent: DoctrineMigrationsExtensionTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	12
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	7
c	1
b	0
f	0
dl	0
loc	12
rs	10
cc	1
nc	1
nop	0

<?php

declare(strict_types=1);

namespace Doctrine\Bundle\MigrationsBundle\Tests\DependencyInjection;

use Doctrine\Bundle\MigrationsBundle\DependencyInjection\DoctrineMigrationsExtension;
use Doctrine\Bundle\MigrationsBundle\DoctrineMigrationsBundle;
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 Doctrine\Migrations\Version\Comparator;
use Doctrine\Migrations\Version\Version;
use Doctrine\ORM\EntityManager;
use InvalidArgumentException;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
use Symfony\Component\Config\FileLocator;
use Symfony\Component\DependencyInjection\Alias;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
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 testXmlConfigs() : void
    {
        $container = $this->getContainerBuilder();

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

        $container->registerExtension(new DoctrineMigrationsExtension());

        $container->setAlias('doctrine.migrations.configuration.test', new Alias('doctrine.migrations.configuration', true));

        $loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Fixtures'));
        $loader->load('conf.xml');

        $container->compile();

        $config = $container->get('doctrine.migrations.configuration.test');
        $this->assertConfigs($config);
    }

    public function testFullConfig() : void
    {
        $config = [
            '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,
        ];
        $container = $this->getContainer($config);

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

        $container->compile();

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

        $this->assertConfigs($config);
    }

    public function testNoConfigsAreNeeded() : void
    {
        $container = $this->getContainer([]);

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

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

        self::assertInstanceOf(Configuration::class, $config);
        self::assertSame([], $config->getMigrationDirectories());
    }

    private function assertConfigs(?object $config) : void
    {
        self::assertInstanceOf(Configuration::class, $config);
        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
    {
        $config    = [
            'migrations_paths' => ['DoctrineMigrationsTest' => 'a'],
            'services' => [Comparator::class => 'my_sorter'],
        ];
        $container = $this->getContainer($config);

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

        $sorter = new class() implements Comparator{
            public function compare(Version $a, Version $b) : int
            {
            }
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        };
        $container->set('my_sorter', $sorter);

        $container->compile();

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

    public function testCustomConnection() : void
    {
        $config    = [
            'migrations_paths' => ['DoctrineMigrationsTest' => 'a'],
            'connection' => 'custom',
        ];
        $container = $this->getContainer($config);

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

        $container->compile();

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


    public function testPrefersEntityManagerOverConnection() : void
    {
        $config    = [
            'migrations_paths' => ['DoctrineMigrationsTest' => 'a'],
        ];
        $container = $this->getContainer($config);

        $em = $this->createMock(EntityManager::class);
        $container->set('doctrine.orm.default_entity_manager', $em);

        $container->compile();

        $di = $container->get('doctrine.migrations.dependency_factory');

        self::assertInstanceOf(DependencyFactory::class, $di);
        self::assertSame($em, $di->getEntityManager());
    }

    public function testCustomEntityManager() : void
    {
        $config    = [
            'em' => 'custom',
            'migrations_paths' => ['DoctrineMigrationsTest' => 'a'],
        ];
        $container = $this->getContainer($config);

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

        $container->compile();

        $di = $container->get('doctrine.migrations.dependency_factory');
        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
    {
        $config = [
            'migrations_paths' => ['DoctrineMigrationsTest' => 'a'],
            'services' => [MetadataStorage::class => 'mock_storage_service'],
        ];

        $container = $this->getContainer($config);

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

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

        $container->compile();

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

    public function testInvalidService() : void
    {
        $this->expectException(InvalidConfigurationException::class);
        $this->expectExceptionMessage('Invalid configuration for path "doctrine_migrations.services": Valid services for the DoctrineMigrationsBundle must be in the "Doctrine\Migrations" namespace.');

        $config    = [
            'migrations_paths' => ['DoctrineMigrationsTest' => 'a'],
            'services' => ['foo' => 'mock_storage_service'],
        ];
        $container = $this->getContainer($config);

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

        $container->compile();
    }

    public function testCanNotSpecifyBothEmAndConnection() : void
    {
        $this->expectExceptionMessage('You cannot specify both "connection" and "em" in the DoctrineMigrationsBundle configurations');
        $this->expectException(InvalidArgumentException::class);

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

        $container = $this->getContainer($config);

        $container->compile();
    }

    /**
     * @param mixed[] $config
     */
    private function getContainer(array $config) : ContainerBuilder
    {
        $container = $this->getContainerBuilder();

        $bundle = new DoctrineMigrationsBundle();
        $bundle->build($container);

        $extension = new DoctrineMigrationsExtension();

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

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

        return $container;
    }

    private function getContainerBuilder() : ContainerBuilder
    {
        return new ContainerBuilder(new ParameterBag([
            'kernel.debug' => false,
            'kernel.bundles' => [],
            'kernel.cache_dir' => sys_get_temp_dir(),
            'kernel.environment' => 'test',
            'kernel.project_dir' => __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\DoctrineMigrationsBundle;
9			use Doctrine\Bundle\MigrationsBundle\Tests\Fixtures\CustomEntityManager;
10			use Doctrine\DBAL\Connection;
11			use Doctrine\Migrations\Configuration\Configuration;
12			use Doctrine\Migrations\DependencyFactory;
13			use Doctrine\Migrations\Metadata\Storage\MetadataStorage;
14			use Doctrine\Migrations\Metadata\Storage\TableMetadataStorageConfiguration;
15			use Doctrine\Migrations\Version\Comparator;
16			use Doctrine\Migrations\Version\Version;
17			use Doctrine\ORM\EntityManager;
18			use InvalidArgumentException;
19			use PHPUnit\Framework\TestCase;
20			use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
21			use Symfony\Component\Config\FileLocator;
22			use Symfony\Component\DependencyInjection\Alias;
23			use Symfony\Component\DependencyInjection\ContainerBuilder;
24			use Symfony\Component\DependencyInjection\Definition;
25			use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
26			use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
27			use function assert;
28			use function method_exists;
29			use function sys_get_temp_dir;
30
31			class DoctrineMigrationsExtensionTest extends TestCase
32			{
33			public function testXmlConfigs() : void
34			{
35			$container = $this->getContainerBuilder();
36
37			$conn = $this->createMock(Connection::class);
38			$container->set('doctrine.dbal.default_connection', $conn);
39
40			$container->registerExtension(new DoctrineMigrationsExtension());
41
42			$container->setAlias('doctrine.migrations.configuration.test', new Alias('doctrine.migrations.configuration', true));
43
44			$loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Fixtures'));
45			$loader->load('conf.xml');
46
47			$container->compile();
48
49			$config = $container->get('doctrine.migrations.configuration.test');
50			$this->assertConfigs($config);
51			}
52
53			public function testFullConfig() : void
54			{
55			$config = [
56			'storage' => [
57			'table_storage' => [
58			'table_name' => 'doctrine_migration_versions_test',
59			'version_column_name' => 'doctrine_migration_column_test',
60			'version_column_length' => 2000,
61			'executed_at_column_name' => 'doctrine_migration_executed_at_column_test',
62			'execution_time_column_name' => 'doctrine_migration_execution_time_column_test',
63			],
64			],
65
66			'migrations_paths' => [
67			'DoctrineMigrationsTest' => 'a',
68			'DoctrineMigrationsTest2' => 'b',
69			],
70
71			'migrations' => ['Foo', 'Bar'],
72
73			'organize_migrations' => 'BY_YEAR_AND_MONTH',
74
75			'all_or_nothing' => true,
76			'check_database_platform' => true,
77			];
78			$container = $this->getContainer($config);
79
80			$conn = $this->createMock(Connection::class);
81			$container->set('doctrine.dbal.default_connection', $conn);
82
83			$container->compile();
84
85			$config = $container->get('doctrine.migrations.configuration');
86
87			$this->assertConfigs($config);
88			}
89
90			public function testNoConfigsAreNeeded() : void
91			{
92			$container = $this->getContainer([]);
93
94			$conn = $this->createMock(Connection::class);
95			$container->set('doctrine.dbal.default_connection', $conn);
96			$container->compile();
97
98			$config = $container->get('doctrine.migrations.configuration');
99
100			self::assertInstanceOf(Configuration::class, $config);
101			self::assertSame([], $config->getMigrationDirectories());
102			}
103
104			private function assertConfigs(?object $config) : void
105			{
106			self::assertInstanceOf(Configuration::class, $config);
107			self::assertSame([
108			'DoctrineMigrationsTest' => 'a',
109			'DoctrineMigrationsTest2' => 'b',
110
111			], $config->getMigrationDirectories());
112
113			self::assertSame(['Foo', 'Bar'], $config->getMigrationClasses());
114			self::assertTrue($config->isAllOrNothing());
115			self::assertTrue($config->isDatabasePlatformChecked());
116			self::assertTrue($config->areMigrationsOrganizedByYearAndMonth());
117
118			$storage = $config->getMetadataStorageConfiguration();
119			self::assertInstanceOf(TableMetadataStorageConfiguration::class, $storage);
120
121			self::assertSame('doctrine_migration_versions_test', $storage->getTableName());
122			self::assertSame('doctrine_migration_column_test', $storage->getVersionColumnName());
123			self::assertSame(2000, $storage->getVersionColumnLength());
124			self::assertSame('doctrine_migration_execution_time_column_test', $storage->getExecutionTimeColumnName());
125			self::assertSame('doctrine_migration_executed_at_column_test', $storage->getExecutedAtColumnName());
126			}
127
128			public function testCustomSorter() : void
129			{
130			$config = [
131			'migrations_paths' => ['DoctrineMigrationsTest' => 'a'],
132			'services' => [Comparator::class => 'my_sorter'],
133			];
134			$container = $this->getContainer($config);
135
136			$conn = $this->createMock(Connection::class);
137			$container->set('doctrine.dbal.default_connection', $conn);
138
139			$sorter = new class() implements Comparator{
140			public function compare(Version $a, Version $b) : int
141			{
142			}
			0 ignored issues – show Bug Best Practice introduced 2020-01-20 05:58 UTC by Report Bug Copy Issue Report In this branch, the function will implicitly return `null` which is incompatible with the type-hinted return `integer`. Consider adding a return statement or allowing `null` as return value. For hinted functions/methods where all return statements with the correct type are only reachable via conditions, ?null? gets implicitly returned which may be incompatible with the hinted type. Let?s take a look at an example: interface ReturnsInt { public function returnsIntHinted(): int; } class MyClass implements ReturnsInt { public function returnsIntHinted(): int { if (foo()) { return 123; } // here: null is implicitly returned } } Loading history...
143			};
144			$container->set('my_sorter', $sorter);
145
146			$container->compile();
147
148			$di = $container->get('doctrine.migrations.dependency_factory');
149			self::assertInstanceOf(DependencyFactory::class, $di);
150			self::assertSame($sorter, $di->getVersionComparator());
151			}
152
153			public function testCustomConnection() : void
154			{
155			$config = [
156			'migrations_paths' => ['DoctrineMigrationsTest' => 'a'],
157			'connection' => 'custom',
158			];
159			$container = $this->getContainer($config);
160
161			$conn = $this->createMock(Connection::class);
162			$container->set('doctrine.dbal.custom_connection', $conn);
163
164			$container->compile();
165
166			$di = $container->get('doctrine.migrations.dependency_factory');
167			self::assertInstanceOf(DependencyFactory::class, $di);
168			self::assertSame($conn, $di->getConnection());
169			}
170
171
172			public function testPrefersEntityManagerOverConnection() : void
173			{
174			$config = [
175			'migrations_paths' => ['DoctrineMigrationsTest' => 'a'],
176			];
177			$container = $this->getContainer($config);
178
179			$em = $this->createMock(EntityManager::class);
180			$container->set('doctrine.orm.default_entity_manager', $em);
181
182			$container->compile();
183
184			$di = $container->get('doctrine.migrations.dependency_factory');
185
186			self::assertInstanceOf(DependencyFactory::class, $di);
187			self::assertSame($em, $di->getEntityManager());
188			}
189
190			public function testCustomEntityManager() : void
191			{
192			$config = [
193			'em' => 'custom',
194			'migrations_paths' => ['DoctrineMigrationsTest' => 'a'],
195			];
196			$container = $this->getContainer($config);
197
198			$em = new Definition(CustomEntityManager::class);
199			$container->setDefinition('doctrine.orm.custom_entity_manager', $em);
200
201			$container->compile();
202
203			$di = $container->get('doctrine.migrations.dependency_factory');
204			self::assertInstanceOf(DependencyFactory::class, $di);
205
206			$em = $di->getEntityManager();
207			self::assertInstanceOf(CustomEntityManager::class, $em);
208
209			assert(method_exists($di->getConnection(), 'getEm'));
210			self::assertInstanceOf(CustomEntityManager::class, $di->getConnection()->getEm());
211			self::assertSame($em, $di->getConnection()->getEm());
212			}
213
214			public function testCustomMetadataStorage() : void
215			{
216			$config = [
217			'migrations_paths' => ['DoctrineMigrationsTest' => 'a'],
218			'services' => [MetadataStorage::class => 'mock_storage_service'],
219			];
220
221			$container = $this->getContainer($config);
222
223			$mockStorage = $this->createMock(MetadataStorage::class);
224			$container->set('mock_storage_service', $mockStorage);
225
226			$conn = $this->createMock(Connection::class);
227			$container->set('doctrine.dbal.default_connection', $conn);
228
229			$container->compile();
230
231			$di = $container->get('doctrine.migrations.dependency_factory');
232			self::assertInstanceOf(DependencyFactory::class, $di);
233			self::assertSame($mockStorage, $di->getMetadataStorage());
234			}
235
236			public function testInvalidService() : void
237			{
238			$this->expectException(InvalidConfigurationException::class);
239			$this->expectExceptionMessage('Invalid configuration for path "doctrine_migrations.services": Valid services for the DoctrineMigrationsBundle must be in the "Doctrine\Migrations" namespace.');
240
241			$config = [
242			'migrations_paths' => ['DoctrineMigrationsTest' => 'a'],
243			'services' => ['foo' => 'mock_storage_service'],
244			];
245			$container = $this->getContainer($config);
246
247			$conn = $this->createMock(Connection::class);
248			$container->set('doctrine.dbal.default_connection', $conn);
249
250			$container->compile();
251			}
252
253			public function testCanNotSpecifyBothEmAndConnection() : void
254			{
255			$this->expectExceptionMessage('You cannot specify both "connection" and "em" in the DoctrineMigrationsBundle configurations');
256			$this->expectException(InvalidArgumentException::class);
257
258			$config = [
259			'migrations_paths' => ['DoctrineMigrationsTest' => 'a'],
260			'em' => 'custom',
261			'connection' => 'custom',
262			];
263
264			$container = $this->getContainer($config);
265
266			$container->compile();
267			}
268
269			/**
270			* @param mixed[] $config
271			*/
272			private function getContainer(array $config) : ContainerBuilder
273			{
274			$container = $this->getContainerBuilder();
275
276			$bundle = new DoctrineMigrationsBundle();
277			$bundle->build($container);
278
279			$extension = new DoctrineMigrationsExtension();
280
281			$extension->load(['doctrine_migrations' => $config], $container);
282
283			$container->getDefinition('doctrine.migrations.dependency_factory')->setPublic(true);
284			$container->getDefinition('doctrine.migrations.configuration')->setPublic(true);
285
286			return $container;
287			}
288
289			private function getContainerBuilder() : ContainerBuilder
290			{
291			return new ContainerBuilder(new ParameterBag([
292			'kernel.debug' => false,
293			'kernel.bundles' => [],
294			'kernel.cache_dir' => sys_get_temp_dir(),
295			'kernel.environment' => 'test',
296			'kernel.project_dir' => __DIR__ . '/../',
297			]));
298			}
299			}
300

doctrine / DoctrineMigrationsBundle

Push — master ( 521d07...1946f9 )

testNoConfigsAreNeeded() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like