CacheTest::testSetMultipleWithFailure() - Code Metrics - Inspection of "Unit Tests:" - djsmithme/Cache - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#12)

by Dan
created 2017-03-22 14:39 UTC
CacheTest::testSetMultipleWithFailure() B

↳ Parent: CacheTest
Complexity

Conditions	3
Paths	3
Size

Total Lines	36
Code Lines	23
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
c	0
b	0
f	0
dl	0
loc	36
rs	8.8571
cc	3
eloc	23
nc	3
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 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(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);
    }

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

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

Pull Request — master (#12)

CacheTest::testSetMultipleWithFailure() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
