DatabaseCacheStoreTest::test_decrement_function() - Code Metrics - Inspection of "Refactor[Tests]: Rename Test Files" - silviooosilva/CacheerPHP - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 1a2591...d5d45e )

by Sílvio

created 2025-04-30 03:17 UTC

DatabaseCacheStoreTest::test_decrement_function() A

↳ Parent: DatabaseCacheStoreTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	15
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	9
nc	1
nop	0
dl	0
loc	15
rs	9.9666
c	0
b	0
f	0

<?php

use PHPUnit\Framework\TestCase;
use Silviooosilva\CacheerPhp\Cacheer;
use Silviooosilva\CacheerPhp\Core\Connect;

class DatabaseCacheStoreTest extends TestCase
{
    private $cache;

    protected function setUp(): void
    {
        $this->cache = new Cacheer();
        $this->cache->setConfig()->setDatabaseConnection(Connect::getInstance()->getAttribute(PDO::ATTR_DRIVER_NAME));
        $this->cache->setDriver()->useDatabaseDriver();
        $this->cache->setConfig()->setTimeZone('America/Toronto');
    }

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

    public function testPutCacheInDatabase()
    {
        $cacheKey = 'test_key';
        $cacheData = ['name' => 'John Doe', 'email' => '[email protected]'];

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

        $result = $this->cache->getCache($cacheKey);

        $this->assertNotEmpty($result);
        $this->assertEquals($cacheData, $result);
    }

    public function testGetCacheFromDatabase()
    {
        $cacheKey = 'test_key02';
        $cacheData = ['name' => 'Jane Doe', 'email' => '[email protected]'];

        $this->cache->putCache($cacheKey, $cacheData, '', 3600);
        $this->assertEquals("Cache Stored Successfully", $this->cache->getMessage());

        $result = $this->cache->getCache($cacheKey);

        $this->assertNotEmpty($result);
        $this->assertEquals($cacheData, $result);
    }

    public function testExpiredCacheInDatabase()
    {
        $cacheKey = 'expired_key';
        $cacheData = ['name' => 'Expired User', 'email' => '[email protected]'];

        $this->cache->putCache($cacheKey, $cacheData, '', -3600);
        $this->assertEquals("Cache Stored Successfully", $this->cache->getMessage());

        $this->assertEmpty($this->cache->getCache($cacheKey));
        $this->assertFalse($this->cache->isSuccess());
    }
    public function testOverwriteExistingCacheInDatabase()
    {

        $cacheKey = 'overwrite_key';
        $initialCacheData = ['name' => 'Initial Data', 'email' => '[email protected]'];
        $newCacheData = ['name' => 'New Data', 'email' => '[email protected]'];

        $expirationTime = date('Y-m-d H:i:s', time() + 3600);


        $db = Connect::getInstance();
        $query = $db->prepare("INSERT INTO cacheer_table (cacheKey, cacheData, cacheNamespace, expirationTime) VALUES (?, ?, ?, ?)");
        $query->bindValue(1, $cacheKey);
        $query->bindValue(2, serialize($initialCacheData));
        $query->bindValue(3, '');
        $query->bindValue(4, $expirationTime);

        $this->assertTrue($query->execute());

        $this->cache->appendCache($cacheKey, $newCacheData);
        $this->assertEquals("Cache updated successfully.", $this->cache->getMessage());

        $driver = Connect::getInstance()->getAttribute(PDO::ATTR_DRIVER_NAME);
        $nowFunction = ($driver === 'sqlite') ? "DATETIME('now', 'localtime')" : "NOW()";

        $query = $db->prepare("SELECT cacheData FROM cacheer_table WHERE cacheKey = ? AND cacheNamespace = ? AND expirationTime > $nowFunction");
        $query->bindValue(1, $cacheKey);
        $query->bindValue(2, '');

        $this->assertTrue($query->execute());

        $result = $query->fetch(PDO::FETCH_ASSOC);

        $this->assertEquals($newCacheData, unserialize($result['cacheData']));
    }

    public function testPutManyCacheItemsInDatabase(): void
    {

        $items = [
            [
                'cacheKey' => 'user_1_profile',
                'cacheData' => [
                    ['name' => 'John Doe', 'email' => '[email protected]'],
                    ['name' => 'John Doe', 'email' => '[email protected]'],
                    ['name' => 'John Doe', 'email' => '[email protected]'],
                    ['name' => 'John Doe', 'email' => '[email protected]']
                ]
            ],
            [
                'cacheKey' => 'user_2_profile',
                'cacheData' => [
                    ['name' => 'Jane Doe', 'email' => '[email protected]'],
                    ['name' => 'Jane Doe', 'email' => '[email protected]'],
                    ['name' => 'Jane Doe', 'email' => '[email protected]'],
                    ['name' => 'Jane Doe', 'email' => '[email protected]']
                ]
            ]
        ];

        $this->cache->putMany($items);

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

    public function testAppendCacheWithNamespaceInDatabase(): void
    {
        $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()
    {
        $this->cache->useFormatter();

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

        $this->cache->useFormatter();

        $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()
    {
        $this->cache->useFormatter();

        $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 testClearCacheDataFromDatabase(): void
    {
        $cacheKey = 'test_key';
        $data = 'test_data';

        $this->cache->putCache($cacheKey, $data);
        $this->assertEquals("Cache Stored Successfully", $this->cache->getMessage());

        $this->cache->clearCache($cacheKey);
        $this->assertTrue($this->cache->isSuccess());
        $this->assertEquals("Cache deleted successfully!", $this->cache->getMessage());

        $this->assertEmpty($this->cache->getCache($cacheKey));
    }


    public function testFlushCacheDataFromDatabase(): void
    {
        $key1 = 'test_key1';
        $data1 = 'test_data1';

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

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

        $this->cache->flushCache();
        $this->assertTrue($this->cache->isSuccess());
        $this->assertEquals("Flush finished successfully", $this->cache->getMessage());
    }

    public function test_remember_saves_and_recover_values()
    {
        $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()
    {

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

    }


}


1			<?php
2
3			use PHPUnit\Framework\TestCase;
4			use Silviooosilva\CacheerPhp\Cacheer;
5			use Silviooosilva\CacheerPhp\Core\Connect;
6
7			class DatabaseCacheStoreTest extends TestCase
8			{
9			private $cache;
10
11			protected function setUp(): void
12			{
13			$this->cache = new Cacheer();
14			$this->cache->setConfig()->setDatabaseConnection(Connect::getInstance()->getAttribute(PDO::ATTR_DRIVER_NAME));
15			$this->cache->setDriver()->useDatabaseDriver();
16			$this->cache->setConfig()->setTimeZone('America/Toronto');
17			}
18
19			protected function tearDown(): void
20			{
21			$this->cache->flushCache();
22			}
23
24			public function testPutCacheInDatabase()
25			{
26			$cacheKey = 'test_key';
27			$cacheData = ['name' => 'John Doe', 'email' => '[email protected]'];
28
29			$this->cache->putCache($cacheKey, $cacheData, '', 3600);
30
31			$result = $this->cache->getCache($cacheKey);
32
33			$this->assertNotEmpty($result);
34			$this->assertEquals($cacheData, $result);
35			}
36
37			public function testGetCacheFromDatabase()
38			{
39			$cacheKey = 'test_key02';
40			$cacheData = ['name' => 'Jane Doe', 'email' => '[email protected]'];
41
42			$this->cache->putCache($cacheKey, $cacheData, '', 3600);
43			$this->assertEquals("Cache Stored Successfully", $this->cache->getMessage());
44
45			$result = $this->cache->getCache($cacheKey);
46
47			$this->assertNotEmpty($result);
48			$this->assertEquals($cacheData, $result);
49			}
50
51			public function testExpiredCacheInDatabase()
52			{
53			$cacheKey = 'expired_key';
54			$cacheData = ['name' => 'Expired User', 'email' => '[email protected]'];
55
56			$this->cache->putCache($cacheKey, $cacheData, '', -3600);
57			$this->assertEquals("Cache Stored Successfully", $this->cache->getMessage());
58
59			$this->assertEmpty($this->cache->getCache($cacheKey));
60			$this->assertFalse($this->cache->isSuccess());
61			}
62			public function testOverwriteExistingCacheInDatabase()
63			{
64
65			$cacheKey = 'overwrite_key';
66			$initialCacheData = ['name' => 'Initial Data', 'email' => '[email protected]'];
67			$newCacheData = ['name' => 'New Data', 'email' => '[email protected]'];
68
69			$expirationTime = date('Y-m-d H:i:s', time() + 3600);
70
71
72			$db = Connect::getInstance();
73			$query = $db->prepare("INSERT INTO cacheer_table (cacheKey, cacheData, cacheNamespace, expirationTime) VALUES (?, ?, ?, ?)");
74			$query->bindValue(1, $cacheKey);
75			$query->bindValue(2, serialize($initialCacheData));
76			$query->bindValue(3, '');
77			$query->bindValue(4, $expirationTime);
78
79			$this->assertTrue($query->execute());
80
81			$this->cache->appendCache($cacheKey, $newCacheData);
82			$this->assertEquals("Cache updated successfully.", $this->cache->getMessage());
83
84			$driver = Connect::getInstance()->getAttribute(PDO::ATTR_DRIVER_NAME);
85			$nowFunction = ($driver === 'sqlite') ? "DATETIME('now', 'localtime')" : "NOW()";
86
87			$query = $db->prepare("SELECT cacheData FROM cacheer_table WHERE cacheKey = ? AND cacheNamespace = ? AND expirationTime > $nowFunction");
88			$query->bindValue(1, $cacheKey);
89			$query->bindValue(2, '');
90
91			$this->assertTrue($query->execute());
92
93			$result = $query->fetch(PDO::FETCH_ASSOC);
94
95			$this->assertEquals($newCacheData, unserialize($result['cacheData']));
96			}
97
98			public function testPutManyCacheItemsInDatabase(): void
99			{
100
101			$items = [
102			[
103			'cacheKey' => 'user_1_profile',
104			'cacheData' => [
105			['name' => 'John Doe', 'email' => '[email protected]'],
106			['name' => 'John Doe', 'email' => '[email protected]'],
107			['name' => 'John Doe', 'email' => '[email protected]'],
108			['name' => 'John Doe', 'email' => '[email protected]']
109			]
110			],
111			[
112			'cacheKey' => 'user_2_profile',
113			'cacheData' => [
114			['name' => 'Jane Doe', 'email' => '[email protected]'],
115			['name' => 'Jane Doe', 'email' => '[email protected]'],
116			['name' => 'Jane Doe', 'email' => '[email protected]'],
117			['name' => 'Jane Doe', 'email' => '[email protected]']
118			]
119			]
120			];
121
122			$this->cache->putMany($items);
123
124			foreach ($items as $item) {
125			$this->assertEquals($item['cacheData'], $this->cache->getCache($item['cacheKey']));
126			}
127			}
128
129			public function testAppendCacheWithNamespaceInDatabase(): void
130			{
131			$cacheKey = 'test_append_key_ns';
132			$namespace = 'test_namespace';
133
134			$initialData = ['initial' => 'data'];
135			$additionalData = ['new' => 'data'];
136
137			$expectedData = array_merge($initialData, $additionalData);
138
139			// Armazena os dados iniciais no cache com namespace
140			$this->cache->putCache($cacheKey, $initialData, $namespace);
141			$this->assertTrue($this->cache->isSuccess());
142
143			// Adiciona novos dados ao cache existente com namespace
144			$this->cache->appendCache($cacheKey, $additionalData, $namespace);
145			$this->assertTrue($this->cache->isSuccess());
146
147			// Verifica se os dados no cache são os esperados
148			$cachedData = $this->cache->getCache($cacheKey, $namespace);
149			$this->assertEquals($expectedData, $cachedData);
150			}
151
152			public function testDataOutputShouldBeOfTypeJson()
153			{
154			$this->cache->useFormatter();
155
156			$cacheKey = "key_json";
157			$cacheData = "data_json";
158
159			$this->cache->putCache($cacheKey, $cacheData);
160			$this->assertTrue($this->cache->isSuccess());
161
162			$cacheOutput = $this->cache->getCache($cacheKey)->toJson();
163			$this->assertTrue($this->cache->isSuccess());
164			$this->assertJson($cacheOutput);
165			}
166
167			public function testDataOutputShouldBeOfTypeArray()
168			{
169
170			$this->cache->useFormatter();
171
172			$cacheKey = "key_array";
173			$cacheData = "data_array";
174
175			$this->cache->putCache($cacheKey, $cacheData);
176			$this->assertTrue($this->cache->isSuccess());
177
178			$cacheOutput = $this->cache->getCache($cacheKey)->toArray();
179			$this->assertTrue($this->cache->isSuccess());
180			$this->assertIsArray($cacheOutput);
181			}
182
183			public function testDataOutputShouldBeOfTypeObject()
184			{
185			$this->cache->useFormatter();
186
187			$cacheKey = "key_object";
188			$cacheData = ["id" => 123];
189
190			$this->cache->putCache($cacheKey, $cacheData);
191			$this->assertTrue($this->cache->isSuccess());
192
193			$cacheOutput = $this->cache->getCache($cacheKey)->toObject();
194			$this->assertTrue($this->cache->isSuccess());
195			$this->assertIsObject($cacheOutput);
196			}
197
198
199			public function testClearCacheDataFromDatabase(): void
200			{
201			$cacheKey = 'test_key';
202			$data = 'test_data';
203
204			$this->cache->putCache($cacheKey, $data);
205			$this->assertEquals("Cache Stored Successfully", $this->cache->getMessage());
206
207			$this->cache->clearCache($cacheKey);
208			$this->assertTrue($this->cache->isSuccess());
209			$this->assertEquals("Cache deleted successfully!", $this->cache->getMessage());
210
211			$this->assertEmpty($this->cache->getCache($cacheKey));
212			}
213
214
215			public function testFlushCacheDataFromDatabase(): void
216			{
217			$key1 = 'test_key1';
218			$data1 = 'test_data1';
219
220			$key2 = 'test_key2';
221			$data2 = 'test_data2';
222
223			$this->cache->putCache($key1, $data1);
224			$this->cache->putCache($key2, $data2);
225			$this->assertTrue($this->cache->isSuccess());
226			$this->assertTrue($this->cache->isSuccess());
227
228			$this->cache->flushCache();
229			$this->assertTrue($this->cache->isSuccess());
230			$this->assertEquals("Flush finished successfully", $this->cache->getMessage());
231			}
232
233			public function test_remember_saves_and_recover_values()
234			{
235			$value = $this->cache->remember('remember_test_key', 60, function () {
236			return 'valor_teste';
237			});
238
239			$this->assertEquals('valor_teste', $value);
240
241			$cachedValue = $this->cache->remember('remember_test_key', 60, function (){
242			return 'novo_valor';
243			});
244
245
246			$this->assertEquals('valor_teste', $cachedValue);
247			}
248
249			public function test_remember_forever_saves_value_indefinitely()
250			{
251
252			$value = $this->cache->rememberForever('remember_forever_key', function () {
253			return 'valor_eterno';
254			});
255			$this->assertEquals('valor_eterno', $value);
256
257			$cachedValue = $this->cache->rememberForever('remember_forever_key', function () {
258			return 'novo_valor';
259			});
260
261			$this->assertEquals('valor_eterno', $cachedValue);
262			}
263
264			public function test_get_and_forget()
265			{
266			$cacheKey = 'cache_key_test';
267			$this->cache->putCache($cacheKey, 10);
268
269			$this->assertTrue($this->cache->isSuccess());
270
271			$cacheData = $this->cache->getAndForget($cacheKey);
272
273			$this->assertTrue($this->cache->isSuccess());
274			$this->assertEquals(10, $cacheData);
275
276			$oldCacheData = $this->cache->getAndForget($cacheKey);
277
278			$this->assertNull($oldCacheData);
279			$this->assertFalse($this->cache->isSuccess());
280
281			$noCacheData = $this->cache->getAndForget('non_existent_cache_key');
282			$this->assertNull($noCacheData);
283			}
284
285			public function test_store_if_not_present_with_add_function()
286			{
287			$existentKey = 'cache_key_test';
288
289			$nonExistentKey = 'non_existent_key';
290
291			$this->cache->putCache($existentKey, 'existent_data');
292
293			$this->assertTrue($this->cache->isSuccess());
294			$this->assertEquals('existent_data', $this->cache->getCache($existentKey));
295
296			$addCache = $this->cache->add($existentKey, 100);
297
298			$this->assertTrue($addCache);
299			$this->assertNotEquals(100, 'existent_data');
300
301			$addNonExistentKey = $this->cache->add($nonExistentKey, 'non_existent_data');
302
303			$this->assertFalse($addNonExistentKey);
304			$this->assertEquals('non_existent_data', $this->cache->getCache($nonExistentKey));
305			$this->assertTrue($this->cache->isSuccess());
306			}
307
308
309			public function test_increment_function() {
310
311			$cacheKey = 'test_increment';
312			$cacheData = 2025;
313
314			$this->cache->putCache($cacheKey, $cacheData);
315
316			$this->assertTrue($this->cache->isSuccess());
317			$this->assertEquals($cacheData, $this->cache->getCache($cacheKey));
318			$this->assertIsNumeric($this->cache->getCache($cacheKey));
319
320			$increment = $this->cache->increment($cacheKey, 2);
321			$this->assertTrue($increment);
322
323			$this->assertEquals(2027, $this->cache->getCache($cacheKey));
324
325			}
326
327			public function test_decrement_function() {
328
329			$cacheKey = 'test_decrement';
330			$cacheData = 2027;
331
332			$this->cache->putCache($cacheKey, $cacheData);
333
334			$this->assertTrue($this->cache->isSuccess());
335			$this->assertEquals($cacheData, $this->cache->getCache($cacheKey));
336			$this->assertIsNumeric($this->cache->getCache($cacheKey));
337
338			$increment = $this->cache->decrement($cacheKey, 2);
339			$this->assertTrue($increment);
340
341			$this->assertEquals(2025, $this->cache->getCache($cacheKey));
342
343			}
344
345
346			}
347

silviooosilva / CacheerPHP

Push — main ( 1a2591...d5d45e )

DatabaseCacheStoreTest::test_decrement_function() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like