AbstractInMemoryCacheHandlerTest::testLoadMethodsCacheMiss() - Code Metrics - Inspection of "EZP-29659: As a v2 Cluster Admin & Developer I wan..." - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 955b04...f00653 )

by André

created 2019-03-18 15:54 UTC

testLoadMethodsCacheMiss() B

↳ Parent: AbstractInMemoryCacheHandlerTest

Complexity

Conditions	3
Paths	4

Size

Total Lines

Duplication

Lines	12
Ratio	19.67 %

Importance

Changes

Metric	Value
cc	3
nc	4
nop	6
dl	12
loc	61
rs	8.8509
c	0
b	0
f	0

How to fix Long Method

<?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.
 */
declare(strict_types=1);

namespace eZ\Publish\Core\Persistence\Cache\Tests;

/**
 * Abstract test case for spi cache impl, with in-memory handling.
 */
abstract class AbstractInMemoryCacheHandlerTest extends AbstractBaseHandlerTest
{
    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 array|null $key
     * @param mixed $returnValue
     */
    final public function testUnCachedMethods(string $method, array $arguments, array $tags = null, array $key = null, $returnValue = null)
    {
        $handlerMethodName = $this->getHandlerMethodName();

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

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

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

        if ($tags || $key) {

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

            $this->cacheMock
                ->expects(!empty($key) ? $this->once() : $this->never())
                ->method('deleteItems')
                ->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
     * @param bool $multi Default false, set to true if method will lookup several cache items.
     * @param array $additionalCalls Sets of additional calls being made to handlers, with 4 values (0: handler name, 1: handler class, 2: method, 3: return data)
     */
    final public function testLoadMethodsCacheHit(string $method, array $arguments, string $key, $data = null, bool $multi = false, array $additionalCalls = [])
    {
        $cacheItem = $this->getCacheItem($key, $multi ? reset($data) : $data);
        $handlerMethodName = $this->getHandlerMethodName();

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

        if ($multi) {
            $this->cacheMock
                ->expects($this->once())
                ->method('getItems')
                ->with([$cacheItem->getKey()])
                ->willReturn([$key => $cacheItem]);
        } else {
            $this->cacheMock
                ->expects($this->once())
                ->method('getItem')
                ->with($cacheItem->getKey())
                ->willReturn($cacheItem);
        }

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

        foreach ($additionalCalls as $additionalCall) {
            $this->persistenceHandlerMock
                ->expects($this->never())
                ->method($additionalCall[0]);
        }

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

        $this->assertEquals($data, $return);
    }

    /**
     * @dataProvider providerForCachedLoadMethods
     *
     * @param string $method
     * @param array $arguments
     * @param string $key
     * @param object $data
     * @param bool $multi Default false, set to true if method will lookup several cache items.
     * @param array $additionalCalls Sets of additional calls being made to handlers, with 4 values (0: handler name, 1: handler class, 2: method, 3: return data)
     */
    final public function testLoadMethodsCacheMiss(string $method, array $arguments, string $key, $data = null, bool $multi = false, array $additionalCalls = [])
    {
        $cacheItem = $this->getCacheItem($key, null);
        $handlerMethodName = $this->getHandlerMethodName();

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

        if ($multi) {
            $this->cacheMock
                ->expects($this->once())
                ->method('getItems')
                ->with([$cacheItem->getKey()])
                ->willReturn([$key => $cacheItem]);
        } else {
            $this->cacheMock
                ->expects($this->once())
                ->method('getItem')
                ->with($cacheItem->getKey())
                ->willReturn($cacheItem);
        }

        $innerHandlerMock = $this->createMock($this->getHandlerClassName());
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method($handlerMethodName)
            ->willReturn($innerHandlerMock);

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

        foreach ($additionalCalls as $additionalCall) {

            $innerHandlerMock = $this->createMock($additionalCall[1]);
            $this->persistenceHandlerMock
                ->expects($this->once())
                ->method($additionalCall[0])
                ->willReturn($innerHandlerMock);

            $innerHandlerMock
                ->expects($this->once())
                ->method($additionalCall[2])
                ->willReturn($additionalCall[3]);
        }

        $this->cacheMock
            ->expects($this->once())
            ->method('save')
            ->with($cacheItem);

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

        $this->assertEquals($data, $return);

        // Assert use of tags would probably need custom logic as internal property is [$tag => $tag] value and we don't want to know that.
        //$this->assertAttributeEquals([], 'tags', $cacheItem);
    }
}


1		<?php
2
3		/**
4		* File contains Test class.
5		*
6		* @copyright Copyright (C) eZ Systems AS. All rights reserved.
7		* @license For full copyright and license information view LICENSE file distributed with this source code.
8		*/
9		declare(strict_types=1);
10
11		namespace eZ\Publish\Core\Persistence\Cache\Tests;
12
13		/**
14		* Abstract test case for spi cache impl, with in-memory handling.
15		*/
16		abstract class AbstractInMemoryCacheHandlerTest extends AbstractBaseHandlerTest
17		{
18		abstract public function getHandlerMethodName(): string;
19
20		abstract public function getHandlerClassName(): string;
21
22		abstract public function providerForUnCachedMethods(): array;
23
24		/**
25		* @dataProvider providerForUnCachedMethods
26		*
27		* @param string $method
28		* @param array $arguments
29		* @param array\|null $tags
30		* @param array\|null $key
31		* @param mixed $returnValue
32		*/
33		final public function testUnCachedMethods(string $method, array $arguments, array $tags = null, array $key = null, $returnValue = null)
34		{
35		$handlerMethodName = $this->getHandlerMethodName();
36
37		$this->loggerMock->expects($this->once())->method('logCall');
38		$this->loggerMock->expects($this->never())->method('logCacheHit');
39		$this->loggerMock->expects($this->never())->method('logCacheMiss');
40
41		$innerHandler = $this->createMock($this->getHandlerClassName());
42		$this->persistenceHandlerMock
43		->expects($this->once())
44		->method($handlerMethodName)
45		->will($this->returnValue($innerHandler));
46
47		$innerHandler
48		->expects($this->once())
49		->method($method)
50		->with(...$arguments)
51		->will($this->returnValue($returnValue));
52
53	View Code Duplication	if ($tags \|\| $key) {
		0 ignored issues – show Duplication introduced 2019-03-03 12:27 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
54		$this->cacheMock
55		->expects(!empty($tags) ? $this->once() : $this->never())
56		->method('invalidateTags')
57		->with($tags);
58
59		$this->cacheMock
60		->expects(!empty($key) ? $this->once() : $this->never())
61		->method('deleteItems')
62		->with($key);
63		} else {
64		$this->cacheMock
65		->expects($this->never())
66		->method($this->anything());
67		}
68
69		$handler = $this->persistenceCacheHandler->$handlerMethodName();
70		call_user_func_array(array($handler, $method), $arguments);
71		}
72
73		abstract public function providerForCachedLoadMethods(): array;
74
75		/**
76		* @dataProvider providerForCachedLoadMethods
77		*
78		* @param string $method
79		* @param array $arguments
80		* @param string $key
81		* @param mixed $data
82		* @param bool $multi Default false, set to true if method will lookup several cache items.
83		* @param array $additionalCalls Sets of additional calls being made to handlers, with 4 values (0: handler name, 1: handler class, 2: method, 3: return data)
84		*/
85		final public function testLoadMethodsCacheHit(string $method, array $arguments, string $key, $data = null, bool $multi = false, array $additionalCalls = [])
86		{
87		$cacheItem = $this->getCacheItem($key, $multi ? reset($data) : $data);
88		$handlerMethodName = $this->getHandlerMethodName();
89
90		$this->loggerMock->expects($this->once())->method('logCacheHit');
91		$this->loggerMock->expects($this->never())->method('logCall');
92		$this->loggerMock->expects($this->never())->method('logCacheMiss');
93
94		if ($multi) {
95		$this->cacheMock
96		->expects($this->once())
97		->method('getItems')
98		->with([$cacheItem->getKey()])
99		->willReturn([$key => $cacheItem]);
100		} else {
101		$this->cacheMock
102		->expects($this->once())
103		->method('getItem')
104		->with($cacheItem->getKey())
105		->willReturn($cacheItem);
106		}
107
108		$this->persistenceHandlerMock
109		->expects($this->never())
110		->method($handlerMethodName);
111
112		foreach ($additionalCalls as $additionalCall) {
113		$this->persistenceHandlerMock
114		->expects($this->never())
115		->method($additionalCall[0]);
116		}
117
118		$handler = $this->persistenceCacheHandler->$handlerMethodName();
119		$return = call_user_func_array([$handler, $method], $arguments);
120
121		$this->assertEquals($data, $return);
122		}
123
124		/**
125		* @dataProvider providerForCachedLoadMethods
126		*
127		* @param string $method
128		* @param array $arguments
129		* @param string $key
130		* @param object $data
131		* @param bool $multi Default false, set to true if method will lookup several cache items.
132		* @param array $additionalCalls Sets of additional calls being made to handlers, with 4 values (0: handler name, 1: handler class, 2: method, 3: return data)
133		*/
134		final public function testLoadMethodsCacheMiss(string $method, array $arguments, string $key, $data = null, bool $multi = false, array $additionalCalls = [])
135		{
136		$cacheItem = $this->getCacheItem($key, null);
137		$handlerMethodName = $this->getHandlerMethodName();
138
139		$this->loggerMock->expects($this->once())->method('logCacheMiss');
140		$this->loggerMock->expects($this->never())->method('logCall');
141		$this->loggerMock->expects($this->never())->method('logCacheHit');
142
143		if ($multi) {
144		$this->cacheMock
145		->expects($this->once())
146		->method('getItems')
147		->with([$cacheItem->getKey()])
148		->willReturn([$key => $cacheItem]);
149		} else {
150		$this->cacheMock
151		->expects($this->once())
152		->method('getItem')
153		->with($cacheItem->getKey())
154		->willReturn($cacheItem);
155		}
156
157		$innerHandlerMock = $this->createMock($this->getHandlerClassName());
158		$this->persistenceHandlerMock
159		->expects($this->once())
160		->method($handlerMethodName)
161		->willReturn($innerHandlerMock);
162
163		$innerHandlerMock
164		->expects($this->once())
165		->method($method)
166		->with(...$arguments)
167		->willReturn($data);
168
169	View Code Duplication	foreach ($additionalCalls as $additionalCall) {
		0 ignored issues – show Duplication introduced 2019-03-03 12:27 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
170		$innerHandlerMock = $this->createMock($additionalCall[1]);
171		$this->persistenceHandlerMock
172		->expects($this->once())
173		->method($additionalCall[0])
174		->willReturn($innerHandlerMock);
175
176		$innerHandlerMock
177		->expects($this->once())
178		->method($additionalCall[2])
179		->willReturn($additionalCall[3]);
180		}
181
182		$this->cacheMock
183		->expects($this->once())
184		->method('save')
185		->with($cacheItem);
186
187		$handler = $this->persistenceCacheHandler->$handlerMethodName();
188		$return = call_user_func_array([$handler, $method], $arguments);
189
190		$this->assertEquals($data, $return);
191
192		// Assert use of tags would probably need custom logic as internal property is [$tag => $tag] value and we don't want to know that.
193		//$this->assertAttributeEquals([], 'tags', $cacheItem);
194		}
195		}
196

ezsystems / ezpublish-kernel

Push — master ( 955b04...f00653 )

testLoadMethodsCacheMiss() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like