RedisTest::testExists() - Code Metrics - Inspection of "Switching from Travis to Drone" - joomla-framework/cache - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#31)

unknown

created 2020-09-02 19:22 UTC

RedisTest::testExists() A

↳ Parent: RedisTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	14
rs	9.7998
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php
/**
 * @copyright  Copyright (C) 2005 - 2018 Open Source Matters, Inc. All rights reserved.
 * @license    GNU General Public License version 2 or later; see LICENSE
 */

namespace Joomla\Cache\Tests;

use Joomla\Cache;
use PHPUnit\Framework\TestCase;

/**
 * Tests for the Joomla\Cache\Redis class.
 *
 * @since  1.0
 */
class RedisTest extends TestCase
{
	/**
	 * @var	Cache\Redis
	 * @since  1.0
	 */
	private $instance;

	/**
	 * Tests for the correct Psr\Cache return values.
	 *
	 * @return  void
	 *
	 * @coversNothing
	 * @since   1.0
	 */
	public function testPsrCache()
	{
		$this->assertInternalType('boolean', $this->instance->clear(), 'Checking clear.');
		$this->assertInstanceOf('\Psr\Cache\CacheItemInterface', $this->instance->get('foo'), 'Checking get.');
		$this->assertInternalType('array', $this->instance->getMultiple(array('foo')), 'Checking getMultiple.');
		$this->assertInternalType('boolean', $this->instance->remove('foo'), 'Checking remove.');
		$this->assertInternalType('array', $this->instance->removeMultiple(array('foo')), 'Checking removeMultiple.');
		$this->assertInternalType('boolean', $this->instance->set('for', 'bar'), 'Checking set.');
		$this->assertInternalType('boolean', $this->instance->setMultiple(array('foo' => 'bar')), 'Checking setMultiple.');
	}

	/**
	 * Tests the Joomla\Cache\Redis::get and Joomla\Cache\Redis::set methods.
	 *
	 * @return  void
	 *
	 * @covers  Joomla\Cache\Redis::get
	 * @covers  Joomla\Cache\Redis::set
	 * @covers  Joomla\Cache\Redis::connect
	 * @since   1.0
	 */
	public function testGetAndSet()
	{
		$this->assertTrue(
			$this->instance->set('foo', 'bar'),
			'Should store the data properly'
		);

		$this->assertEquals(
			'bar',
			$this->instance->get('foo')->getValue(),
			'Checking get'
		);
	}

	/**
	 * Tests the Joomla\Cache\Redis::get and Joomla\Cache\Redis::set methods with timeout
	 *
	 * @return  void
	 *
	 * @covers  Joomla\Cache\Redis::get
	 * @covers  Joomla\Cache\Redis::set
	 * @covers  Joomla\Cache\Redis::connect
	 * @since   1.0
	 */
	public function testGetAndSetWithTimeout()
	{
		$this->assertTrue(
			$this->instance->set('foo', 'bar', 1),
			'Should store the data properly'
		);

		sleep(2);

		$this->assertFalse(
			$this->instance->get('foo')->isHit(),
			'Checks expired get.'
		);
	}

	/**
	 * Tests the Joomla\Cache\Redis::clear method.
	 *
	 * @return  void
	 *
	 * @covers  Joomla\Cache\Redis::clear
	 * @covers  Joomla\Cache\Redis::connect
	 * @since   1.0
	 */
	public function testClear()

	{
		$this->instance->set('foo', 'bar');
		$this->instance->set('boo', 'car');

		$this->instance->clear();

		$this->assertFalse(
			$this->instance->get('foo')->isHit(),
			'Item should have been removed'
		);

		$this->assertFalse(
			$this->instance->get('goo')->isHit(),
			'Item should have been removed'
		);
	}

	/**
	 * Tests the Joomla\Cache\Redis::exists method.
	 *
	 * @return  void
	 *
	 * @covers  Joomla\Cache\Redis::connect
	 * @covers  Joomla\Cache\Redis::exists
	 * @since   1.0
	 */
	public function testExists()
	{
		$this->assertFalse(
			$this->instance->exists('foo'),
			'Item should not exist'
		);

		$this->instance->set('foo', 'bar');

		$this->assertTrue(
			$this->instance->exists('foo'),
			'Item should exist'
		);
	}

	/**
	 * Tests the Joomla\Cache\Redis::remove method.
	 *
	 * @return  void
	 *
	 * @covers  Joomla\Cache\Redis::connect
	 * @covers  Joomla\Cache\Redis::remove
	 * @since   1.0
	 */

	public function testRemove()
	{
		$this->instance->set('foo', 'bar');
		$this->assertTrue(
			$this->instance->get('foo')->isHit(),
			'Item should exist'
		);

		$this->instance->remove('foo');

		$this->assertFalse(
			$this->instance->get('foo')->isHit(),
			'Item should have been removed'
		);
	}

	/**
	 * Tests the Joomla\Cache\Redis::getMultiple method.
	 *
	 * @return  void
	 *
	 * @covers  Joomla\Cache\Redis::getMultiple
	 * @since   1.0
	 */
	public function testGetMultiple()
	{
		$this->instance->set('foo', 'bar');
		$this->instance->set('boo', 'bar');

		$fooResult = $this->instance->getMultiple(array('foo', 'boo'));

		$this->assertArrayHasKey('foo', $fooResult, 'Missing array key');
		$this->assertArrayHasKey('boo', $fooResult, 'Missing array key');

		$this->assertInstanceOf(
			'Joomla\Cache\Item',
			$fooResult['foo'],
			'Expected instance of Joomla\Cache\Item'
		);
		$this->assertInstanceOf(
			'Joomla\Cache\Item',
			$fooResult['boo'],
			'Expected instance of Joomla\Cache\Item'
		);

		$this->assertTrue(
			$fooResult['foo']->isHit(),
			'Item should be returned from cache'
		);
		$this->assertTrue(
			$fooResult['boo']->isHit(),
			'Item should be returned from cache'
		);
	}

	/**
	 * Tests the Joomla\Cache\Redis::setMultiple method.
	 *
	 * @return  void
	 *
	 * @covers  Joomla\Cache\Redis::setMultiple
	 * @since   1.0
	 */
	public function testSetMultiple()
	{
		$data = array('foo' => 'bar', 'boo' => 'bar');

		$this->instance->setMultiple($data);

		$this->assertEquals(
			'bar',
			$this->instance->get('foo')->getValue(),
			'Item should be cached'
			);

		$this->assertEquals(
			'bar', $this->instance->get('boo')->getValue(),
			'Item should be cached'
		);
	}

	/**
	 * Tests the Joomla\Cache\Redis::removeMultiple method.
	 *
	 * @return  void
	 *
	 * @covers  Joomla\Cache\Redis::removeMultiple
	 * @since   1.0
	 */
	public function removeMultiple()

	{
		$this->instance->set('foo', 'bar');
		$this->instance->set('boo', 'bar');

		$this->instance->removeMultiple(array('foo', 'bar'));

		$this->assertFalse(
			$this->instance->get('foo')->isHit(),
			'Item should have been removed'
		);
		$this->assertFalse(
			$this->instance->get('boo')->isHit(),
			'Item should have been removed'
		);
	}

	/**
	 * Setup the tests.
	 *
	 * @return  void
	 *
	 * @covers  Joomla\Cache\Redis::__construct
	 * @since   1.0
	 */
	protected function setUp()
	{
		// Parse the DSN details for the test server
		$dsn = defined('JTEST_CACHE_REDIS_DSN') ? JTEST_CACHE_REDIS_DSN : getenv('JTEST_CACHE_REDIS_DSN');

		if ($dsn)
		{
			$options = $this->cacheOptions;
class MyClass { }

$x = new MyClass();
$x->foo = true;

			if (!$options)
			{
				$options = array();
			}

			// First let's trim the redis: part off the front of the DSN if it exists.
			if (strpos($dsn, 'redis:') === 0)
			{
				$dsn = substr($dsn, 6);
			}

			if (!is_array($options))
			{
				$options = array($options);
			}

			// Split the DSN into its parts over semicolons.
			$parts = explode(';', $dsn);

			// Parse each part and populate the options array.
			foreach ($parts as $part)

			{
				list ($k, $v) = explode('=', $part, 2);
				switch ($k)
				{
					case 'host':
					case 'port':
						$options['redis.' . $k] = $v;
						break;
				}
			}

			$this->cacheOptions = $options;
		}
		else
		{
			$this->markTestSkipped('No configuration for Redis given');
		}

		parent::setUp();

		try
		{
			$this->instance = new Cache\Redis($options);
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
		}
		catch (\Exception $e)
		{
			$this->markTestSkipped($e->getMessage());
		}
	}

	/**
	 * Flush all data before each test
	 *
	 * @return  void
	 *
	 * @since   1.0
	 */
	protected function assertPreConditions()
	{
		if ($this->instance)
		{
			$this->instance->clear();
		}
	}

	/**
	 * Teardown the test.
	 *
	 * @return  void
	 *
	 * @since   1.0
	 */
	protected function tearDown()
	{
		if ($this->instance)
		{
			$this->instance->clear();
		}
	}
}


1		<?php
2		/**
3		* @copyright Copyright (C) 2005 - 2018 Open Source Matters, Inc. All rights reserved.
4		* @license GNU General Public License version 2 or later; see LICENSE
5		*/
6
7		namespace Joomla\Cache\Tests;
8
9		use Joomla\Cache;
10		use PHPUnit\Framework\TestCase;
11
12		/**
13		* Tests for the Joomla\Cache\Redis class.
14		*
15		* @since 1.0
16		*/
17		class RedisTest extends TestCase
18		{
19		/**
20		* @var Cache\Redis
21		* @since 1.0
22		*/
23		private $instance;
24
25		/**
26		* Tests for the correct Psr\Cache return values.
27		*
28		* @return void
29		*
30		* @coversNothing
31		* @since 1.0
32		*/
33		public function testPsrCache()
34		{
35		$this->assertInternalType('boolean', $this->instance->clear(), 'Checking clear.');
36		$this->assertInstanceOf('\Psr\Cache\CacheItemInterface', $this->instance->get('foo'), 'Checking get.');
37		$this->assertInternalType('array', $this->instance->getMultiple(array('foo')), 'Checking getMultiple.');
38		$this->assertInternalType('boolean', $this->instance->remove('foo'), 'Checking remove.');
39		$this->assertInternalType('array', $this->instance->removeMultiple(array('foo')), 'Checking removeMultiple.');
40		$this->assertInternalType('boolean', $this->instance->set('for', 'bar'), 'Checking set.');
41		$this->assertInternalType('boolean', $this->instance->setMultiple(array('foo' => 'bar')), 'Checking setMultiple.');
42		}
43
44		/**
45		* Tests the Joomla\Cache\Redis::get and Joomla\Cache\Redis::set methods.
46		*
47		* @return void
48		*
49		* @covers Joomla\Cache\Redis::get
50		* @covers Joomla\Cache\Redis::set
51		* @covers Joomla\Cache\Redis::connect
52		* @since 1.0
53		*/
54		public function testGetAndSet()
55		{
56		$this->assertTrue(
57		$this->instance->set('foo', 'bar'),
58		'Should store the data properly'
59		);
60
61		$this->assertEquals(
62		'bar',
63		$this->instance->get('foo')->getValue(),
64		'Checking get'
65		);
66		}
67
68		/**
69		* Tests the Joomla\Cache\Redis::get and Joomla\Cache\Redis::set methods with timeout
70		*
71		* @return void
72		*
73		* @covers Joomla\Cache\Redis::get
74		* @covers Joomla\Cache\Redis::set
75		* @covers Joomla\Cache\Redis::connect
76		* @since 1.0
77		*/
78		public function testGetAndSetWithTimeout()
79		{
80		$this->assertTrue(
81		$this->instance->set('foo', 'bar', 1),
82		'Should store the data properly'
83		);
84
85		sleep(2);
86
87		$this->assertFalse(
88		$this->instance->get('foo')->isHit(),
89		'Checks expired get.'
90		);
91		}
92
93		/**
94		* Tests the Joomla\Cache\Redis::clear method.
95		*
96		* @return void
97		*
98		* @covers Joomla\Cache\Redis::clear
99		* @covers Joomla\Cache\Redis::connect
100		* @since 1.0
101		*/
102	View Code Duplication	public function testClear()
		0 ignored issues – show Duplication introduced 2018-01-30 01:54 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
103		{
104		$this->instance->set('foo', 'bar');
105		$this->instance->set('boo', 'car');
106
107		$this->instance->clear();
108
109		$this->assertFalse(
110		$this->instance->get('foo')->isHit(),
111		'Item should have been removed'
112		);
113
114		$this->assertFalse(
115		$this->instance->get('goo')->isHit(),
116		'Item should have been removed'
117		);
118		}
119
120		/**
121		* Tests the Joomla\Cache\Redis::exists method.
122		*
123		* @return void
124		*
125		* @covers Joomla\Cache\Redis::connect
126		* @covers Joomla\Cache\Redis::exists
127		* @since 1.0
128		*/
129		public function testExists()
130		{
131		$this->assertFalse(
132		$this->instance->exists('foo'),
133		'Item should not exist'
134		);
135
136		$this->instance->set('foo', 'bar');
137
138		$this->assertTrue(
139		$this->instance->exists('foo'),
140		'Item should exist'
141		);
142		}
143
144		/**
145		* Tests the Joomla\Cache\Redis::remove method.
146		*
147		* @return void
148		*
149		* @covers Joomla\Cache\Redis::connect
150		* @covers Joomla\Cache\Redis::remove
151		* @since 1.0
152		*/
153
154		public function testRemove()
155		{
156		$this->instance->set('foo', 'bar');
157		$this->assertTrue(
158		$this->instance->get('foo')->isHit(),
159		'Item should exist'
160		);
161
162		$this->instance->remove('foo');
163
164		$this->assertFalse(
165		$this->instance->get('foo')->isHit(),
166		'Item should have been removed'
167		);
168		}
169
170		/**
171		* Tests the Joomla\Cache\Redis::getMultiple method.
172		*
173		* @return void
174		*
175		* @covers Joomla\Cache\Redis::getMultiple
176		* @since 1.0
177		*/
178		public function testGetMultiple()
179		{
180		$this->instance->set('foo', 'bar');
181		$this->instance->set('boo', 'bar');
182
183		$fooResult = $this->instance->getMultiple(array('foo', 'boo'));
184
185		$this->assertArrayHasKey('foo', $fooResult, 'Missing array key');
186		$this->assertArrayHasKey('boo', $fooResult, 'Missing array key');
187
188		$this->assertInstanceOf(
189		'Joomla\Cache\Item',
190		$fooResult['foo'],
191		'Expected instance of Joomla\Cache\Item'
192		);
193		$this->assertInstanceOf(
194		'Joomla\Cache\Item',
195		$fooResult['boo'],
196		'Expected instance of Joomla\Cache\Item'
197		);
198
199		$this->assertTrue(
200		$fooResult['foo']->isHit(),
201		'Item should be returned from cache'
202		);
203		$this->assertTrue(
204		$fooResult['boo']->isHit(),
205		'Item should be returned from cache'
206		);
207		}
208
209		/**
210		* Tests the Joomla\Cache\Redis::setMultiple method.
211		*
212		* @return void
213		*
214		* @covers Joomla\Cache\Redis::setMultiple
215		* @since 1.0
216		*/
217		public function testSetMultiple()
218		{
219		$data = array('foo' => 'bar', 'boo' => 'bar');
220
221		$this->instance->setMultiple($data);
222
223		$this->assertEquals(
224		'bar',
225		$this->instance->get('foo')->getValue(),
226		'Item should be cached'
227		);
228
229		$this->assertEquals(
230		'bar', $this->instance->get('boo')->getValue(),
231		'Item should be cached'
232		);
233		}
234
235		/**
236		* Tests the Joomla\Cache\Redis::removeMultiple method.
237		*
238		* @return void
239		*
240		* @covers Joomla\Cache\Redis::removeMultiple
241		* @since 1.0
242		*/
243	View Code Duplication	public function removeMultiple()
		0 ignored issues – show Duplication introduced 2018-01-30 01:54 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
244		{
245		$this->instance->set('foo', 'bar');
246		$this->instance->set('boo', 'bar');
247
248		$this->instance->removeMultiple(array('foo', 'bar'));
249
250		$this->assertFalse(
251		$this->instance->get('foo')->isHit(),
252		'Item should have been removed'
253		);
254		$this->assertFalse(
255		$this->instance->get('boo')->isHit(),
256		'Item should have been removed'
257		);
258		}
259
260		/**
261		* Setup the tests.
262		*
263		* @return void
264		*
265		* @covers Joomla\Cache\Redis::__construct
266		* @since 1.0
267		*/
268		protected function setUp()
269		{
270		// Parse the DSN details for the test server
271		$dsn = defined('JTEST_CACHE_REDIS_DSN') ? JTEST_CACHE_REDIS_DSN : getenv('JTEST_CACHE_REDIS_DSN');
272
273		if ($dsn)
274		{
275		$options = $this->cacheOptions;
		0 ignored issues – show Bug introduced 2020-09-02 19:24 UTC by Report Bug Copy Issue Report The property `cacheOptions` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
276
277		if (!$options)
278		{
279		$options = array();
280		}
281
282		// First let's trim the redis: part off the front of the DSN if it exists.
283		if (strpos($dsn, 'redis:') === 0)
284		{
285		$dsn = substr($dsn, 6);
286		}
287
288		if (!is_array($options))
289		{
290		$options = array($options);
291		}
292
293		// Split the DSN into its parts over semicolons.
294		$parts = explode(';', $dsn);
295
296		// Parse each part and populate the options array.
297	View Code Duplication	foreach ($parts as $part)
		0 ignored issues – show Duplication introduced 2020-09-02 19:24 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
298		{
299		list ($k, $v) = explode('=', $part, 2);
300		switch ($k)
301		{
302		case 'host':
303		case 'port':
304		$options['redis.' . $k] = $v;
305		break;
306		}
307		}
308
309		$this->cacheOptions = $options;
310		}
311		else
312		{
313		$this->markTestSkipped('No configuration for Redis given');
314		}
315
316		parent::setUp();
317
318		try
319		{
320		$this->instance = new Cache\Redis($options);
		0 ignored issues – show Bug introduced 2020-09-02 19:24 UTC by Report Bug Copy Issue Report The variable `$options` does not seem to be defined for all execution paths leading up to this point. If you define a variable conditionally, it can happen that it is not defined for all execution paths. Let’s take a look at an example: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } // $x is potentially undefined here. echo $x; } In the above example, the variable `$x` is defined if you pass “foo” or “bar” as argument for `$a`. However, since the `switch` statement has no default case statement, if you pass any other value, the variable `$x` would be undefined. Available Fixes Check for existence of the variable explicitly: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } if (isset($x)) { // Make sure it's always set. echo $x; } } Define a default value for the variable: function myFunction($a) { $x = ''; // Set a default which gets overridden for certain paths. switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } echo $x; } Add a value for the missing path: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; // We add support for the missing case. default: $x = ''; break; } echo $x; } Loading history... Deprecated Code introduced 2020-09-02 19:24 UTC by Report Bug Copy Issue Report The class `Joomla\Cache\Redis` has been deprecated with message: The joomla/cache package is deprecated This class, trait or interface has been deprecated. The supplier of the file has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the type will be removed from the class and what other constant to use instead. Loading history...
321		}
322		catch (\Exception $e)
323		{
324		$this->markTestSkipped($e->getMessage());
325		}
326		}
327
328		/**
329		* Flush all data before each test
330		*
331		* @return void
332		*
333		* @since 1.0
334		*/
335		protected function assertPreConditions()
336		{
337		if ($this->instance)
338		{
339		$this->instance->clear();
340		}
341		}
342
343		/**
344		* Teardown the test.
345		*
346		* @return void
347		*
348		* @since 1.0
349		*/
350		protected function tearDown()
351		{
352		if ($this->instance)
353		{
354		$this->instance->clear();
355		}
356		}
357		}
358

joomla-framework / cache

Pull Request — master (#31)

RedisTest::testExists() A

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like