SimpleCacheAdapterTest::testConstructorThrowsExceptionWhenNotClearableCacheIsUsed() - Code Metrics - Inspection of "Added support for Doctrine\Cache 1.7 with deleteMu..." - Roave/DoctrineSimpleCache - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#22)

by James
created 2017-08-29 19:36 UTC
henNotClearableCacheIsUsed() A

↳ Parent: SimpleCacheAdapterTest::testGetProxiesToDoctrineFetch()
Complexity

Conditions	1
Paths	1
Size

Total Lines	8
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Importance

Changes	2
Bugs	0	Features	1
Metric	Value
dl	0
loc	8
rs	9.4285
c	2
b	0
f	1
cc	1
eloc	4
nc	1
nop	0
<?php
declare(strict_types = 1);

namespace RoaveTest\DoctrineSimpleCache;

use Doctrine\Common\Cache\ArrayCache;
use Roave\DoctrineSimpleCache\Exception\CacheException;
use Roave\DoctrineSimpleCache\Exception\InvalidArgumentException;
use Roave\DoctrineSimpleCache\SimpleCacheAdapter;
use RoaveTestAsset\DoctrineSimpleCache\FullyImplementedCache;
use RoaveTestAsset\DoctrineSimpleCache\NotClearableCache;
use RoaveTestAsset\DoctrineSimpleCache\NotMultiOperationCache;

/**
 * @covers \Roave\DoctrineSimpleCache\SimpleCacheAdapter
 */
final class SimpleCacheAdapterTest extends \PHPUnit_Framework_TestCase
{
    public function invalidTTLs() : array
    {
        return [
            [''],
            [true],
            [false],
            ['abc'],
            [2.5],
            [' 1'], // can be casted to a int
            ['12foo'], // can be casted to a int
            ['025'], // can be interpreted as hex
            [new \stdClass()],
            [['array']],
        ];
    }

    public function validKeys()
    {
        return [
            ['AbC19_.'],
            ['1234567890123456789012345678901234567890123456789012345678901234'],
        ];
    }

    public function invalidKeys()
    {
        return [
            [''],
            [true],
            [false],
            [null],
            [2],
            [2.5],
            ['{str'],
            ['rand{'],
            ['rand{str'],
            ['rand}str'],
            ['rand(str'],
            ['rand)str'],
            ['rand/str'],
            ['rand\\str'],
            ['rand@str'],
            ['rand:str'],
            [new \stdClass()],
            [['array']],
        ];
    }

    public function testConstructorThrowsExceptionWhenNotMultiPuttableCacheIsUsed()
    {
        /** @var NotMultiOperationCache|\PHPUnit_Framework_MockObject_MockObject $doctrineCache */
        $doctrineCache = $this->createMock(NotMultiOperationCache::class);

        $this->expectException(CacheException::class);
        new SimpleCacheAdapter($doctrineCache);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    public function testGetProxiesToDoctrineFetch()

    {
        $key = uniqid('key', true);
        $value = uniqid('value', true);

        /** @var FullyImplementedCache|\PHPUnit_Framework_MockObject_MockObject $doctrineCache */
        $doctrineCache = $this->createMock(FullyImplementedCache::class);
        $doctrineCache->expects(self::once())->method('fetch')->with($key)->willReturn($value);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $psrCache = new SimpleCacheAdapter($doctrineCache);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        self::assertSame($value, $psrCache->get($key));
    }

    public function testGetWithNotExistingKey()
    {
        $key = uniqid('key', true);
        $value = uniqid('value', true);

        $psrCache = new SimpleCacheAdapter(new ArrayCache());
        $psrCache->set($key, $value);

        $default = uniqid('default', true);
        self::assertSame($value, $psrCache->get($key, $default));

        $anotherKey = uniqid('key', true);
        self::assertSame($default, $psrCache->get($anotherKey, $default));
    }

    public function testGetWithFalseValueStoredInCache()

    {
        $key = uniqid('key', true);

        $psrCache = new SimpleCacheAdapter(new ArrayCache());
        $psrCache->set($key, false);

        self::assertFalse($psrCache->get($key, uniqid('default', true)));
    }

    public function testSetProxiesToDoctrineSave()
    {
        $key = uniqid('key', true);
        $value = uniqid('value', true);
        $ttl = random_int(1000, 9999);

        /** @var FullyImplementedCache|\PHPUnit_Framework_MockObject_MockObject $doctrineCache */
        $doctrineCache = $this->createMock(FullyImplementedCache::class);
        $doctrineCache->expects(self::once())->method('save')->with($key, $value, $ttl)->willReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $psrCache = new SimpleCacheAdapter($doctrineCache);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        self::assertTrue($psrCache->set($key, $value, $ttl));
    }

    public function testSetWithDateIntervalTTL()
    {
        $key = uniqid('key', true);
        $value = uniqid('value', true);
        $ttl_date = \DateInterval::createFromDateString('1 day');

        $psrCache = new SimpleCacheAdapter(new ArrayCache());

        // This does not test if ttl is correctly set to 86400 sec.
        self::assertTrue($psrCache->set($key, $value, $ttl_date));
        self::assertSame($psrCache->get($key), $value);
    }

    public function testSetWithNonPositiveTTL()
    {
        $key = uniqid('key', true);
        $value = uniqid('value', true);
        $ttl = random_int(1000, 9999);

        $psrCache = new SimpleCacheAdapter(new ArrayCache());

        $psrCache->set($key, $value, $ttl);
        self::assertSame($psrCache->get($key), $value);

        $psrCache->set($key, $value, -1);
        self::assertNull($psrCache->get($key), null);
    }

    /**
     * @param mixed $ttl
     * @dataProvider invalidTTLs
     */
    public function testSetWithInvalidTTL($ttl)

    {
        $key = uniqid('key', true);
        $value = uniqid('value', true);

        $psrCache = new SimpleCacheAdapter(new ArrayCache());

        $this->expectException(InvalidArgumentException::class);
        $psrCache->set($key, $value, $ttl);
    }

    public function testDeleteProxiesToDoctrineDelete()

    {
        $key = uniqid('key', true);

        /** @var FullyImplementedCache|\PHPUnit_Framework_MockObject_MockObject $doctrineCache */
        $doctrineCache = $this->createMock(FullyImplementedCache::class);
        $doctrineCache->expects(self::once())->method('delete')->with($key)->willReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $psrCache = new SimpleCacheAdapter($doctrineCache);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        self::assertTrue($psrCache->delete($key));
    }

    public function testClearProxiesToDeleteAll()
    {
        /** @var FullyImplementedCache|\PHPUnit_Framework_MockObject_MockObject $doctrineCache */
        $doctrineCache = $this->createMock(FullyImplementedCache::class);
        $doctrineCache->expects(self::once())->method('deleteAll')->with()->willReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $psrCache = new SimpleCacheAdapter($doctrineCache);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        self::assertTrue($psrCache->clear());
    }

    public function testGetMultipleProxiesToFetchMultiple()
    {
        $values = [
            uniqid('key1', true) => uniqid('value1', true),
            uniqid('key2', true) => uniqid('value2', true),
        ];
        $keys = array_keys($values);

        /** @var FullyImplementedCache|\PHPUnit_Framework_MockObject_MockObject $doctrineCache */
        $doctrineCache = $this->createMock(FullyImplementedCache::class);
        $doctrineCache->expects(self::once())->method('fetchMultiple')->with($keys)->willReturn($values);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $psrCache = new SimpleCacheAdapter($doctrineCache);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        self::assertSame($values, $psrCache->getMultiple($keys));
    }

    public function testGetMultipleWithPartialKeys()
    {
        $values = [
            uniqid('key1', true) => uniqid('value1', true),
            uniqid('key2', true) => uniqid('value2', true),
        ];
        $keys = array_keys($values);

        $psrCache = new SimpleCacheAdapter(new ArrayCache());
        $psrCache->setMultiple($values);

        $default = uniqid('default', true);
        $invalid_key = uniqid('key3', true);
        $keys[] = $invalid_key;
        $values[$invalid_key] = $default;

        self::assertSame($values, $psrCache->getMultiple($keys, $default));
    }

    /**
     * @param mixed $key
     * @dataProvider invalidKeys
     */
    public function testGetMultipleThrowsExceptionWithInvalidKeys($key)
    {
        $this->expectException(InvalidArgumentException::class);

        $psrCache = new SimpleCacheAdapter(new ArrayCache());
        $psrCache->getMultiple([$key]);
    }

    /**
     * @param mixed $key
     * @dataProvider validKeys
     */
    public function testGetMultipleAcceptsTraversable($key)

    {
        $values = [
            $key => uniqid('value', true),
        ];

        /** @var FullyImplementedCache|\PHPUnit_Framework_MockObject_MockObject $doctrineCache */
        $doctrineCache = $this->createMock(FullyImplementedCache::class);
        $doctrineCache->expects(self::once())->method('fetchMultiple')->with(array_keys($values))->willReturn($values);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $psrCache = new SimpleCacheAdapter($doctrineCache);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        $psrCache->getMultiple(new \ArrayObject(array_keys($values)));
    }

    public function testGetMultipleAcceptsGenerator()
    {
        $values = [
            uniqid('key0', true) => uniqid('value0', true),
            uniqid('key1', true) => uniqid('value1', true),
        ];

        $generator = function () use ($values) {
            /** @noinspection ForeachOnArrayComponentsInspection */
            foreach (array_keys($values) as $k) {
                yield $k;
            }
        };

        $psrCache = new SimpleCacheAdapter(new ArrayCache());
        $psrCache->setMultiple($values);

        self::assertSame($values, $psrCache->getMultiple($generator()));
    }

    public function testGetMultipleThrowsExceptionWhenNotArrayOrTraversable()

    {
        $this->expectException(InvalidArgumentException::class);

        $psrCache = new SimpleCacheAdapter(new ArrayCache());
        $psrCache->getMultiple(uniqid('string', true));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    public function testSetMultipleProxiesToSaveMultiple()
    {
        $values = [
            uniqid('key1', true) => uniqid('value1', true),
            uniqid('key2', true) => uniqid('value2', true),
        ];

        /** @var FullyImplementedCache|\PHPUnit_Framework_MockObject_MockObject $doctrineCache */
        $doctrineCache = $this->createMock(FullyImplementedCache::class);
        $doctrineCache->expects(self::once())->method('saveMultiple')->with($values)->willReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $psrCache = new SimpleCacheAdapter($doctrineCache);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        self::assertTrue($psrCache->setMultiple($values));
    }

    public function testSetMultipleWithDateIntervalTTL()
    {
        $values = [
            uniqid('key1', true) => uniqid('value1', true),
            uniqid('key2', true) => uniqid('value2', true),
        ];
        $keys = array_keys($values);
        $ttl_date = \DateInterval::createFromDateString('1 day');

        $psrCache = new SimpleCacheAdapter(new ArrayCache());

        // This does not test if ttl is correctly set to 86400 sec.
        self::assertTrue($psrCache->setMultiple($values, $ttl_date));
        self::assertSame($values, $psrCache->getMultiple($keys));
    }

    public function testSetMultipleWithNonPositiveTTL()
    {
        $values = [
            uniqid('key1', true) => uniqid('value1', true),
            uniqid('key2', true) => uniqid('value2', true),
        ];
        $keys = array_keys($values);

        $psrCache = new SimpleCacheAdapter(new ArrayCache());
        $psrCache->setMultiple($values);

        $volatile = [$keys[0] => uniqid('value3', true)];
        $psrCache->setMultiple($volatile, -1);

        self::assertNull($psrCache->get($keys[0]));
        self::assertNotNull($psrCache->get($keys[1]));
    }

    /**
     * @param mixed $ttl
     * @dataProvider invalidTTLs
     */
    public function testSetMultipleWithInvalidTTL($ttl)
    {
        $values = [
            uniqid('key1', true) => uniqid('value1', true),
            uniqid('key2', true) => uniqid('value2', true),
        ];

        $psrCache = new SimpleCacheAdapter(new ArrayCache());

        $this->expectException(InvalidArgumentException::class);
        $psrCache->setMultiple($values, $ttl);
    }

    public function testSetMultipleThrowsExceptionWhenNotArrayOrTraversable()

    {
        $this->expectException(InvalidArgumentException::class);

        $psrCache = new SimpleCacheAdapter(new ArrayCache());
        $psrCache->setMultiple(uniqid('string', true));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    public function testSetMultipleAcceptsGenerator()
    {
        $key0 = uniqid('key0', true);
        $key1 = uniqid('key1', true);
        $values = [
            $key0 => uniqid('value0', true),
            $key1 => uniqid('value1', true),
        ];

        $generator = function () use ($values) {
            foreach ($values as $k => $v) {
                yield $k => $v;
            }
        };

        $psrCache = new SimpleCacheAdapter(new ArrayCache());
        $psrCache->setMultiple($generator());

        self::assertSame($values[$key0], $psrCache->get($key0));
        self::assertSame($values[$key1], $psrCache->get($key1));
    }

    public function testDeleteMultipleReturnsTrueWhenAllDeletesSucceed()

    {
        $keys = [
            uniqid('key1', true),
            uniqid('key2', true),
        ];

        /** @var FullyImplementedCache|\PHPUnit_Framework_MockObject_MockObject $doctrineCache */
        $doctrineCache = $this->createMock(FullyImplementedCache::class);
        $doctrineCache->expects(self::once())->method('deleteMultiple')->with($keys)->willReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $psrCache = new SimpleCacheAdapter($doctrineCache);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        self::assertTrue($psrCache->deleteMultiple($keys));
    }

    public function testDeleteMultipleReturnsFalseWhenOneDeleteFails()

    {
        $keys = [
            uniqid('key1', true),
            uniqid('key2', true),
        ];

        /** @var FullyImplementedCache|\PHPUnit_Framework_MockObject_MockObject $doctrineCache */
        $doctrineCache = $this->createMock(FullyImplementedCache::class);
        $doctrineCache->expects(self::once())->method('deleteMultiple')->with($keys)->willReturn(false);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $psrCache = new SimpleCacheAdapter($doctrineCache);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        self::assertFalse($psrCache->deleteMultiple($keys));
    }

    public function testHasProxiesToDoctrineContains()

    {
        $key = uniqid('key', true);

        /** @var FullyImplementedCache|\PHPUnit_Framework_MockObject_MockObject $doctrineCache */
        $doctrineCache = $this->createMock(FullyImplementedCache::class);
        $doctrineCache->expects(self::once())->method('contains')->with($key)->willReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $psrCache = new SimpleCacheAdapter($doctrineCache);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        self::assertTrue($psrCache->has($key));
    }
}

Pull Request — master (#22)

henNotClearableCacheIsUsed() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2			declare(strict_types = 1);
3
4			namespace RoaveTest\DoctrineSimpleCache;
5
6			use Doctrine\Common\Cache\ArrayCache;
7			use Roave\DoctrineSimpleCache\Exception\CacheException;
8			use Roave\DoctrineSimpleCache\Exception\InvalidArgumentException;
9			use Roave\DoctrineSimpleCache\SimpleCacheAdapter;
10			use RoaveTestAsset\DoctrineSimpleCache\FullyImplementedCache;
11			use RoaveTestAsset\DoctrineSimpleCache\NotClearableCache;
12			use RoaveTestAsset\DoctrineSimpleCache\NotMultiOperationCache;
13
14			/**
15			* @covers \Roave\DoctrineSimpleCache\SimpleCacheAdapter
16			*/
17			final class SimpleCacheAdapterTest extends \PHPUnit_Framework_TestCase
18			{
19			public function invalidTTLs() : array
20			{
21			return [
22			[''],
23			[true],
24			[false],
25			['abc'],
26			[2.5],
27			[' 1'], // can be casted to a int
28			['12foo'], // can be casted to a int
29			['025'], // can be interpreted as hex
30			[new \stdClass()],
31			[['array']],
32			];
33			}
34
35			public function validKeys()
36			{
37			return [
38			['AbC19_.'],
39			['1234567890123456789012345678901234567890123456789012345678901234'],
40			];
Roave / DoctrineSimpleCache

Pull Request — master (#22)

henNotClearableCacheIsUsed() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like
