RoaveTest\DoctrineSimpleCache\SimpleCacheAdapterTest

Complexity

Total Complexity

31

Size/Duplication

Total Lines	465
Duplicated Lines	27.1 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

29 Methods

Rating	Name	Duplication	Size	Complexity
A	invalidTTLs()	0	15	1
A	validKeys()	0	7	1
A	invalidKeys()	0	23	1
A	testConstructorThrowsExceptionWhenNotMultiOperationCacheIsUsed()	9	9	1
A	testConstructorThrowsExceptionWhenNotClearableCacheIsUsed()	9	9	1
A	testGetProxiesToDoctrineFetch()	12	12	1
A	testGetWithNotExistingKey()	0	14	1
A	testGetWithFalseValueStoredInCache()	9	9	1
A	testSetProxiesToDoctrineSave()	0	13	1
A	testSetWithDateIntervalTTL()	0	12	1
A	testSetWithNonPositiveTTL()	0	14	1
A	testSetWithInvalidTTL()	10	10	1
A	testDeleteProxiesToDoctrineDelete()	11	11	1
A	testClearProxiesToDeleteAll()	0	9	1
A	testGetMultipleProxiesToFetchMultiple()	0	15	1
A	testGetMultipleWithPartialKeys()	0	18	1
A	testGetMultipleThrowsExceptionWithInvalidKeys()	0	7	1
A	testGetMultipleAcceptsTraversable()	13	13	1
A	testGetMultipleAcceptsGenerator()	0	19	2
A	testGetMultipleThrowsExceptionWhenNotArrayOrTraversable()	7	7	1
A	testSetMultipleProxiesToSaveMultiple()	0	14	1
A	testSetMultipleWithDateIntervalTTL()	0	15	1
A	testSetMultipleWithNonPositiveTTL()	0	17	1
A	testSetMultipleWithInvalidTTL()	0	12	1
A	testSetMultipleThrowsExceptionWhenNotArrayOrTraversable()	7	7	1
A	testSetMultipleAcceptsGenerator()	0	21	2
A	testDeleteMultipleReturnsTrueWhenAllDeletesSucceed()	14	14	1
A	testDeleteMultipleReturnsFalseWhenOneDeleteFails()	14	14	1
A	testHasProxiesToDoctrineContains()	11	11	1

<?php
declare(strict_types = 1);

namespace RoaveTest\DoctrineSimpleCache;

use Doctrine\Common\Cache\ArrayCache;
use PHPUnit\Framework\TestCase;
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 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 testConstructorThrowsExceptionWhenNotMultiOperationCacheIsUsed()

This method seems to be duplicated in your project.

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

        $this->expectException(CacheException::class);
        $this->expectExceptionMessage('not support multiple operations');
        new SimpleCacheAdapter($doctrineCache);
    }

    public function testConstructorThrowsExceptionWhenNotClearableCacheIsUsed()

This method seems to be duplicated in your project.

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

        $this->expectException(CacheException::class);
        $this->expectExceptionMessage('not clearable');
        new SimpleCacheAdapter($doctrineCache);
    }

    /**
     * @throws \Psr\SimpleCache\InvalidArgumentException
     */
    public function testGetProxiesToDoctrineFetch()

This method seems to be duplicated in your project.

    {
        $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);

The method expects() does not seem to exist on object<RoaveTestAsset\DoctrineSimpleCache\FullyImplementedCache>.

        $psrCache = new SimpleCacheAdapter($doctrineCache);
        self::assertSame($value, $psrCache->get($key));
    }

    /**
     * @throws \Psr\SimpleCache\InvalidArgumentException
     */
    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));
    }

    /**
     * @throws \Psr\SimpleCache\InvalidArgumentException
     */
    public function testGetWithFalseValueStoredInCache()

This method seems to be duplicated in your project.

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

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

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

    /**
     * @throws \Psr\SimpleCache\InvalidArgumentException
     * @throws \Exception
     */
    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);

The method expects() does not seem to exist on object<RoaveTestAsset\DoctrineSimpleCache\FullyImplementedCache>.

        $psrCache = new SimpleCacheAdapter($doctrineCache);
        self::assertTrue($psrCache->set($key, $value, $ttl));
    }

    /**
     * @throws \Psr\SimpleCache\InvalidArgumentException
     */
    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);
    }

    /**
     * @throws \Psr\SimpleCache\InvalidArgumentException
     * @throws \Exception
     */
    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));
    }

    /**
     * @param mixed $ttl
     * @dataProvider invalidTTLs
     * @throws \Psr\SimpleCache\InvalidArgumentException
     */
    public function testSetWithInvalidTTL($ttl)

This method seems to be duplicated in your project.

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

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

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

    /**
     * @throws \Psr\SimpleCache\InvalidArgumentException
     */
    public function testDeleteProxiesToDoctrineDelete()

This method seems to be duplicated in your project.

    {
        $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);

The method expects() does not seem to exist on object<RoaveTestAsset\DoctrineSimpleCache\FullyImplementedCache>.

        $psrCache = new SimpleCacheAdapter($doctrineCache);
        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);

The method expects() does not seem to exist on object<RoaveTestAsset\DoctrineSimpleCache\FullyImplementedCache>.

        $psrCache = new SimpleCacheAdapter($doctrineCache);
        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);

The method expects() does not seem to exist on object<RoaveTestAsset\DoctrineSimpleCache\FullyImplementedCache>.

        $psrCache = new SimpleCacheAdapter($doctrineCache);
        self::assertSame($values, $psrCache->getMultiple($keys));
    }

    /**
     * @throws \Exception
     */
    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)

This method seems to be duplicated in your project.

    {
        $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);

The method expects() does not seem to exist on object<RoaveTestAsset\DoctrineSimpleCache\FullyImplementedCache>.

        $psrCache = new SimpleCacheAdapter($doctrineCache);
        $psrCache->getMultiple(new \ArrayObject(array_keys($values)));
    }

    /**
     * @throws \Exception
     */
    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 method seems to be duplicated in your project.

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

        $psrCache = new SimpleCacheAdapter(new ArrayCache());
        $psrCache->getMultiple(uniqid('string', true));

uniqid('string', true) is of type string, but the function expects a array|object<Traversable>.

    }

    /**
     * @throws \Exception
     */
    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);

The method expects() does not seem to exist on object<RoaveTestAsset\DoctrineSimpleCache\FullyImplementedCache>.

        $psrCache = new SimpleCacheAdapter($doctrineCache);
        self::assertTrue($psrCache->setMultiple($values));
    }

    /**
     * @throws \Exception
     */
    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));
    }

    /**
     * @throws \Psr\SimpleCache\InvalidArgumentException
     */
    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
     * @throws \Exception
     */
    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 method seems to be duplicated in your project.

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

        $psrCache = new SimpleCacheAdapter(new ArrayCache());
        $psrCache->setMultiple(uniqid('string', true));

uniqid('string', true) is of type string, but the function expects a array|object<Traversable>.

    }

    /**
     * @throws \Psr\SimpleCache\InvalidArgumentException
     * @throws \Exception
     */
    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()

This method seems to be duplicated in your project.

    {
        $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);

The method expects() does not seem to exist on object<RoaveTestAsset\DoctrineSimpleCache\FullyImplementedCache>.

        $psrCache = new SimpleCacheAdapter($doctrineCache);
        self::assertTrue($psrCache->deleteMultiple($keys));
    }

    public function testDeleteMultipleReturnsFalseWhenOneDeleteFails()

This method seems to be duplicated in your project.

    {
        $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);

The method expects() does not seem to exist on object<RoaveTestAsset\DoctrineSimpleCache\FullyImplementedCache>.

        $psrCache = new SimpleCacheAdapter($doctrineCache);
        self::assertFalse($psrCache->deleteMultiple($keys));
    }

    /**
     * @throws \Psr\SimpleCache\InvalidArgumentException
     */
    public function testHasProxiesToDoctrineContains()

This method seems to be duplicated in your project.

    {
        $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);

The method expects() does not seem to exist on object<RoaveTestAsset\DoctrineSimpleCache\FullyImplementedCache>.

        $psrCache = new SimpleCacheAdapter($doctrineCache);
        self::assertTrue($psrCache->has($key));
    }
}