ArrayCacheStoreTest::testRenewCacheFromArray() - Code Metrics - Inspection of "Array Cache Store Added" - silviooosilva/CacheerPHP - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — main (#2)

by Sílvio

created 2025-04-30 03:24 UTC

ArrayCacheStoreTest::testRenewCacheFromArray() A

↳ Parent: ArrayCacheStoreTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	16
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

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

<?php

use PHPUnit\Framework\TestCase;
use Silviooosilva\CacheerPhp\Cacheer;
use Silviooosilva\CacheerPhp\CacheStore\ArrayCacheStore;

class ArrayCacheStoreTest extends TestCase
{

  private $cache;

  protected function setUp(): void
  {
    $this->cache = new Cacheer();
    $this->cache->setDriver()->useArrayDriver();
    $this->cache->setConfig()->setTimeZone('America/Toronto');
  }

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

    public function testUsingArrayDriverSetsProperInstance()
  {
    $this->assertInstanceOf(ArrayCacheStore::class, $this->cache->cacheStore);
  }

  public function testPutAndGetCacheInArray()
  {
      $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 testExpiredCacheInArray()
  {
    $cacheKey = 'expired_key';
    $cacheData = ['name' => 'Expired User', 'email' => '[email protected]'];

    $this->cache->putCache($cacheKey, $cacheData, '', 1);
    sleep(3);

    $this->assertEquals("Cache stored successfully", $this->cache->getMessage());
    $this->assertEmpty($this->cache->getCache($cacheKey));
    $this->assertFalse($this->cache->isSuccess());
  }


  public function testOverwriteExistingCacheInArray()
  {
    $cacheKey = 'overwrite_key';
    $initialCacheData = ['name' => 'Initial Data', 'email' => '[email protected]'];
    $newCacheData = ['name' => 'New Data', 'email' => '[email protected]'];

    $this->cache->putCache($cacheKey, $initialCacheData);
    $this->assertEquals("Cache stored successfully", $this->cache->getMessage());

    $this->cache->appendCache($cacheKey, $newCacheData);
    $this->assertEquals("Cache appended successfully", $this->cache->getMessage());
    $this->assertEquals($newCacheData, $this->cache->getCache($cacheKey));
  }


  public function testPutManyCacheItemsInArray()
  {
     $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]']
                ]
            ]
        ];

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

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

  public function testHasCacheFromArray()
  {
    $cacheKey = 'test_key';
    $cacheData = ['name' => 'Sílvio Silva', 'role' => 'Developer'];

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

    $this->assertEquals("Cache stored successfully", $this->cache->getMessage());
    $this->assertTrue($this->cache->isSuccess());

    $hasCache = $this->cache->has($cacheKey);


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

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

    // Define TTL de 10 seg para que a chave ainda exista quando renovarmos
    $this->cache->putCache($cacheKey, $cacheData, '', 120);
    $this->assertEquals("Cache stored successfully", $this->cache->getMessage());
    sleep(2);

    // Verifica que a chave existe antes de renovar
    $this->assertNotEmpty($this->cache->getCache($cacheKey));

    $this->cache->renewCache($cacheKey, 7200);
    $this->assertTrue($this->cache->isSuccess());
    $this->assertNotEmpty($this->cache->getCache($cacheKey));
  }

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

    $this->cache->putCache($cacheKey, $cacheData, $namespace, 120);
    $this->assertEquals("Cache stored successfully", $this->cache->getMessage());
    sleep(2);

    $this->assertNotEmpty($this->cache->getCache($cacheKey, $namespace));

    $this->cache->renewCache($cacheKey, 7200, $namespace);
    $this->assertTrue($this->cache->isSuccess());
    $this->assertNotEmpty($this->cache->getCache($cacheKey, $namespace));
  }

    public function testClearCacheDataFromRedis()
    {
        $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 cleared successfully", $this->cache->getMessage());

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

    public function testFlushCacheDataFromRedis()
    {
        $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("Cache flushed successfully", $this->cache->getMessage());
    }

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

    }

}

1			<?php
2
3			use PHPUnit\Framework\TestCase;
4			use Silviooosilva\CacheerPhp\Cacheer;
5			use Silviooosilva\CacheerPhp\CacheStore\ArrayCacheStore;
6
7			class ArrayCacheStoreTest extends TestCase
8			{
9
10			private $cache;
11
12			protected function setUp(): void
13			{
14			$this->cache = new Cacheer();
15			$this->cache->setDriver()->useArrayDriver();
16			$this->cache->setConfig()->setTimeZone('America/Toronto');
17			}
18
19			protected function tearDown(): void
20			{
21			$this->cache->flushCache();
22			}
23
24			public function testUsingArrayDriverSetsProperInstance()
25			{
26			$this->assertInstanceOf(ArrayCacheStore::class, $this->cache->cacheStore);
27			}
28
29			public function testPutAndGetCacheInArray()
30			{
31			$cacheKey = 'test_key';
32			$cacheData = ['name' => 'John Doe', 'email' => '[email protected]'];
33
34			$this->cache->putCache($cacheKey, $cacheData, '', 3600);
35
36			$result = $this->cache->getCache($cacheKey);
37
38			$this->assertNotEmpty($result);
39			$this->assertEquals($cacheData, $result);
40			}
41
42			public function testExpiredCacheInArray()
43			{
44			$cacheKey = 'expired_key';
45			$cacheData = ['name' => 'Expired User', 'email' => '[email protected]'];
46
47			$this->cache->putCache($cacheKey, $cacheData, '', 1);
48			sleep(3);
49
50			$this->assertEquals("Cache stored successfully", $this->cache->getMessage());
51			$this->assertEmpty($this->cache->getCache($cacheKey));
52			$this->assertFalse($this->cache->isSuccess());
53			}
54
55
56			public function testOverwriteExistingCacheInArray()
57			{
58			$cacheKey = 'overwrite_key';
59			$initialCacheData = ['name' => 'Initial Data', 'email' => '[email protected]'];
60			$newCacheData = ['name' => 'New Data', 'email' => '[email protected]'];
61
62			$this->cache->putCache($cacheKey, $initialCacheData);
63			$this->assertEquals("Cache stored successfully", $this->cache->getMessage());
64
65			$this->cache->appendCache($cacheKey, $newCacheData);
66			$this->assertEquals("Cache appended successfully", $this->cache->getMessage());
67			$this->assertEquals($newCacheData, $this->cache->getCache($cacheKey));
68			}
69
70
71			public function testPutManyCacheItemsInArray()
72			{
73			$items = [
74			[
75			'cacheKey' => 'user_1_profile',
76			'cacheData' => [
77			['name' => 'John Doe', 'email' => '[email protected]'],
78			['name' => 'John Doe', 'email' => '[email protected]'],
79			['name' => 'John Doe', 'email' => '[email protected]'],
80			['name' => 'John Doe', 'email' => '[email protected]']
81			]
82			],
83			[
84			'cacheKey' => 'user_2_profile',
85			'cacheData' => [
86			['name' => 'Jane Doe', 'email' => '[email protected]'],
87			['name' => 'Jane Doe', 'email' => '[email protected]'],
88			['name' => 'Jane Doe', 'email' => '[email protected]'],
89			['name' => 'Jane Doe', 'email' => '[email protected]']
90			]
91			]
92			];
93
94			$storeCache = $this->cache->putMany($items);
			0 ignored issues – show Unused Code introduced 2025-04-30 03:33 UTC by Report Bug Copy Issue Report The assignment to `$storeCache` is dead and can be removed. Loading history...
95			foreach ($items as $item) {
96
97			$this->assertEquals($item['cacheData'], $this->cache->getCache($item['cacheKey']));
98			}
99			}
100
101			public function testHasCacheFromArray()
102			{
103			$cacheKey = 'test_key';
104			$cacheData = ['name' => 'Sílvio Silva', 'role' => 'Developer'];
105
106			$this->cache->putCache($cacheKey, $cacheData);
107
108			$this->assertEquals("Cache stored successfully", $this->cache->getMessage());
109			$this->assertTrue($this->cache->isSuccess());
110
111			$hasCache = $this->cache->has($cacheKey);
			0 ignored issues – show Unused Code introduced 2025-04-30 03:33 UTC by Report Bug Copy Issue Report The assignment to `$hasCache` is dead and can be removed. Loading history...
112
113			$this->assertTrue($this->cache->isSuccess());
114			}
115
116			public function testRenewCacheFromArray()
117			{
118			$cacheKey = 'expired_key';
119			$cacheData = ['name' => 'Expired User', 'email' => '[email protected]'];
120
121			// Define TTL de 10 seg para que a chave ainda exista quando renovarmos
122			$this->cache->putCache($cacheKey, $cacheData, '', 120);
123			$this->assertEquals("Cache stored successfully", $this->cache->getMessage());
124			sleep(2);
125
126			// Verifica que a chave existe antes de renovar
127			$this->assertNotEmpty($this->cache->getCache($cacheKey));
128
129			$this->cache->renewCache($cacheKey, 7200);
130			$this->assertTrue($this->cache->isSuccess());
131			$this->assertNotEmpty($this->cache->getCache($cacheKey));
132			}
133
134			public function testRenewCacheWithNamespaceFromRedis()
135			{
136			$cacheKey = 'expired_key';
137			$namespace = 'expired_namespace';
138			$cacheData = ['name' => 'Expired User', 'email' => '[email protected]'];
139
140			$this->cache->putCache($cacheKey, $cacheData, $namespace, 120);
141			$this->assertEquals("Cache stored successfully", $this->cache->getMessage());
142			sleep(2);
143
144			$this->assertNotEmpty($this->cache->getCache($cacheKey, $namespace));
145
146			$this->cache->renewCache($cacheKey, 7200, $namespace);
147			$this->assertTrue($this->cache->isSuccess());
148			$this->assertNotEmpty($this->cache->getCache($cacheKey, $namespace));
149			}
150
151			public function testClearCacheDataFromRedis()
152			{
153			$cacheKey = 'test_key';
154			$data = 'test_data';
155
156			$this->cache->putCache($cacheKey, $data);
157			$this->assertEquals("Cache stored successfully", $this->cache->getMessage());
158
159			$this->cache->clearCache($cacheKey);
160			$this->assertTrue($this->cache->isSuccess());
161			$this->assertEquals("Cache cleared successfully", $this->cache->getMessage());
162
163			$this->assertEmpty($this->cache->getCache($cacheKey));
164			}
165
166			public function testFlushCacheDataFromRedis()
167			{
168			$key1 = 'test_key1';
169			$data1 = 'test_data1';
170
171			$key2 = 'test_key2';
172			$data2 = 'test_data2';
173
174			$this->cache->putCache($key1, $data1);
175			$this->cache->putCache($key2, $data2);
176			$this->assertTrue($this->cache->isSuccess());
177			$this->assertTrue($this->cache->isSuccess());
178
179			$this->cache->flushCache();
180
181			$this->assertTrue($this->cache->isSuccess());
182			$this->assertEquals("Cache flushed successfully", $this->cache->getMessage());
183			}
184
185			public function test_remember_saves_and_recover_values()
186			{
187			$this->cache->flushCache();
188
189			$value = $this->cache->remember('remember_test_key', 60, function () {
190			return 'valor_teste';
191			});
192
193			$this->assertEquals('valor_teste', $value);
194
195			$cachedValue = $this->cache->remember('remember_test_key', 60, function (){
196			return 'novo_valor';
197			});
198
199
200			$this->assertEquals('valor_teste', $cachedValue);
201			}
202
203			public function test_remember_forever_saves_value_indefinitely()
204			{
205			$this->cache->flushCache();
206
207			$value = $this->cache->rememberForever('remember_forever_key', function () {
208			return 'valor_eterno';
209			});
210			$this->assertEquals('valor_eterno', $value);
211
212			$cachedValue = $this->cache->rememberForever('remember_forever_key', function () {
213			return 'novo_valor';
214			});
215
216			$this->assertEquals('valor_eterno', $cachedValue);
217			}
218
219
220			public function test_get_and_forget()
221			{
222			$cacheKey = 'cache_key_test';
223			$this->cache->putCache($cacheKey, 10);
224
225			$this->assertTrue($this->cache->isSuccess());
226
227			$cacheData = $this->cache->getAndForget($cacheKey);
228
229			$this->assertTrue($this->cache->isSuccess());
230			$this->assertEquals(10, $cacheData);
231
232			$oldCacheData = $this->cache->getAndForget($cacheKey);
233
234			$this->assertNull($oldCacheData);
235			$this->assertFalse($this->cache->isSuccess());
236
237			$noCacheData = $this->cache->getAndForget('non_existent_cache_key');
238			$this->assertNull($noCacheData);
239			}
240
241			public function test_store_if_not_present_with_add_function()
242			{
243			$existentKey = 'cache_key_test';
244
245			$nonExistentKey = 'non_existent_key';
246
247			$this->cache->putCache($existentKey, 'existent_data');
248
249			$this->assertTrue($this->cache->isSuccess());
250			$this->assertEquals('existent_data', $this->cache->getCache($existentKey));
251
252			$addCache = $this->cache->add($existentKey, 100);
253
254			$this->assertTrue($addCache);
255			$this->assertNotEquals(100, 'existent_data');
256
257			$addNonExistentKey = $this->cache->add($nonExistentKey, 'non_existent_data');
258
259			$this->assertFalse($addNonExistentKey);
260			$this->assertEquals('non_existent_data', $this->cache->getCache($nonExistentKey));
261			$this->assertTrue($this->cache->isSuccess());
262
263			}
264
265			public function test_increment_function() {
266
267			$cacheKey = 'test_increment';
268			$cacheData = 2025;
269
270			$this->cache->putCache($cacheKey, $cacheData);
271
272			$this->assertTrue($this->cache->isSuccess());
273			$this->assertEquals($cacheData, $this->cache->getCache($cacheKey));
274			$this->assertIsNumeric($this->cache->getCache($cacheKey));
275
276			$increment = $this->cache->increment($cacheKey, 2);
277			$this->assertTrue($increment);
278
279			$this->assertEquals(2027, $this->cache->getCache($cacheKey));
280
281			}
282
283			public function test_decrement_function() {
284
285			$cacheKey = 'test_decrement';
286			$cacheData = 2027;
287
288			$this->cache->putCache($cacheKey, $cacheData);
289
290			$this->assertTrue($this->cache->isSuccess());
291			$this->assertEquals($cacheData, $this->cache->getCache($cacheKey));
292			$this->assertIsNumeric($this->cache->getCache($cacheKey));
293
294			$increment = $this->cache->decrement($cacheKey, 2);
295			$this->assertTrue($increment);
296
297			$this->assertEquals(2025, $this->cache->getCache($cacheKey));
298
299			}
300
301			}

silviooosilva / CacheerPHP

Pull Request — main (#2)

ArrayCacheStoreTest::testRenewCacheFromArray() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like