FileCacheStoreTest::test_get_many_cache_items() - Code Metrics - Inspection of "Merge pull request #39 from silviooosilva/feature/..." - silviooosilva/CacheerPHP - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 29b1f6...a8c6a0 )

by Sílvio

created 2025-07-06 03:57 UTC

FileCacheStoreTest::test_get_many_cache_items() A

↳ Parent: FileCacheStoreTest

Complexity

Conditions	2
Paths	2

Size

Total Lines	15
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	11
nc	2
nop	0
dl	0
loc	15
rs	9.9
c	0
b	0
f	0

<?php

use PHPUnit\Framework\TestCase;
use Silviooosilva\CacheerPhp\Cacheer;
use Silviooosilva\CacheerPhp\Helpers\EnvHelper;
use Silviooosilva\CacheerPhp\Utils\CacheDriver;

class FileCacheStoreTest extends TestCase
{
    private $cache;
    private $cacheDir;

    protected function setUp(): void
    {
        $this->cacheDir = __DIR__ . '/cache';
        if (!file_exists($this->cacheDir) || !is_dir($this->cacheDir)) {
            mkdir($this->cacheDir, 0755, true);
        }

        $options = [
            'cacheDir' => $this->cacheDir,
        ];

        $this->cache = new Cacheer($options);
    }

    protected function tearDown(): void
    {
        $this->cache->flushCache();
    }

    public function testPutCache()
    {
        $cacheKey = 'test_key';
        $data = 'test_data';

        $this->cache->putCache($cacheKey, $data);
        $this->assertTrue($this->cache->isSuccess());
        $this->assertEquals('Cache file created successfully', $this->cache->getMessage());

        $cacheFile = $this->cacheDir . '/' . md5($cacheKey) . '.cache';
        $this->assertFileExists($cacheFile);
        $this->assertEquals($data, $this->cache->getCache($cacheKey));
    }

    public function testGetCache()
    {
        $cacheKey = 'test_key';
        $data = 'test_data';

        $this->cache->putCache($cacheKey, $data);

        $cachedData = $this->cache->getCache($cacheKey);
        $this->assertTrue($this->cache->isSuccess());
        $this->assertEquals($data, $cachedData);

        // Recuperar cache fora do período de expiração
        sleep(2);
        $cachedData = $this->cache->getCache($cacheKey, '', '2 seconds');

        $this->assertFalse($this->cache->isSuccess());
        $this->assertEquals('cacheFile not found, does not exists or expired', $this->cache->getMessage());
    }

    public function testClearCache()
    {
        $cacheKey = 'test_key';
        $data = 'test_data';

        $this->cache->putCache($cacheKey, $data);
        $this->cache->clearCache($cacheKey);

        $this->assertTrue($this->cache->isSuccess());
        $this->assertEquals('Cache file deleted successfully!', $this->cache->getMessage());

        $cacheFile = $this->cacheDir . '/' . md5($cacheKey) . '.cache';
        $this->assertFileDoesNotExist($cacheFile);
    }

    public function testFlushCache()
    {
        $key1 = 'test_key1';
        $data1 = 'test_data1';

        $key2 = 'test_key2';
        $data2 = 'test_data2';

        $this->cache->putCache($key1, $data1);
        $this->cache->putCache($key2, $data2);
        $this->cache->flushCache();

        $cacheFile1 = $this->cacheDir . '/' . md5($key1) . '.cache';
        $cacheFile2 = $this->cacheDir . '/' . md5($key2) . '.cache';

        $this->assertFileDoesNotExist($cacheFile1);
        $this->assertFileDoesNotExist($cacheFile2);
    }

    public function testAutoFlush()
    {
        $options = [
            'cacheDir' => $this->cacheDir,
            'flushAfter' => '10 seconds'
        ];

        $this->cache = new Cacheer($options);
        $this->cache->putCache('test_key', 'test_data');

        // Verifica se o cache foi criado com sucesso
        $this->assertEquals('test_data', $this->cache->getCache('test_key'));
        $this->assertTrue($this->cache->isSuccess());

        // Espera 11 segundos para o cache ser limpo automaticamente
        sleep(11);

        $this->cache = new Cacheer($options);

        // Verifica se o cache foi limpo automaticamente
        $cachedData = $this->cache->getCache('test_key');

        $this->assertFalse($this->cache->isSuccess());
        $this->assertEquals('cacheFile not found, does not exists or expired', $this->cache->getMessage());
    }

    public function testAppendCache()
    {
        $cacheKey = 'test_append_key';
        $initialData = ['initial' => 'data'];
        $additionalData = ['new' => 'data'];
        $expectedData = array_merge($initialData, $additionalData);

        // Armazena os dados iniciais no cache
        $this->cache->putCache($cacheKey, $initialData);
        $this->assertTrue($this->cache->isSuccess());

        // Adiciona novos dados ao cache existente
        $this->cache->appendCache($cacheKey, $additionalData);
        $this->assertTrue($this->cache->isSuccess());

        // Verifica se os dados no cache são os esperados
        $cachedData = $this->cache->getCache($cacheKey);
        $this->assertEquals($expectedData, $cachedData);

        // Testa adicionar dados como string
        $additionalData = ['string_data' => 'string data'];
        $expectedData = array_merge($expectedData, $additionalData);
        $this->cache->appendCache($cacheKey, $additionalData);
        $cachedData = $this->cache->getCache($cacheKey);
        $this->assertEquals($expectedData, $cachedData);
    }

    public function testAppendCacheFileNotExists()
    {
        $cacheKey = 'non_existing_key';
        $data = ['data'];

        // Tenta adicionar dados a um arquivo de cache que não existe
        $this->cache->appendCache($cacheKey, $data);
        $this->assertFalse($this->cache->isSuccess());
        $this->assertEquals('cacheFile not found, does not exists or expired', $this->cache->getMessage());
    }

    public function testAppendCacheWithNamespace()
    {
        $cacheKey = 'test_append_key_ns';
        $namespace = 'test_namespace';

        $initialData = ['initial' => 'data'];
        $additionalData = ['new' => 'data'];

        $expectedData = array_merge($initialData, $additionalData);

        // Armazena os dados iniciais no cache com namespace
        $this->cache->putCache($cacheKey, $initialData, $namespace);
        $this->assertTrue($this->cache->isSuccess());

        // Adiciona novos dados ao cache existente com namespace
        $this->cache->appendCache($cacheKey, $additionalData, $namespace);
        $this->assertTrue($this->cache->isSuccess());

        // Verifica se os dados no cache são os esperados
        $cachedData = $this->cache->getCache($cacheKey, $namespace);
        $this->assertEquals($expectedData, $cachedData);
    }

    public function testDataOutputShouldBeOfTypeJson()
    {
        $options = [
            'cacheDir' => $this->cacheDir
        ];
        $this->cache = new Cacheer($options, true);

        $cacheKey = "key_json";
        $cacheData = "data_json";

        $this->cache->putCache($cacheKey, $cacheData);
        $this->assertTrue($this->cache->isSuccess());

        $cacheOutput = $this->cache->getCache($cacheKey)->toJson();
        $this->assertTrue($this->cache->isSuccess());
        $this->assertJson($cacheOutput);
    }

    public function testDataOutputShouldBeOfTypeArray()
    {
        $options = [
            'cacheDir' => $this->cacheDir
        ];
        $this->cache = new Cacheer($options, true);

        $cacheKey = "key_array";
        $cacheData = "data_array";

        $this->cache->putCache($cacheKey, $cacheData);
        $this->assertTrue($this->cache->isSuccess());

        $cacheOutput = $this->cache->getCache($cacheKey)->toArray();
        $this->assertTrue($this->cache->isSuccess());
        $this->assertIsArray($cacheOutput);
    }

    public function testDataOutputShouldBeOfTypeObject()
    {
        $options = [
            'cacheDir' => $this->cacheDir
        ];
        $this->cache = new Cacheer($options, true);

        $cacheKey = "key_object";
        $cacheData = ["id" => 123];

        $this->cache->putCache($cacheKey, $cacheData);
        $this->assertTrue($this->cache->isSuccess());

        $cacheOutput = $this->cache->getCache($cacheKey)->toObject();
        $this->assertTrue($this->cache->isSuccess());
        $this->assertIsObject($cacheOutput);
    }

    public function testPutMany()
    {
        $cacheer = new Cacheer(['cacheDir' => __DIR__ . '/cache']);
        $items = [
            [
                'cacheKey' => 'user_1_profile',
                'cacheData' => ['name' => 'John Doe', 'email' => '[email protected]']
            ],
            [
                'cacheKey' => 'user_2_profile',
                'cacheData' => ['name' => 'Jane Doe', 'email' => '[email protected]']
            ],
        ];

        $cacheer->putMany($items);

        foreach ($items as $item) {
            $this->assertEquals($item['cacheData'], $cacheer->getCache($item['cacheKey']));
        }
    }

    public function test_remember_saves_and_recover_values() 
    {
        $this->cache->flushCache();

        $value = $this->cache->remember('remember_test_key', 60, function () {
            return 'valor_teste';
        });

        $this->assertEquals('valor_teste', $value);

        $cachedValue = $this->cache->remember('remember_test_key', 60, function (){
            return 'novo_valor';
        });


        $this->assertEquals('valor_teste', $cachedValue);
    }

    public function test_remember_forever_saves_value_indefinitely()
    {
        $this->cache->flushCache();

        $value = $this->cache->rememberForever('remember_forever_key', function () {
            return 'valor_eterno';
        });
        $this->assertEquals('valor_eterno', $value);

        $cachedValue = $this->cache->rememberForever('remember_forever_key', function () {
            return 'novo_valor';
        });

        $this->assertEquals('valor_eterno', $cachedValue);
    }

    public function test_get_and_forget()
    {
        $cacheKey = 'cache_key_test';
        $this->cache->putCache($cacheKey, 10);

        $this->assertTrue($this->cache->isSuccess());

        $cacheData = $this->cache->getAndForget($cacheKey);

        $this->assertTrue($this->cache->isSuccess());
        $this->assertEquals(10, $cacheData);

        $oldCacheData = $this->cache->getAndForget($cacheKey);

        $this->assertNull($oldCacheData);
        $this->assertFalse($this->cache->isSuccess());

        $noCacheData = $this->cache->getAndForget('non_existent_cache_key');
        $this->assertNull($noCacheData);
    }

    public function test_store_if_not_present_with_add_function()
    {
        $existentKey = 'cache_key_test';

        $nonExistentKey = 'non_existent_key';

        $this->cache->putCache($existentKey, 'existent_data');

        $this->assertTrue($this->cache->isSuccess());
        $this->assertEquals('existent_data', $this->cache->getCache($existentKey));

        $addCache = $this->cache->add($existentKey, 100);
        
        $this->assertTrue($addCache);
        $this->assertNotEquals(100, 'existent_data');
    
        $addNonExistentKey = $this->cache->add($nonExistentKey, 'non_existent_data');

        $this->assertFalse($addNonExistentKey);
        $this->assertEquals('non_existent_data', $this->cache->getCache($nonExistentKey));
        $this->assertTrue($this->cache->isSuccess());

    }

    public function test_increment_function() {

        $cacheKey = 'test_increment';
        $cacheData = 2025;

        $this->cache->putCache($cacheKey, $cacheData);

        $this->assertTrue($this->cache->isSuccess());
        $this->assertEquals($cacheData, $this->cache->getCache($cacheKey));
        $this->assertIsNumeric($this->cache->getCache($cacheKey));

        $increment = $this->cache->increment($cacheKey, 2);
        $this->assertTrue($increment);

        $this->assertEquals(2027, $this->cache->getCache($cacheKey));

    }

        public function test_decrement_function() {

        $cacheKey = 'test_decrement';
        $cacheData = 2027;

        $this->cache->putCache($cacheKey, $cacheData);

        $this->assertTrue($this->cache->isSuccess());
        $this->assertEquals($cacheData, $this->cache->getCache($cacheKey));
        $this->assertIsNumeric($this->cache->getCache($cacheKey));

        $increment = $this->cache->decrement($cacheKey, 2);
        $this->assertTrue($increment);

        $this->assertEquals(2025, $this->cache->getCache($cacheKey));

        }

        private function removeDirectoryRecursively($dir)
        {
        if (!is_dir($dir)) {
            return;
        }
        $items = scandir($dir);
        foreach ($items as $item) {
            if ($item === '.' || $item === '..') {
            continue;
            }
            $path = $dir . DIRECTORY_SEPARATOR . $item;
            if (is_dir($path)) {
            $this->removeDirectoryRecursively($path);
            } else {
            unlink($path);
            }
        }
        rmdir($dir);
        }

        public function testUseDefaultDriverCreatesCacheDirInProjectRoot()
        {
        $cacheer = new Cacheer();
        $driver = new CacheDriver($cacheer);

        $projectRoot = EnvHelper::getRootPath();
        $expectedCacheDir = $projectRoot . DIRECTORY_SEPARATOR . "CacheerPHP" . DIRECTORY_SEPARATOR . "Cache";

        if (is_dir($expectedCacheDir)) {
            $this->removeDirectoryRecursively($expectedCacheDir);
        }

        $driver->useDefaultDriver();

        $this->assertDirectoryExists($expectedCacheDir);

        if (is_dir($expectedCacheDir)) {
            $this->removeDirectoryRecursively($expectedCacheDir);
        }
        }

        public function testPutCacheWithNamespace()
        {
        $cacheKey = 'namespace_key';
        $data = 'namespace_data';
        $namespace = 'my_namespace';

        $this->cache->putCache($cacheKey, $data, $namespace);
        $this->assertTrue($this->cache->isSuccess());

        $cachedData = $this->cache->getCache($cacheKey, $namespace);
        $this->assertEquals($data, $cachedData);
        }

        public function testClearCacheWithNamespace()
        {
        $cacheKey = 'namespace_key_clear';
        $data = 'namespace_data_clear';
        $namespace = 'clear_namespace';

        $this->cache->putCache($cacheKey, $data, $namespace);
        $this->assertTrue($this->cache->isSuccess());

        $this->cache->clearCache($cacheKey, $namespace);
        $this->assertTrue($this->cache->isSuccess());

        $cachedData = $this->cache->getCache($cacheKey, $namespace);
        $this->assertFalse($this->cache->isSuccess());
        $this->assertNull($cachedData);
        }

        public function testFlushCacheRemovesNamespacedFiles()
        {
        $cacheKey = 'ns_flush_key';
        $data = 'ns_flush_data';
        $namespace = 'flush_namespace';

        $this->cache->putCache($cacheKey, $data, $namespace);
        $this->assertTrue($this->cache->isSuccess());

        $this->cache->flushCache();

        $cachedData = $this->cache->getCache($cacheKey, $namespace);
        $this->assertFalse($this->cache->isSuccess());
        $this->assertNull($cachedData);
        }

        public function testAppendCacheWithDifferentTypes()
        {
        $cacheKey = 'append_type_key';
        $initialData = ['a' => 1];
        $additionalData = ['b' => 2];
        $expectedData = ['a' => 1, 'b' => 2];

        $this->cache->putCache($cacheKey, $initialData);
        $this->cache->appendCache($cacheKey, $additionalData);
        $this->assertEquals($expectedData, $this->cache->getCache($cacheKey));

        $this->cache->appendCache($cacheKey, ['c' => 'string']);
        $expectedData['c'] = 'string';
        $this->assertEquals($expectedData, $this->cache->getCache($cacheKey));
        }

    public function test_get_many_cache_items()
    {
        $cacheItems = [
            'key1' => 'value1',
            'key2' => 'value2',
            'key3' => 'value3'
        ];
        foreach ($cacheItems as $key => $value) {
            $this->cache->putCache($key, $value);
        }
        $this->assertTrue($this->cache->isSuccess());
        $retrievedItems = $this->cache->getMany(array_keys($cacheItems));
        $this->assertTrue($this->cache->isSuccess());
        $this->assertCount(3, $retrievedItems);
        $this->assertEquals($cacheItems, $retrievedItems);
    }

    }


1			<?php
2
3			use PHPUnit\Framework\TestCase;
4			use Silviooosilva\CacheerPhp\Cacheer;
5			use Silviooosilva\CacheerPhp\Helpers\EnvHelper;
6			use Silviooosilva\CacheerPhp\Utils\CacheDriver;
7
8			class FileCacheStoreTest extends TestCase
9			{
10			private $cache;
11			private $cacheDir;
12
13			protected function setUp(): void
14			{
15			$this->cacheDir = __DIR__ . '/cache';
16			if (!file_exists($this->cacheDir) \|\| !is_dir($this->cacheDir)) {
17			mkdir($this->cacheDir, 0755, true);
18			}
19
20			$options = [
21			'cacheDir' => $this->cacheDir,
22			];
23
24			$this->cache = new Cacheer($options);
25			}
26
27			protected function tearDown(): void
28			{
29			$this->cache->flushCache();
30			}
31
32			public function testPutCache()
33			{
34			$cacheKey = 'test_key';
35			$data = 'test_data';
36
37			$this->cache->putCache($cacheKey, $data);
38			$this->assertTrue($this->cache->isSuccess());
39			$this->assertEquals('Cache file created successfully', $this->cache->getMessage());
40
41			$cacheFile = $this->cacheDir . '/' . md5($cacheKey) . '.cache';
42			$this->assertFileExists($cacheFile);
43			$this->assertEquals($data, $this->cache->getCache($cacheKey));
44			}
45
46			public function testGetCache()
47			{
48			$cacheKey = 'test_key';
49			$data = 'test_data';
50
51			$this->cache->putCache($cacheKey, $data);
52
53			$cachedData = $this->cache->getCache($cacheKey);
54			$this->assertTrue($this->cache->isSuccess());
55			$this->assertEquals($data, $cachedData);
56
57			// Recuperar cache fora do período de expiração
58			sleep(2);
59			$cachedData = $this->cache->getCache($cacheKey, '', '2 seconds');
			0 ignored issues – show Unused Code introduced 2025-02-13 01:26 UTC by Report Bug Copy Issue Report The assignment to `$cachedData` is dead and can be removed. Loading history...
60			$this->assertFalse($this->cache->isSuccess());
61			$this->assertEquals('cacheFile not found, does not exists or expired', $this->cache->getMessage());
62			}
63
64			public function testClearCache()
65			{
66			$cacheKey = 'test_key';
67			$data = 'test_data';
68
69			$this->cache->putCache($cacheKey, $data);
70			$this->cache->clearCache($cacheKey);
71
72			$this->assertTrue($this->cache->isSuccess());
73			$this->assertEquals('Cache file deleted successfully!', $this->cache->getMessage());
74
75			$cacheFile = $this->cacheDir . '/' . md5($cacheKey) . '.cache';
76			$this->assertFileDoesNotExist($cacheFile);
77			}
78
79			public function testFlushCache()
80			{
81			$key1 = 'test_key1';
82			$data1 = 'test_data1';
83
84			$key2 = 'test_key2';
85			$data2 = 'test_data2';
86
87			$this->cache->putCache($key1, $data1);
88			$this->cache->putCache($key2, $data2);
89			$this->cache->flushCache();
90
91			$cacheFile1 = $this->cacheDir . '/' . md5($key1) . '.cache';
92			$cacheFile2 = $this->cacheDir . '/' . md5($key2) . '.cache';
93
94			$this->assertFileDoesNotExist($cacheFile1);
95			$this->assertFileDoesNotExist($cacheFile2);
96			}
97
98			public function testAutoFlush()
99			{
100			$options = [
101			'cacheDir' => $this->cacheDir,
102			'flushAfter' => '10 seconds'
103			];
104
105			$this->cache = new Cacheer($options);
106			$this->cache->putCache('test_key', 'test_data');
107
108			// Verifica se o cache foi criado com sucesso
109			$this->assertEquals('test_data', $this->cache->getCache('test_key'));
110			$this->assertTrue($this->cache->isSuccess());
111
112			// Espera 11 segundos para o cache ser limpo automaticamente
113			sleep(11);
114
115			$this->cache = new Cacheer($options);
116
117			// Verifica se o cache foi limpo automaticamente
118			$cachedData = $this->cache->getCache('test_key');
			0 ignored issues – show Unused Code introduced 2025-02-13 01:26 UTC by Report Bug Copy Issue Report The assignment to `$cachedData` is dead and can be removed. Loading history...
119			$this->assertFalse($this->cache->isSuccess());
120			$this->assertEquals('cacheFile not found, does not exists or expired', $this->cache->getMessage());
121			}
122
123			public function testAppendCache()
124			{
125			$cacheKey = 'test_append_key';
126			$initialData = ['initial' => 'data'];
127			$additionalData = ['new' => 'data'];
128			$expectedData = array_merge($initialData, $additionalData);
129
130			// Armazena os dados iniciais no cache
131			$this->cache->putCache($cacheKey, $initialData);
132			$this->assertTrue($this->cache->isSuccess());
133
134			// Adiciona novos dados ao cache existente
135			$this->cache->appendCache($cacheKey, $additionalData);
136			$this->assertTrue($this->cache->isSuccess());
137
138			// Verifica se os dados no cache são os esperados
139			$cachedData = $this->cache->getCache($cacheKey);
140			$this->assertEquals($expectedData, $cachedData);
141
142			// Testa adicionar dados como string
143			$additionalData = ['string_data' => 'string data'];
144			$expectedData = array_merge($expectedData, $additionalData);
145			$this->cache->appendCache($cacheKey, $additionalData);
146			$cachedData = $this->cache->getCache($cacheKey);
147			$this->assertEquals($expectedData, $cachedData);
148			}
149
150			public function testAppendCacheFileNotExists()
151			{
152			$cacheKey = 'non_existing_key';
153			$data = ['data'];
154
155			// Tenta adicionar dados a um arquivo de cache que não existe
156			$this->cache->appendCache($cacheKey, $data);
157			$this->assertFalse($this->cache->isSuccess());
158			$this->assertEquals('cacheFile not found, does not exists or expired', $this->cache->getMessage());
159			}
160
161			public function testAppendCacheWithNamespace()
162			{
163			$cacheKey = 'test_append_key_ns';
164			$namespace = 'test_namespace';
165
166			$initialData = ['initial' => 'data'];
167			$additionalData = ['new' => 'data'];
168
169			$expectedData = array_merge($initialData, $additionalData);
170
171			// Armazena os dados iniciais no cache com namespace
172			$this->cache->putCache($cacheKey, $initialData, $namespace);
173			$this->assertTrue($this->cache->isSuccess());
174
175			// Adiciona novos dados ao cache existente com namespace
176			$this->cache->appendCache($cacheKey, $additionalData, $namespace);
177			$this->assertTrue($this->cache->isSuccess());
178
179			// Verifica se os dados no cache são os esperados
180			$cachedData = $this->cache->getCache($cacheKey, $namespace);
181			$this->assertEquals($expectedData, $cachedData);
182			}
183
184			public function testDataOutputShouldBeOfTypeJson()
185			{
186			$options = [
187			'cacheDir' => $this->cacheDir
188			];
189			$this->cache = new Cacheer($options, true);
190
191			$cacheKey = "key_json";
192			$cacheData = "data_json";
193
194			$this->cache->putCache($cacheKey, $cacheData);
195			$this->assertTrue($this->cache->isSuccess());
196
197			$cacheOutput = $this->cache->getCache($cacheKey)->toJson();
198			$this->assertTrue($this->cache->isSuccess());
199			$this->assertJson($cacheOutput);
200			}
201
202			public function testDataOutputShouldBeOfTypeArray()
203			{
204			$options = [
205			'cacheDir' => $this->cacheDir
206			];
207			$this->cache = new Cacheer($options, true);
208
209			$cacheKey = "key_array";
210			$cacheData = "data_array";
211
212			$this->cache->putCache($cacheKey, $cacheData);
213			$this->assertTrue($this->cache->isSuccess());
214
215			$cacheOutput = $this->cache->getCache($cacheKey)->toArray();
216			$this->assertTrue($this->cache->isSuccess());
217			$this->assertIsArray($cacheOutput);
218			}
219
220			public function testDataOutputShouldBeOfTypeObject()
221			{
222			$options = [
223			'cacheDir' => $this->cacheDir
224			];
225			$this->cache = new Cacheer($options, true);
226
227			$cacheKey = "key_object";
228			$cacheData = ["id" => 123];
229
230			$this->cache->putCache($cacheKey, $cacheData);
231			$this->assertTrue($this->cache->isSuccess());
232
233			$cacheOutput = $this->cache->getCache($cacheKey)->toObject();
234			$this->assertTrue($this->cache->isSuccess());
235			$this->assertIsObject($cacheOutput);
236			}
237
238			public function testPutMany()
239			{
240			$cacheer = new Cacheer(['cacheDir' => __DIR__ . '/cache']);
241			$items = [
242			[
243			'cacheKey' => 'user_1_profile',
244			'cacheData' => ['name' => 'John Doe', 'email' => '[email protected]']
245			],
246			[
247			'cacheKey' => 'user_2_profile',
248			'cacheData' => ['name' => 'Jane Doe', 'email' => '[email protected]']
249			],
250			];
251
252			$cacheer->putMany($items);
253
254			foreach ($items as $item) {
255			$this->assertEquals($item['cacheData'], $cacheer->getCache($item['cacheKey']));
256			}
257			}
258
259			public function test_remember_saves_and_recover_values()
260			{
261			$this->cache->flushCache();
262
263			$value = $this->cache->remember('remember_test_key', 60, function () {
264			return 'valor_teste';
265			});
266
267			$this->assertEquals('valor_teste', $value);
268
269			$cachedValue = $this->cache->remember('remember_test_key', 60, function (){
270			return 'novo_valor';
271			});
272
273
274			$this->assertEquals('valor_teste', $cachedValue);
275			}
276
277			public function test_remember_forever_saves_value_indefinitely()
278			{
279			$this->cache->flushCache();
280
281			$value = $this->cache->rememberForever('remember_forever_key', function () {
282			return 'valor_eterno';
283			});
284			$this->assertEquals('valor_eterno', $value);
285
286			$cachedValue = $this->cache->rememberForever('remember_forever_key', function () {
287			return 'novo_valor';
288			});
289
290			$this->assertEquals('valor_eterno', $cachedValue);
291			}
292
293			public function test_get_and_forget()
294			{
295			$cacheKey = 'cache_key_test';
296			$this->cache->putCache($cacheKey, 10);
297
298			$this->assertTrue($this->cache->isSuccess());
299
300			$cacheData = $this->cache->getAndForget($cacheKey);
301
302			$this->assertTrue($this->cache->isSuccess());
303			$this->assertEquals(10, $cacheData);
304
305			$oldCacheData = $this->cache->getAndForget($cacheKey);
306
307			$this->assertNull($oldCacheData);
308			$this->assertFalse($this->cache->isSuccess());
309
310			$noCacheData = $this->cache->getAndForget('non_existent_cache_key');
311			$this->assertNull($noCacheData);
312			}
313
314			public function test_store_if_not_present_with_add_function()
315			{
316			$existentKey = 'cache_key_test';
317
318			$nonExistentKey = 'non_existent_key';
319
320			$this->cache->putCache($existentKey, 'existent_data');
321
322			$this->assertTrue($this->cache->isSuccess());
323			$this->assertEquals('existent_data', $this->cache->getCache($existentKey));
324
325			$addCache = $this->cache->add($existentKey, 100);
326
327			$this->assertTrue($addCache);
328			$this->assertNotEquals(100, 'existent_data');
329
330			$addNonExistentKey = $this->cache->add($nonExistentKey, 'non_existent_data');
331
332			$this->assertFalse($addNonExistentKey);
333			$this->assertEquals('non_existent_data', $this->cache->getCache($nonExistentKey));
334			$this->assertTrue($this->cache->isSuccess());
335
336			}
337
338			public function test_increment_function() {
339
340			$cacheKey = 'test_increment';
341			$cacheData = 2025;
342
343			$this->cache->putCache($cacheKey, $cacheData);
344
345			$this->assertTrue($this->cache->isSuccess());
346			$this->assertEquals($cacheData, $this->cache->getCache($cacheKey));
347			$this->assertIsNumeric($this->cache->getCache($cacheKey));
348
349			$increment = $this->cache->increment($cacheKey, 2);
350			$this->assertTrue($increment);
351
352			$this->assertEquals(2027, $this->cache->getCache($cacheKey));
353
354			}
355
356			public function test_decrement_function() {
357
358			$cacheKey = 'test_decrement';
359			$cacheData = 2027;
360
361			$this->cache->putCache($cacheKey, $cacheData);
362
363			$this->assertTrue($this->cache->isSuccess());
364			$this->assertEquals($cacheData, $this->cache->getCache($cacheKey));
365			$this->assertIsNumeric($this->cache->getCache($cacheKey));
366
367			$increment = $this->cache->decrement($cacheKey, 2);
368			$this->assertTrue($increment);
369
370			$this->assertEquals(2025, $this->cache->getCache($cacheKey));
371
372			}
373
374			private function removeDirectoryRecursively($dir)
375			{
376			if (!is_dir($dir)) {
377			return;
378			}
379			$items = scandir($dir);
380			foreach ($items as $item) {
381			if ($item === '.' \|\| $item === '..') {
382			continue;
383			}
384			$path = $dir . DIRECTORY_SEPARATOR . $item;
385			if (is_dir($path)) {
386			$this->removeDirectoryRecursively($path);
387			} else {
388			unlink($path);
389			}
390			}
391			rmdir($dir);
392			}
393
394			public function testUseDefaultDriverCreatesCacheDirInProjectRoot()
395			{
396			$cacheer = new Cacheer();
397			$driver = new CacheDriver($cacheer);
398
399			$projectRoot = EnvHelper::getRootPath();
400			$expectedCacheDir = $projectRoot . DIRECTORY_SEPARATOR . "CacheerPHP" . DIRECTORY_SEPARATOR . "Cache";
401
402			if (is_dir($expectedCacheDir)) {
403			$this->removeDirectoryRecursively($expectedCacheDir);
404			}
405
406			$driver->useDefaultDriver();
407
408			$this->assertDirectoryExists($expectedCacheDir);
409
410			if (is_dir($expectedCacheDir)) {
411			$this->removeDirectoryRecursively($expectedCacheDir);
412			}
413			}
414
415			public function testPutCacheWithNamespace()
416			{
417			$cacheKey = 'namespace_key';
418			$data = 'namespace_data';
419			$namespace = 'my_namespace';
420
421			$this->cache->putCache($cacheKey, $data, $namespace);
422			$this->assertTrue($this->cache->isSuccess());
423
424			$cachedData = $this->cache->getCache($cacheKey, $namespace);
425			$this->assertEquals($data, $cachedData);
426			}
427
428			public function testClearCacheWithNamespace()
429			{
430			$cacheKey = 'namespace_key_clear';
431			$data = 'namespace_data_clear';
432			$namespace = 'clear_namespace';
433
434			$this->cache->putCache($cacheKey, $data, $namespace);
435			$this->assertTrue($this->cache->isSuccess());
436
437			$this->cache->clearCache($cacheKey, $namespace);
438			$this->assertTrue($this->cache->isSuccess());
439
440			$cachedData = $this->cache->getCache($cacheKey, $namespace);
441			$this->assertFalse($this->cache->isSuccess());
442			$this->assertNull($cachedData);
443			}
444
445			public function testFlushCacheRemovesNamespacedFiles()
446			{
447			$cacheKey = 'ns_flush_key';
448			$data = 'ns_flush_data';
449			$namespace = 'flush_namespace';
450
451			$this->cache->putCache($cacheKey, $data, $namespace);
452			$this->assertTrue($this->cache->isSuccess());
453
454			$this->cache->flushCache();
455
456			$cachedData = $this->cache->getCache($cacheKey, $namespace);
457			$this->assertFalse($this->cache->isSuccess());
458			$this->assertNull($cachedData);
459			}
460
461			public function testAppendCacheWithDifferentTypes()
462			{
463			$cacheKey = 'append_type_key';
464			$initialData = ['a' => 1];
465			$additionalData = ['b' => 2];
466			$expectedData = ['a' => 1, 'b' => 2];
467
468			$this->cache->putCache($cacheKey, $initialData);
469			$this->cache->appendCache($cacheKey, $additionalData);
470			$this->assertEquals($expectedData, $this->cache->getCache($cacheKey));
471
472			$this->cache->appendCache($cacheKey, ['c' => 'string']);
473			$expectedData['c'] = 'string';
474			$this->assertEquals($expectedData, $this->cache->getCache($cacheKey));
475			}
476
477			public function test_get_many_cache_items()
478			{
479			$cacheItems = [
480			'key1' => 'value1',
481			'key2' => 'value2',
482			'key3' => 'value3'
483			];
484			foreach ($cacheItems as $key => $value) {
485			$this->cache->putCache($key, $value);
486			}
487			$this->assertTrue($this->cache->isSuccess());
488			$retrievedItems = $this->cache->getMany(array_keys($cacheItems));
489			$this->assertTrue($this->cache->isSuccess());
490			$this->assertCount(3, $retrievedItems);
491			$this->assertEquals($cacheItems, $retrievedItems);
492			}
493
494			}
495

silviooosilva / CacheerPHP

Push — main ( 29b1f6...a8c6a0 )

FileCacheStoreTest::test_get_many_cache_items() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like