SimpleCacheAdapterTest::testGetMultipleThrowsExceptionWhenNotArrayOrTraversable() - Code Metrics - Inspection of "[WIP] Validate keys" - Roave/DoctrineSimpleCache - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#15)

by James

created 2017-01-19 11:07 UTC

testGetMultipleThrowsExceptionWhenNotArrayOrTraversable() A

↳ Parent: SimpleCacheAdapterTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	7
Ratio	100 %

Importance

Changes

Metric	Value
dl	7
loc	7
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	4
nc	1
nop	0

<?php
declare(strict_types = 1);

namespace RoaveTest\DoctrineSimpleCache;

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

/**
 * @covers \Roave\DoctrineSimpleCache\SimpleCacheAdapter
 */
final class SimpleCacheAdapterTest extends \PHPUnit_Framework_TestCase
{
    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 NotMultiPuttableCache|\PHPUnit_Framework_MockObject_MockObject $doctrineCache */
        $doctrineCache = $this->createMock(NotMultiPuttableCache::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 testConstructorThrowsExceptionWhenNotClearableCacheIsUsed()
    {
        /** @var NotClearableCache|\PHPUnit_Framework_MockObject_MockObject $doctrineCache */
        $doctrineCache = $this->createMock(NotClearableCache::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 testConstructorThrowsExceptionWhenNotMultiGettableCacheIsUsed()
    {
        /** @var NotMultiGettableCache|\PHPUnit_Framework_MockObject_MockObject $doctrineCache */
        $doctrineCache = $this->createMock(NotMultiGettableCache::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 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 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 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 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 testDeleteMultipleReturnsTrueWhenAllDeletesSucceed()

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

        /** @var FullyImplementedCache|\PHPUnit_Framework_MockObject_MockObject $doctrineCache */
        $doctrineCache = $this->createMock(FullyImplementedCache::class);
        $doctrineCache->expects(self::at(0))->method('delete')->with($keys[0])->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.
}
        $doctrineCache->expects(self::at(1))->method('delete')->with($keys[1])->willReturn(true);

        $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::at(0))->method('delete')->with($keys[0])->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.
}
        $doctrineCache->expects(self::at(1))->method('delete')->with($keys[1])->willReturn(true);

        $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 (#15)

testGetMultipleThrowsExceptionWhenNotArrayOrTraversable() 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\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\NotMultiGettableCache;
13			use RoaveTestAsset\DoctrineSimpleCache\NotMultiPuttableCache;
14
15			/**
16			* @covers \Roave\DoctrineSimpleCache\SimpleCacheAdapter
17			*/
18			final class SimpleCacheAdapterTest extends \PHPUnit_Framework_TestCase
19			{
20			public function validKeys()
21			{
22			return [
23			['AbC19_.'],
24			['1234567890123456789012345678901234567890123456789012345678901234'],
25			];
26			}
27
28			public function invalidKeys()
29			{
30			return [
31			[''],
32			[true],
33			[false],
34			[null],
35			[2],
36			[2.5],
37			['{str'],
38			['rand{'],
39			['rand{str'],
40			['rand}str'],

Roave / DoctrineSimpleCache

Pull Request — master (#15)

testGetMultipleThrowsExceptionWhenNotArrayOrTraversable() 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