CacheTest::testConstructWithStorage() - Code Metrics - Inspection of "Merge pull request #6 from djsmithme/psr-simple-ca..." - djsmithme/Cache - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 00fae0...ee941a )

by Dan

created 2017-03-21 15:12 UTC

CacheTest::testConstructWithStorage() A

↳ Parent: CacheTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	5
rs	9.4285
cc	1
eloc	4
nc	1
nop	0

<?php

namespace Tests\Cache;

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

/**
 * Class CacheTest
 * @package Tests\Cache
 */
class CacheTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @var Cache
     */
    public $cache;

    /**
     * @var CacheStorageInterface
     */
    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 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);
    }

    public function testclear(){
        $this->storageMock->expects($this->once())

            ->method('clear');

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

    /**
     * Private functions
     */
    public function test_isValidKeyValid(){}
    public function test_isValidKeyInvalid(){}
    public function test_checkTraversableArray(){}
    public function test_checkTraversableTraversable(){}
    public function test_checkTraversableException(){}
    public function test_hasFailureNoFailure(){}
    public function test_hasFailureException(){}
}


1		<?php
2
3		namespace Tests\Cache;
4
5		use Ds\Cache\Cache;
6		use Ds\Cache\CacheStorageInterface;
7		use Ds\Cache\NullStorage;
8		use Psr\SimpleCache\InvalidArgumentException;
9
10		/**
11		* Class CacheTest
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 CacheStorageInterface
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 2016-04-09 18:07 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())
		0 ignored issues – show Bug introduced 2016-05-24 12:07 UTC by Report Bug Copy Issue Report The method `expects()` does not seem to exist on `object<Ds\Cache\CacheStorageInterface>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
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())
		0 ignored issues – show Bug introduced 2017-03-21 15:27 UTC by Report Bug Copy Issue Report The method `expects()` does not seem to exist on `object<Ds\Cache\CacheStorageInterface>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
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	View Code Duplication	public function testHasFoundWithKey()
		0 ignored issues – show Duplication introduced 2016-04-09 18:07 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...
100		{
101		$key = 'key';
102		$expected = true;
103
104		$this->storageMock->expects($this->once())
		0 ignored issues – show Bug introduced 2017-03-21 15:27 UTC by Report Bug Copy Issue Report The method `expects()` does not seem to exist on `object<Ds\Cache\CacheStorageInterface>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
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	View Code Duplication	public function testHasFoundNoKey()
		0 ignored issues – show Duplication introduced 2017-03-21 15:27 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...
119		{
120		$key = 'key';
121		$expected = false;
122
123		$this->storageMock->expects($this->once())
		0 ignored issues – show Bug introduced 2017-03-21 15:27 UTC by Report Bug Copy Issue Report The method `expects()` does not seem to exist on `object<Ds\Cache\CacheStorageInterface>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
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())
		0 ignored issues – show Bug introduced 2017-03-21 15:27 UTC by Report Bug Copy Issue Report The method `expects()` does not seem to exist on `object<Ds\Cache\CacheStorageInterface>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
155		->method('has')
156		->with(
157		$this->equalTo($key)
158		)
159		->willReturn(true);
160
161		$this->storageMock->expects($this->once())
		0 ignored issues – show Bug introduced 2017-03-21 15:27 UTC by Report Bug Copy Issue Report The method `expects()` does not seem to exist on `object<Ds\Cache\CacheStorageInterface>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
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		public function testGetDefaultValue()
176		{
177		$key = 'key';
178		$default = 'default value';
179
180		$this->storageMock->expects($this->once())
		0 ignored issues – show Bug introduced 2017-03-21 15:27 UTC by Report Bug Copy Issue Report The method `expects()` does not seem to exist on `object<Ds\Cache\CacheStorageInterface>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
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())
		0 ignored issues – show Bug introduced 2017-03-21 15:27 UTC by Report Bug Copy Issue Report The method `expects()` does not seem to exist on `object<Ds\Cache\CacheStorageInterface>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
198		->method('delete')
199		->with(
200		$this->equalTo($key)
201		);
202		$this->cache->delete($key);
203		}
204
205		public function testGetMultiple(){
206
207		$expected = [
208		'foo' => 'fooValue',
209		'bar' => 'barValue',
210		'baz' => 'bazValue'
211		];
212
213		$i = 0;
214
215		foreach ($expected as $key => $value){
216
217		$this->storageMock->expects($this->at($i))
		0 ignored issues – show Bug introduced 2017-03-21 15:27 UTC by Report Bug Copy Issue Report The method `expects()` does not seem to exist on `object<Ds\Cache\CacheStorageInterface>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
218		->method('get')
219		->with(
220		$this->equalTo($key)
221		)
222		->willReturn($value);
223		$i++;
224		}
225
226		$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...
227
228		$this->assertEquals($expected, $actual);
229
230		}
231
232		public function testSetMultiple(){
233
234		$keys = [
235		'foo' => 'fooValue',
236		'bar' => 'barValue',
237		'baz' => 'bazValue'
238		];
239
240		$addStatus = true;
241		$expected = true;
242
243		$i = 0;
244		$expires = 60 * 60;
245
246		foreach ($keys as $key => $value){
247		$this->storageMock->expects($this->at($i))
		0 ignored issues – show Bug introduced 2017-03-21 15:27 UTC by Report Bug Copy Issue Report The method `expects()` does not seem to exist on `object<Ds\Cache\CacheStorageInterface>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
248		->method('set')
249		->with(
250		$this->equalTo($key),
251		$this->equalTo($value),
252		$this->equalTo($expires)
253		)
254		->willReturn($addStatus);
255		$i++;
256		}
257
258		$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...
259		$this->assertEquals($expected, $actual);
260		}
261
262		public function testDeleteMultiple(){
263
264		$keys = ['foo','bar','baz'];
265		$deleteStatus = true;
266		$expected = true;
267
268		foreach ($keys as $i => $key){
269		$this->storageMock->expects($this->at($i))
		0 ignored issues – show Bug introduced 2017-03-21 15:27 UTC by Report Bug Copy Issue Report The method `expects()` does not seem to exist on `object<Ds\Cache\CacheStorageInterface>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
270		->method('delete')
271		->with(
272		$this->equalTo($key)
273		)
274		->willReturn($deleteStatus);
275		}
276
277		$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...
278		$this->assertEquals($expected, $actual);
279		}
280
281		public function testDeleteMultipleFailure(){
282
283		$keys = ['foo','bar','baz'];
284		$expected = false;
285		$deleteStatus = true;
286
287		foreach ($keys as $i => $key){
288
289		if ($i === 1){
290		$deleteStatus = false;
291		}
292
293		$this->storageMock->expects($this->at($i))
		0 ignored issues – show Bug introduced 2017-03-21 15:27 UTC by Report Bug Copy Issue Report The method `expects()` does not seem to exist on `object<Ds\Cache\CacheStorageInterface>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
294		->method('delete')
295		->with(
296		$this->equalTo($key)
297		)
298		->willReturn($deleteStatus);
299		}
300
301		$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...
302		$this->assertEquals($expected, $actual);
303		}
304
305		public function testclear(){
306		$this->storageMock->expects($this->once())
		0 ignored issues – show Bug introduced 2017-03-21 15:27 UTC by Report Bug Copy Issue Report The method `expects()` does not seem to exist on `object<Ds\Cache\CacheStorageInterface>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
307		->method('clear');
308
309		$this->cache->clear();
310		}
311
312		/**
313		* Private functions
314		*/
315		public function test_isValidKeyValid(){}
316		public function test_isValidKeyInvalid(){}
317		public function test_checkTraversableArray(){}
318		public function test_checkTraversableTraversable(){}
319		public function test_checkTraversableException(){}
320		public function test_hasFailureNoFailure(){}
321		public function test_hasFailureException(){}
322		}
323

djsmithme / Cache

Push — master ( 00fae0...ee941a )

CacheTest::testConstructWithStorage() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like