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

Passed

Push — master ( 756562...2dbe85 )

by Dan

created 2017-03-22 14:01 UTC

CacheTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	420
Duplicated Lines	23.81 %

Importance

Changes

Metric	Value
wmc	13
c	0
b	0
f	0
dl	100
loc	420
rs	10

35 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	5	1
A	testSetInvalidKey()	0	6	1
A	testSet()	15	15	1
A	testSetDateInterval()	0	17	1
A	testHasInvalidKey()	0	6	1
A	testHasFoundWithKey()	15	15	1
A	testHasFoundNoKey()	15	15	1
A	testGetInvalidKey()	0	6	1
A	testGetFoundValue()	0	23	1
A	testGetDefaultValue()	0	15	1
A	testDelete()	0	10	1
A	hp$0 ➔ current()	0	1	1
A	hp$0 ➔ next()	0	1	1
A	hp$0 ➔ key()	0	1	1
A	hp$0 ➔ valid()	0	1	1
A	hp$0 ➔ rewind()	0	1	1
B	testGetMultiple()	0	26	2
B	testSetMultiple()	0	29	2
A	testDeleteMultiple()	0	18	2
A	testDeleteMultipleFailure()	0	23	3
A	testclear()	0	5	1
A	testArrayHasKeys()	10	10	1
A	testArrayHasNoKeys()	8	8	1
A	testHasFailure()	9	9	1
A	testHasNoFailure()	9	9	1
A	testIsTraversable()	9	9	1
A	testIsNotTraversable()	8	8	1
A	testIsTraversableIterator()	0	15	1
A	test_isValidKeyValid()	0	1	1
A	test_isValidKeyInvalid()	0	1	1
A	test_checkTraversableArray()	0	1	1
A	test_checkTraversableTraversable()	0	1	1
A	test_checkTraversableException()	0	1	1
A	test_hasFailureNoFailure()	0	1	1
A	test_hasFailureException()	0	1	1

How to fix Duplicated Code

<?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);
    }

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

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

    /**
     * Test that array has keys.
     */
    public function testArrayHasKeys(){

        $data = ['a' => 'foo', 'b' => 'bar'];

        $reflector = new \ReflectionClass(Cache::class);
        $method = $reflector->getMethod('_hasKeys');
        $method->setAccessible(true);
        $actual = $method->invokeArgs($this->cache, [$data]);

        $this->assertEquals(true, $actual);
    }

    /**
     * Test exception thrown when array is missing keys.
     */
    public function testArrayHasNoKeys(){

        $this->expectException(InvalidArgumentException::class);
        $data = ['foo','bar'];
        $reflector = new \ReflectionClass(Cache::class);
        $method = $reflector->getMethod('_hasKeys');
        $method->setAccessible(true);
        $method->invokeArgs($this->cache, [$data]);
    }

    /**
     * Test array contains a failure.
     */
    public function testHasFailure(){

        $results = [true,true,true,false,true];
        $reflector = new \ReflectionClass(Cache::class);
        $method = $reflector->getMethod('_hasFailure');
        $method->setAccessible(true);
        $actual = $method->invokeArgs($this->cache, [$results]);
        $expected = true;
        $this->assertEquals($expected, $actual);
    }

    /**
     * Test array doesn't contain a failure.
     */
    public function testHasNoFailure(){

        $results = [true,true,true,true,true];
        $reflector = new \ReflectionClass(Cache::class);
        $method = $reflector->getMethod('_hasFailure');
        $method->setAccessible(true);
        $actual = $method->invokeArgs($this->cache, [$results]);
        $expected = false;
        $this->assertEquals($expected, $actual);
    }

    /**
     * Test that array is Traversable
     */
    public function testIsTraversable(){

        $data = ['a','b','c','d'];
        $reflector = new \ReflectionClass(Cache::class);
        $method = $reflector->getMethod('_isTraversable');
        $method->setAccessible(true);
        $actual = $method->invokeArgs($this->cache, [$data]);
        $expected = true;
        $this->assertEquals($expected, $actual);
    }

    /**
     * Test that string is not Traversable
     */
    public function testIsNotTraversable(){

        $this->expectException(InvalidArgumentException::class);
        $data = 'some-random-string';
        $reflector = new \ReflectionClass(Cache::class);
        $method = $reflector->getMethod('_isTraversable');
        $method->setAccessible(true);
        $method->invokeArgs($this->cache, [$data]);
    }

    /**
     * Test that instance of Iterator is traversable
     */
    public function testIsTraversableIterator(){
        $iterator = new class implements \Iterator {
            public function current(){}
            public function next(){}
            public function key(){}
            public function valid(){}
            public function rewind(){}
        };
        $reflector = new \ReflectionClass(Cache::class);
        $method = $reflector->getMethod('_isTraversable');
        $method->setAccessible(true);
        $actual = $method->invokeArgs($this->cache, [$iterator]);
        $expected = true;
        $this->assertEquals($expected, $actual);
    }


    /**
     * 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;

djsmithme / Cache

Push — master ( 756562...2dbe85 )

CacheTest A

Complexity

Size/Duplication

Importance

35 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like