CachePSR16Test::testTtl() - Code Metrics - Inspection of "Fixed Redis::delete() deprecation exception." - byjg/cache-engine-php - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — master (f6ba96)

by Joao

created 2020-05-11 14:41 UTC

CachePSR16Test::testTtl() A

↳ Parent: Project

Complexity

Conditions	3
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	31
rs	9.424
c	0
b	0
f	0
cc	3
nc	3
nop	1

<?php

namespace Test;

use ByJG\Cache\Psr16\BaseCacheEngine;
use ByJG\Cache\Psr16\NoCacheEngine;

require_once 'BaseCacheTest.php';

class CachePSR16Test extends BaseCacheTest
{
    /**
     * @dataProvider CachePoolProvider
     * @param \ByJG\Cache\Psr16\BaseCacheEngine $cacheEngine
     * @throws \Psr\SimpleCache\InvalidArgumentException
     */
    public function testGetOneItem(BaseCacheEngine $cacheEngine)
    {
        $this->cacheEngine = $cacheEngine;

        if ($cacheEngine->isAvailable()) {
            // First time
            $item = $cacheEngine->get('chave', null);
            $this->assertEquals(null, $item);
            $item = $cacheEngine->get('chave', 'default');
            $this->assertEquals('default', $item);

            // Set object
            $cacheEngine->set('chave', 'valor');

            // Get Object
            if (!($cacheEngine instanceof NoCacheEngine)) {
                $item2 = $cacheEngine->get('chave', 'default');
                $this->assertEquals('valor', $item2);
            }

            // Remove
            $cacheEngine->delete('chave');

            // Check Removed
            $item = $cacheEngine->get('chave');
            $this->assertEquals(null, $item);
        } else {
            $this->markTestIncomplete('Object is not fully functional');
        }
    }

    /**
     * @dataProvider CachePoolProvider
     * @param \ByJG\Cache\Psr16\BaseCacheEngine $cacheEngine
     * @throws \ByJG\Cache\InvalidArgumentException
     * @throws \Psr\SimpleCache\InvalidArgumentException
     */
    public function testGetMultipleItems(BaseCacheEngine $cacheEngine)
    {
        $this->cacheEngine = $cacheEngine;

        if ($cacheEngine->isAvailable()) {
            // First time
            $items = $cacheEngine->getMultiple(['chave1', 'chave2']);
            $this->assertEquals(null, $items['chave1']);
            $this->assertEquals(null, $items['chave2']);
            $items = $cacheEngine->getMultiple(['chave1', 'chave2'], 'default');
            $this->assertEquals('default', $items['chave1']);
            $this->assertEquals('default', $items['chave2']);

            // Set object
            $cacheEngine->set('chave1', 'valor1');
            $cacheEngine->set('chave2', 'valor2');

            // Get Object
            if (!($cacheEngine instanceof NoCacheEngine)) {
                $item2 = $cacheEngine->getMultiple(['chave1', 'chave2']);
                $this->assertEquals('valor1', $item2['chave1']);
                $this->assertEquals('valor2', $item2['chave2']);
            }

            // Remove
            $cacheEngine->deleteMultiple(['chave1', 'chave2']);

            // Check Removed
            $items = $cacheEngine->getMultiple(['chave1', 'chave2']);
            $this->assertEquals(null, $items['chave1']);
            $this->assertEquals(null, $items['chave2']);
        } else {
            $this->markTestIncomplete('Object is not fully functional');
        }
    }

    /**
     * @dataProvider CachePoolProvider
     * @param \ByJG\Cache\Psr16\BaseCacheEngine $cacheEngine
     * @throws \Psr\SimpleCache\InvalidArgumentException
     */
    public function testTtl(BaseCacheEngine $cacheEngine)
    {
        $this->cacheEngine = $cacheEngine;

        if ($cacheEngine->isAvailable()) {
            // First time
            $item = $cacheEngine->get('chave');
            $this->assertEquals(null, $item);
            $this->assertFalse($cacheEngine->has('chave'));
            $item2 = $cacheEngine->get('chave2');
            $this->assertEquals(null, $item2);
            $this->assertFalse($cacheEngine->has('chave2'));

            // Set object
            $cacheEngine->set('chave', 'valor', 2);
            $cacheEngine->set('chave2', 'valor2', 2);

            // Get Object
            if (!($cacheEngine instanceof NoCacheEngine)) {
                $item2 = $cacheEngine->get('chave');
                $this->assertEquals('valor', $item2);
                $this->assertTrue($cacheEngine->has('chave2'));
                sleep(3);
                $item2 = $cacheEngine->get('chave');
                $this->assertEquals(null, $item2);
                $this->assertFalse($cacheEngine->has('chave2'));
            }
        } else {
            $this->markTestIncomplete('Object is not fully functional');
        }
    }

    /**
     * @dataProvider CachePoolProvider
     * @param \ByJG\Cache\Psr16\BaseCacheEngine $cacheEngine
     * @throws \Psr\SimpleCache\InvalidArgumentException
     */
    public function testCacheObject(BaseCacheEngine $cacheEngine)
    {
        $this->cacheEngine = $cacheEngine;

        if ($cacheEngine->isAvailable()) {
            // First time
            $item = $cacheEngine->get('chave');
            $this->assertEquals(null, $item);

            // Set object
            $model = new Model(10, 20);
            $cacheEngine->set('chave', $model);

            // Get Object
            if (!($cacheEngine instanceof NoCacheEngine)) {
                $item2 = $cacheEngine->get('chave');
                $this->assertEquals($model, $item2);
            }

            // Delete
            $cacheEngine->delete('chave');
            $item = $cacheEngine->get('chave');
            $this->assertEquals(null, $item);
        } else {
            $this->markTestIncomplete('Object is not fully functional');
        }
    }

    /**
     * @dataProvider CachePoolProvider
     * @param \ByJG\Cache\Psr16\BaseCacheEngine $cacheEngine
     * @throws \ByJG\Cache\InvalidArgumentException
     * @throws \Psr\SimpleCache\InvalidArgumentException
     */
    public function testClear(BaseCacheEngine $cacheEngine)
    {
        $this->cacheEngine = $cacheEngine;

        if ($cacheEngine->isAvailable()) {
            // Values
            $empty = [
                'chave'  => null,
                'chave2' => null,
                'chave3' => null
            ];
            $set = [
                'chave'  => 'val',
                'chave2' => 'val2',
                'chave3' => 'val3'
            ];

            // First time
            $item = $cacheEngine->getMultiple(['chave', 'chave2', 'chave3']);
            $this->assertEquals($empty, $item);

            // Set and Check
            $cacheEngine->setMultiple($set);
            if (!($cacheEngine instanceof NoCacheEngine)) {
                $item = $cacheEngine->getMultiple(['chave', 'chave2', 'chave3']);
                $this->assertEquals($set, $item);
            }

            // Clear and Check
            $cacheEngine->clear();
            $item = $cacheEngine->getMultiple(['chave', 'chave2', 'chave3']);
            $this->assertEquals($empty, $item);
        } else {
            $this->markTestIncomplete('Object is not fully functional');
        }
    }
}


1			<?php
2
3			namespace Test;
4
5			use ByJG\Cache\Psr16\BaseCacheEngine;
6			use ByJG\Cache\Psr16\NoCacheEngine;
7
8			require_once 'BaseCacheTest.php';
9
10			class CachePSR16Test extends BaseCacheTest
11			{
12			/**
13			* @dataProvider CachePoolProvider
14			* @param \ByJG\Cache\Psr16\BaseCacheEngine $cacheEngine
15			* @throws \Psr\SimpleCache\InvalidArgumentException
16			*/
17			public function testGetOneItem(BaseCacheEngine $cacheEngine)
18			{
19			$this->cacheEngine = $cacheEngine;
20
21			if ($cacheEngine->isAvailable()) {
22			// First time
23			$item = $cacheEngine->get('chave', null);
24			$this->assertEquals(null, $item);
25			$item = $cacheEngine->get('chave', 'default');
26			$this->assertEquals('default', $item);
27
28			// Set object
29			$cacheEngine->set('chave', 'valor');
30
31			// Get Object
32			if (!($cacheEngine instanceof NoCacheEngine)) {
33			$item2 = $cacheEngine->get('chave', 'default');
34			$this->assertEquals('valor', $item2);
35			}
36
37			// Remove
38			$cacheEngine->delete('chave');
39
40			// Check Removed
41			$item = $cacheEngine->get('chave');
42			$this->assertEquals(null, $item);
43			} else {
44			$this->markTestIncomplete('Object is not fully functional');
45			}
46			}
47
48			/**
49			* @dataProvider CachePoolProvider
50			* @param \ByJG\Cache\Psr16\BaseCacheEngine $cacheEngine
51			* @throws \ByJG\Cache\InvalidArgumentException
52			* @throws \Psr\SimpleCache\InvalidArgumentException
53			*/
54			public function testGetMultipleItems(BaseCacheEngine $cacheEngine)
55			{
56			$this->cacheEngine = $cacheEngine;
57
58			if ($cacheEngine->isAvailable()) {
59			// First time
60			$items = $cacheEngine->getMultiple(['chave1', 'chave2']);
61			$this->assertEquals(null, $items['chave1']);
62			$this->assertEquals(null, $items['chave2']);
63			$items = $cacheEngine->getMultiple(['chave1', 'chave2'], 'default');
64			$this->assertEquals('default', $items['chave1']);
65			$this->assertEquals('default', $items['chave2']);
66
67			// Set object
68			$cacheEngine->set('chave1', 'valor1');
69			$cacheEngine->set('chave2', 'valor2');
70
71			// Get Object
72			if (!($cacheEngine instanceof NoCacheEngine)) {
73			$item2 = $cacheEngine->getMultiple(['chave1', 'chave2']);
74			$this->assertEquals('valor1', $item2['chave1']);
75			$this->assertEquals('valor2', $item2['chave2']);
76			}
77
78			// Remove
79			$cacheEngine->deleteMultiple(['chave1', 'chave2']);
80
81			// Check Removed
82			$items = $cacheEngine->getMultiple(['chave1', 'chave2']);
83			$this->assertEquals(null, $items['chave1']);
84			$this->assertEquals(null, $items['chave2']);
85			} else {
86			$this->markTestIncomplete('Object is not fully functional');
87			}
88			}
89
90			/**
91			* @dataProvider CachePoolProvider
92			* @param \ByJG\Cache\Psr16\BaseCacheEngine $cacheEngine
93			* @throws \Psr\SimpleCache\InvalidArgumentException
94			*/
95			public function testTtl(BaseCacheEngine $cacheEngine)
96			{
97			$this->cacheEngine = $cacheEngine;
98
99			if ($cacheEngine->isAvailable()) {
100			// First time
101			$item = $cacheEngine->get('chave');
102			$this->assertEquals(null, $item);
103			$this->assertFalse($cacheEngine->has('chave'));
104			$item2 = $cacheEngine->get('chave2');
105			$this->assertEquals(null, $item2);
106			$this->assertFalse($cacheEngine->has('chave2'));
107
108			// Set object
109			$cacheEngine->set('chave', 'valor', 2);
110			$cacheEngine->set('chave2', 'valor2', 2);
111
112			// Get Object
113			if (!($cacheEngine instanceof NoCacheEngine)) {
114			$item2 = $cacheEngine->get('chave');
115			$this->assertEquals('valor', $item2);
116			$this->assertTrue($cacheEngine->has('chave2'));
117			sleep(3);
118			$item2 = $cacheEngine->get('chave');
119			$this->assertEquals(null, $item2);
120			$this->assertFalse($cacheEngine->has('chave2'));
121			}
122			} else {
123			$this->markTestIncomplete('Object is not fully functional');
124			}
125			}
126
127			/**
128			* @dataProvider CachePoolProvider
129			* @param \ByJG\Cache\Psr16\BaseCacheEngine $cacheEngine
130			* @throws \Psr\SimpleCache\InvalidArgumentException
131			*/
132			public function testCacheObject(BaseCacheEngine $cacheEngine)
133			{
134			$this->cacheEngine = $cacheEngine;
135
136			if ($cacheEngine->isAvailable()) {
137			// First time
138			$item = $cacheEngine->get('chave');
139			$this->assertEquals(null, $item);
140
141			// Set object
142			$model = new Model(10, 20);
143			$cacheEngine->set('chave', $model);
144
145			// Get Object
146			if (!($cacheEngine instanceof NoCacheEngine)) {
147			$item2 = $cacheEngine->get('chave');
148			$this->assertEquals($model, $item2);
149			}
150
151			// Delete
152			$cacheEngine->delete('chave');
153			$item = $cacheEngine->get('chave');
154			$this->assertEquals(null, $item);
155			} else {
156			$this->markTestIncomplete('Object is not fully functional');
157			}
158			}
159
160			/**
161			* @dataProvider CachePoolProvider
162			* @param \ByJG\Cache\Psr16\BaseCacheEngine $cacheEngine
163			* @throws \ByJG\Cache\InvalidArgumentException
164			* @throws \Psr\SimpleCache\InvalidArgumentException
165			*/
166			public function testClear(BaseCacheEngine $cacheEngine)
167			{
168			$this->cacheEngine = $cacheEngine;
169
170			if ($cacheEngine->isAvailable()) {
171			// Values
172			$empty = [
173			'chave' => null,
174			'chave2' => null,
175			'chave3' => null
176			];
177			$set = [
178			'chave' => 'val',
179			'chave2' => 'val2',
180			'chave3' => 'val3'
181			];
182
183			// First time
184			$item = $cacheEngine->getMultiple(['chave', 'chave2', 'chave3']);
185			$this->assertEquals($empty, $item);
186
187			// Set and Check
188			$cacheEngine->setMultiple($set);
189			if (!($cacheEngine instanceof NoCacheEngine)) {
190			$item = $cacheEngine->getMultiple(['chave', 'chave2', 'chave3']);
191			$this->assertEquals($set, $item);
192			}
193
194			// Clear and Check
195			$cacheEngine->clear();
196			$item = $cacheEngine->getMultiple(['chave', 'chave2', 'chave3']);
197			$this->assertEquals($empty, $item);
198			} else {
199			$this->markTestIncomplete('Object is not fully functional');
200			}
201			}
202			}
203

byjg / cache-engine-php

Branch — master (f6ba96)

CachePSR16Test::testTtl() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like