FileCacheDecoratorExtraTest::testKeyPrefix()

Passed

Branch — master (0b4094)

by Alexander

created 2019-08-14 21:26 UTC

↳ Parent: FileCacheDecoratorExtraTest

Size

Total Lines	18
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	11
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	18

<?php

namespace Yiisoft\Cache\Tests\FileCache;

use DateInterval;
use Psr\SimpleCache\CacheInterface;
use Yiisoft\Cache\FileCache;
use Yiisoft\Cache\Cache;
use Yiisoft\Cache\Dependency\TagDependency;
use Yiisoft\Cache\Tests\TestCase;

class FileCacheDecoratorExtraTest extends TestCase
{
    protected const CACHE_DIRECTORY = __DIR__ . '/runtime/cache';

    protected function createCacheInstance(): CacheInterface
    {
        return new Cache(new FileCache(static::CACHE_DIRECTORY));
    }

    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 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,
                ]
            )
        );

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

    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 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 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 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()
    {
        // [prefix, normalization]
        return [
            [['', false]],
            [['testprefix', false]],
            [['testprefix', true]],
            [['', true]],
        ];
    }

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

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

        $data = array_merge($this->getDataProviderData(), $dataWithPrefix, ['nonexistent-key' => null]);
        $dataWithDefault = $data;
        $dataWithDefault['nonexistent-key'] = 'default';

        foreach ($data as $key => $value) {
            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(array_keys($data)));
        $this->assertSameExceptObject($dataWithDefault, $cache->getMultiple(array_keys($data), '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\FileCache;
4
5			use DateInterval;
6			use Psr\SimpleCache\CacheInterface;
7			use Yiisoft\Cache\FileCache;
8			use Yiisoft\Cache\Cache;
9			use Yiisoft\Cache\Dependency\TagDependency;
10			use Yiisoft\Cache\Tests\TestCase;
11
12			class FileCacheDecoratorExtraTest extends TestCase
13			{
14			protected const CACHE_DIRECTORY = __DIR__ . '/runtime/cache';
15
16			protected function createCacheInstance(): CacheInterface
17			{
18			return new Cache(new FileCache(static::CACHE_DIRECTORY));
19			}
20
21			public function testAdd(): void
22			{
23			/** @var Cache $cache */
24			$cache = $this->createCacheInstance();
25			$cache = $this->prepare($cache);
26
27			// should not change existing keys
28			$this->assertSameExceptObject('a', $cache->get('test_string'));
29			$this->assertFalse($cache->add('test_string', 'b'));
30
31
32			// should store data if it's not there yet
33			$this->assertNull($cache->get('add_test'));
34			$this->assertTrue($cache->add('add_test', 13));
35			$this->assertSameExceptObject(13, $cache->get('add_test'));
36			}
37
38			public function testAddMultiple(): void
39			{
40			/** @var Cache $cache */
41			$cache = $this->createCacheInstance();
42			$cache = $this->prepare($cache);
43
44			$this->assertNull($cache->get('add_test'));
45
46			$this->assertTrue(
47			$cache->addMultiple(
48			[
49			'test_integer' => 13,
50			'add_test' => 13,
51			]
52			)
53			);
54
55			$this->assertSameExceptObject(1, $cache->get('test_integer'));
56			$this->assertSameExceptObject(13, $cache->get('add_test'));
57			}
58
59			public function testGetOrSet(): void
60			{
61			$cache = $this->createCacheInstance();
62			$cache = $this->prepare($cache);
63
64			$expected = get_class($cache);
65
66			$this->assertSameExceptObject(null, $cache->get('something'));
67			$this->assertSameExceptObject($expected, $cache->getOrSet('something', static function (CacheInterface $cache): string {
68			return get_class($cache);
69			}));
70			$this->assertSameExceptObject($expected, $cache->get('something'));
71			}
72
73			public function testGetOrSetWithDependencies(): void
74			{
75			/** @var Cache $cache */
76			$cache = $this->createCacheInstance();
77
78			$dependency = new TagDependency('test');
79
80			$expected = 'SilverFire';
81			$loginClosure = static function (): string {
82			return 'SilverFire';
83			};
84			$this->assertSameExceptObject($expected, $cache->getOrSet('some-login', $loginClosure, null, $dependency));
85
86			// Call again with another login to make sure that value is cached
87			$loginClosure = static function (): string {
88			return 'SamDark';
89			};
90			$cache->getOrSet('some-login', $loginClosure, null, $dependency);
91			$this->assertSameExceptObject($expected, $cache->getOrSet('some-login', $loginClosure, null, $dependency));
92
93			TagDependency::invalidate($cache, 'test');
94			$expected = 'SamDark';
95			$this->assertSameExceptObject($expected, $cache->getOrSet('some-login', $loginClosure, null, $dependency));
96			}
97
98			public function testWithArrayKeys(): void
99			{
100			$key = [42];
101			$cache = $this->createCacheInstance();
102			$cache->clear();
103
104			$this->assertNull($cache->get($key));
105
106			$cache->set($key, 42);
107			$this->assertSame(42, $cache->get($key));
108			}
109
110			public function testWithObjectKeys(): void
111			{
112			$key = new class {
113			public $value = 42;
114			};
115			$cache = $this->createCacheInstance();
116			$cache->clear();
117
118			$this->assertNull($cache->get($key));
119
120			$cache->set($key, 42);
121			$this->assertSame(42, $cache->get($key));
122			}
123
124			public function testNormalizeKey(): void
125			{
126			/** @var Cache $cache */
127			$cache = $this->createCacheInstance();
128			$cache->clear();
129			$cache->enableKeyNormalization();
130
131			$cache->set('test_normalized', 1);
132
133			$cache->disableKeyNormalization();
134
135			$cache->set('test_not_normalized', 2);
136
137			$cache->disableKeyNormalization();
138			$this->assertFalse($cache->has('test_normalized'));
139			$this->assertSameExceptObject(1, $cache->get('2753a58fdc3bf713af86cb3a97a55e57'));
140			$this->assertSameExceptObject(2, $cache->get('test_not_normalized'));
141			}
142
143			public function testGetWithPrefix(): void
144			{
145			/** @var Cache $cache */
146			$cache = $this->createCacheInstance();
147			$cache->setKeyPrefix('prefix');
148			$cache = $this->prepare($cache);
149			$this->assertSameExceptObject(1, $cache->get('test_integer'));
150			}
151
152			public function testKeyPrefix(): void
153			{
154			/** @var Cache $cache */
155			$cache = $this->createCacheInstance();
156			$cache->clear();
157			$cache->disableKeyNormalization();
158			$cache->setKeyPrefix('prefix');
159
160			$cache->set('test_with_prefix', 1);
161
162			$cache->setKeyPrefix('');
163
164			$cache->set('test_without_prefix', 2);
165
166			$cache->setKeyPrefix('');
167			$this->assertFalse($cache->has('test_with_prefix'));
168			$this->assertSameExceptObject(1, $cache->get('prefixtest_with_prefix'));
169			$this->assertSameExceptObject(2, $cache->get('test_without_prefix'));
170			}
171
172			/**
173			* @dataProvider featuresProvider
174			* @param $features
175			*/
176			public function testFeatures($features): void
177			{
178			/** @var Cache $cache */
179			$cache = $this->createCacheInstance();
180			$cache->setKeyPrefix($features[0]);
181			$features[1] ? $cache->enableKeyNormalization() : $cache->disableKeyNormalization();
182
183			$this->featuresTest($cache);
184			}
185
186			public function featuresProvider()
187			{
188			// [prefix, normalization]
189			return [
190			[['', false]],
191			[['testprefix', false]],
192			[['testprefix', true]],
193			[['', true]],
194			];
195			}
196
197			private function featuresTest(Cache $cache)
198			{
199			$this->prepare($cache);
200
201			$dataWithPrefix = $this->getDataProviderData('for_multiple_');
202			$cache->setMultiple($dataWithPrefix);
203
204			$data = array_merge($this->getDataProviderData(), $dataWithPrefix, ['nonexistent-key' => null]);
205			$dataWithDefault = $data;
206			$dataWithDefault['nonexistent-key'] = 'default';
207
208			foreach ($data as $key => $value) {
209			if ($key === 'nonexistent-key') {
210			$this->assertFalse($cache->has($key));
211			$this->assertSameExceptObject(null, $cache->get($key));
212			$this->assertSameExceptObject('default', $cache->get($key, 'default'));
213			} else {
214			$this->assertTrue($cache->has($key));
215			$this->assertSameExceptObject($value, $cache->get($key));
216			$this->assertSameExceptObject($value, $cache->get($key, 'default'));
217			}
218			}
219
220			$this->assertSameExceptObject($data, $cache->getMultiple(array_keys($data)));
221			$this->assertSameExceptObject($dataWithDefault, $cache->getMultiple(array_keys($data), 'default'));
222			}
223
224			public function testDefaultTtl(): void
225			{
226			$cache = $this->createCacheInstance();
227			$cache->clear();
228			/** @var Cache $cache */
229			$cache->setDefaultTtl(2);
230			$this->assertSameExceptObject(2, $cache->getDefaultTtl());
231			}
232
233			public function testDateIntervalTtl(): void
234			{
235			$interval = new DateInterval('PT3S');
236			$cache = $this->createCacheInstance();
237			$cache->clear();
238			/** @var Cache $cache */
239			$cache->setDefaultTtl($interval);
240			$this->assertSameExceptObject(3, $cache->getDefaultTtl());
241			}
242			}
243

yiisoft / cache

Branch — master (0b4094)

FileCacheDecoratorExtraTest::testKeyPrefix()

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like