cakephp/tests/TestCase/Routing/DispatcherTest.php

<?php
/**
 * CakePHP(tm) Tests <http://book.cakephp.org/2.0/en/development/testing.html>
 * Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
 *
 * Licensed under The MIT License
 * Redistributions of files must retain the above copyright notice
 *
 * @copyright     Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
 * @link          http://book.cakephp.org/2.0/en/development/testing.html CakePHP(tm) Tests
 * @since         1.2.0
 * @license       http://www.opensource.org/licenses/mit-license.php MIT License
 */
namespace Cake\Test\TestCase\Routing;

use Cake\Controller\Controller;
use Cake\Core\App;
use Cake\Core\Configure;
use Cake\Core\Plugin;
use Cake\Error;
use Cake\Event\Event;
use Cake\Network\Request;
use Cake\Network\Response;
use Cake\Network\Session;
use Cake\Routing\Dispatcher;
use Cake\Routing\Filter\ControllerFactoryFilter;
use Cake\Routing\Router;
use Cake\TestSuite\TestCase;
use Cake\Utility\Inflector;

/**
 * A testing stub that doesn't send headers.
 */
class DispatcherMockResponse extends Response {

	protected function _sendHeader($name, $value = null) {
		return $name . ' ' . $value;
	}

}

/**
 * TestDispatcher class
 */
class TestDispatcher extends Dispatcher {

/**
 * Controller instance, made publicly available for testing
 *
 * @var Controller
 */
	public $controller;

/**
 * invoke method
 *
 * @param \Cake\Controller\Controller $controller
 * @return \Cake\Network\Response $response
 */
	protected function _invoke(Controller $controller) {
		$this->controller = $controller;
		return parent::_invoke($controller);
	}

}

/**
 * MyPluginAppController class
 *
 */
class MyPluginAppController extends Controller {
}

interface DispatcherTestInterfaceController {

	public function index();

}

/**
 * MyPluginController class
 *
 */
class MyPluginController extends MyPluginAppController {

/**
 * name property
 *
 * @var string
 */
	public $name = 'MyPlugin';

/**
 * index method
 *
 * @return void
 */
	public function index() {
		return true;
	}

/**
 * add method
 *
 * @return void
 */
	public function add() {
		return true;
	}

/**
 * admin_add method
 *
 * @param mixed $id
 * @return void
 */
	public function admin_add($id = null) {
		return $id;
	}

}

/**
 * OtherPagesController class
 *
 */
class OtherPagesController extends MyPluginAppController {

/**
 * name property
 *
 * @var string
 */
	public $name = 'OtherPages';

/**
 * display method
 *
 * @param string $page
 * @return void
 */
	public function display($page = null) {
		return $page;
	}

/**
 * index method
 *
 * @return void
 */
	public function index() {
		return true;
	}

}

/**
 * ArticlesTestAppController class
 *
 */
class ArticlesTestAppController extends Controller {
}

/**
 * ArticlesTestController class
 *
 */
class ArticlesTestController extends ArticlesTestAppController {

/**
 * name property
 *
 * @var string
 */
	public $name = 'ArticlesTest';

/**
 * admin_index method
 *
 * @return void
 */
	public function admin_index() {
		return true;
	}

/**
 * fake index method.
 *
 * @return void
 */
	public function index() {
		return true;
	}

}

/**
 * DispatcherTest class
 *
 */
class DispatcherTest extends TestCase {

/**
 * setUp method
 *
 * @return void
 */
	public function setUp() {
		parent::setUp();
		$_GET = [];

		Configure::write('App.base', false);
		Configure::write('App.baseUrl', false);
		Configure::write('App.dir', 'app');
		Configure::write('App.webroot', 'webroot');
		Configure::write('App.namespace', 'TestApp');

		$this->dispatcher = new TestDispatcher();
		$this->dispatcher->addFilter(new ControllerFactoryFilter());
	}

/**
 * tearDown method
 *
 * @return void
 */
	public function tearDown() {
		parent::tearDown();
		Plugin::unload();
	}

/**
 * testMissingController method
 *
 * @expectedException \Cake\Routing\Error\MissingControllerException
 * @expectedExceptionMessage Controller class SomeController could not be found.
 * @return void
 */
	public function testMissingController() {
		$request = new Request([
			'url' => 'some_controller/home',
			'params' => [
				'controller' => 'SomeController',
				'action' => 'home',
			]
		]);
		$response = $this->getMock('Cake\Network\Response');
		$this->dispatcher->dispatch($request, $response, array('return' => 1));
	}

/**
 * testMissingControllerInterface method
 *
 * @expectedException \Cake\Routing\Error\MissingControllerException
 * @expectedExceptionMessage Controller class DispatcherTestInterface could not be found.
 * @return void
 */
	public function testMissingControllerInterface() {
		$request = new Request([
			'url' => 'dispatcher_test_interface/index',
			'params' => [
				'controller' => 'DispatcherTestInterface',
				'action' => 'index',
			]
		]);
		$url = new Request('dispatcher_test_interface/index');
		$response = $this->getMock('Cake\Network\Response');
		$this->dispatcher->dispatch($request, $response, array('return' => 1));
	}

/**
 * testMissingControllerInterface method
 *
 * @expectedException \Cake\Routing\Error\MissingControllerException
 * @expectedExceptionMessage Controller class Abstract could not be found.
 * @return void
 */
	public function testMissingControllerAbstract() {
		$request = new Request([
			'url' => 'abstract/index',
			'params' => [
				'controller' => 'Abstract',
				'action' => 'index',
			]
		]);
		$response = $this->getMock('Cake\Network\Response');
		$this->dispatcher->dispatch($request, $response, array('return' => 1));
	}

/**
 * testDispatch method
 *
 * @return void
 */
	public function testDispatchBasic() {
		$url = new Request([
			'url' => 'pages/home',
			'params' => [
				'controller' => 'Pages',
				'action' => 'display',
				'pass' => ['extract'],
				'return' => 1
			]
		]);
		$response = $this->getMock('Cake\Network\Response');

		$this->dispatcher->dispatch($url, $response);
		$expected = 'Pages';
		$this->assertEquals($expected, $this->dispatcher->controller->name);
	}

/**
 * Test that Dispatcher handles actions that return response objects.
 *
 * @return void
 */
	public function testDispatchActionReturnsResponse() {
		$request = new Request([
			'url' => 'some_pages/responseGenerator',
			'params' => [
				'controller' => 'SomePages',
				'action' => 'responseGenerator',
				'pass' => []
			]
		]);
		$response = $this->getMock('Cake\Network\Response', array('_sendHeader'));

		ob_start();
		$this->dispatcher->dispatch($request, $response);
		$result = ob_get_clean();

		$this->assertEquals('new response', $result);
	}

/**
 * testPrefixDispatch method
 *
 * @return void
 */
	public function testPrefixDispatch() {
		$request = new Request([
			'url' => 'admin/posts/index',
			'params' => [
				'prefix' => 'Admin',
				'controller' => 'Posts',
				'action' => 'index',
				'pass' => [],
				'return' => 1
			]
		]);
		$response = $this->getMock('Cake\Network\Response');

		$this->dispatcher->dispatch($request, $response);

		$this->assertInstanceOf(
			'TestApp\Controller\Admin\PostsController',
			$this->dispatcher->controller
		);
		$expected = '/admin/posts/index';
		$this->assertSame($expected, $request->here);
	}

/**
 * test prefix dispatching in a plugin.
 *
 * @return void
 */
	public function testPrefixDispatchPlugin() {
		Plugin::load('TestPlugin');

		$request = new Request([
			'url' => 'admin/test_plugin/comments/index',
			'params' => [
				'plugin' => 'TestPlugin',
				'prefix' => 'Admin',
				'controller' => 'Comments',
				'action' => 'index',
				'pass' => [],
				'return' => 1
			]
		]);
		$response = $this->getMock('Cake\Network\Response');

		$this->dispatcher->dispatch($request, $response);

		$this->assertInstanceOf(
			'TestPlugin\Controller\Admin\CommentsController',
			$this->dispatcher->controller
		);
	}

/**
 * Test dispatcher filters being called.
 *
 * @return void
 */
	public function testDispatcherFilter() {
		$filter = $this->getMock(
			'Cake\Routing\DispatcherFilter',
			['beforeDispatch', 'afterDispatch']
		);

		$filter->expects($this->at(0))
			->method('beforeDispatch');
		$filter->expects($this->at(1))
			->method('afterDispatch');
		$this->dispatcher->addFilter($filter);

		$request = new Request([
			'url' => '/',
			'params' => [
				'controller' => 'pages',
				'action' => 'display',
				'home',
				'pass' => []
			]
		]);
		$response = $this->getMock('Cake\Network\Response', ['send']);
		$this->dispatcher->dispatch($request, $response);
	}

/**
 * Test dispatcher filters being called and changing the response.
 *
 * @return void
 */
	public function testBeforeDispatchAbortDispatch() {
		$response = $this->getMock('Cake\Network\Response', ['send']);
		$response->expects($this->once())
			->method('send');

		$filter = $this->getMock(
			'Cake\Routing\DispatcherFilter',
			['beforeDispatch', 'afterDispatch']);
		$filter->expects($this->once())
			->method('beforeDispatch')
			->will($this->returnValue($response));

		$filter->expects($this->never())
			->method('afterDispatch');

		$request = new Request();
		$res = new Response();
		$this->dispatcher->addFilter($filter);
		$this->dispatcher->dispatch($request, $res);
	}

/**
 * Test dispatcher filters being called and changing the response.
 *
 * @return void
 */
	public function testAfterDispatchReplaceResponse() {
		$response = $this->getMock('Cake\Network\Response', ['_sendHeader', 'send']);
		$response->expects($this->once())
			->method('send');

		$filter = $this->getMock(
			'Cake\Routing\DispatcherFilter',
			['beforeDispatch', 'afterDispatch']);

		$filter->expects($this->once())
			->method('afterDispatch')
			->will($this->returnValue($response));

		$request = new Request([
			'url' => '/posts',
			'params' => [
				'plugin' => null,
				'controller' => 'Posts',
				'action' => 'index',
				'pass' => [],
			],
			'session' => new Session
		]);
		$this->dispatcher->addFilter($filter);
		$this->dispatcher->dispatch($request, $response);
	}

}