Doctrine\Tests\ORM\Functional\Ticket\Issue7735Test

Complexity

Total Complexity

19

Size/Duplication

Total Lines	192
Duplicated Lines	0 %

Importance

Changes	2
Bugs	1	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	evictRegions()	0	5	1
A	setUp()	0	26	1
F	_getEntityManager()	0	97	15
A	testFindByReturnsCachedEntity()	0	11	2

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

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\Mapping\OneToOne;
use Doctrine\ORM\Tools\DebugUnitOfWorkListener;
use Doctrine\Tests\EventListener\CacheMetadataListener;
use Doctrine\Tests\OrmFunctionalTestCase;
use Doctrine\ORM\Mapping\Cache;
use Doctrine\ORM\Mapping\Column;
use Doctrine\ORM\Mapping\Entity;

This use statement conflicts with another class in this namespace, Doctrine\Tests\ORM\Functional\Ticket\Entity. Consider defining an alias.

use Doctrine\ORM\Mapping\GeneratedValue;
use Doctrine\ORM\Mapping\Id;
use Doctrine\ORM\Mapping\JoinColumn;
use Doctrine\ORM\Mapping\ManyToOne;
use Doctrine\ORM\Mapping\Table;

/**
 * Class Issue7735Test
 * @package Doctrine\Tests\ORM\Functional\Ticket\Issue7735
 */
class Issue7735Test extends OrmFunctionalTestCase
{
    /**
     * Depend on PC performance
     */
    private const ITERATION_COUNT_FOR_BUG_DETECTION = 1000000;

    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;

    /**
     * @throws \Doctrine\Common\Persistence\Mapping\MappingException
     * @throws \Doctrine\ORM\ORMException
     * @throws \Doctrine\ORM\OptimisticLockException
     * @throws \Doctrine\ORM\Tools\ToolsException
     */
    public function setUp()
    {
        $this->enableSecondLevelCache();
        parent::setUp();

        $this->_schemaTool->createSchema(
            [
                $this->_em->getClassMetadata(Car::class),
                $this->_em->getClassMetadata(Power::class),
                $this->_em->getClassMetadata(Engine::class),
            ]
        );

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

    }

    /**
     * @throws \Doctrine\Common\Persistence\Mapping\MappingException
     */
    public function testFindByReturnsCachedEntity()
    {
        for ($i = self::ITERATION_COUNT_FOR_BUG_DETECTION; $i > 0; $i--) {
            $carRepository = $this->_em->getRepository(Car::class);
            $car = $carRepository->find(1);
            /** @var Engine $engine */
            $engine = $car->getEngine();
            $power = $engine->getPower();

The assignment to $power is dead and can be removed.

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

The method getConfiguration() does not exist on Doctrine\DBAL\Driver\Connection. It seems like you code against a sub-type of Doctrine\DBAL\Driver\Connection such as Doctrine\DBAL\Connection.

The method getConfiguration() does not exist on null.

        // get rid of more global state
        $evm = $conn->getEventManager();

The method getEventManager() does not exist on Doctrine\DBAL\Driver\Connection. It seems like you code against a sub-type of Doctrine\DBAL\Driver\Connection such as Doctrine\DBAL\Connection.

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

/**
 * @Entity
 * @Table(name="car")
 * @Cache(usage="READ_ONLY", region="car")
 */
class Car
{
    /**
     * @Id
     * @Column(type="integer")
     * @GeneratedValue(strategy="IDENTITY")
     */
    private $id;

    /**
     * @var Engine
     * @Cache("READ_ONLY")
     * @ManyToOne(targetEntity="Engine")
     * @JoinColumn(name="engine", referencedColumnName="id", nullable=false)
     */
    protected $engine;

    /**
     * Car constructor.
     * @param Engine $engine
     * @param string $color
     */
    public function __construct(Engine $engine)
    {
        $this->engine = $engine;
    }

    /**
     * @return mixed
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * @return Engine
     */
    public function getEngine(): Engine
    {
        return $this->engine;
    }
}

/**
 * @Entity
 * @Table(name="engine")
 * @Cache(usage="READ_ONLY", region="engine")
 */
class Engine
{
    /**
     * @Id
     * @Column(type="integer")
     * @GeneratedValue(strategy="IDENTITY")
     */
    private $id;

    /**
     * @var Power
     * @Cache("READ_ONLY")
     * @OneToOne(targetEntity="Power", mappedBy="engine")
     */
    private $power;

    /**
     * @var string
     * @Column(name="model", type="string", nullable=false)
     */
    private $model;

    /**
     * Engine constructor.
     * @param string $model
     */
    public function __construct(string $model)
    {
        $this->model = $model;
    }

    /**
     * @return Power
     */
    public function getPower(): Power
    {
        return $this->power;
    }

    /**
     * @return mixed
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * @return string
     */
    public function getModel(): string
    {
        return $this->model;
    }
}

/**
 * @Entity
 * @Table(name="power")
 * @Cache(usage="READ_ONLY", region="power")
 */
class Power
{
    /**
     * @Id
     * @Column(type="integer")
     * @GeneratedValue(strategy="IDENTITY")
     */
    private $id;

    /**
     * @var Engine
     * @OneToOne(targetEntity="Engine")
     * @Cache("READ_ONLY")
     * @JoinColumn(name="engine_id", referencedColumnName="id", onDelete="CASCADE")
     */
    protected $engine;

    /**
     * Power constructor.
     * @param int $horsePower
     * @param int $kilowatt
     * @param Engine $engine
     */
    public function __construct(Engine $engine)
    {
        $this->engine = $engine;
    }

    /**
     * @return Engine
     */
    public function getEngine(): Engine
    {
        return $this->engine;
    }
}