CacheTest::testGetMultiple() - Code Metrics - Inspection of "Merge pull request #16 from djsmithme/psr" - djsmithme/Cache - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (1afc22)

by Dan

created 2017-12-03 12:33 UTC

CacheTest::testGetMultiple() B

↳ Parent: CacheTest

Complexity

Conditions	2
Paths	2

Size

Total Lines	26
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	26
rs	8.8571
c	0
b	0
f	0
cc	2
eloc	15
nc	2
nop	0

<?php

namespace Tests\Cache;

use Ds\Cache\Cache;
use Ds\Cache\CacheStorageInterface;
use Psr\SimpleCache\InvalidArgumentException;

/**
 * Cache Tests
 *
 * @package Tests\Cache
 */
class CacheTest extends \PHPUnit\Framework\TestCase
{
    /**
     * @var Cache
     */
    public $cache;

    /**
     * @var \PHPUnit_Framework_MockObject_MockObject
     */
    public $storageMock;

    /**
     *
     */
    public function setUp()
    {
        $this->storageMock = $this->getMockBuilder(CacheStorageInterface::class)->getMock();
        $this->cache = new Cache($this->storageMock);
    }

    /**
     * Test that CacheStorageInterface::set() invalid key exception
     */
    public function testSetInvalidKey()
    {
        $key = 21021000;
        $this->expectException(InvalidArgumentException::class);
        $this->cache->set($key,'value');
    }

    /**
     * Test that CacheStorageInterface::set() is called
     */
    public function testSet()

    {
        $key = 'key';
        $value = 'value';
        $expires = 10;

        $this->storageMock->expects($this->once())
            ->method('set')
            ->with(
                $this->equalTo($key),
                $this->equalTo($value),
                $this->equalTo($expires)
            );
        $this->cache->set($key, $value, $expires);
    }

    /**
     * Test that CacheStorageInterface::set() is called
     */
    public function testSetDateInterval()
    {
        $key = 'key';
        $value = 'value';
        $expires = new \DateInterval('PT1H');
        $oneHour = 60 * 60 * 1;

        $this->storageMock->expects($this->once())
            ->method('set')
            ->with(
                $this->equalTo($key),
                $this->equalTo($value),
                $this->equalTo($oneHour)
            );

        $this->cache->set($key, $value, $expires);
    }

    /**
     * Test that CacheStorageInterface::has() invalid key exception
     */
    public function testHasInvalidKey()
    {
        $key = 21021000;
        $this->expectException(InvalidArgumentException::class);
        $this->cache->has($key);
    }


    /**
     * Test that CacheStorageInterface::has() is called and returns true on finding key
     */
    public function testHasFoundWithKey()
    {
        $key = 'key';
        $expected = true;

        $this->storageMock->expects($this->once())
            ->method('has')
            ->with(
                $this->equalTo($key)
            )
            ->willReturn($expected);

        $actual = $this->cache->has($key);
        $this->assertEquals($expected, $actual);
    }

    /**
     * Test that CacheStorageInterface::has() is called and returns false on failing to find key
     */
    public function testHasFoundNoKey()
    {
        $key = 'key';
        $expected = false;

        $this->storageMock->expects($this->once())
            ->method('has')
            ->with(
                $this->equalTo($key)
            )
            ->willReturn($expected);

        $actual = $this->cache->has($key);
        $this->assertEquals($expected, $actual);
    }


    /**
     * Test that CacheStorageInterface::has() is called and returns false on failing to find key
     */
    public function testGetInvalidKey()
    {
        $key = 21021000;
        $this->expectException(InvalidArgumentException::class);
        $this->cache->get($key);
    }

    /**
     * Test that CacheStorageInterface::get() returns values when key is present.
     */
    public function testGetFoundValue()
    {
        $key = 'key';
        $expected = 'cacheValue';
        $default = 'default value';

        $this->storageMock->expects($this->once())
            ->method('has')
            ->with(
                $this->equalTo($key)
            )
            ->willReturn(true);

        $this->storageMock->expects($this->once())
            ->method('get')
            ->with(
                $this->equalTo($key)
            )
            ->willReturn($expected);

        $actual = $this->cache->get($key, $default);
        $this->assertEquals($expected, $actual);
    }

    /**
     * Test that CacheStorageInterface::get() doesn't return values and default is returned.
     */
    public function testGetDefaultValue()

    {
        $key = 'key';
        $default = 'default value';

        $this->storageMock->expects($this->once())
            ->method('has')
            ->with(
                $this->equalTo($key)
            )
            ->willReturn(false);

        $actual = $this->cache->get($key, $default);
        $this->assertEquals($default, $actual);
    }

    /**
     * Test that CacheStorageInterface::delete() is called
     */
    public function testDelete()
    {
        $key = 'key';
        $this->storageMock->expects($this->once())
            ->method('delete')
            ->with(
                $this->equalTo($key)
            );
        $this->cache->delete($key);
    }

    /**
     *
     */
    public function testGetMultiple(){

        $expected = [
            'foo' => 'fooValue',
            'bar' => 'barValue',
            'baz' => 'bazValue'
        ];

        $i = 0;

        foreach ($expected as $key => $value){

            $this->storageMock->expects($this->at($i))
                ->method('get')
                ->with(
                    $this->equalTo($key)
                )
                ->willReturn($value);
            $i++;
        }

        $actual = $this->cache->getMultiple(\array_keys($expected));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $this->assertEquals($expected, $actual);

    }

    /**
     *
     */
    public function testSetMultiple(){

        $keys = [
            'foo' => 'fooValue',
            'bar' => 'barValue',
            'baz' => 'bazValue'
        ];

        $addStatus = true;
        $expected = true;

        $i = 0;
        $expires = 60 * 60;

        foreach ($keys as $key => $value){
            $this->storageMock->expects($this->at($i))
                ->method('set')
                ->with(
                    $this->equalTo($key),
                    $this->equalTo($value),
                    $this->equalTo($expires)
                )
                ->willReturn($addStatus);
            $i++;
        }

        $actual = $this->cache->setMultiple($keys,$expires);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $this->assertEquals($expected, $actual);
    }

    /**
     *
     */
    public function testSetMultipleWithFailure(){

        $keys = [
            'foo' => 'fooValue',
            'bar' => 'barValue',
            'baz' => 'bazValue'
        ];

        $addStatus = true;
        $expected = false;

        $i = 0;
        $expires = 60 * 60;

        foreach ($keys as $key => $value){

            $status = $addStatus;

            if ($i === 1){
                $status = false;
            }

            $this->storageMock->expects($this->at($i))
                ->method('set')
                ->with(
                    $this->equalTo($key),
                    $this->equalTo($value),
                    $this->equalTo($expires)
                )
                ->willReturn($status);
            $i++;
        }

        $actual = $this->cache->setMultiple($keys,$expires);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $this->assertEquals($expected, $actual);
    }

    /**
     *
     */
    public function testDeleteMultiple(){

        $keys = ['foo','bar','baz'];
        $deleteStatus = true;
        $expected = true;

        foreach ($keys as $i => $key){
            $this->storageMock->expects($this->at($i))
                ->method('delete')
                ->with(
                    $this->equalTo($key)
                )
                ->willReturn($deleteStatus);
        }

        $actual = $this->cache->deleteMultiple($keys);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $this->assertEquals($expected, $actual);
    }

    /**
     *
     */
    public function testDeleteMultipleFailure(){
        $keys = ['foo','bar','baz'];
        $expected = false;
        $deleteStatus = true;
        foreach ($keys as $i => $key){
            if ($i === 1){
                $deleteStatus = false;
            }
            $this->storageMock->expects($this->at($i))
                ->method('delete')
                ->with(
                    $this->equalTo($key)
                )
                ->willReturn($deleteStatus);
        }
        $actual = $this->cache->deleteMultiple($keys);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $this->assertEquals($expected, $actual);
    }

    /**
     * Test that storage clear is called.
     */
    public function testclear(){
        $this->storageMock
            ->expects($this->once())
            ->method('clear');

        $this->cache->clear();
    }
}


1		<?php
2
3		namespace Tests\Cache;
4
5		use Ds\Cache\Cache;
6		use Ds\Cache\CacheStorageInterface;
7		use Psr\SimpleCache\InvalidArgumentException;
8
9		/**
10		* Cache Tests
11		*
12		* @package Tests\Cache
13		*/
14		class CacheTest extends \PHPUnit\Framework\TestCase
15		{
16		/**
17		* @var Cache
18		*/
19		public $cache;
20
21		/**
22		* @var \PHPUnit_Framework_MockObject_MockObject
23		*/
24		public $storageMock;
25
26		/**
27		*
28		*/
29		public function setUp()
30		{
31		$this->storageMock = $this->getMockBuilder(CacheStorageInterface::class)->getMock();
32		$this->cache = new Cache($this->storageMock);
33		}
34
35		/**
36		* Test that CacheStorageInterface::set() invalid key exception
37		*/
38		public function testSetInvalidKey()
39		{
40		$key = 21021000;
41		$this->expectException(InvalidArgumentException::class);
42		$this->cache->set($key,'value');
43		}
44
45		/**
46		* Test that CacheStorageInterface::set() is called
47		*/
48	View Code Duplication	public function testSet()
		0 ignored issues – show Duplication introduced 2017-12-03 12:38 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
49		{
50		$key = 'key';
51		$value = 'value';
52		$expires = 10;
53
54		$this->storageMock->expects($this->once())
55		->method('set')
56		->with(
57		$this->equalTo($key),
58		$this->equalTo($value),
59		$this->equalTo($expires)
60		);
61		$this->cache->set($key, $value, $expires);
62		}
63
64		/**
65		* Test that CacheStorageInterface::set() is called
66		*/
67		public function testSetDateInterval()
68		{
69		$key = 'key';
70		$value = 'value';
71		$expires = new \DateInterval('PT1H');
72		$oneHour = 60 * 60 * 1;
73
74		$this->storageMock->expects($this->once())
75		->method('set')
76		->with(
77		$this->equalTo($key),
78		$this->equalTo($value),
79		$this->equalTo($oneHour)
80		);
81
82		$this->cache->set($key, $value, $expires);
83		}
84
85		/**
86		* Test that CacheStorageInterface::has() invalid key exception
87		*/
88		public function testHasInvalidKey()
89		{
90		$key = 21021000;
91		$this->expectException(InvalidArgumentException::class);
92		$this->cache->has($key);
93		}
94
95
96		/**
97		* Test that CacheStorageInterface::has() is called and returns true on finding key
98		*/
99		public function testHasFoundWithKey()
100		{
101		$key = 'key';
102		$expected = true;
103
104		$this->storageMock->expects($this->once())
105		->method('has')
106		->with(
107		$this->equalTo($key)
108		)
109		->willReturn($expected);
110
111		$actual = $this->cache->has($key);
112		$this->assertEquals($expected, $actual);
113		}
114
115		/**
116		* Test that CacheStorageInterface::has() is called and returns false on failing to find key
117		*/
118		public function testHasFoundNoKey()
119		{
120		$key = 'key';
121		$expected = false;
122
123		$this->storageMock->expects($this->once())
124		->method('has')
125		->with(
126		$this->equalTo($key)
127		)
128		->willReturn($expected);
129
130		$actual = $this->cache->has($key);
131		$this->assertEquals($expected, $actual);
132		}
133
134
135		/**
136		* Test that CacheStorageInterface::has() is called and returns false on failing to find key
137		*/
138		public function testGetInvalidKey()
139		{
140		$key = 21021000;
141		$this->expectException(InvalidArgumentException::class);
142		$this->cache->get($key);
143		}
144
145		/**
146		* Test that CacheStorageInterface::get() returns values when key is present.
147		*/
148		public function testGetFoundValue()
149		{
150		$key = 'key';
151		$expected = 'cacheValue';
152		$default = 'default value';
153
154		$this->storageMock->expects($this->once())
155		->method('has')
156		->with(
157		$this->equalTo($key)
158		)
159		->willReturn(true);
160
161		$this->storageMock->expects($this->once())
162		->method('get')
163		->with(
164		$this->equalTo($key)
165		)
166		->willReturn($expected);
167
168		$actual = $this->cache->get($key, $default);
169		$this->assertEquals($expected, $actual);
170		}
171
172		/**
173		* Test that CacheStorageInterface::get() doesn't return values and default is returned.
174		*/
175	View Code Duplication	public function testGetDefaultValue()
		0 ignored issues – show Duplication introduced 2017-12-03 12:38 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
176		{
177		$key = 'key';
178		$default = 'default value';
179
180		$this->storageMock->expects($this->once())
181		->method('has')
182		->with(
183		$this->equalTo($key)
184		)
185		->willReturn(false);
186
187		$actual = $this->cache->get($key, $default);
188		$this->assertEquals($default, $actual);
189		}
190
191		/**
192		* Test that CacheStorageInterface::delete() is called
193		*/
194		public function testDelete()
195		{
196		$key = 'key';
197		$this->storageMock->expects($this->once())
198		->method('delete')
199		->with(
200		$this->equalTo($key)
201		);
202		$this->cache->delete($key);
203		}
204
205		/**
206		*
207		*/
208		public function testGetMultiple(){
209
210		$expected = [
211		'foo' => 'fooValue',
212		'bar' => 'barValue',
213		'baz' => 'bazValue'
214		];
215
216		$i = 0;
217
218		foreach ($expected as $key => $value){
219
220		$this->storageMock->expects($this->at($i))
221		->method('get')
222		->with(
223		$this->equalTo($key)
224		)
225		->willReturn($value);
226		$i++;
227		}
228
229		$actual = $this->cache->getMultiple(\array_keys($expected));
		0 ignored issues – show Documentation introduced 2017-03-21 15:27 UTC by Report Bug Copy Issue Report `\array_keys($expected)` is of type `array<integer,string>`, but the function expects a `object<iterable>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
230
231		$this->assertEquals($expected, $actual);
232
233		}
234
235		/**
236		*
237		*/
238		public function testSetMultiple(){
239
240		$keys = [
241		'foo' => 'fooValue',
242		'bar' => 'barValue',
243		'baz' => 'bazValue'
244		];
245
246		$addStatus = true;
247		$expected = true;
248
249		$i = 0;
250		$expires = 60 * 60;
251
252		foreach ($keys as $key => $value){
253		$this->storageMock->expects($this->at($i))
254		->method('set')
255		->with(
256		$this->equalTo($key),
257		$this->equalTo($value),
258		$this->equalTo($expires)
259		)
260		->willReturn($addStatus);
261		$i++;
262		}
263
264		$actual = $this->cache->setMultiple($keys,$expires);
		0 ignored issues – show Documentation introduced 2017-03-21 15:27 UTC by Report Bug Copy Issue Report `$keys` is of type `array<string,string,{"fo...tring","baz":"string"}>`, but the function expects a `object<iterable>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
265		$this->assertEquals($expected, $actual);
266		}
267
268		/**
269		*
270		*/
271		public function testSetMultipleWithFailure(){
272
273		$keys = [
274		'foo' => 'fooValue',
275		'bar' => 'barValue',
276		'baz' => 'bazValue'
277		];
278
279		$addStatus = true;
280		$expected = false;
281
282		$i = 0;
283		$expires = 60 * 60;
284
285		foreach ($keys as $key => $value){
286
287		$status = $addStatus;
288
289		if ($i === 1){
290		$status = false;
291		}
292
293		$this->storageMock->expects($this->at($i))
294		->method('set')
295		->with(
296		$this->equalTo($key),
297		$this->equalTo($value),
298		$this->equalTo($expires)
299		)
300		->willReturn($status);
301		$i++;
302		}
303
304		$actual = $this->cache->setMultiple($keys,$expires);
		0 ignored issues – show Documentation introduced 2017-03-22 14:37 UTC by Report Bug Copy Issue Report `$keys` is of type `array<string,string,{"fo...tring","baz":"string"}>`, but the function expects a `object<iterable>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
305		$this->assertEquals($expected, $actual);
306		}
307
308		/**
309		*
310		*/
311		public function testDeleteMultiple(){
312
313		$keys = ['foo','bar','baz'];
314		$deleteStatus = true;
315		$expected = true;
316
317		foreach ($keys as $i => $key){
318		$this->storageMock->expects($this->at($i))
319		->method('delete')
320		->with(
321		$this->equalTo($key)
322		)
323		->willReturn($deleteStatus);
324		}
325
326		$actual = $this->cache->deleteMultiple($keys);
		0 ignored issues – show Documentation introduced 2017-03-21 15:27 UTC by Report Bug Copy Issue Report `$keys` is of type `array<integer,string,{"0..."string","2":"string"}>`, but the function expects a `object<iterable>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
327		$this->assertEquals($expected, $actual);
328		}
329
330		/**
331		*
332		*/
333		public function testDeleteMultipleFailure(){
334		$keys = ['foo','bar','baz'];
335		$expected = false;
336		$deleteStatus = true;
337		foreach ($keys as $i => $key){
338		if ($i === 1){
339		$deleteStatus = false;
340		}
341		$this->storageMock->expects($this->at($i))
342		->method('delete')
343		->with(
344		$this->equalTo($key)
345		)
346		->willReturn($deleteStatus);
347		}
348		$actual = $this->cache->deleteMultiple($keys);
		0 ignored issues – show Documentation introduced 2017-03-21 15:27 UTC by Report Bug Copy Issue Report `$keys` is of type `array<integer,string,{"0..."string","2":"string"}>`, but the function expects a `object<iterable>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
349		$this->assertEquals($expected, $actual);
350		}
351
352		/**
353		* Test that storage clear is called.
354		*/
355		public function testclear(){
356		$this->storageMock
357		->expects($this->once())
358		->method('clear');
359
360		$this->cache->clear();
361		}
362		}
363

djsmithme / Cache

Branch — master (1afc22)

CacheTest::testGetMultiple() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like