ArrayCacheDecoratorExtraTest::testInvalidKey() - Code Metrics - Inspection of "Fix phan issues" - yiisoft/cache - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#36)

by Alexander

created 2019-10-08 09:06 UTC

ArrayCacheDecoratorExtraTest::testInvalidKey() A

↳ Parent: ArrayCacheDecoratorExtraTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	6
nc	1
nop	0
dl	0
loc	8
rs	10
c	0
b	0
f	0

<?php

namespace Yiisoft\Cache\Tests\ArrayCache;

use DateInterval;
use Psr\SimpleCache\CacheInterface;
use Yiisoft\Cache\ArrayCache;
use Yiisoft\Cache\Cache;
use Yiisoft\Cache\Dependency\TagDependency;
use Yiisoft\Cache\Exception\InvalidArgumentException;
use Yiisoft\Cache\Exception\SetCacheException;
use Yiisoft\Cache\Tests\FalseCache;
use Yiisoft\Cache\Tests\MockHelper;
use Yiisoft\Cache\Tests\TestCase;

class ArrayCacheDecoratorExtraTest extends TestCase
{
    protected function tearDown(): void
    {
        MockHelper::resetMocks();
    }

    protected function createCacheInstance(): CacheInterface
    {
        return new Cache(new ArrayCache());
    }

    public function testAdd(): void
    {
        /** @var Cache $cache */
        $cache = $this->createCacheInstance();
        $cache = $this->prepare($cache);

        // should not change existing keys
        $this->assertSameExceptObject('a', $cache->get('test_string'));
        $this->assertFalse($cache->add('test_string', 'b'));


        // should store data if it's not there yet
        $this->assertNull($cache->get('add_test'));
        $this->assertTrue($cache->add('add_test', 13));
        $this->assertSameExceptObject(13, $cache->get('add_test'));
    }

    public function testAddWithDependency(): void
    {
        /** @var Cache $cache */
        $cache = $this->createCacheInstance();

        $dependency = new TagDependency('tag_test');

        $cache->add('a', 1, null, $dependency);

        $this->assertSameExceptObject(1, $cache->get('a'));

        TagDependency::invalidate($cache, 'tag_test');

        $this->assertSameExceptObject(null, $cache->get('a'));
    }

    public function testSetMultipleWithDependency(): void
    {
        /** @var Cache $cache */
        $cache = $this->createCacheInstance();

        $dependency = new TagDependency('tag_test');

        $cache->setMultiple(['a' => 1, 'b' => 2], null, $dependency);

        $this->assertSameExceptObject(['a' => 1, 'b' => 2], $cache->getMultiple(['a', 'b']));

        TagDependency::invalidate($cache, 'tag_test');

        $this->assertSameExceptObject(['a' => null, 'b' => null], $cache->getMultiple(['a', 'b']));
    }

    public function testAddMultiple(): void
    {
        /** @var Cache $cache */
        $cache = $this->createCacheInstance();
        $cache = $this->prepare($cache);

        $this->assertNull($cache->get('add_test'));

        $this->assertTrue(
            $cache->addMultiple(
                [
                    'test_integer' => 13,
                    'add_test' => 13,
                    '444' => 14,
                ]
            )
        );

        $this->assertSameExceptObject(1, $cache->get('test_integer'));
        $this->assertSameExceptObject(13, $cache->get('add_test'));
        $this->assertSameExceptObject(14, $cache->get('444'));
    }

    public function testGetOrSet(): void
    {
        $cache = $this->createCacheInstance();
        $cache = $this->prepare($cache);

        $expected = get_class($cache);

        $this->assertSameExceptObject(null, $cache->get('something'));
        $this->assertSameExceptObject($expected, $cache->getOrSet('something', static function (CacheInterface $cache): string {
            return get_class($cache);
        }));
        $this->assertSameExceptObject($expected, $cache->get('something'));
    }

    public function testGetOrSetException(): void
    {
        $this->expectException(SetCacheException::class);

        $cache = new Cache(new FalseCache());

        $cache->getOrSet('something', static function (CacheInterface $cache): string {
            return get_class($cache);
        });
    }

    public function testSetCacheException(): void
    {
        $cache = new Cache(new FalseCache());

        try {
            $cache->getOrSet('something', static function (CacheInterface $cache): string {
                return get_class($cache);
            });
        } catch (SetCacheException $e) {
            $this->assertEquals('something', $e->getKey());
            $this->assertEquals('Yiisoft\Cache\Cache', $e->getValue());
            $this->assertEquals($cache, $e->getCache());
        }
    }

    public function testGetOrSetWithDependencies(): void
    {
        /** @var Cache $cache */
        $cache = $this->createCacheInstance();

        $dependency = new TagDependency('test');

        $expected = 'SilverFire';
        $loginClosure = static function (): string {
            return 'SilverFire';
        };
        $this->assertSameExceptObject($expected, $cache->getOrSet('some-login', $loginClosure, null, $dependency));

        // Call again with another login to make sure that value is cached
        $loginClosure = static function (): string {
            return 'SamDark';
        };
        $cache->getOrSet('some-login', $loginClosure, null, $dependency);
        $this->assertSameExceptObject($expected, $cache->getOrSet('some-login', $loginClosure, null, $dependency));

        TagDependency::invalidate($cache, 'test');
        $expected = 'SamDark';
        $this->assertSameExceptObject($expected, $cache->getOrSet('some-login', $loginClosure, null, $dependency));
    }

    public function testWithArrayKeys(): void
    {
        $key = [42];
        $cache = $this->createCacheInstance();
        $cache->clear();

        $this->assertNull($cache->get($key));

        $cache->set($key, 42);
        $this->assertSame(42, $cache->get($key));
    }

    public function testInvalidKey(): void
    {
        $this->expectException(InvalidArgumentException::class);
        MockHelper::$mock_json_encode = false;
        $key = [42];
        $cache = $this->createCacheInstance();
        $cache->clear();
        $cache->set($key, 42);
    }

    public function testWithObjectKeys(): void
    {
        $key = new class {
            public $value = 42;
        };
        $cache = $this->createCacheInstance();
        $cache->clear();

        $this->assertNull($cache->get($key));

        $cache->set($key, 42);
        $this->assertSame(42, $cache->get($key));
    }

    public function testNormalizeKey(): void
    {
        /** @var Cache $cache */
        $cache = $this->createCacheInstance();
        $cache->clear();
        $cache->enableKeyNormalization();

        $cache->set('test_normalized', 1);

        $cache->disableKeyNormalization();

        $cache->set('test_not_normalized', 2);

        $cache->disableKeyNormalization();
        $this->assertFalse($cache->has('test_normalized'));
        $this->assertSameExceptObject(1, $cache->get('2753a58fdc3bf713af86cb3a97a55e57'));
        $this->assertSameExceptObject(2, $cache->get('test_not_normalized'));
    }

    public function testGetWithPrefix(): void
    {
        /** @var Cache $cache */
        $cache = $this->createCacheInstance();
        $cache->setKeyPrefix('prefix');
        $cache = $this->prepare($cache);
        $this->assertSameExceptObject(1, $cache->get('test_integer'));
    }

    public function testInvalidKeyPrefix(): void
    {
        $this->expectException(InvalidArgumentException::class);

        /** @var Cache $cache */
        $cache = $this->createCacheInstance();
        $cache->setKeyPrefix('_prefix');
    }

    public function testKeyPrefix(): void
    {
        /** @var Cache $cache */
        $cache = $this->createCacheInstance();
        $cache->clear();
        $cache->disableKeyNormalization();
        $cache->setKeyPrefix('prefix');

        $cache->set('test_with_prefix', 1);

        $cache->setKeyPrefix('');

        $cache->set('test_without_prefix', 2);

        $cache->setKeyPrefix('');
        $this->assertFalse($cache->has('test_with_prefix'));
        $this->assertSameExceptObject(1, $cache->get('prefixtest_with_prefix'));
        $this->assertSameExceptObject(2, $cache->get('test_without_prefix'));
    }

    /**
     * @dataProvider featuresProvider
     * @param $features
     */
    public function testFeatures($features): void
    {
        /** @var Cache $cache */
        $cache = $this->createCacheInstance();
        $cache->setKeyPrefix($features[0]);
        $features[1] ? $cache->enableKeyNormalization() : $cache->disableKeyNormalization();

        $this->featuresTest($cache);
    }

    public function featuresProvider(): array
    {
        // [prefix, normalization]
        return [
            [['', false]],
            [['testprefix', false]],
            [['testprefix', true]],
            [['', true]],
        ];
    }

    private function featuresTest(Cache $cache): void
    {
        $this->prepare($cache);

        $dataWithPrefix = $this->getDataProviderData('for_multiple_');
        $cache->setMultiple($dataWithPrefix);

        $data = $this->getDataProviderData() + $dataWithPrefix + ['nonexistent-key' => null];
        $keys = array_map('strval', array_keys($data));
        $dataWithDefault = $data;
        $dataWithDefault['nonexistent-key'] = 'default';

        foreach ($data as $key => $value) {
            $key = (string)$key;
            if ($key === 'nonexistent-key') {
                $this->assertFalse($cache->has($key));
                $this->assertSameExceptObject(null, $cache->get($key));
                $this->assertSameExceptObject('default', $cache->get($key, 'default'));
            } else {
                $this->assertTrue($cache->has($key));
                $this->assertSameExceptObject($value, $cache->get($key));
                $this->assertSameExceptObject($value, $cache->get($key, 'default'));
            }
        }

        $this->assertSameExceptObject($data, $cache->getMultiple($keys));
        $this->assertSameExceptObject($dataWithDefault, $cache->getMultiple($keys, 'default'));
    }

    public function testDefaultTtl(): void
    {
        $cache = $this->createCacheInstance();
        $cache->clear();
        /** @var Cache $cache */
        $cache->setDefaultTtl(2);
        $this->assertSameExceptObject(2, $cache->getDefaultTtl());
    }

    public function testDateIntervalTtl(): void
    {
        $interval = new DateInterval('PT3S');
        $cache = $this->createCacheInstance();
        $cache->clear();
        /** @var Cache $cache */
        $cache->setDefaultTtl($interval);
        $this->assertSameExceptObject(3, $cache->getDefaultTtl());
    }
}


1			<?php
2
3			namespace Yiisoft\Cache\Tests\ArrayCache;
4
5			use DateInterval;
6			use Psr\SimpleCache\CacheInterface;
7			use Yiisoft\Cache\ArrayCache;
8			use Yiisoft\Cache\Cache;
9			use Yiisoft\Cache\Dependency\TagDependency;
10			use Yiisoft\Cache\Exception\InvalidArgumentException;
11			use Yiisoft\Cache\Exception\SetCacheException;
12			use Yiisoft\Cache\Tests\FalseCache;
13			use Yiisoft\Cache\Tests\MockHelper;
14			use Yiisoft\Cache\Tests\TestCase;
15
16			class ArrayCacheDecoratorExtraTest extends TestCase
17			{
18			protected function tearDown(): void
19			{
20			MockHelper::resetMocks();
21			}
22
23			protected function createCacheInstance(): CacheInterface
24			{
25			return new Cache(new ArrayCache());
26			}
27
28			public function testAdd(): void
29			{
30			/** @var Cache $cache */
31			$cache = $this->createCacheInstance();
32			$cache = $this->prepare($cache);
33
34			// should not change existing keys
35			$this->assertSameExceptObject('a', $cache->get('test_string'));
36			$this->assertFalse($cache->add('test_string', 'b'));
37
38
39			// should store data if it's not there yet
40			$this->assertNull($cache->get('add_test'));
41			$this->assertTrue($cache->add('add_test', 13));
42			$this->assertSameExceptObject(13, $cache->get('add_test'));
43			}
44
45			public function testAddWithDependency(): void
46			{
47			/** @var Cache $cache */
48			$cache = $this->createCacheInstance();
49
50			$dependency = new TagDependency('tag_test');
51
52			$cache->add('a', 1, null, $dependency);
53
54			$this->assertSameExceptObject(1, $cache->get('a'));
55
56			TagDependency::invalidate($cache, 'tag_test');
57
58			$this->assertSameExceptObject(null, $cache->get('a'));
59			}
60
61			public function testSetMultipleWithDependency(): void
62			{
63			/** @var Cache $cache */
64			$cache = $this->createCacheInstance();
65
66			$dependency = new TagDependency('tag_test');
67
68			$cache->setMultiple(['a' => 1, 'b' => 2], null, $dependency);
69
70			$this->assertSameExceptObject(['a' => 1, 'b' => 2], $cache->getMultiple(['a', 'b']));
71
72			TagDependency::invalidate($cache, 'tag_test');
73
74			$this->assertSameExceptObject(['a' => null, 'b' => null], $cache->getMultiple(['a', 'b']));
75			}
76
77			public function testAddMultiple(): void
78			{
79			/** @var Cache $cache */
80			$cache = $this->createCacheInstance();
81			$cache = $this->prepare($cache);
82
83			$this->assertNull($cache->get('add_test'));
84
85			$this->assertTrue(
86			$cache->addMultiple(
87			[
88			'test_integer' => 13,
89			'add_test' => 13,
90			'444' => 14,
91			]
92			)
93			);
94
95			$this->assertSameExceptObject(1, $cache->get('test_integer'));
96			$this->assertSameExceptObject(13, $cache->get('add_test'));
97			$this->assertSameExceptObject(14, $cache->get('444'));
98			}
99
100			public function testGetOrSet(): void
101			{
102			$cache = $this->createCacheInstance();
103			$cache = $this->prepare($cache);
104
105			$expected = get_class($cache);
106
107			$this->assertSameExceptObject(null, $cache->get('something'));
108			$this->assertSameExceptObject($expected, $cache->getOrSet('something', static function (CacheInterface $cache): string {
109			return get_class($cache);
110			}));
111			$this->assertSameExceptObject($expected, $cache->get('something'));
112			}
113
114			public function testGetOrSetException(): void
115			{
116			$this->expectException(SetCacheException::class);
117
118			$cache = new Cache(new FalseCache());
119
120			$cache->getOrSet('something', static function (CacheInterface $cache): string {
121			return get_class($cache);
122			});
123			}
124
125			public function testSetCacheException(): void
126			{
127			$cache = new Cache(new FalseCache());
128
129			try {
130			$cache->getOrSet('something', static function (CacheInterface $cache): string {
131			return get_class($cache);
132			});
133			} catch (SetCacheException $e) {
134			$this->assertEquals('something', $e->getKey());
135			$this->assertEquals('Yiisoft\Cache\Cache', $e->getValue());
136			$this->assertEquals($cache, $e->getCache());
137			}
138			}
139
140			public function testGetOrSetWithDependencies(): void
141			{
142			/** @var Cache $cache */
143			$cache = $this->createCacheInstance();
144
145			$dependency = new TagDependency('test');
146
147			$expected = 'SilverFire';
148			$loginClosure = static function (): string {
149			return 'SilverFire';
150			};
151			$this->assertSameExceptObject($expected, $cache->getOrSet('some-login', $loginClosure, null, $dependency));
152
153			// Call again with another login to make sure that value is cached
154			$loginClosure = static function (): string {
155			return 'SamDark';
156			};
157			$cache->getOrSet('some-login', $loginClosure, null, $dependency);
158			$this->assertSameExceptObject($expected, $cache->getOrSet('some-login', $loginClosure, null, $dependency));
159
160			TagDependency::invalidate($cache, 'test');
161			$expected = 'SamDark';
162			$this->assertSameExceptObject($expected, $cache->getOrSet('some-login', $loginClosure, null, $dependency));
163			}
164
165			public function testWithArrayKeys(): void
166			{
167			$key = [42];
168			$cache = $this->createCacheInstance();
169			$cache->clear();
170
171			$this->assertNull($cache->get($key));
172
173			$cache->set($key, 42);
174			$this->assertSame(42, $cache->get($key));
175			}
176
177			public function testInvalidKey(): void
178			{
179			$this->expectException(InvalidArgumentException::class);
180			MockHelper::$mock_json_encode = false;
181			$key = [42];
182			$cache = $this->createCacheInstance();
183			$cache->clear();
184			$cache->set($key, 42);
185			}
186
187			public function testWithObjectKeys(): void
188			{
189			$key = new class {
190			public $value = 42;
191			};
192			$cache = $this->createCacheInstance();
193			$cache->clear();
194
195			$this->assertNull($cache->get($key));
196
197			$cache->set($key, 42);
198			$this->assertSame(42, $cache->get($key));
199			}
200
201			public function testNormalizeKey(): void
202			{
203			/** @var Cache $cache */
204			$cache = $this->createCacheInstance();
205			$cache->clear();
206			$cache->enableKeyNormalization();
207
208			$cache->set('test_normalized', 1);
209
210			$cache->disableKeyNormalization();
211
212			$cache->set('test_not_normalized', 2);
213
214			$cache->disableKeyNormalization();
215			$this->assertFalse($cache->has('test_normalized'));
216			$this->assertSameExceptObject(1, $cache->get('2753a58fdc3bf713af86cb3a97a55e57'));
217			$this->assertSameExceptObject(2, $cache->get('test_not_normalized'));
218			}
219
220			public function testGetWithPrefix(): void
221			{
222			/** @var Cache $cache */
223			$cache = $this->createCacheInstance();
224			$cache->setKeyPrefix('prefix');
225			$cache = $this->prepare($cache);
226			$this->assertSameExceptObject(1, $cache->get('test_integer'));
227			}
228
229			public function testInvalidKeyPrefix(): void
230			{
231			$this->expectException(InvalidArgumentException::class);
232
233			/** @var Cache $cache */
234			$cache = $this->createCacheInstance();
235			$cache->setKeyPrefix('_prefix');
236			}
237
238			public function testKeyPrefix(): void
239			{
240			/** @var Cache $cache */
241			$cache = $this->createCacheInstance();
242			$cache->clear();
243			$cache->disableKeyNormalization();
244			$cache->setKeyPrefix('prefix');
245
246			$cache->set('test_with_prefix', 1);
247
248			$cache->setKeyPrefix('');
249
250			$cache->set('test_without_prefix', 2);
251
252			$cache->setKeyPrefix('');
253			$this->assertFalse($cache->has('test_with_prefix'));
254			$this->assertSameExceptObject(1, $cache->get('prefixtest_with_prefix'));
255			$this->assertSameExceptObject(2, $cache->get('test_without_prefix'));
256			}
257
258			/**
259			* @dataProvider featuresProvider
260			* @param $features
261			*/
262			public function testFeatures($features): void
263			{
264			/** @var Cache $cache */
265			$cache = $this->createCacheInstance();
266			$cache->setKeyPrefix($features[0]);
267			$features[1] ? $cache->enableKeyNormalization() : $cache->disableKeyNormalization();
268
269			$this->featuresTest($cache);
270			}
271
272			public function featuresProvider(): array
273			{
274			// [prefix, normalization]
275			return [
276			[['', false]],
277			[['testprefix', false]],
278			[['testprefix', true]],
279			[['', true]],
280			];
281			}
282
283			private function featuresTest(Cache $cache): void
284			{
285			$this->prepare($cache);
286
287			$dataWithPrefix = $this->getDataProviderData('for_multiple_');
288			$cache->setMultiple($dataWithPrefix);
289
290			$data = $this->getDataProviderData() + $dataWithPrefix + ['nonexistent-key' => null];
291			$keys = array_map('strval', array_keys($data));
292			$dataWithDefault = $data;
293			$dataWithDefault['nonexistent-key'] = 'default';
294
295			foreach ($data as $key => $value) {
296			$key = (string)$key;
297			if ($key === 'nonexistent-key') {
298			$this->assertFalse($cache->has($key));
299			$this->assertSameExceptObject(null, $cache->get($key));
300			$this->assertSameExceptObject('default', $cache->get($key, 'default'));
301			} else {
302			$this->assertTrue($cache->has($key));
303			$this->assertSameExceptObject($value, $cache->get($key));
304			$this->assertSameExceptObject($value, $cache->get($key, 'default'));
305			}
306			}
307
308			$this->assertSameExceptObject($data, $cache->getMultiple($keys));
309			$this->assertSameExceptObject($dataWithDefault, $cache->getMultiple($keys, 'default'));
310			}
311
312			public function testDefaultTtl(): void
313			{
314			$cache = $this->createCacheInstance();
315			$cache->clear();
316			/** @var Cache $cache */
317			$cache->setDefaultTtl(2);
318			$this->assertSameExceptObject(2, $cache->getDefaultTtl());
319			}
320
321			public function testDateIntervalTtl(): void
322			{
323			$interval = new DateInterval('PT3S');
324			$cache = $this->createCacheInstance();
325			$cache->clear();
326			/** @var Cache $cache */
327			$cache->setDefaultTtl($interval);
328			$this->assertSameExceptObject(3, $cache->getDefaultTtl());
329			}
330			}
331

yiisoft / cache

Pull Request — master (#36)

ArrayCacheDecoratorExtraTest::testInvalidKey() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like