MemcachedDecoratorExtraTest::testAdd() - Code Metrics - Inspection of "Reorganization" - yiisoft/cache - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#30)

by Alexander

created 2019-08-10 16:12 UTC

MemcachedDecoratorExtraTest::testAdd() A

↳ Parent: MemcachedDecoratorExtraTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	15
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	7
nc	1
nop	0
dl	0
loc	15
rs	10
c	0
b	0
f	0

<?php

namespace Yiisoft\Cache\Tests\Memcached;

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

class MemcachedDecoratorExtraTest extends TestCase
{
    protected function createCacheInstance(): CacheInterface
    {
        return new Cache(new Memcached());
    }

    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));
    }

    // TODO commented for speed
    /*public function testExpireAdd(): void
    {
        $cache = $this->createCacheInstance();
        $cache->clear();

        $this->assertTrue($cache->add('expire_testa', 'expire_testa', 2));
        usleep(500000);
        $this->assertSameExceptObject('expire_testa', $cache->get('expire_testa'));
        usleep(2500000);
        $this->assertNull($cache->get('expire_testa'));
    }*/

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

yiisoft / cache

Pull Request — master (#30)

MemcachedDecoratorExtraTest::testAdd() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like