CIPHPUnitTestCase - Code Metrics - Inspection of "Merge pull request #161 from kenjis/new-library" - kenjis/ci-phpunit-test - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 7a55ba...f9e493 )

by Kenji

created 2016-12-14 10:09 UTC

CIPHPUnitTestCase B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	404
Duplicated Lines	0 %

Coupling/Cohesion

Components	4
Dependencies	4

Importance

Changes

Metric	Value
dl	0
loc	404
rs	8.2608
c	0
b	0
f	0
wmc	40
lcom	4
cbo	4

21 Methods

Rating	Name	Size	Complexity
A	setCI()	4	1
A	__get()	10	2
A	setUpBeforeClass()	12	1
A	resetInstance()	6	1
A	newController()	7	1
A	newModel()	6	1
A	newLibrary()	8	1
C	tearDown()	34	7
A	request()	4	1
A	ajaxRequest()	5	1
A	getDouble()	4	1
A	verifyInvokedMultipleTimes()	6	1
A	verifyInvoked()	4	1
A	verifyInvokedOnce()	4	1
A	verifyNeverInvoked()	4	1
A	warningOff()	6	1
A	warningOn()	4	1
A	assertResponseCode()	11	1
A	assertResponseHeader()	16	2
C	assertResponseCookie()	44	8
B	assertRedirect()	37	5

How to fix Complexity

<?php
/**
 * Part of ci-phpunit-test
 *
 * @author     Kenji Suzuki <https://github.com/kenjis>
 * @license    MIT License
 * @copyright  2015 Kenji Suzuki
 * @link       https://github.com/kenjis/ci-phpunit-test
 */

/**
 * @property CIPHPUnitTestRequest    $request
 * @property CIPHPUnitTestDouble     $double
 * @property CIPHPUnitTestReflection $reflection
 */
class CIPHPUnitTestCase extends PHPUnit_Framework_TestCase
namespace YourVendor;

class YourClass { }
{
	protected $_error_reporting = -1;

	/**
	 * If you have a route with closure, PHPUnit can't serialize global variables.
	 * You would see `Exception: Serialization of 'Closure' is not allowed`.
	 *
	 * @var array
	 */
	protected $backupGlobalsBlacklist = ['RTR'];

	/**
	 * @var CI_Controller CodeIgniter instance
	 */
	protected $CI;
	
	protected $class_map = [
		'request'    => 'CIPHPUnitTestRequest',
		'double'     => 'CIPHPUnitTestDouble',
		'reflection' => 'CIPHPUnitTestReflection',
	];

	public function setCI(CI_Controller $CI)
	{
		$this->CI = $CI;
	}

	public function __get($name)
	{
		if (isset($this->class_map[$name]))
		{
			$this->$name = new $this->class_map[$name]($this);
			return $this->$name;
		}

		throw new LogicException('No such property: ' . $name);
	}

	public static function setUpBeforeClass()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
	{
		// Fix CLI args, because you may set invalid URI characters
		// For example, when you run tests on NetBeans
		$_SERVER['argv'] = [
			'index.php',
		];
		$_SERVER['argc'] = 1;
		
		// Reset current directroy
		chdir(FCPATH);
	}

	/**
	 * Reset CodeIgniter instance and assign new CodeIgniter instance as $this->CI
	 */
	public function resetInstance()
	{
		reset_instance();
		CIPHPUnitTest::createCodeIgniterInstance();
		$this->CI =& get_instance();
	}

	/**
	 * Create a controller instance
	 *
	 * @param string $classname
	 * @return CI_Controller
	 */
	public function newController($classname)
	{
		reset_instance();
		$controller = new $classname;
		$this->CI =& get_instance();
		return $controller;
	}

	/**
	 * Create a model instance
	 *
	 * @param string $classname
	 * @return CI_Model
	 */
	public function newModel($classname)
	{
		$this->resetInstance();
		$this->CI->load->model($classname);
		return $this->CI->$classname;
	}

	/**
	 * Create a library instance
	 *
	 * @param string $classname
	 * @return object
	 */
	public function newLibrary($classname)
	{
		$classname = strtolower($classname);
		
		$this->resetInstance();
		$this->CI->load->library($classname);
		return $this->CI->$classname;
	}

	protected function tearDown()
	{
		if (class_exists('MonkeyPatch', false))
		{
			if (MonkeyPatchManager::isEnabled('FunctionPatcher'))
			{
				try {
					MonkeyPatch::verifyFunctionInvocations();
				} catch (Exception $e) {
					MonkeyPatch::resetFunctions();
					throw $e;
				}

				MonkeyPatch::resetFunctions();
			}

			if (MonkeyPatchManager::isEnabled('ConstantPatcher'))
			{
				MonkeyPatch::resetConstants();
			}

			if (MonkeyPatchManager::isEnabled('MethodPatcher'))
			{
				try {
					MonkeyPatch::verifyMethodInvocations();
				} catch (Exception $e) {
					MonkeyPatch::resetMethods();
					throw $e;
				}

				MonkeyPatch::resetMethods();
			}
		}
	}

	/**
	 * Request to Controller
	 *
	 * @param string       $http_method HTTP method
	 * @param array|string $argv        array of controller,method,arg|uri
	 * @param array        $params      POST parameters/Query string
	 */
	public function request($http_method, $argv, $params = [])
	{
		return $this->request->request($http_method, $argv, $params);
	}

	/**
	 * Request to Controller using ajax request
	 *
	 * @param string       $http_method HTTP method
	 * @param array|string $argv        array of controller,method,arg|uri
	 * @param array        $params      POST parameters/Query string
	 */
	public function ajaxRequest($http_method, $argv, $params = [])
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
	{
		$_SERVER['HTTP_X_REQUESTED_WITH'] = 'xmlhttprequest';
		return $this->request($http_method, $argv, $params);
	}

	/**
	 * Get Mock Object
	 *
	 * $email = $this->getMockBuilder('CI_Email')
	 *	->setMethods(['send'])
	 *	->getMock();
	 * $email->method('send')->willReturn(TRUE);
	 *
	 *  will be
	 *
	 * $email = $this->getDouble('CI_Email', ['send' => TRUE]);
	 *
	 * @param  string $classname
	 * @param  array  $params             [method_name => return_value]
	 * @param  bool   $enable_constructor enable constructor or not
	 * @return object PHPUnit mock object
	 */
	public function getDouble($classname, $params, $enable_constructor = false)
	{
		return $this->double->getDouble($classname, $params, $enable_constructor);
	}

	/**
	 * Verifies that method was called exactly $times times
	 *
	 * $loader->expects($this->exactly(2))
	 * 	->method('view')
	 * 	->withConsecutive(
	 *		['shop_confirm', $this->anything(), TRUE],
	 * 		['shop_tmpl_checkout', $this->anything()]
	 * 	);
	 *
	 *  will be
	 *
	 * $this->verifyInvokedMultipleTimes(
	 * 	$loader,
	 * 	'view',
	 * 	2,
	 * 	[
	 * 		['shop_confirm', $this->anything(), TRUE],
	 * 		['shop_tmpl_checkout', $this->anything()]
	 * 	]
	 * );
	 *
	 * @param object $mock   PHPUnit mock object
	 * @param string $method
	 * @param int    $times
	 * @param array  $params arguments
	 */
	public function verifyInvokedMultipleTimes($mock, $method, $times, $params = null)
	{
		$this->double->verifyInvokedMultipleTimes(
			$mock, $method, $times, $params
		);
	}

	/**
	 * Verifies a method was invoked at least once
	 *
	 * @param object $mock   PHPUnit mock object
	 * @param string $method
	 * @param array  $params arguments
	 */
	public function verifyInvoked($mock, $method, $params = null)
	{
		$this->double->verifyInvoked($mock, $method, $params);
	}

	/**
	 * Verifies that method was invoked only once
	 *
	 * @param object $mock   PHPUnit mock object
	 * @param string $method
	 * @param array  $params arguments
	 */
	public function verifyInvokedOnce($mock, $method, $params = null)
	{
		$this->double->verifyInvokedOnce($mock, $method, $params);
	}

	/**
	 * Verifies that method was not called
	 *
	 * @param object $mock   PHPUnit mock object
	 * @param string $method
	 * @param array  $params arguments
	 */
	public function verifyNeverInvoked($mock, $method, $params = null)
	{
		$this->double->verifyNeverInvoked($mock, $method, $params);
	}

	public function warningOff()
	{
		$this->_error_reporting = error_reporting(
			E_ALL & ~E_WARNING & ~E_NOTICE
		);
	}

	public function warningOn()
	{
		error_reporting($this->_error_reporting);
	}

	/**
	 * Asserts HTTP response code
	 * 
	 * @param int $code
	 */
	public function assertResponseCode($code)
	{
		$status = $this->request->getStatus();
		$actual = $status['code'];

		$this->assertSame(
			$code,
			$actual,
			'Status code is not ' . $code . ' but ' . $actual . '.'
		);
	}

	/**
	 * Asserts HTTP response header
	 * 
	 * @param string $name  header name
	 * @param string $value header value
	 */
	public function assertResponseHeader($name, $value)
	{
		$CI =& get_instance();
		$actual = $CI->output->get_header($name);

		if ($actual === null)
		{
			$this->fail("The '$name' header is not set.\nNote that `assertResponseHeader()` can only assert headers set by `\$this->output->set_header()`");
		}

		$this->assertEquals(
			$value,
			$actual,
			"The '$name' header is not '$value' but '$actual'."
		);
	}

	/**
	 * Asserts HTTP response cookie
	 * 
	 * @param string       $name            cookie name
	 * @param string|array $value           cookie value|array of cookie params
	 * @param bool         $allow_duplicate whether to allow duplicated cookies
	 */
	public function assertResponseCookie($name, $value, $allow_duplicate = false)
	{
		$CI =& get_instance();
		$cookies = isset($CI->output->_cookies[$name])
			? $CI->output->_cookies[$name] : null;

		if ($cookies === null)
		{
			$this->fail("The cookie '$name' is not set.\nNote that `assertResponseCookie()` can only assert cookies set by `\$this->input->set_cookie()`");
		}

		$count = count($cookies);
		if ($count > 1 && ! $allow_duplicate)
		{
			$values = [];
			foreach ($cookies as $key => $val)
			{
				$values[] = "'{$val['value']}'";
			}
			$values = implode(' and ', $values);
			$this->fail("You have more than one cookie '$name'. The values are $values.\nIf it is okay, please set `true` as the 3rd argument of `assertResponseCookie()`");
		}

		// Get the last cookie
		$cookie = $cookies[$count - 1];
		if (is_string($value))
		{
			$this->assertEquals(
				$value,
				$cookie['value'],
				"The cookie '$name' value is not '$value' but '{$cookie['value']}'."
			);
			return;
		}

		foreach ($value as $key => $val)
		{
			$this->assertEquals(
				$value[$key],
				$cookie[$key],
				"The cookie '$name' $key is not '{$value[$key]}' but '{$cookie[$key]}'."
			);
		}
	}

	/**
	 * Asserts Redirect
	 * 
	 * @param string $uri  URI to redirect
	 * @param int    $code response code
	 */
	public function assertRedirect($uri, $code = null)
	{
		$status = $this->request->getStatus();

		if ($status['redirect'] === null)
		{
			$this->fail('redirect() is not called.');
		}

		if (! function_exists('site_url'))
		{
			$CI =& get_instance();
			$CI->load->helper('url');
		}

		if (! preg_match('#^(\w+:)?//#i', $uri))
		{
			$uri = site_url($uri);
		}
		$absolute_url = $uri;
		$expected = 'Redirect to ' . $absolute_url;

		$this->assertSame(
			$expected,
			$status['redirect'],
			'URL to redirect is not ' . $expected . ' but ' . $status['redirect'] . '.'
		);

		if ($code !== null)
		{
			$this->assertSame(
				$code,
				$status['code'],
				'Status code is not ' . $code . ' but ' . $status['code'] . '.'
			);
		}
	}
}


1			<?php
2			/**
3			* Part of ci-phpunit-test
4			*
5			* @author Kenji Suzuki <https://github.com/kenjis>
6			* @license MIT License
7			* @copyright 2015 Kenji Suzuki
8			* @link https://github.com/kenjis/ci-phpunit-test
9			*/
10
11			/**
12			* @property CIPHPUnitTestRequest $request
13			* @property CIPHPUnitTestDouble $double
14			* @property CIPHPUnitTestReflection $reflection
15			*/
16			class CIPHPUnitTestCase extends PHPUnit_Framework_TestCase
			0 ignored issues – show Coding Style Compatibility introduced 2015-11-20 22:47 UTC by Report Bug Copy Issue Report PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions. You can fix this by adding a namespace to your class: namespace YourVendor; class YourClass { } When choosing a vendor namespace, try to pick something that is not too generic to avoid conflicts with other libraries. Loading history...
17			{
18			protected $_error_reporting = -1;
19
20			/**
21			* If you have a route with closure, PHPUnit can't serialize global variables.
22			* You would see `Exception: Serialization of 'Closure' is not allowed`.
23			*
24			* @var array
25			*/
26			protected $backupGlobalsBlacklist = ['RTR'];
27
28			/**
29			* @var CI_Controller CodeIgniter instance
30			*/
31			protected $CI;
32
33			protected $class_map = [
34			'request' => 'CIPHPUnitTestRequest',
35			'double' => 'CIPHPUnitTestDouble',
36			'reflection' => 'CIPHPUnitTestReflection',
37			];
38
39			public function setCI(CI_Controller $CI)
40			{
41			$this->CI = $CI;
42			}
43
44			public function __get($name)
45			{
46			if (isset($this->class_map[$name]))
47			{
48			$this->$name = new $this->class_map[$name]($this);
49			return $this->$name;
50			}
51
52			throw new LogicException('No such property: ' . $name);
53			}
54
55			public static function setUpBeforeClass()
			0 ignored issues – show Coding Style introduced 2015-11-20 22:47 UTC by Report Bug Copy Issue Report `setUpBeforeClass` uses the super-global variable `$_SERVER` which is generally not recommended. Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad class Router { public function generate($path) { return $_SERVER['HOST'].$path; } } // Better class Router { private $host; public function __construct($host) { $this->host = $host; } public function generate($path) { return $this->host.$path; } } class Controller { public function myAction(Request $request) { // Instead of $page = isset($_GET['page']) ? intval($_GET['page']) : 1; // Better (assuming you use the Symfony2 request) $page = $request->query->get('page', 1); } } Loading history...
56			{
57			// Fix CLI args, because you may set invalid URI characters
58			// For example, when you run tests on NetBeans
59			$_SERVER['argv'] = [
60			'index.php',
61			];
62			$_SERVER['argc'] = 1;
63
64			// Reset current directroy
65			chdir(FCPATH);
66			}
67
68			/**
69			* Reset CodeIgniter instance and assign new CodeIgniter instance as $this->CI
70			*/
71			public function resetInstance()
72			{
73			reset_instance();
74			CIPHPUnitTest::createCodeIgniterInstance();
75			$this->CI =& get_instance();
76			}
77
78			/**
79			* Create a controller instance
80			*
81			* @param string $classname
82			* @return CI_Controller
83			*/
84			public function newController($classname)
85			{
86			reset_instance();
87			$controller = new $classname;
88			$this->CI =& get_instance();
89			return $controller;
90			}
91
92			/**
93			* Create a model instance
94			*
95			* @param string $classname
96			* @return CI_Model
97			*/
98			public function newModel($classname)
99			{
100			$this->resetInstance();
101			$this->CI->load->model($classname);
102			return $this->CI->$classname;
103			}
104
105			/**
106			* Create a library instance
107			*
108			* @param string $classname
109			* @return object
110			*/
111			public function newLibrary($classname)
112			{
113			$classname = strtolower($classname);
114
115			$this->resetInstance();
116			$this->CI->load->library($classname);
117			return $this->CI->$classname;
118			}
119
120			protected function tearDown()
121			{
122			if (class_exists('MonkeyPatch', false))
123			{
124			if (MonkeyPatchManager::isEnabled('FunctionPatcher'))
125			{
126			try {
127			MonkeyPatch::verifyFunctionInvocations();
128			} catch (Exception $e) {
129			MonkeyPatch::resetFunctions();
130			throw $e;
131			}
132
133			MonkeyPatch::resetFunctions();
134			}
135
136			if (MonkeyPatchManager::isEnabled('ConstantPatcher'))
137			{
138			MonkeyPatch::resetConstants();
139			}
140
141			if (MonkeyPatchManager::isEnabled('MethodPatcher'))
142			{
143			try {
144			MonkeyPatch::verifyMethodInvocations();
145			} catch (Exception $e) {
146			MonkeyPatch::resetMethods();
147			throw $e;
148			}
149
150			MonkeyPatch::resetMethods();
151			}
152			}
153			}
154
155			/**
156			* Request to Controller
157			*
158			* @param string $http_method HTTP method
159			* @param array\|string $argv array of controller,method,arg\|uri
160			* @param array $params POST parameters/Query string
161			*/
162			public function request($http_method, $argv, $params = [])
163			{
164			return $this->request->request($http_method, $argv, $params);
165			}
166
167			/**
168			* Request to Controller using ajax request
169			*
170			* @param string $http_method HTTP method
171			* @param array\|string $argv array of controller,method,arg\|uri
172			* @param array $params POST parameters/Query string
173			*/
174			public function ajaxRequest($http_method, $argv, $params = [])
			0 ignored issues – show Coding Style introduced 2015-11-20 22:47 UTC by Report Bug Copy Issue Report `ajaxRequest` uses the super-global variable `$_SERVER` which is generally not recommended. Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad class Router { public function generate($path) { return $_SERVER['HOST'].$path; } } // Better class Router { private $host; public function __construct($host) { $this->host = $host; } public function generate($path) { return $this->host.$path; } } class Controller { public function myAction(Request $request) { // Instead of $page = isset($_GET['page']) ? intval($_GET['page']) : 1; // Better (assuming you use the Symfony2 request) $page = $request->query->get('page', 1); } } Loading history...
175			{
176			$_SERVER['HTTP_X_REQUESTED_WITH'] = 'xmlhttprequest';
177			return $this->request($http_method, $argv, $params);
178			}
179
180			/**
181			* Get Mock Object
182			*
183			* $email = $this->getMockBuilder('CI_Email')
184			* ->setMethods(['send'])
185			* ->getMock();
186			* $email->method('send')->willReturn(TRUE);
187			*
188			* will be
189			*
190			* $email = $this->getDouble('CI_Email', ['send' => TRUE]);
191			*
192			* @param string $classname
193			* @param array $params [method_name => return_value]
194			* @param bool $enable_constructor enable constructor or not
195			* @return object PHPUnit mock object
196			*/
197			public function getDouble($classname, $params, $enable_constructor = false)
198			{
199			return $this->double->getDouble($classname, $params, $enable_constructor);
200			}
201
202			/**
203			* Verifies that method was called exactly $times times
204			*
205			* $loader->expects($this->exactly(2))
206			* ->method('view')
207			* ->withConsecutive(
208			* ['shop_confirm', $this->anything(), TRUE],
209			* ['shop_tmpl_checkout', $this->anything()]
210			* );
211			*
212			* will be
213			*
214			* $this->verifyInvokedMultipleTimes(
215			* $loader,
216			* 'view',
217			* 2,
218			* [
219			* ['shop_confirm', $this->anything(), TRUE],
220			* ['shop_tmpl_checkout', $this->anything()]
221			* ]
222			* );
223			*
224			* @param object $mock PHPUnit mock object
225			* @param string $method
226			* @param int $times
227			* @param array $params arguments
228			*/
229			public function verifyInvokedMultipleTimes($mock, $method, $times, $params = null)
230			{
231			$this->double->verifyInvokedMultipleTimes(
232			$mock, $method, $times, $params
233			);
234			}
235
236			/**
237			* Verifies a method was invoked at least once
238			*
239			* @param object $mock PHPUnit mock object
240			* @param string $method
241			* @param array $params arguments
242			*/
243			public function verifyInvoked($mock, $method, $params = null)
244			{
245			$this->double->verifyInvoked($mock, $method, $params);
246			}
247
248			/**
249			* Verifies that method was invoked only once
250			*
251			* @param object $mock PHPUnit mock object
252			* @param string $method
253			* @param array $params arguments
254			*/
255			public function verifyInvokedOnce($mock, $method, $params = null)
256			{
257			$this->double->verifyInvokedOnce($mock, $method, $params);
258			}
259
260			/**
261			* Verifies that method was not called
262			*
263			* @param object $mock PHPUnit mock object
264			* @param string $method
265			* @param array $params arguments
266			*/
267			public function verifyNeverInvoked($mock, $method, $params = null)
268			{
269			$this->double->verifyNeverInvoked($mock, $method, $params);
270			}
271
272			public function warningOff()
273			{
274			$this->_error_reporting = error_reporting(
275			E_ALL & ~E_WARNING & ~E_NOTICE
276			);
277			}
278
279			public function warningOn()
280			{
281			error_reporting($this->_error_reporting);
282			}
283
284			/**
285			* Asserts HTTP response code
286			*
287			* @param int $code
288			*/
289			public function assertResponseCode($code)
290			{
291			$status = $this->request->getStatus();
292			$actual = $status['code'];
293
294			$this->assertSame(
295			$code,
296			$actual,
297			'Status code is not ' . $code . ' but ' . $actual . '.'
298			);
299			}
300
301			/**
302			* Asserts HTTP response header
303			*
304			* @param string $name header name
305			* @param string $value header value
306			*/
307			public function assertResponseHeader($name, $value)
308			{
309			$CI =& get_instance();
310			$actual = $CI->output->get_header($name);
311
312			if ($actual === null)
313			{
314			$this->fail("The '$name' header is not set.\nNote that `assertResponseHeader()` can only assert headers set by `\$this->output->set_header()`");
315			}
316
317			$this->assertEquals(
318			$value,
319			$actual,
320			"The '$name' header is not '$value' but '$actual'."
321			);
322			}
323
324			/**
325			* Asserts HTTP response cookie
326			*
327			* @param string $name cookie name
328			* @param string\|array $value cookie value\|array of cookie params
329			* @param bool $allow_duplicate whether to allow duplicated cookies
330			*/
331			public function assertResponseCookie($name, $value, $allow_duplicate = false)
332			{
333			$CI =& get_instance();
334			$cookies = isset($CI->output->_cookies[$name])
335			? $CI->output->_cookies[$name] : null;
336
337			if ($cookies === null)
338			{
339			$this->fail("The cookie '$name' is not set.\nNote that `assertResponseCookie()` can only assert cookies set by `\$this->input->set_cookie()`");
340			}
341
342			$count = count($cookies);
343			if ($count > 1 && ! $allow_duplicate)
344			{
345			$values = [];
346			foreach ($cookies as $key => $val)
347			{
348			$values[] = "'{$val['value']}'";
349			}
350			$values = implode(' and ', $values);
351			$this->fail("You have more than one cookie '$name'. The values are $values.\nIf it is okay, please set `true` as the 3rd argument of `assertResponseCookie()`");
352			}
353
354			// Get the last cookie
355			$cookie = $cookies[$count - 1];
356			if (is_string($value))
357			{
358			$this->assertEquals(
359			$value,
360			$cookie['value'],
361			"The cookie '$name' value is not '$value' but '{$cookie['value']}'."
362			);
363			return;
364			}
365
366			foreach ($value as $key => $val)
367			{
368			$this->assertEquals(
369			$value[$key],
370			$cookie[$key],
371			"The cookie '$name' $key is not '{$value[$key]}' but '{$cookie[$key]}'."
372			);
373			}
374			}
375
376			/**
377			* Asserts Redirect
378			*
379			* @param string $uri URI to redirect
380			* @param int $code response code
381			*/
382			public function assertRedirect($uri, $code = null)
383			{
384			$status = $this->request->getStatus();
385
386			if ($status['redirect'] === null)
387			{
388			$this->fail('redirect() is not called.');
389			}
390
391			if (! function_exists('site_url'))
392			{
393			$CI =& get_instance();
394			$CI->load->helper('url');
395			}
396
397			if (! preg_match('#^(\w+:)?//#i', $uri))
398			{
399			$uri = site_url($uri);
400			}
401			$absolute_url = $uri;
402			$expected = 'Redirect to ' . $absolute_url;
403
404			$this->assertSame(
405			$expected,
406			$status['redirect'],
407			'URL to redirect is not ' . $expected . ' but ' . $status['redirect'] . '.'
408			);
409
410			if ($code !== null)
411			{
412			$this->assertSame(
413			$code,
414			$status['code'],
415			'Status code is not ' . $code . ' but ' . $status['code'] . '.'
416			);
417			}
418			}
419			}
420

kenjis / ci-phpunit-test

Push — master ( 7a55ba...f9e493 )

CIPHPUnitTestCase B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

21 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like