Issue7735Test::_getEntityManager() - Code Metrics - Inspection of "null values in cached entity fix for 2.6" - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — 2.6 (#7750)

unknown
created 2019-07-08 09:09 UTC
Issue7735Test::_getEntityManager() F

↳ Parent: Issue7735Test
Complexity

Conditions	15
Paths	864
Size

Total Lines	97
Code Lines	51
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	15
eloc	51
c	0
b	0
f	0
nc	864
nop	2
dl	0
loc	97
rs	1.9388
How to fix Long Method Complexity

<?php
namespace Doctrine\Tests\ORM\Functional\Ticket\Issue7735;

use Doctrine\Common\Cache\ArrayCache;
use Doctrine\Common\Persistence\Mapping\Driver\MappingDriver;
use Doctrine\DBAL\Driver\Connection;
use Doctrine\DBAL\Logging\DebugStack;
use Doctrine\ORM\Cache\CacheConfiguration;
use Doctrine\ORM\Cache\DefaultCacheFactory;
use Doctrine\ORM\Cache\Logging\StatisticsCacheLogger;
use Doctrine\ORM\Configuration;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Tools\DebugUnitOfWorkListener;
use Doctrine\Tests\EventListener\CacheMetadataListener;
use Doctrine\Tests\OrmFunctionalTestCase;

/**
 * Class Issue7735Test
 * @package Doctrine\Tests\ORM\Functional\Ticket\Issue7735
 */
class Issue7735Test extends OrmFunctionalTestCase
{
    protected const DEFAULT_CACHE_REGION_LIFE_TIME = 1;

    /**
     * The metadata cache shared between all functional tests.
     *
     * @var \Doctrine\Common\Cache\Cache|null
     */
    private static $_metadataCacheImpl = null;

    /**
     * The query cache shared between all functional tests.
     *
     * @var \Doctrine\Common\Cache\Cache|null
     */
    private static $_queryCacheImpl = null;

    /**
     * @var \Doctrine\ORM\Cache
     */
    protected $cache;

    public function setUp()
    {
        $this->enableSecondLevelCache();
        $this->useModelSet('issue7735');
        parent::setUp();
        $this->cache = $this->_em->getCache();


        $engine = new Engine('turbo');
        $power = new Power($engine);
        $car = new Car($engine);

        $this->_em->persist($car);
        $this->_em->persist($power);
        $this->_em->persist($engine);

        $this->_em->flush();
        $this->_em->clear();
        $this->evictRegions();

    }

    public function testFindByReturnsCachedEntity()
    {
        for ($i = 1000000; $i > 0; $i--) {
            $carRepository = $this->_em->getRepository(Car::class);
            $car = $carRepository->find(1);
            $engine = $car->getEngine();
            $power = $engine->getPower();

            $model = $engine->getModel();
            $this->assertNotEmpty($model);
            $this->_em->clear();
        }
    }

    private function evictRegions()
    {
        $this->cache->evictQueryRegions();
        $this->cache->evictEntityRegions();
        $this->cache->evictCollectionRegions();
    }

    /**
     * Gets an EntityManager for testing purposes.
     *
     * @return EntityManager
     *
     * @throws \Doctrine\ORM\ORMException
     */
    protected function _getEntityManager(
        Connection $connection = null,
        MappingDriver $mappingDriver = null
    )
    {
        // NOTE: Functional tests use their own shared metadata cache, because
        // the actual database platform used during execution has effect on some
        // metadata mapping behaviors (like the choice of the ID generation).
        if (is_null(self::$_metadataCacheImpl)) {
            if (isset($GLOBALS['DOCTRINE_CACHE_IMPL'])) {
                self::$_metadataCacheImpl = new $GLOBALS['DOCTRINE_CACHE_IMPL'];
            } else {
                self::$_metadataCacheImpl = new ArrayCache();
            }
        }

        if (is_null(self::$_queryCacheImpl)) {
            self::$_queryCacheImpl = new ArrayCache();
        }

        $this->_sqlLoggerStack = new DebugStack();
        $this->_sqlLoggerStack->enabled = false;

        //FIXME: two different configs! $conn and the created entity manager have
        // different configs.
        $config = new Configuration();
        $config->setMetadataCacheImpl(self::$_metadataCacheImpl);
        $config->setQueryCacheImpl(self::$_queryCacheImpl);
        $config->setProxyDir(__DIR__ . '/../../../../Proxies');
        $config->setProxyNamespace('Doctrine\Tests\Proxies');

        if (null !== $this->resultCacheImpl) {
            $config->setResultCacheImpl($this->resultCacheImpl);
        }

        $enableSecondLevelCache = getenv('ENABLE_SECOND_LEVEL_CACHE');

        if ($this->isSecondLevelCacheEnabled || $enableSecondLevelCache) {

            $cacheConfig = new CacheConfiguration();
            $cache = $this->getSharedSecondLevelCacheDriverImpl();

            $regionConfig = $cacheConfig->getRegionsConfiguration();
            $regionConfig->setDefaultLifetime(static::DEFAULT_CACHE_REGION_LIFE_TIME);
            $factory = new DefaultCacheFactory($regionConfig, $cache);

            $this->secondLevelCacheFactory = $factory;

            if ($this->isSecondLevelCacheLogEnabled) {
                $this->secondLevelCacheLogger = new StatisticsCacheLogger();
                $cacheConfig->setCacheLogger($this->secondLevelCacheLogger);
            }

            $cacheConfig->setCacheFactory($factory);
            $config->setSecondLevelCacheEnabled(true);
            $config->setSecondLevelCacheConfiguration($cacheConfig);

            $this->isSecondLevelCacheEnabled = true;
        }

        $config->setMetadataDriverImpl(
            $mappingDriver ?? $config->newDefaultAnnotationDriver(
                [
                    realpath(__DIR__ . '/../../../../Models/Cache'),
                    realpath(__DIR__ . '/../../../../Models/GeoNames')
                ],
                true
            )
        );

        $conn = $connection ?: static::$_sharedConn;
        $conn->getConfiguration()->setSQLLogger($this->_sqlLoggerStack);
               getConfiguration()->setSQLLogger($this->_sqlLoggerStack);

        // get rid of more global state
        $evm = $conn->getEventManager();
        $evm = $conn->getEventManager();
        foreach ($evm->getListeners() AS $event => $listeners) {
            foreach ($listeners AS $listener) {
                $evm->removeEventListener([$event], $listener);
            }
        }

        if ($enableSecondLevelCache) {
            $evm->addEventListener('loadClassMetadata', new CacheMetadataListener());
        }

        if (isset($GLOBALS['db_event_subscribers'])) {
            foreach (explode(",", $GLOBALS['db_event_subscribers']) AS $subscriberClass) {
                $subscriberInstance = new $subscriberClass();
                $evm->addEventSubscriber($subscriberInstance);
            }
        }

        if (isset($GLOBALS['debug_uow_listener'])) {
            $evm->addEventListener(['onFlush'], new DebugUnitOfWorkListener());
        }

        return EntityManager::create($conn, $config);
    }
}

doctrine / orm

Pull Request — 2.6 (#7750)

Issue7735Test::_getEntityManager() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
