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

Passed
Push — master ( 2dbe85...59ef95 )

by Dan
created 2017-03-22 14:54 UTC
CacheTest::testHasInvalidKey() A

↳ Parent: CacheTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	6
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
dl	0
loc	6
rs	9.4285
c	0
b	0
f	0
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;
use Tests\Cache\Mock\IteratorMock;

/**
 * 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 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();
    }

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

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

        $reflector = new \ReflectionClass('\Ds\Cache\Cache');
        $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('\Ds\Cache\Cache');
        $method = $reflector->getMethod('_hasFailure');
        $method->setAccessible(true);
        $actual = $method->invokeArgs($this->cache, [$results]);
        $expected = true;
        $this->assertEquals($expected, $actual);
    }

    /**
     *
     */
    public function testHasNoFailure(){

        $results = [true,true,true,true,true];
        $reflector = new \ReflectionClass('\Ds\Cache\Cache');
        $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('\Ds\Cache\Cache');
        $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('\Ds\Cache\Cache');
        $method = $reflector->getMethod('_isTraversable');
        $method->setAccessible(true);
        $method->invokeArgs($this->cache, [$data]);
    }

    /**
     * Test that instance of Iterator is traversable
     */
    public function testIsTraversableIterator(){

        $iterator = new IteratorMock();
        $reflector = new \ReflectionClass('\Ds\Cache\Cache');
        $method = $reflector->getMethod('_isTraversable');
        $method->setAccessible(true);
        $actual = $method->invokeArgs($this->cache, [$iterator]);
        $expected = true;
        $this->assertEquals($expected, $actual);
    }
}

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			use Tests\Cache\Mock\IteratorMock;
10
11			/**
12			* Class CacheTest
13			* @package Tests\Cache
14			*/
15			class CacheTest extends \PHPUnit_Framework_TestCase
16			{
17			/**
18			* @var Cache
19			*/
20			public $cache;
21
22			/**
23			* @var CacheStorageInterface
24			*/
25			public $storageMock;
26
27			/**
28			*
29			*/
30			public function setUp()
31			{
32			$this->storageMock = $this->getMockBuilder(CacheStorageInterface::class)->getMock();
33			$this->cache = new Cache($this->storageMock);
34			}
35
36			/**
37			* Test that CacheStorageInterface::set() invalid key exception
38			*/
39			public function testSetInvalidKey()
40			{
djsmithme / Cache

Push — master ( 2dbe85...59ef95 )

CacheTest::testHasInvalidKey() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
