eZ\Publish\Core\Persistence\Cache\Tests\HandlerTest

Complexity

Total Complexity

10

Size/Duplication

Total Lines	234
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	13

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
B	setUp()	0	38	1
A	tearDown()	0	9	1
	getHandlerMethodName()	0	1	?
	getHandlerClassName()	0	1	?
	providerForUnCachedMethods()	0	1	?
B	testUnCachedMethods()	0	37	5
	providerForCachedLoadMethods()	0	1	?
A	testLoadMethodsCacheHit()	0	20	1
B	testLoadMethodsCacheMiss()	0	34	1
A	getCacheItem()	0	5	1

<?php

/**
 * File contains Test class.
 *
 * @copyright Copyright (C) eZ Systems AS. All rights reserved.
 * @license For full copyright and license information view LICENSE file distributed with this source code.
 */
namespace eZ\Publish\Core\Persistence\Cache\Tests;

use eZ\Publish\Core\Persistence\Cache\Handler as CacheHandler;
use eZ\Publish\Core\Persistence\Cache\SectionHandler as CacheSectionHandler;
use eZ\Publish\Core\Persistence\Cache\LocationHandler as CacheLocationHandler;
use eZ\Publish\Core\Persistence\Cache\ContentHandler as CacheContentHandler;
use eZ\Publish\Core\Persistence\Cache\ContentLanguageHandler as CacheContentLanguageHandler;
use eZ\Publish\Core\Persistence\Cache\ContentTypeHandler as CacheContentTypeHandler;
use eZ\Publish\Core\Persistence\Cache\UserHandler as CacheUserHandler;
use eZ\Publish\Core\Persistence\Cache\TransactionHandler as CacheTransactionHandler;
use eZ\Publish\Core\Persistence\Cache\TrashHandler as CacheTrashHandler;
use eZ\Publish\Core\Persistence\Cache\UrlAliasHandler as CacheUrlAliasHandler;
use eZ\Publish\Core\Persistence\Cache\ObjectStateHandler as CacheObjectStateHandler;
use Symfony\Component\Cache\Adapter\TagAwareAdapterInterface;
use Symfony\Component\Cache\CacheItem;
use PHPUnit_Framework_TestCase;

/**
 * Abstract test case for spi cache impl.
 */
abstract class HandlerTest extends PHPUnit_Framework_TestCase
{
    /**
     * @var \Symfony\Component\Cache\Adapter\TagAwareAdapterInterface|\PHPUnit_Framework_MockObject_MockObject
     */
    protected $cacheMock;

    /**
     * @var \eZ\Publish\SPI\Persistence\Handler|\PHPUnit_Framework_MockObject_MockObject
     */
    protected $persistenceHandlerMock;

    /**
     * @var \eZ\Publish\SPI\Persistence\TransactionHandler|\PHPUnit_Framework_MockObject_MockObject
     */
    protected $transactionHandlerMock;

    /**
     * @var \eZ\Publish\Core\Persistence\Cache\Handler
     */
    protected $persistenceCacheHandler;

    /**
     * @var \eZ\Publish\Core\Persistence\Cache\PersistenceLogger|\PHPUnit_Framework_MockObject_MockObject
     */
    protected $loggerMock;

    /**
     * @param array|null $persistenceFactoryMockMethod
     */
    protected $persistenceFactoryMockMethods = array();

    /**
     * @var \Closure
     */
    protected $cacheItemsClosure;

    /**
     * Setup the HandlerTest.
     */
    final protected function setUp()
    {
        parent::setUp();

        $this->persistenceHandlerMock = $this->getMock('eZ\Publish\SPI\Persistence\Handler');
        $this->cacheMock = $this->getMock(TagAwareAdapterInterface::class);
        $this->loggerMock = $this->getMock('eZ\\Publish\\Core\\Persistence\\Cache\\PersistenceLogger');

        $this->persistenceCacheHandler = new CacheHandler(
            $this->persistenceHandlerMock,
            new CacheSectionHandler($this->cacheMock, $this->persistenceHandlerMock, $this->loggerMock),
            new CacheLocationHandler($this->cacheMock, $this->persistenceHandlerMock, $this->loggerMock),
            new CacheContentHandler($this->cacheMock, $this->persistenceHandlerMock, $this->loggerMock),
            new CacheContentLanguageHandler($this->cacheMock, $this->persistenceHandlerMock, $this->loggerMock),
            new CacheContentTypeHandler($this->cacheMock, $this->persistenceHandlerMock, $this->loggerMock),
            new CacheUserHandler($this->cacheMock, $this->persistenceHandlerMock, $this->loggerMock),
            new CacheTransactionHandler($this->cacheMock, $this->persistenceHandlerMock, $this->loggerMock),
            new CacheTrashHandler($this->cacheMock, $this->persistenceHandlerMock, $this->loggerMock),
            new CacheUrlAliasHandler($this->cacheMock, $this->persistenceHandlerMock, $this->loggerMock),
            new CacheObjectStateHandler($this->cacheMock, $this->persistenceHandlerMock, $this->loggerMock),
            $this->loggerMock,
            $this->cacheMock
        );

        $this->cacheItemsClosure = \Closure::bind(
            function ($key, $value, $isHit, $defaultLifetime = 0) {
                $item = new CacheItem();
                $item->key = $key;

The property key cannot be accessed from this context as it is declared protected in class Symfony\Component\Cache\CacheItem.

                $item->value = $value;

The property value cannot be accessed from this context as it is declared protected in class Symfony\Component\Cache\CacheItem.

                $item->isHit = $isHit;

The property isHit cannot be accessed from this context as it is declared protected in class Symfony\Component\Cache\CacheItem.

                $item->defaultLifetime = $defaultLifetime;

The property defaultLifetime cannot be accessed from this context as it is declared protected in class Symfony\Component\Cache\CacheItem.

                return $item;
            },
            null,
            CacheItem::class
        );
    }

    /**
     * Tear down test (properties).
     */
    final protected function tearDown()
    {
        unset($this->cacheMock);
        unset($this->persistenceHandlerMock);
        unset($this->persistenceCacheHandler);
        unset($this->loggerMock);
        unset($this->cacheItemsClosure);
        parent::tearDown();
    }


    abstract public function getHandlerMethodName() : string;

    abstract public function getHandlerClassName() : string;

    abstract public function providerForUnCachedMethods() : array;

    /**
     * @dataProvider providerForUnCachedMethods
     *
     * @param string $method
     * @param array $arguments
     * @param array|null $tags
     * @param string|null $key
     */
    final public function testUnCachedMethods(string $method, array $arguments, array $tags = null, string $key = null)
    {
        $handlerMethodName = $this->getHandlerMethodName();

        $this->loggerMock->expects($this->once())->method('logCall');

        $innerHandler = $this->getMock($this->getHandlerClassName());
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method($handlerMethodName)
            ->will($this->returnValue($innerHandler));

        $innerHandler
            ->expects($this->once())
            ->method($method)
            ->with(...$arguments)
            ->will($this->returnValue(null));

        if ($tags || $key) {

The expression $key of type null|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $this->cacheMock
                ->expects(!empty($tags) ? $this->once() : $this->never())
                ->method('invalidateTags')
                ->with($tags);

            $this->cacheMock
                ->expects(!empty($key) ? $this->once() : $this->never())
                ->method('deleteItem')
                ->with($key);
        } else {
            $this->cacheMock
                ->expects($this->never())
                ->method($this->anything());
        }

        $handler = $this->persistenceCacheHandler->$handlerMethodName();
        call_user_func_array(array($handler, $method), $arguments);
    }


    abstract public function providerForCachedLoadMethods() : array;

    /**
     * @dataProvider providerForCachedLoadMethods
     *
     * @param string $method
     * @param array $arguments
     * @param string $key
     * @param mixed $data
     */
    final public function testLoadMethodsCacheHit(string $method, array $arguments, string $key, $data = null)
    {
        $cacheItem = $this->getCacheItem($key, $data);
        $handlerMethodName = $this->getHandlerMethodName();

        $this->loggerMock->expects($this->never())->method('logCall');

        $this->cacheMock
            ->expects($this->once())
            ->method('getItem')
            ->with($cacheItem->getKey())
            ->will($this->returnValue($cacheItem));

        $this->persistenceHandlerMock
            ->expects($this->never())
            ->method($handlerMethodName);

        $handler = $this->persistenceCacheHandler->$handlerMethodName();
        call_user_func_array([$handler, $method], $arguments);
    }

    /**
     * @dataProvider providerForCachedLoadMethods
     *
     * @param string $method
     * @param array $arguments
     * @param string $key
     * @param object $data
     */
    final public function testLoadMethodsCacheMiss(string $method, array $arguments, string $key, $data = null)
    {
        $cacheItem = $this->getCacheItem($key, null);
        $handlerMethodName = $this->getHandlerMethodName();

        $this->loggerMock->expects($this->once())->method('logCall');

        $this->cacheMock
            ->expects($this->once())
            ->method('getItem')
            ->with($cacheItem->getKey())
            ->will($this->returnValue($cacheItem));

        $innerHandlerMock = $this->getMock($this->getHandlerClassName());
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method($handlerMethodName)
            ->will($this->returnValue($innerHandlerMock));

        $innerHandlerMock
            ->expects($this->once())
            ->method($method)
            ->with(...$arguments)
            ->will($this->returnValue($data));

        // @todo find way to also verify tags on the cache item
        $this->cacheMock
            ->expects($this->once())
            ->method('save')
            ->with($cacheItem);

        $handler = $this->persistenceCacheHandler->$handlerMethodName();
        call_user_func_array([$handler, $method], $arguments);
    }


    /**
     * @param $key
     * @param null $value If null the cache item will be assumed to be a cache miss here.
     * @param int $defaultLifetime
     *
     * @return CacheItem
     */
    final protected function getCacheItem($key, $value = null, $defaultLifetime = 0)
    {
        $cacheItemsClosure = $this->cacheItemsClosure;
        return $cacheItemsClosure($key, $value, !!$value, $defaultLifetime);
    }
}