Subversion Repositories SmartDukaan

<?php
/**
 * RequestHandlerComponentTest file
 *
 * 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
 * For full copyright and license information, please see the LICENSE.txt
 * 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
 * @package       Cake.Test.Case.Controller.Component
 * @since         CakePHP(tm) v 1.2.0.5435
 * @license       http://www.opensource.org/licenses/mit-license.php MIT License
 */

App::uses('Controller', 'Controller');
App::uses('RequestHandlerComponent', 'Controller/Component');
App::uses('CakeRequest', 'Network');
App::uses('CakeResponse', 'Network');
App::uses('Router', 'Routing');
App::uses('JsonView', 'View');

/**
 * RequestHandlerTestController class
 *
 * @package       Cake.Test.Case.Controller.Component
 */
class RequestHandlerTestController extends Controller {

/**
 * uses property
 *
 * @var mixed
 */
        public $uses = null;

/**
 * test method for ajax redirection
 *
 * @return void
 */
        public function destination() {
                $this->viewPath = 'Posts';
                $this->render('index');
        }

/**
 * test method for ajax redirection + parameter parsing
 *
 * @return void
 */
        public function param_method($one = null, $two = null) {
                echo "one: $one two: $two";
                $this->autoRender = false;
        }

/**
 * test method for testing layout rendering when isAjax()
 *
 * @return void
 */
        public function ajax2_layout() {
                if ($this->autoLayout) {
                        $this->layout = 'ajax2';
                }
                $this->destination();
        }

}

/**
 * CustomJsonView class
 *
 * @package       Cake.Test.Case.Controller.Component
 */
class CustomJsonView extends JsonView {

}

/**
 * RequestHandlerComponentTest class
 *
 * @package       Cake.Test.Case.Controller.Component
 */
class RequestHandlerComponentTest extends CakeTestCase {

/**
 * Controller property
 *
 * @var RequestHandlerTestController
 */
        public $Controller;

/**
 * RequestHandler property
 *
 * @var RequestHandlerComponent
 */
        public $RequestHandler;

/**
 * setUp method
 *
 * @return void
 */
        public function setUp() {
                parent::setUp();
                $this->_init();
        }

/**
 * init method
 *
 * @return void
 */
        protected function _init() {
                $request = new CakeRequest('controller_posts/index');
                $response = new CakeResponse();
                $this->Controller = new RequestHandlerTestController($request, $response);
                $this->Controller->constructClasses();
                $this->RequestHandler = new RequestHandlerComponent($this->Controller->Components);
                $this->_extensions = Router::extensions();
        }

/**
 * tearDown method
 *
 * @return void
 */
        public function tearDown() {
                parent::tearDown();
                unset($this->RequestHandler, $this->Controller);
                if (!headers_sent()) {
                        header('Content-type: text/html'); //reset content type.
                }
                call_user_func_array('Router::parseExtensions', $this->_extensions);
        }

/**
 * Test that the constructor sets the settings.
 *
 * @return void
 */
        public function testConstructorSettings() {
                $settings = array(
                        'ajaxLayout' => 'test_ajax',
                        'viewClassMap' => array('json' => 'MyPlugin.MyJson')
                );
                $Collection = new ComponentCollection();
                $Collection->init($this->Controller);
                $RequestHandler = new RequestHandlerComponent($Collection, $settings);
                $this->assertEquals('test_ajax', $RequestHandler->ajaxLayout);
                $this->assertEquals(array('json' => 'MyPlugin.MyJson'), $RequestHandler->settings['viewClassMap']);
        }

/**
 * testInitializeCallback method
 *
 * @return void
 */
        public function testInitializeCallback() {
                $this->assertNull($this->RequestHandler->ext);
                $this->Controller->request->params['ext'] = 'rss';
                $this->RequestHandler->initialize($this->Controller);
                $this->assertEquals('rss', $this->RequestHandler->ext);
        }

/**
 * test that a mapped Accept-type header will set $this->ext correctly.
 *
 * @return void
 */
        public function testInitializeContentTypeSettingExt() {
                $this->assertNull($this->RequestHandler->ext);

                $_SERVER['HTTP_ACCEPT'] = 'application/json';
                Router::parseExtensions('json');

                $this->RequestHandler->initialize($this->Controller);
                $this->assertEquals('json', $this->RequestHandler->ext);
        }

/**
 * Test that RequestHandler sets $this->ext when jQuery sends its wonky-ish headers.
 *
 * @return void
 */
        public function testInitializeContentTypeWithjQueryAccept() {
                $_SERVER['HTTP_ACCEPT'] = 'application/json, application/javascript, */*; q=0.01';
                $this->assertNull($this->RequestHandler->ext);
                Router::parseExtensions('json');

                $this->RequestHandler->initialize($this->Controller);
                $this->assertEquals('json', $this->RequestHandler->ext);
        }

/**
 * Test that RequestHandler sets $this->ext when jQuery sends its wonky-ish headers
 * and the application is configured to handle multiple extensions
 *
 * @return void
 */
        public function testInitializeContentTypeWithjQueryAcceptAndMultiplesExtensions() {
                $_SERVER['HTTP_ACCEPT'] = 'application/json, application/javascript, */*; q=0.01';
                $this->assertNull($this->RequestHandler->ext);
                Router::parseExtensions('rss', 'json');

                $this->RequestHandler->initialize($this->Controller);
                $this->assertEquals('json', $this->RequestHandler->ext);
        }

/**
 * Test that RequestHandler does not set $this->ext when multiple accepts are sent.
 *
 * @return void
 */
        public function testInitializeNoContentTypeWithSingleAccept() {
                $_SERVER['HTTP_ACCEPT'] = 'application/json, text/html, */*; q=0.01';
                $this->assertNull($this->RequestHandler->ext);
                Router::parseExtensions('json');

                $this->RequestHandler->initialize($this->Controller);
                $this->assertNull($this->RequestHandler->ext);
        }

/**
 * Test that ext is set to the first listed extension with multiple accepted
 * content types.
 * Having multiple types accepted with same weight, means the client lets the
 * server choose the returned content type.
 *
 * @return void
 */
        public function testInitializeNoContentTypeWithMultipleAcceptedTypes() {
                $_SERVER['HTTP_ACCEPT'] = 'application/json, application/javascript, application/xml, */*; q=0.01';
                $this->assertNull($this->RequestHandler->ext);
                Router::parseExtensions('xml', 'json');

                $this->RequestHandler->initialize($this->Controller);
                $this->assertEquals('xml', $this->RequestHandler->ext);

                $this->RequestHandler->ext = null;
                Router::setExtensions(array('json', 'xml'), false);

                $this->RequestHandler->initialize($this->Controller);
                $this->assertEquals('json', $this->RequestHandler->ext);
        }

/**
 * Test that ext is set to type with highest weight
 *
 * @return void
 */
        public function testInitializeContentTypeWithMultipleAcceptedTypes() {
                $_SERVER['HTTP_ACCEPT'] = 'text/csv;q=1.0, application/json;q=0.8, application/xml;q=0.7';
                $this->assertNull($this->RequestHandler->ext);
                Router::parseExtensions('xml', 'json');

                $this->RequestHandler->initialize($this->Controller);
                $this->assertEquals('json', $this->RequestHandler->ext);
        }

/**
 * Test that ext is not set with confusing android accepts headers.
 *
 * @return void
 */
        public function testInitializeAmbiguousAndroidAccepts() {
                $_SERVER['HTTP_ACCEPT'] = 'application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5';
                $this->assertNull($this->RequestHandler->ext);
                Router::parseExtensions('html', 'xml');

                $this->RequestHandler->initialize($this->Controller);
                $this->assertNull($this->RequestHandler->ext);
        }

/**
 * Test that the headers sent by firefox are not treated as XML requests.
 *
 * @return void
 */
        public function testInititalizeFirefoxHeaderNotXml() {
                $_SERVER['HTTP_ACCEPT'] = 'text/html,application/xhtml+xml,application/xml;image/png,image/jpeg,image/*;q=0.9,*/*;q=0.8';
                Router::parseExtensions('xml', 'json');

                $this->RequestHandler->initialize($this->Controller);
                $this->assertNull($this->RequestHandler->ext);
        }

/**
 * Test that a type mismatch doesn't incorrectly set the ext
 *
 * @return void
 */
        public function testInitializeContentTypeAndExtensionMismatch() {
                $this->assertNull($this->RequestHandler->ext);
                $extensions = Router::extensions();
                Router::parseExtensions('xml');

                $this->Controller->request = $this->getMock('CakeRequest');
                $this->Controller->request->expects($this->any())
                        ->method('accepts')
                        ->will($this->returnValue(array('application/json')));

                $this->RequestHandler->initialize($this->Controller);
                $this->assertNull($this->RequestHandler->ext);

                call_user_func_array(array('Router', 'parseExtensions'), $extensions);
        }

/**
 * testViewClassMap method
 *
 * @return void
 */
        public function testViewClassMap() {
                $this->RequestHandler->settings = array('viewClassMap' => array('json' => 'CustomJson'));
                $this->RequestHandler->initialize($this->Controller);
                $result = $this->RequestHandler->viewClassMap();
                $expected = array(
                        'json' => 'CustomJson',
                        'xml' => 'Xml'
                );
                $this->assertEquals($expected, $result);

                $result = $this->RequestHandler->viewClassMap('xls', 'Excel.Excel');
                $expected = array(
                        'json' => 'CustomJson',
                        'xml' => 'Xml',
                        'xls' => 'Excel.Excel'
                );
                $this->assertEquals($expected, $result);

                $this->RequestHandler->renderAs($this->Controller, 'json');
                $this->assertEquals('CustomJson', $this->Controller->viewClass);
        }

/**
 * testDisabling method
 *
 * @return void
 */
        public function testDisabling() {
                $_SERVER['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest';
                $this->_init();
                $this->RequestHandler->initialize($this->Controller);
                $this->Controller->beforeFilter();
                $this->RequestHandler->startup($this->Controller);
                $this->assertEquals(true, $this->Controller->params['isAjax']);
        }

/**
 * testAutoAjaxLayout method
 *
 * @return void
 */
        public function testAutoAjaxLayout() {
                $_SERVER['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest';
                $this->RequestHandler->startup($this->Controller);
                $this->assertEquals($this->Controller->layout, $this->RequestHandler->ajaxLayout);

                $this->_init();
                $this->Controller->request->params['ext'] = 'js';
                $this->RequestHandler->initialize($this->Controller);
                $this->RequestHandler->startup($this->Controller);
                $this->assertNotEquals('ajax', $this->Controller->layout);

                unset($_SERVER['HTTP_X_REQUESTED_WITH']);
        }

/**
 * testStartupCallback method
 *
 * @return void
 */
        public function testStartupCallback() {
                $_SERVER['REQUEST_METHOD'] = 'PUT';
                $_SERVER['CONTENT_TYPE'] = 'application/xml';
                $this->Controller->request = $this->getMock('CakeRequest', array('_readInput'));
                $this->RequestHandler->startup($this->Controller);
                $this->assertTrue(is_array($this->Controller->data));
                $this->assertFalse(is_object($this->Controller->data));
        }

/**
 * testStartupCallback with charset.
 *
 * @return void
 */
        public function testStartupCallbackCharset() {
                $_SERVER['REQUEST_METHOD'] = 'PUT';
                $_SERVER['CONTENT_TYPE'] = 'application/xml; charset=UTF-8';
                $this->Controller->request = $this->getMock('CakeRequest', array('_readInput'));
                $this->RequestHandler->startup($this->Controller);
                $this->assertTrue(is_array($this->Controller->data));
                $this->assertFalse(is_object($this->Controller->data));
        }

/**
 * Test mapping a new type and having startup process it.
 *
 * @return void
 */
        public function testStartupCustomTypeProcess() {
                if (!function_exists('str_getcsv')) {
                        $this->markTestSkipped('Need "str_getcsv" for this test.');
                }
                $_SERVER['REQUEST_METHOD'] = 'POST';
                $_SERVER['CONTENT_TYPE'] = 'text/csv';
                $this->Controller->request = $this->getMock('CakeRequest', array('_readInput'));
                $this->Controller->request->expects($this->once())
                        ->method('_readInput')
                        ->will($this->returnValue('"A","csv","string"'));
                $this->RequestHandler->addInputType('csv', array('str_getcsv'));
                $this->RequestHandler->startup($this->Controller);
                $expected = array(
                        'A', 'csv', 'string'
                );
                $this->assertEquals($expected, $this->Controller->request->data);
        }

/**
 * testNonAjaxRedirect method
 *
 * @return void
 */
        public function testNonAjaxRedirect() {
                $this->RequestHandler->initialize($this->Controller);
                $this->RequestHandler->startup($this->Controller);
                $this->assertNull($this->RequestHandler->beforeRedirect($this->Controller, '/'));
        }

/**
 * test that redirects with ajax and no URL don't do anything.
 *
 * @return void
 */
        public function testAjaxRedirectWithNoUrl() {
                $_SERVER['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest';
                $this->Controller->response = $this->getMock('CakeResponse');

                $this->Controller->response->expects($this->never())
                        ->method('body');

                $this->RequestHandler->initialize($this->Controller);
                $this->RequestHandler->startup($this->Controller);
                $this->assertNull($this->RequestHandler->beforeRedirect($this->Controller, null));
        }

/**
 * testRenderAs method
 *
 * @return void
 */
        public function testRenderAs() {
                $this->assertFalse(in_array('Rss', $this->Controller->helpers));
                $this->RequestHandler->renderAs($this->Controller, 'rss');
                $this->assertTrue(in_array('Rss', $this->Controller->helpers));

                $this->Controller->viewPath = 'request_handler_test\\rss';
                $this->RequestHandler->renderAs($this->Controller, 'js');
                $this->assertEquals('request_handler_test' . DS . 'js', $this->Controller->viewPath);
        }

/**
 * test that attachment headers work with renderAs
 *
 * @return void
 */
        public function testRenderAsWithAttachment() {
                $this->RequestHandler->request = $this->getMock('CakeRequest');
                $this->RequestHandler->request->expects($this->any())
                        ->method('parseAccept')
                        ->will($this->returnValue(array('1.0' => array('application/xml'))));

                $this->RequestHandler->response = $this->getMock('CakeResponse', array('type', 'download', 'charset'));
                $this->RequestHandler->response->expects($this->at(0))
                        ->method('type')
                        ->with('application/xml');
                $this->RequestHandler->response->expects($this->at(1))
                        ->method('charset')
                        ->with('UTF-8');
                $this->RequestHandler->response->expects($this->at(2))
                        ->method('download')
                        ->with('myfile.xml');

                $this->RequestHandler->renderAs($this->Controller, 'xml', array('attachment' => 'myfile.xml'));

                $this->assertEquals('Xml', $this->Controller->viewClass);
        }

/**
 * test that respondAs works as expected.
 *
 * @return void
 */
        public function testRespondAs() {
                $this->RequestHandler->response = $this->getMock('CakeResponse', array('type'));
                $this->RequestHandler->response->expects($this->at(0))->method('type')
                        ->with('application/json');
                $this->RequestHandler->response->expects($this->at(1))->method('type')
                        ->with('text/xml');

                $result = $this->RequestHandler->respondAs('json');
                $this->assertTrue($result);
                $result = $this->RequestHandler->respondAs('text/xml');
                $this->assertTrue($result);
        }

/**
 * test that attachment headers work with respondAs
 *
 * @return void
 */
        public function testRespondAsWithAttachment() {
                $this->RequestHandler = $this->getMock(
                        'RequestHandlerComponent',
                        array('_header'),
                        array(&$this->Controller->Components)
                );
                $this->RequestHandler->response = $this->getMock('CakeResponse', array('type', 'download'));
                $this->RequestHandler->request = $this->getMock('CakeRequest');

                $this->RequestHandler->request->expects($this->once())
                        ->method('parseAccept')
                        ->will($this->returnValue(array('1.0' => array('application/xml'))));

                $this->RequestHandler->response->expects($this->once())->method('download')
                        ->with('myfile.xml');
                $this->RequestHandler->response->expects($this->once())->method('type')
                        ->with('application/xml');

                $result = $this->RequestHandler->respondAs('xml', array('attachment' => 'myfile.xml'));
                $this->assertTrue($result);
        }

/**
 * test that calling renderAs() more than once continues to work.
 *
 * @link #6466
 * @return void
 */
        public function testRenderAsCalledTwice() {
                $this->RequestHandler->renderAs($this->Controller, 'print');
                $this->assertEquals('RequestHandlerTest' . DS . 'print', $this->Controller->viewPath);
                $this->assertEquals('print', $this->Controller->layoutPath);

                $this->RequestHandler->renderAs($this->Controller, 'js');
                $this->assertEquals('RequestHandlerTest' . DS . 'js', $this->Controller->viewPath);
                $this->assertEquals('js', $this->Controller->layoutPath);
                $this->assertTrue(in_array('Js', $this->Controller->helpers));
        }

/**
 * testRequestClientTypes method
 *
 * @return void
 */
        public function testRequestClientTypes() {
                $_SERVER['HTTP_X_PROTOTYPE_VERSION'] = '1.5';
                $this->assertEquals('1.5', $this->RequestHandler->getAjaxVersion());

                unset($_SERVER['HTTP_X_REQUESTED_WITH'], $_SERVER['HTTP_X_PROTOTYPE_VERSION']);
                $this->assertFalse($this->RequestHandler->getAjaxVersion());
        }

/**
 * Tests the detection of various Flash versions
 *
 * @return void
 */
        public function testFlashDetection() {
                $request = $this->getMock('CakeRequest');
                $request->expects($this->once())->method('is')
                        ->with('flash')
                        ->will($this->returnValue(true));

                $this->RequestHandler->request = $request;
                $this->assertTrue($this->RequestHandler->isFlash());
        }

/**
 * testRequestContentTypes method
 *
 * @return void
 */
        public function testRequestContentTypes() {
                $_SERVER['REQUEST_METHOD'] = 'GET';
                $this->assertNull($this->RequestHandler->requestedWith());

                $_SERVER['REQUEST_METHOD'] = 'POST';
                $_SERVER['CONTENT_TYPE'] = 'application/json';
                $this->assertEquals('json', $this->RequestHandler->requestedWith());

                $result = $this->RequestHandler->requestedWith(array('json', 'xml'));
                $this->assertEquals('json', $result);

                $result = $this->RequestHandler->requestedWith(array('rss', 'atom'));
                $this->assertFalse($result);

                $_SERVER['REQUEST_METHOD'] = 'POST';
                unset($_SERVER['CONTENT_TYPE']);
                $_SERVER['HTTP_CONTENT_TYPE'] = 'application/json';

                $result = $this->RequestHandler->requestedWith(array('json', 'xml'));
                $this->assertEquals('json', $result);

                $result = $this->RequestHandler->requestedWith(array('rss', 'atom'));
                $this->assertFalse($result);

                $_SERVER['HTTP_ACCEPT'] = 'text/xml,application/xml,application/xhtml+xml,text/html,text/plain,image/png,*/*';
                $this->assertTrue($this->RequestHandler->isXml());
                $this->assertFalse($this->RequestHandler->isAtom());
                $this->assertFalse($this->RequestHandler->isRSS());

                $_SERVER['HTTP_ACCEPT'] = 'application/atom+xml,text/xml,application/xml,application/xhtml+xml,text/html,text/plain,image/png,*/*';
                $this->assertTrue($this->RequestHandler->isAtom());
                $this->assertFalse($this->RequestHandler->isRSS());

                $_SERVER['HTTP_ACCEPT'] = 'application/rss+xml,text/xml,application/xml,application/xhtml+xml,text/html,text/plain,image/png,*/*';
                $this->assertFalse($this->RequestHandler->isAtom());
                $this->assertTrue($this->RequestHandler->isRSS());

                $this->assertFalse($this->RequestHandler->isWap());
                $_SERVER['HTTP_ACCEPT'] = 'text/vnd.wap.wml,text/html,text/plain,image/png,*/*';
                $this->assertTrue($this->RequestHandler->isWap());

                $_SERVER['HTTP_ACCEPT'] = 'application/rss+xml,text/xml,application/xml,application/xhtml+xml,text/html,text/plain,image/png,*/*';
        }

/**
 * testResponseContentType method
 *
 * @return void
 */
        public function testResponseContentType() {
                $this->assertEquals('html', $this->RequestHandler->responseType());
                $this->assertTrue($this->RequestHandler->respondAs('atom'));
                $this->assertEquals('atom', $this->RequestHandler->responseType());
        }

/**
 * testMobileDeviceDetection method
 *
 * @return void
 */
        public function testMobileDeviceDetection() {
                $request = $this->getMock('CakeRequest');
                $request->expects($this->once())->method('is')
                        ->with('mobile')
                        ->will($this->returnValue(true));

                $this->RequestHandler->request = $request;
                $this->assertTrue($this->RequestHandler->isMobile());
        }

/**
 * testRequestProperties method
 *
 * @return void
 */
        public function testRequestProperties() {
                $request = $this->getMock('CakeRequest');
                $request->expects($this->once())->method('is')
                        ->with('ssl')
                        ->will($this->returnValue(true));

                $this->RequestHandler->request = $request;
                $this->assertTrue($this->RequestHandler->isSsl());
        }

/**
 * testRequestMethod method
 *
 * @return void
 */
        public function testRequestMethod() {
                $request = $this->getMock('CakeRequest');
                $request->expects($this->at(0))->method('is')
                        ->with('get')
                        ->will($this->returnValue(true));

                $request->expects($this->at(1))->method('is')
                        ->with('post')
                        ->will($this->returnValue(false));

                $request->expects($this->at(2))->method('is')
                        ->with('delete')
                        ->will($this->returnValue(true));

                $request->expects($this->at(3))->method('is')
                        ->with('put')
                        ->will($this->returnValue(false));

                $this->RequestHandler->request = $request;
                $this->assertTrue($this->RequestHandler->isGet());
                $this->assertFalse($this->RequestHandler->isPost());
                $this->assertTrue($this->RequestHandler->isDelete());
                $this->assertFalse($this->RequestHandler->isPut());
        }

/**
 * test that map alias converts aliases to content types.
 *
 * @return void
 */
        public function testMapAlias() {
                $result = $this->RequestHandler->mapAlias('xml');
                $this->assertEquals('application/xml', $result);

                $result = $this->RequestHandler->mapAlias('text/html');
                $this->assertNull($result);

                $result = $this->RequestHandler->mapAlias('wap');
                $this->assertEquals('text/vnd.wap.wml', $result);

                $result = $this->RequestHandler->mapAlias(array('xml', 'js', 'json'));
                $expected = array('application/xml', 'application/javascript', 'application/json');
                $this->assertEquals($expected, $result);
        }

/**
 * test accepts() on the component
 *
 * @return void
 */
        public function testAccepts() {
                $_SERVER['HTTP_ACCEPT'] = 'text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5';
                $this->assertTrue($this->RequestHandler->accepts(array('js', 'xml', 'html')));
                $this->assertFalse($this->RequestHandler->accepts(array('gif', 'jpeg', 'foo')));

                $_SERVER['HTTP_ACCEPT'] = '*/*;q=0.5';
                $this->assertFalse($this->RequestHandler->accepts('rss'));
        }

/**
 * test accepts and prefers methods.
 *
 * @return void
 */
        public function testPrefers() {
                $_SERVER['HTTP_ACCEPT'] = 'text/xml,application/xml,application/xhtml+xml,text/html,text/plain,image/png,*/*';
                $this->assertNotEquals('rss', $this->RequestHandler->prefers());
                $this->RequestHandler->ext = 'rss';
                $this->assertEquals('rss', $this->RequestHandler->prefers());
                $this->assertFalse($this->RequestHandler->prefers('xml'));
                $this->assertEquals('xml', $this->RequestHandler->prefers(array('js', 'xml', 'xhtml')));
                $this->assertFalse($this->RequestHandler->prefers(array('red', 'blue')));
                $this->assertEquals('xhtml', $this->RequestHandler->prefers(array('js', 'json', 'xhtml')));
                $this->assertTrue($this->RequestHandler->prefers(array('rss')), 'Should return true if input matches ext.');
                $this->assertFalse($this->RequestHandler->prefers(array('html')), 'No match with ext, return false.');

                $_SERVER['HTTP_ACCEPT'] = 'text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5';
                $this->_init();
                $this->assertEquals('xml', $this->RequestHandler->prefers());

                $_SERVER['HTTP_ACCEPT'] = '*/*;q=0.5';
                $this->assertEquals('html', $this->RequestHandler->prefers());
                $this->assertFalse($this->RequestHandler->prefers('rss'));
        }

/**
 * testCustomContent method
 *
 * @return void
 */
        public function testCustomContent() {
                $_SERVER['HTTP_ACCEPT'] = 'text/x-mobile,text/html;q=0.9,text/plain;q=0.8,*/*;q=0.5';
                $this->RequestHandler->setContent('mobile', 'text/x-mobile');
                $this->RequestHandler->startup($this->Controller);
                $this->assertEquals('mobile', $this->RequestHandler->prefers());
        }

/**
 * testClientProperties method
 *
 * @return void
 */
        public function testClientProperties() {
                $request = $this->getMock('CakeRequest');
                $request->expects($this->once())->method('referer');
                $request->expects($this->once())->method('clientIp')->will($this->returnValue(false));

                $this->RequestHandler->request = $request;

                $this->RequestHandler->getReferer();
                $this->RequestHandler->getClientIP(false);
        }

/**
 * test that ajax requests involving redirects trigger requestAction instead.
 *
 * @return void
 */
        public function testAjaxRedirectAsRequestAction() {
                App::build(array(
                        'View' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'View' . DS)
                ), App::RESET);

                $this->Controller->RequestHandler = $this->getMock('RequestHandlerComponent', array('_stop'), array(&$this->Controller->Components));
                $this->Controller->request = $this->getMock('CakeRequest');
                $this->Controller->response = $this->getMock('CakeResponse', array('_sendHeader'));
                $this->Controller->RequestHandler->request = $this->Controller->request;
                $this->Controller->RequestHandler->response = $this->Controller->response;
                $this->Controller->request->expects($this->any())->method('is')->will($this->returnValue(true));
                $this->Controller->RequestHandler->expects($this->once())->method('_stop');

                ob_start();
                $this->Controller->RequestHandler->beforeRedirect(
                        $this->Controller, array('controller' => 'request_handler_test', 'action' => 'destination')
                );
                $result = ob_get_clean();
                $this->assertRegExp('/posts index/', $result, 'RequestAction redirect failed.');

                App::build();
        }

/**
 * test that ajax requests involving redirects don't force no layout
 * this would cause the ajax layout to not be rendered.
 *
 * @return void
 */
        public function testAjaxRedirectAsRequestActionStillRenderingLayout() {
                App::build(array(
                        'View' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'View' . DS)
                ), App::RESET);

                $this->Controller->RequestHandler = $this->getMock('RequestHandlerComponent', array('_stop'), array(&$this->Controller->Components));
                $this->Controller->request = $this->getMock('CakeRequest');
                $this->Controller->response = $this->getMock('CakeResponse', array('_sendHeader'));
                $this->Controller->RequestHandler->request = $this->Controller->request;
                $this->Controller->RequestHandler->response = $this->Controller->response;
                $this->Controller->request->expects($this->any())->method('is')->will($this->returnValue(true));
                $this->Controller->RequestHandler->expects($this->once())->method('_stop');

                ob_start();
                $this->Controller->RequestHandler->beforeRedirect(
                        $this->Controller, array('controller' => 'request_handler_test', 'action' => 'ajax2_layout')
                );
                $result = ob_get_clean();
                $this->assertRegExp('/posts index/', $result, 'RequestAction redirect failed.');
                $this->assertRegExp('/Ajax!/', $result, 'Layout was not rendered.');

                App::build();
        }

/**
 * test that the beforeRedirect callback properly converts
 * array URLs into their correct string ones, and adds base => false so
 * the correct URLs are generated.
 *
 * @link https://cakephp.lighthouseapp.com/projects/42648-cakephp-1x/tickets/276
 * @return void
 */
        public function testBeforeRedirectCallbackWithArrayUrl() {
                $_SERVER['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest';

                Router::setRequestInfo(array(
                        array('plugin' => null, 'controller' => 'accounts', 'action' => 'index', 'pass' => array(), 'named' => array(), 'form' => array(), 'url' => array('url' => 'accounts/')),
                        array('base' => '/officespace', 'here' => '/officespace/accounts/', 'webroot' => '/officespace/')
                ));

                $RequestHandler = $this->getMock('RequestHandlerComponent', array('_stop'), array(&$this->Controller->Components));
                $RequestHandler->response = $this->getMock('CakeResponse', array('_sendHeader'));
                $RequestHandler->request = new CakeRequest('posts/index');
                $RequestHandler->response = $this->getMock('CakeResponse', array('_sendHeader'));

                ob_start();
                $RequestHandler->beforeRedirect(
                        $this->Controller,
                        array('controller' => 'request_handler_test', 'action' => 'param_method', 'first', 'second')
                );
                $result = ob_get_clean();
                $this->assertEquals('one: first two: second', $result);
        }

/**
 * assure that beforeRedirect with a status code will correctly set the status header
 *
 * @return void
 */
        public function testBeforeRedirectCallingHeader() {
                $_SERVER['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest';

                $controller = $this->getMock('Controller', array('header'));
                $RequestHandler = $this->getMock('RequestHandlerComponent', array('_stop'), array(&$this->Controller->Components));
                $RequestHandler->response = $this->getMock('CakeResponse', array('_sendHeader', 'statusCode'));
                $RequestHandler->request = $this->getMock('CakeRequest');
                $RequestHandler->request->expects($this->once())->method('is')
                        ->with('ajax')
                        ->will($this->returnValue(true));

                $RequestHandler->response->expects($this->once())->method('statusCode')->with(403);

                ob_start();
                $RequestHandler->beforeRedirect($controller, 'request_handler_test/param_method/first/second', 403);
                ob_get_clean();
        }

/**
 * @expectedException CakeException
 * @return void
 */
        public function testAddInputTypeException() {
                $this->RequestHandler->addInputType('csv', array('I am not callable'));
        }

/**
 * Test checkNotModified method
 *
 * @return void
 */
        public function testCheckNotModifiedByEtagStar() {
                $_SERVER['HTTP_IF_NONE_MATCH'] = '*';
                $RequestHandler = $this->getMock('RequestHandlerComponent', array('_stop'), array(&$this->Controller->Components));
                $RequestHandler->response = $this->getMock('CakeResponse', array('notModified'));
                $RequestHandler->response->etag('something');
                $RequestHandler->response->expects($this->once())->method('notModified');
                $this->assertFalse($RequestHandler->beforeRender($this->Controller));
        }

/**
 * Test checkNotModified method
 *
 * @return void
 */
        public function testCheckNotModifiedByEtagExact() {
                $_SERVER['HTTP_IF_NONE_MATCH'] = 'W/"something", "other"';
                $RequestHandler = $this->getMock('RequestHandlerComponent', array('_stop'), array(&$this->Controller->Components));
                $RequestHandler->response = $this->getMock('CakeResponse', array('notModified'));
                $RequestHandler->response->etag('something', true);
                $RequestHandler->response->expects($this->once())->method('notModified');
                $this->assertFalse($RequestHandler->beforeRender($this->Controller));
        }

/**
 * Test checkNotModified method
 *
 * @return void
 */
        public function testCheckNotModifiedByEtagAndTime() {
                $_SERVER['HTTP_IF_NONE_MATCH'] = 'W/"something", "other"';
                $_SERVER['HTTP_IF_MODIFIED_SINCE'] = '2012-01-01 00:00:00';
                $RequestHandler = $this->getMock('RequestHandlerComponent', array('_stop'), array(&$this->Controller->Components));
                $RequestHandler->response = $this->getMock('CakeResponse', array('notModified'));
                $RequestHandler->response->etag('something', true);
                $RequestHandler->response->modified('2012-01-01 00:00:00');
                $RequestHandler->response->expects($this->once())->method('notModified');
                $this->assertFalse($RequestHandler->beforeRender($this->Controller));
        }

/**
 * Test checkNotModified method
 *
 * @return void
 */
        public function testCheckNotModifiedNoInfo() {
                $RequestHandler = $this->getMock('RequestHandlerComponent', array('_stop'), array(&$this->Controller->Components));
                $RequestHandler->response = $this->getMock('CakeResponse', array('notModified'));
                $RequestHandler->response->expects($this->never())->method('notModified');
                $this->assertNull($RequestHandler->beforeRender($this->Controller));
        }
}