ConfigurationFactoryTest::testCanInstantiateWithSecondLevelCacheConfig() - Code Metrics - doctrine/DoctrineORMModule - Measure and Improve Code Quality continuously with Scrutinizer

testCanInstantiateWithSecondLevelCacheConfig() B
last analyzed 2020-03-08 20:17 UTC

↳ Parent: ConfigurationFactoryTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	58
rs	8.9163
c	0
b	0
f	0
cc	1
nc	1
nop	0

How to fix Long Method

<?php

namespace DoctrineORMModuleTest\Service;

use PHPUnit\Framework\TestCase;
use DoctrineORMModule\Service\ConfigurationFactory;
use Doctrine\Common\Cache\ArrayCache;
use Laminas\ServiceManager\ServiceManager;

class ConfigurationFactoryTest extends TestCase
{
    /**
     * @var ServiceManager
     */
    protected $serviceManager;
    /**
     * @var ConfigurationFactory
     */
    protected $factory;

    /**
     * {@inheritDoc}
     */
    public function setUp() : void
    {
        $this->serviceManager = new ServiceManager();
        $this->factory = new ConfigurationFactory('test_default');
        $this->serviceManager->setService('doctrine.cache.array', new ArrayCache());
        $this->serviceManager->setService(
            'doctrine.driver.orm_default',
            $this->createMock(\Doctrine\Common\Persistence\Mapping\Driver\MappingDriver::class)
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        );
    }

    public function testWillInstantiateConfigWithoutNamingStrategySetting()
    {
        $config = [
            'doctrine' => [
                'configuration' => [
                    'test_default' => [],
                ],
            ],
        ];
        $this->serviceManager->setService('config', $config);
        $ormConfig = $this->factory->createService($this->serviceManager);
        $this->assertInstanceOf(\Doctrine\ORM\Mapping\NamingStrategy::class, $ormConfig->getNamingStrategy());

    }

    public function testWillInstantiateConfigWithNamingStrategyObject()
    {
        $namingStrategy = $this->createMock(\Doctrine\ORM\Mapping\NamingStrategy::class);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();

        $config = [
            'doctrine' => [
                'configuration' => [
                    'test_default' => [
                        'naming_strategy' => $namingStrategy,
                    ],
                ],
            ],
        ];
        $this->serviceManager->setService('config', $config);
        $factory = new ConfigurationFactory('test_default');
        $ormConfig = $factory->createService($this->serviceManager);
        $this->assertSame($namingStrategy, $ormConfig->getNamingStrategy());

    }

    public function testWillInstantiateConfigWithNamingStrategyReference()
    {
        $namingStrategy = $this->createMock(\Doctrine\ORM\Mapping\NamingStrategy::class);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
        $config = [
            'doctrine' => [
                'configuration' => [
                    'test_default' => [
                        'naming_strategy' => 'test_naming_strategy',
                    ],
                ],
            ],
        ];
        $this->serviceManager->setService('config', $config);
        $this->serviceManager->setService('test_naming_strategy', $namingStrategy);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $ormConfig = $this->factory->createService($this->serviceManager);
        $this->assertSame($namingStrategy, $ormConfig->getNamingStrategy());

    }

    public function testWillNotInstantiateConfigWithInvalidNamingStrategyReference()
    {
        $config = [
            'doctrine' => [
                'configuration' => [
                    'test_default' => [
                        'naming_strategy' => 'test_naming_strategy',
                    ],
                ],
            ],
        ];
        $this->serviceManager->setService('config', $config);
        $this->expectException(\Laminas\ServiceManager\Exception\InvalidArgumentException::class);

        $this->factory->createService($this->serviceManager);
    }

    public function testWillInstantiateConfigWithQuoteStrategyObject()
    {
        $quoteStrategy = $this->createMock(\Doctrine\ORM\Mapping\QuoteStrategy::class);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();

        $config = [
            'doctrine' => [
                'configuration' => [
                    'test_default' => [
                        'quote_strategy' => $quoteStrategy,
                    ],
                ],
            ],
        ];
        $this->serviceManager->setService('config', $config);
        $factory = new ConfigurationFactory('test_default');
        $ormConfig = $factory->createService($this->serviceManager);
        $this->assertSame($quoteStrategy, $ormConfig->getQuoteStrategy());

    }

    public function testWillInstantiateConfigWithQuoteStrategyReference()
    {
        $quoteStrategy = $this->createMock(\Doctrine\ORM\Mapping\QuoteStrategy::class);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
        $config = [
            'doctrine' => [
                'configuration' => [
                    'test_default' => [
                        'quote_strategy' => 'test_quote_strategy',
                    ],
                ],
            ],
        ];
        $this->serviceManager->setService('config', $config);
        $this->serviceManager->setService('test_quote_strategy', $quoteStrategy);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $ormConfig = $this->factory->createService($this->serviceManager);
        $this->assertSame($quoteStrategy, $ormConfig->getQuoteStrategy());

    }

    public function testWillNotInstantiateConfigWithInvalidQuoteStrategyReference()
    {
        $config = [
            'doctrine' => [
                'configuration' => [
                    'test_default' => [
                        'quote_strategy' => 'test_quote_strategy',
                    ],
                ],
            ],
        ];
        $this->serviceManager->setService('config', $config);
        $this->expectException(\Laminas\ServiceManager\Exception\InvalidArgumentException::class);

        $this->factory->createService($this->serviceManager);
    }

    public function testWillInstantiateConfigWithHydrationCacheSetting()
    {
        $config = [
            'doctrine' => [
                'configuration' => [
                    'test_default' => [
                        'hydration_cache' => 'array',
                    ],
                ],
            ],
        ];
        $this->serviceManager->setService('config', $config);
        $factory = new ConfigurationFactory('test_default');
        $ormConfig = $factory->createService($this->serviceManager);
        $this->assertInstanceOf(\Doctrine\Common\Cache\ArrayCache::class, $ormConfig->getHydrationCacheImpl());

    }

    public function testCanSetDefaultRepositoryClass()
    {
        $config = [
            'doctrine' => [
                'configuration' => [
                    'test_default' => [

                        'hydration_cache' => 'array',
                        'default_repository_class_name' => \DoctrineORMModuleTest\Assets\RepositoryClass::class,
                    ],
                ],
            ],
        ];
        $this->serviceManager->setService('config', $config);

        $factory = new ConfigurationFactory('test_default');
        $ormConfig = $factory->createService($this->serviceManager);
        $this->assertInstanceOf(\Doctrine\Common\Cache\ArrayCache::class, $ormConfig->getHydrationCacheImpl());

    }

    public function testAcceptsMetadataFactory()
    {
        $config = [
            'doctrine' => [
                'configuration' => [
                    'test_default' => [
                        'classMetadataFactoryName' => 'Factory',
                    ],
                ],
            ],
        ];
        $this->serviceManager->setService('config', $config);
        $factory = new ConfigurationFactory('test_default');
        $ormConfig = $factory->createService($this->serviceManager);
        $this->assertEquals('Factory', $ormConfig->getClassMetadataFactoryName());

    }

    public function testDefaultMetadatFactory()
    {
        $config = [
            'doctrine' => [
                'configuration' => [
                    'test_default' => [
                    ],
                ],
            ],
        ];
        $this->serviceManager->setService('config', $config);
        $factory = new ConfigurationFactory('test_default');
        $ormConfig = $factory->createService($this->serviceManager);
        $this->assertEquals(

            \Doctrine\ORM\Mapping\ClassMetadataFactory::class,
            $ormConfig->getClassMetadataFactoryName()
        );
    }

    public function testWillInstantiateConfigWithoutEntityListenerResolverSetting()
    {
        $config = [
            'doctrine' => [
                'configuration' => [
                    'test_default' => [],
                ],
            ],
        ];

        $this->serviceManager->setService('config', $config);

        $ormConfig = $this->factory->createService($this->serviceManager);

        $this->assertInstanceOf(

            \Doctrine\ORM\Mapping\EntityListenerResolver::class,
            $ormConfig->getEntityListenerResolver()
        );
    }

    public function testWillInstantiateConfigWithEntityListenerResolverObject()
    {
        $entityListenerResolver = $this->createMock(\Doctrine\ORM\Mapping\EntityListenerResolver::class);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();

        $config = [
            'doctrine' => [
                'configuration' => [
                    'test_default' => [
                        'entity_listener_resolver' => $entityListenerResolver,
                    ],
                ],
            ],
        ];

        $this->serviceManager->setService('config', $config);

        $ormConfig = $this->factory->createService($this->serviceManager);

        $this->assertSame($entityListenerResolver, $ormConfig->getEntityListenerResolver());

    }

    public function testWillInstantiateConfigWithEntityListenerResolverReference()
    {
        $entityListenerResolver = $this->createMock(\Doctrine\ORM\Mapping\EntityListenerResolver::class);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();

        $config = [
            'doctrine' => [
                'configuration' => [
                    'test_default' => [
                        'entity_listener_resolver' => 'test_entity_listener_resolver',
                    ],
                ],
            ],
        ];

        $this->serviceManager->setService('config', $config);
        $this->serviceManager->setService('test_entity_listener_resolver', $entityListenerResolver);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $ormConfig = $this->factory->createService($this->serviceManager);

        $this->assertSame($entityListenerResolver, $ormConfig->getEntityListenerResolver());

    }

    public function testDoNotCreateSecondLevelCacheByDefault()
    {
        $config = [
            'doctrine' => [
                'configuration' => [
                    'test_default' => [],
                ],
            ],
        ];

        $this->serviceManager->setService('config', $config);

        $ormConfig = $this->factory->createService($this->serviceManager);

        $this->assertNull($ormConfig->getSecondLevelCacheConfiguration());

    }

    public function testCanInstantiateWithSecondLevelCacheConfig()
    {
        $config = [
            'doctrine' => [
                'configuration' => [
                    'test_default' => [
                        'result_cache' => 'array',

                        'second_level_cache' => [
                            'enabled'                    => true,
                            'default_lifetime'           => 200,
                            'default_lock_lifetime'      => 500,
                            'file_lock_region_directory' => 'my_dir',

                            'regions' => [
                                'my_first_region' => [
                                    'lifetime'      => 800,
                                    'lock_lifetime' => 1000,
                                ],

                                'my_second_region' => [
                                    'lifetime'      => 10,
                                    'lock_lifetime' => 20,
                                ],
                            ],
                        ],
                    ],
                ],
            ],
        ];

        $this->serviceManager->setService('config', $config);

        $ormConfig        = $this->factory->createService($this->serviceManager);
        $secondLevelCache = $ormConfig->getSecondLevelCacheConfiguration();

        $this->assertInstanceOf(\Doctrine\ORM\Cache\CacheConfiguration::class, $secondLevelCache);


        $cacheFactory = $secondLevelCache->getCacheFactory();
        $this->assertInstanceOf(\Doctrine\ORM\Cache\DefaultCacheFactory::class, $cacheFactory);

        $this->assertEquals('my_dir', $cacheFactory->getFileLockRegionDirectory());


        $regionsConfiguration = $secondLevelCache->getRegionsConfiguration();
        $this->assertEquals(200, $regionsConfiguration->getDefaultLifetime());

        $this->assertEquals(500, $regionsConfiguration->getDefaultLockLifetime());


        $this->assertEquals(800, $regionsConfiguration->getLifetime('my_first_region'));

        $this->assertEquals(10, $regionsConfiguration->getLifetime('my_second_region'));


        $this->assertEquals(1000, $regionsConfiguration->getLockLifetime('my_first_region'));

        $this->assertEquals(20, $regionsConfiguration->getLockLifetime('my_second_region'));


        // Doctrine does not allow to retrieve the cache adapter from cache factory, so we are forced to use
        // reflection here
        $reflProperty = new \ReflectionProperty($cacheFactory, 'cache');
        $reflProperty->setAccessible(true);
        $this->assertInstanceOf(\Doctrine\Common\Cache\ArrayCache::class, $reflProperty->getValue($cacheFactory));

    }
}


1			<?php
2
3			namespace DoctrineORMModuleTest\Service;
4
5			use PHPUnit\Framework\TestCase;
6			use DoctrineORMModule\Service\ConfigurationFactory;
7			use Doctrine\Common\Cache\ArrayCache;
8			use Laminas\ServiceManager\ServiceManager;
9
10			class ConfigurationFactoryTest extends TestCase
11			{
12			/**
13			* @var ServiceManager
14			*/
15			protected $serviceManager;
16			/**
17			* @var ConfigurationFactory
18			*/
19			protected $factory;
20
21			/**
22			* {@inheritDoc}
23			*/
24			public function setUp() : void
25			{
26			$this->serviceManager = new ServiceManager();
27			$this->factory = new ConfigurationFactory('test_default');
28			$this->serviceManager->setService('doctrine.cache.array', new ArrayCache());
29			$this->serviceManager->setService(
30			'doctrine.driver.orm_default',
31			$this->createMock(\Doctrine\Common\Persistence\Mapping\Driver\MappingDriver::class)
			0 ignored issues – show Documentation introduced 2020-02-17 18:45 UTC by Report Bug Copy Issue Report `$this->createMock(\Doctr...r\MappingDriver::class)` is of type `null`, but the function expects a `array\|object`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
32			);
33			}
34
35			public function testWillInstantiateConfigWithoutNamingStrategySetting()
36			{
37			$config = [
38			'doctrine' => [
39			'configuration' => [

doctrine / DoctrineORMModule

testCanInstantiateWithSecondLevelCacheConfig() B last analyzed 2020-03-08 20:17 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

testCanInstantiateWithSecondLevelCacheConfig() B
last analyzed 2020-03-08 20:17 UTC