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

Completed

Push — master ( 59ef95...657d07 )

by Dan

created 2017-03-22 16:38 UTC

CacheTest::testIsTraversable() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	8

Duplication

Lines	9
Ratio	100 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	9
loc	9
rs	9.6666
cc	1
eloc	8
nc	1
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 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 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 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		public function testSet()
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		/**
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))
		0 ignored issues – show Bug introduced 2017-03-22 14:04 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...
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))
		0 ignored issues – show Bug introduced 2017-03-22 14:04 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...
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))
		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('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))
		0 ignored issues – show Bug introduced 2017-03-22 14:37 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...
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))
		0 ignored issues – show Bug introduced 2017-03-22 16:41 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...
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
		0 ignored issues – show Bug introduced 2017-03-22 16:41 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...
357		->expects($this->once())
358		->method('clear');
359
360		$this->cache->clear();
361		}
362		}
363

djsmithme / Cache

Push — master ( 59ef95...657d07 )

CacheTest::testIsTraversable() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like