ContentLanguageHandlerTest::testLoadCacheIsMiss() - Code Metrics - Inspection of "TMP Multi tagging" - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — feature-EZP-25696 ( c75b51...ce24f7 )

by André

created 2016-08-22 21:05 UTC

ContentLanguageHandlerTest::testLoadCacheIsMiss() A

↳ Parent: ContentLanguageHandlerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	52
Code Lines	40

Duplication

Lines	52
Ratio	100 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	40
c	1
b	0
f	0
nc	1
nop	0
dl	52
loc	52
rs	9.4929

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.
 *
 * @version //autogentag//
 */
namespace eZ\Publish\Core\Persistence\Cache\Tests;

use eZ\Publish\SPI\Persistence\Content\Language as SPILanguage;
use eZ\Publish\SPI\Persistence\Content\Language\CreateStruct as SPILanguageCreateStruct;

/**
 * Test case for Persistence\Cache\ContentLanguageHandler.
 */
class ContentLanguageHandlerTest extends HandlerTest
{
    /**
     * @covers eZ\Publish\Core\Persistence\Cache\ContentLanguageHandler::create
     */
    public function testCreate()
    {
        $this->loggerMock->expects($this->once())->method('logCall');
        $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
        $this->cacheMock
            ->expects($this->once())
            ->method('getItem')
            ->with('language', 2)
            ->will($this->returnValue($cacheItemMock));

        $innerHandlerMock = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\Language\\Handler');
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method('contentLanguageHandler')
            ->will($this->returnValue($innerHandlerMock));

        $innerHandlerMock
            ->expects($this->once())
            ->method('create')
            ->with($this->isInstanceOf('eZ\\Publish\\SPI\\Persistence\\Content\\Language\\CreateStruct'))
            ->will(
                $this->returnValue(
                    new SPILanguage(
                        array('id' => 2, 'name' => 'English (UK)', 'languageCode' => 'eng-GB')
                    )
                )
            );

        $cacheItemMock
            ->expects($this->once())
            ->method('set')
            ->with($this->isInstanceOf('eZ\\Publish\\SPI\\Persistence\\Content\\Language'))
            ->will($this->returnValue($cacheItemMock));

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

        $cacheItemMock
            ->expects($this->never())
            ->method('get');

        $handler = $this->persistenceCacheHandler->contentLanguageHandler();
        $handler->create(new SPILanguageCreateStruct());
    }

    /**
     * @covers eZ\Publish\Core\Persistence\Cache\ContentLanguageHandler::delete
     */
    public function testDelete()
    {
        $this->loggerMock->expects($this->once())->method('logCall');
        $this->cacheMock
            ->expects($this->once())
            ->method('clear')
            ->with('language', 2)
            ->will($this->returnValue(true));

        $innerHandlerMock = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\Language\\Handler');
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method('contentLanguageHandler')
            ->will($this->returnValue($innerHandlerMock));

        $innerHandlerMock
            ->expects($this->once())
            ->method('delete')
            ->with(2)
            ->will(
                $this->returnValue(true)
            );

        $handler = $this->persistenceCacheHandler->contentLanguageHandler();
        $handler->delete(2);
    }

    /**
     * @covers eZ\Publish\Core\Persistence\Cache\ContentLanguageHandler::load
     */
    public function testLoadCacheIsMiss()
    {
        $this->loggerMock->expects($this->once())->method('logCall');
        $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
        $this->cacheMock
            ->expects($this->once())
            ->method('getItem')
            ->with('language', 2)
            ->will($this->returnValue($cacheItemMock));

        $cacheItemMock
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue(null));

        $cacheItemMock
            ->expects($this->once())
            ->method('isMiss')
            ->will($this->returnValue(true));

        $innerHandlerMock = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\Language\\Handler');
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method('contentLanguageHandler')
            ->will($this->returnValue($innerHandlerMock));

        $innerHandlerMock
            ->expects($this->once())
            ->method('load')
            ->with(2)
            ->will(
                $this->returnValue(
                    new SPILanguage(
                        array('id' => 2, 'name' => 'English (UK)', 'languageCode' => 'eng-GB')
                    )
                )
            );

        $cacheItemMock
            ->expects($this->once())
            ->method('set')
            ->with($this->isInstanceOf('eZ\\Publish\\SPI\\Persistence\\Content\\Language'))
            ->will($this->returnValue($cacheItemMock));

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

        $handler = $this->persistenceCacheHandler->contentLanguageHandler();
        $handler->load(2);
    }

    /**
     * @covers eZ\Publish\Core\Persistence\Cache\ContentLanguageHandler::load
     */
    public function testLoadHasCache()
    {
        $this->loggerMock->expects($this->never())->method($this->anything());
        $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
        $this->cacheMock
            ->expects($this->once())
            ->method('getItem')
            ->with('language', 2)
            ->will($this->returnValue($cacheItemMock));

        $cacheItemMock
            ->expects($this->once())
            ->method('get')
            ->will(
                $this->returnValue(
                    new SPILanguage(
                        array('id' => 2, 'name' => 'English (UK)', 'languageCode' => 'eng-GB')
                    )
                )
            );

        $cacheItemMock
            ->expects($this->once())
            ->method('isMiss')
            ->will($this->returnValue(false));

        $this->persistenceHandlerMock
            ->expects($this->never())
            ->method('contentLanguageHandler');

        $cacheItemMock
            ->expects($this->never())
            ->method('set');

        $handler = $this->persistenceCacheHandler->contentLanguageHandler();
        $handler->load(2);
    }

    /**
     * @covers eZ\Publish\Core\Persistence\Cache\ContentLanguageHandler::loadAll
     */
    public function testLoadAll()
    {
        $this->loggerMock->expects($this->once())->method('logCall');
        $this->cacheMock
            ->expects($this->never())
            ->method($this->anything());

        $innerHandler = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\Language\\Handler');
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method('contentLanguageHandler')
            ->will($this->returnValue($innerHandler));

        $innerHandler
            ->expects($this->once())
            ->method('loadAll')
            ->will($this->returnValue(array()));

        $handler = $this->persistenceCacheHandler->contentLanguageHandler();
        $handler->loadAll();
    }

    /**
     * @covers eZ\Publish\Core\Persistence\Cache\ContentLanguageHandler::loadByLanguageCode
     */
    public function testLoadByLanguageCode()
    {
        $this->loggerMock->expects($this->once())->method('logCall');
        $this->cacheMock
            ->expects($this->never())
            ->method($this->anything());

        $innerHandler = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\Language\\Handler');
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method('contentLanguageHandler')
            ->will($this->returnValue($innerHandler));

        $innerHandler
            ->expects($this->once())
            ->method('loadByLanguageCode')
            ->with('eng-GB')
            ->will(
                $this->returnValue(
                    new SPILanguage(
                        array('id' => 2, 'name' => 'English (UK)', 'languageCode' => 'eng-GB')
                    )
                )
            );

        $handler = $this->persistenceCacheHandler->contentLanguageHandler();
        $handler->loadByLanguageCode('eng-GB');
    }

    /**
     * @covers eZ\Publish\Core\Persistence\Cache\ContentLanguageHandler::update
     */
    public function testUpdate()
    {
        $this->loggerMock->expects($this->once())->method('logCall');
        $this->cacheMock
            ->expects($this->once())
            ->method('clear')
            ->with('language', 2)
            ->will($this->returnValue(true));

        $innerHandler = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\Language\\Handler');
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method('contentLanguageHandler')
            ->will($this->returnValue($innerHandler));

        $innerHandler
            ->expects($this->once())
            ->method('update')
            ->with($this->isInstanceOf('eZ\\Publish\\SPI\\Persistence\\Content\\Language'))
            ->will(
                $this->returnValue(
                    new SPILanguage(
                        array('id' => 2, 'name' => 'English (UK)', 'languageCode' => 'eng-GB')
                    )
                )
            );

        $handler = $this->persistenceCacheHandler->contentLanguageHandler();
        $handler->update(new SPILanguage(array('id' => 2)));
    }
}


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		* @version //autogentag//
10		*/
11		namespace eZ\Publish\Core\Persistence\Cache\Tests;
12
13		use eZ\Publish\SPI\Persistence\Content\Language as SPILanguage;
14		use eZ\Publish\SPI\Persistence\Content\Language\CreateStruct as SPILanguageCreateStruct;
15
16		/**
17		* Test case for Persistence\Cache\ContentLanguageHandler.
18		*/
19		class ContentLanguageHandlerTest extends HandlerTest
20		{
21		/**
22		* @covers eZ\Publish\Core\Persistence\Cache\ContentLanguageHandler::create
23		*/
24		public function testCreate()
25		{
26		$this->loggerMock->expects($this->once())->method('logCall');
27		$cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
28		$this->cacheMock
29		->expects($this->once())
30		->method('getItem')
31		->with('language', 2)
32		->will($this->returnValue($cacheItemMock));
33
34		$innerHandlerMock = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\Language\\Handler');
35		$this->persistenceHandlerMock
36		->expects($this->once())
37		->method('contentLanguageHandler')
38		->will($this->returnValue($innerHandlerMock));
39
40		$innerHandlerMock
41		->expects($this->once())
42		->method('create')
43		->with($this->isInstanceOf('eZ\\Publish\\SPI\\Persistence\\Content\\Language\\CreateStruct'))
44		->will(
45		$this->returnValue(
46		new SPILanguage(
47		array('id' => 2, 'name' => 'English (UK)', 'languageCode' => 'eng-GB')
48		)
49		)
50		);
51
52		$cacheItemMock
53		->expects($this->once())
54		->method('set')
55		->with($this->isInstanceOf('eZ\\Publish\\SPI\\Persistence\\Content\\Language'))
56		->will($this->returnValue($cacheItemMock));
57
58		$cacheItemMock
59		->expects($this->once())
60		->method('save')
61		->with();
62
63		$cacheItemMock
64		->expects($this->never())
65		->method('get');
66
67		$handler = $this->persistenceCacheHandler->contentLanguageHandler();
68		$handler->create(new SPILanguageCreateStruct());
69		}
70
71		/**
72		* @covers eZ\Publish\Core\Persistence\Cache\ContentLanguageHandler::delete
73		*/
74		public function testDelete()
75		{
76		$this->loggerMock->expects($this->once())->method('logCall');
77		$this->cacheMock
78		->expects($this->once())
79		->method('clear')
80		->with('language', 2)
81		->will($this->returnValue(true));
82
83		$innerHandlerMock = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\Language\\Handler');
84		$this->persistenceHandlerMock
85		->expects($this->once())
86		->method('contentLanguageHandler')
87		->will($this->returnValue($innerHandlerMock));
88
89		$innerHandlerMock
90		->expects($this->once())
91		->method('delete')
92		->with(2)
93		->will(
94		$this->returnValue(true)
95		);
96
97		$handler = $this->persistenceCacheHandler->contentLanguageHandler();
98		$handler->delete(2);
99		}
100
101		/**
102		* @covers eZ\Publish\Core\Persistence\Cache\ContentLanguageHandler::load
103		*/
104	View Code Duplication	public function testLoadCacheIsMiss()
105		{
106		$this->loggerMock->expects($this->once())->method('logCall');
107		$cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
108		$this->cacheMock
109		->expects($this->once())
110		->method('getItem')
111		->with('language', 2)
112		->will($this->returnValue($cacheItemMock));
113
114		$cacheItemMock
115		->expects($this->once())
116		->method('get')
117		->will($this->returnValue(null));
118
119		$cacheItemMock
120		->expects($this->once())
121		->method('isMiss')
122		->will($this->returnValue(true));
123
124		$innerHandlerMock = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\Language\\Handler');
125		$this->persistenceHandlerMock
126		->expects($this->once())
127		->method('contentLanguageHandler')
128		->will($this->returnValue($innerHandlerMock));
129
130		$innerHandlerMock
131		->expects($this->once())
132		->method('load')
133		->with(2)
134		->will(
135		$this->returnValue(
136		new SPILanguage(
137		array('id' => 2, 'name' => 'English (UK)', 'languageCode' => 'eng-GB')
138		)
139		)
140		);
141
142		$cacheItemMock
143		->expects($this->once())
144		->method('set')
145		->with($this->isInstanceOf('eZ\\Publish\\SPI\\Persistence\\Content\\Language'))
146		->will($this->returnValue($cacheItemMock));
147
148		$cacheItemMock
149		->expects($this->once())
150		->method('save')
151		->with();
152
153		$handler = $this->persistenceCacheHandler->contentLanguageHandler();
154		$handler->load(2);
155		}
156
157		/**
158		* @covers eZ\Publish\Core\Persistence\Cache\ContentLanguageHandler::load
159		*/
160	View Code Duplication	public function testLoadHasCache()
161		{
162		$this->loggerMock->expects($this->never())->method($this->anything());
163		$cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
164		$this->cacheMock
165		->expects($this->once())
166		->method('getItem')
167		->with('language', 2)
168		->will($this->returnValue($cacheItemMock));
169
170		$cacheItemMock
171		->expects($this->once())
172		->method('get')
173		->will(
174		$this->returnValue(
175		new SPILanguage(
176		array('id' => 2, 'name' => 'English (UK)', 'languageCode' => 'eng-GB')
177		)
178		)
179		);
180
181		$cacheItemMock
182		->expects($this->once())
183		->method('isMiss')
184		->will($this->returnValue(false));
185
186		$this->persistenceHandlerMock
187		->expects($this->never())
188		->method('contentLanguageHandler');
189
190		$cacheItemMock
191		->expects($this->never())
192		->method('set');
193
194		$handler = $this->persistenceCacheHandler->contentLanguageHandler();
195		$handler->load(2);
196		}
197
198		/**
199		* @covers eZ\Publish\Core\Persistence\Cache\ContentLanguageHandler::loadAll
200		*/
201		public function testLoadAll()
202		{
203		$this->loggerMock->expects($this->once())->method('logCall');
204		$this->cacheMock
205		->expects($this->never())
206		->method($this->anything());
207
208		$innerHandler = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\Language\\Handler');
209		$this->persistenceHandlerMock
210		->expects($this->once())
211		->method('contentLanguageHandler')
212		->will($this->returnValue($innerHandler));
213
214		$innerHandler
215		->expects($this->once())
216		->method('loadAll')
217		->will($this->returnValue(array()));
218
219		$handler = $this->persistenceCacheHandler->contentLanguageHandler();
220		$handler->loadAll();
221		}
222
223		/**
224		* @covers eZ\Publish\Core\Persistence\Cache\ContentLanguageHandler::loadByLanguageCode
225		*/
226		public function testLoadByLanguageCode()
227		{
228		$this->loggerMock->expects($this->once())->method('logCall');
229		$this->cacheMock
230		->expects($this->never())
231		->method($this->anything());
232
233		$innerHandler = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\Language\\Handler');
234		$this->persistenceHandlerMock
235		->expects($this->once())
236		->method('contentLanguageHandler')
237		->will($this->returnValue($innerHandler));
238
239		$innerHandler
240		->expects($this->once())
241		->method('loadByLanguageCode')
242		->with('eng-GB')
243		->will(
244		$this->returnValue(
245		new SPILanguage(
246		array('id' => 2, 'name' => 'English (UK)', 'languageCode' => 'eng-GB')
247		)
248		)
249		);
250
251		$handler = $this->persistenceCacheHandler->contentLanguageHandler();
252		$handler->loadByLanguageCode('eng-GB');
253		}
254
255		/**
256		* @covers eZ\Publish\Core\Persistence\Cache\ContentLanguageHandler::update
257		*/
258		public function testUpdate()
259		{
260		$this->loggerMock->expects($this->once())->method('logCall');
261		$this->cacheMock
262		->expects($this->once())
263		->method('clear')
264		->with('language', 2)
265		->will($this->returnValue(true));
266
267		$innerHandler = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\Language\\Handler');
268		$this->persistenceHandlerMock
269		->expects($this->once())
270		->method('contentLanguageHandler')
271		->will($this->returnValue($innerHandler));
272
273		$innerHandler
274		->expects($this->once())
275		->method('update')
276		->with($this->isInstanceOf('eZ\\Publish\\SPI\\Persistence\\Content\\Language'))
277		->will(
278		$this->returnValue(
279		new SPILanguage(
280		array('id' => 2, 'name' => 'English (UK)', 'languageCode' => 'eng-GB')
281		)
282		)
283		);
284
285		$handler = $this->persistenceCacheHandler->contentLanguageHandler();
286		$handler->update(new SPILanguage(array('id' => 2)));
287		}
288		}
289

ezsystems / ezpublish-kernel

Push — feature-EZP-25696 ( c75b51...ce24f7 )

ContentLanguageHandlerTest::testLoadCacheIsMiss() A

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like