RedisTest - 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-10-04 20:19 UTC

RedisTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	336
Duplicated Lines	13.1 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

Metric	Value
wmc	22
lcom	1
cbo	3
dl	44
loc	336
rs	10
c	0
b	0
f	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	testPsrCache()	0	10	1
A	testGetAndSet()	0	13	1
A	testGetAndSetWithTimeout()	0	14	1
A	testClear()	17	17	1
A	testExists()	0	14	1
A	testRemove()	0	15	1
A	testGetMultiple()	0	30	1
A	testSetMultiple()	0	17	1
A	removeMultiple()	16	16	1
B	setUp()	11	54	9
A	assertPreConditions()	0	7	2
A	tearDown()	0	7	2

How to fix Duplicated Code

<?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 = 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;
class MyClass { }

$x = new MyClass();
$x->foo = true;
		}
		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 = array();
276
277		// First let's trim the redis: part off the front of the DSN if it exists.
278		if (strpos($dsn, 'redis:') === 0)
279		{
280		$dsn = substr($dsn, 6);
281		}
282
283		if (!is_array($options))
284		{
285		$options = array($options);
286		}
287
288		// Split the DSN into its parts over semicolons.
289		$parts = explode(';', $dsn);
290
291		// Parse each part and populate the options array.
292	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...
293		{
294		list ($k, $v) = explode('=', $part, 2);
295		switch ($k)
296		{
297		case 'host':
298		case 'port':
299		$options['redis.' . $k] = $v;
300		break;
301		}
302		}
303
304		$this->cacheOptions = $options;
		0 ignored issues – show Bug introduced 2020-10-04 20:20 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...
305		}
306		else
307		{
308		$this->markTestSkipped('No configuration for Redis given');
309		}
310
311		parent::setUp();
312
313		try
314		{
315		$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...
316		}
317		catch (\Exception $e)
318		{
319		$this->markTestSkipped($e->getMessage());
320		}
321		}
322
323		/**
324		* Flush all data before each test
325		*
326		* @return void
327		*
328		* @since 1.0
329		*/
330		protected function assertPreConditions()
331		{
332		if ($this->instance)
333		{
334		$this->instance->clear();
335		}
336		}
337
338		/**
339		* Teardown the test.
340		*
341		* @return void
342		*
343		* @since 1.0
344		*/
345		protected function tearDown()
346		{
347		if ($this->instance)
348		{
349		$this->instance->clear();
350		}
351		}
352		}
353

joomla-framework / cache

Pull Request — master (#31)

RedisTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

12 Methods

How to fix Duplicated Code

Duplicated Code

Available Fixes

Duplication Side-by-Side

Filter issues like