1: <?php
   2: 
   3: /*
   4:  * This file is part of the Symfony package.
   5:  *
   6:  * (c) Fabien Potencier <fabien@symfony.com>
   7:  *
   8:  * For the full copyright and license information, please view the LICENSE
   9:  * file that was distributed with this source code.
  10:  */
  11: 
  12: namespace Symfony\Component\HttpFoundation\Tests;
  13: 
  14: use Symfony\Component\HttpFoundation\Session\Storage\MockArraySessionStorage;
  15: use Symfony\Component\HttpFoundation\Session\Session;
  16: use Symfony\Component\HttpFoundation\Request;
  17: 
  18: class RequestTest extends \PHPUnit_Framework_TestCase
  19: {
  20:     /**
  21:      * @covers Symfony\Component\HttpFoundation\Request::__construct
  22:      */
  23:     public function testConstructor()
  24:     {
  25:         $this->testInitialize();
  26:     }
  27: 
  28:     /**
  29:      * @covers Symfony\Component\HttpFoundation\Request::initialize
  30:      */
  31:     public function testInitialize()
  32:     {
  33:         $request = new Request();
  34: 
  35:         $request->initialize(array('foo' => 'bar'));
  36:         $this->assertEquals('bar', $request->query->get('foo'), '->initialize() takes an array of query parameters as its first argument');
  37: 
  38:         $request->initialize(array(), array('foo' => 'bar'));
  39:         $this->assertEquals('bar', $request->request->get('foo'), '->initialize() takes an array of request parameters as its second argument');
  40: 
  41:         $request->initialize(array(), array(), array('foo' => 'bar'));
  42:         $this->assertEquals('bar', $request->attributes->get('foo'), '->initialize() takes an array of attributes as its third argument');
  43: 
  44:         $request->initialize(array(), array(), array(), array(), array(), array('HTTP_FOO' => 'bar'));
  45:         $this->assertEquals('bar', $request->headers->get('FOO'), '->initialize() takes an array of HTTP headers as its sixth argument');
  46:     }
  47: 
  48:     public function testGetLocale()
  49:     {
  50:         $request = new Request();
  51:         $request->setLocale('pl');
  52:         $locale = $request->getLocale();
  53:         $this->assertEquals('pl', $locale);
  54:     }
  55: 
  56:     public function testGetUser()
  57:     {
  58:         $request = Request::create('http://user_test:password_test@test.com/');
  59:         $user = $request->getUser();
  60: 
  61:         $this->assertEquals('user_test', $user);
  62:     }
  63: 
  64:     public function testGetPassword()
  65:     {
  66:         $request = Request::create('http://user_test:password_test@test.com/');
  67:         $password = $request->getPassword();
  68: 
  69:         $this->assertEquals('password_test', $password);
  70:     }
  71: 
  72:     public function testIsNoCache()
  73:     {
  74:         $request = new Request();
  75:         $isNoCache = $request->isNoCache();
  76: 
  77:         $this->assertFalse($isNoCache);
  78:     }
  79: 
  80:     public function testGetContentType()
  81:     {
  82:         $request = new Request();
  83:         $contentType = $request->getContentType();
  84: 
  85:         $this->assertNull($contentType);
  86:     }
  87: 
  88:     public function testSetDefaultLocale()
  89:     {
  90:         $request = new Request();
  91:         $request->setDefaultLocale('pl');
  92:         $locale = $request->getLocale();
  93: 
  94:         $this->assertEquals('pl', $locale);
  95:     }
  96: 
  97:     /**
  98:      * @covers Symfony\Component\HttpFoundation\Request::create
  99:      */
 100:     public function testCreate()
 101:     {
 102:         $request = Request::create('http://test.com/foo?bar=baz');
 103:         $this->assertEquals('http://test.com/foo?bar=baz', $request->getUri());
 104:         $this->assertEquals('/foo', $request->getPathInfo());
 105:         $this->assertEquals('bar=baz', $request->getQueryString());
 106:         $this->assertEquals(80, $request->getPort());
 107:         $this->assertEquals('test.com', $request->getHttpHost());
 108:         $this->assertFalse($request->isSecure());
 109: 
 110:         $request = Request::create('http://test.com/foo', 'GET', array('bar' => 'baz'));
 111:         $this->assertEquals('http://test.com/foo?bar=baz', $request->getUri());
 112:         $this->assertEquals('/foo', $request->getPathInfo());
 113:         $this->assertEquals('bar=baz', $request->getQueryString());
 114:         $this->assertEquals(80, $request->getPort());
 115:         $this->assertEquals('test.com', $request->getHttpHost());
 116:         $this->assertFalse($request->isSecure());
 117: 
 118:         $request = Request::create('http://test.com/foo?bar=foo', 'GET', array('bar' => 'baz'));
 119:         $this->assertEquals('http://test.com/foo?bar=baz', $request->getUri());
 120:         $this->assertEquals('/foo', $request->getPathInfo());
 121:         $this->assertEquals('bar=baz', $request->getQueryString());
 122:         $this->assertEquals(80, $request->getPort());
 123:         $this->assertEquals('test.com', $request->getHttpHost());
 124:         $this->assertFalse($request->isSecure());
 125: 
 126:         $request = Request::create('https://test.com/foo?bar=baz');
 127:         $this->assertEquals('https://test.com/foo?bar=baz', $request->getUri());
 128:         $this->assertEquals('/foo', $request->getPathInfo());
 129:         $this->assertEquals('bar=baz', $request->getQueryString());
 130:         $this->assertEquals(443, $request->getPort());
 131:         $this->assertEquals('test.com', $request->getHttpHost());
 132:         $this->assertTrue($request->isSecure());
 133: 
 134:         $request = Request::create('test.com:90/foo');
 135:         $this->assertEquals('http://test.com:90/foo', $request->getUri());
 136:         $this->assertEquals('/foo', $request->getPathInfo());
 137:         $this->assertEquals('test.com', $request->getHost());
 138:         $this->assertEquals('test.com:90', $request->getHttpHost());
 139:         $this->assertEquals(90, $request->getPort());
 140:         $this->assertFalse($request->isSecure());
 141: 
 142:         $request = Request::create('https://test.com:90/foo');
 143:         $this->assertEquals('https://test.com:90/foo', $request->getUri());
 144:         $this->assertEquals('/foo', $request->getPathInfo());
 145:         $this->assertEquals('test.com', $request->getHost());
 146:         $this->assertEquals('test.com:90', $request->getHttpHost());
 147:         $this->assertEquals(90, $request->getPort());
 148:         $this->assertTrue($request->isSecure());
 149: 
 150:         $request = Request::create('https://127.0.0.1:90/foo');
 151:         $this->assertEquals('https://127.0.0.1:90/foo', $request->getUri());
 152:         $this->assertEquals('/foo', $request->getPathInfo());
 153:         $this->assertEquals('127.0.0.1', $request->getHost());
 154:         $this->assertEquals('127.0.0.1:90', $request->getHttpHost());
 155:         $this->assertEquals(90, $request->getPort());
 156:         $this->assertTrue($request->isSecure());
 157: 
 158:         $request = Request::create('https://[::1]:90/foo');
 159:         $this->assertEquals('https://[::1]:90/foo', $request->getUri());
 160:         $this->assertEquals('/foo', $request->getPathInfo());
 161:         $this->assertEquals('[::1]', $request->getHost());
 162:         $this->assertEquals('[::1]:90', $request->getHttpHost());
 163:         $this->assertEquals(90, $request->getPort());
 164:         $this->assertTrue($request->isSecure());
 165: 
 166:         $request = Request::create('https://[::1]/foo');
 167:         $this->assertEquals('https://[::1]/foo', $request->getUri());
 168:         $this->assertEquals('/foo', $request->getPathInfo());
 169:         $this->assertEquals('[::1]', $request->getHost());
 170:         $this->assertEquals('[::1]', $request->getHttpHost());
 171:         $this->assertEquals(443, $request->getPort());
 172:         $this->assertTrue($request->isSecure());
 173: 
 174:         $json = '{"jsonrpc":"2.0","method":"echo","id":7,"params":["Hello World"]}';
 175:         $request = Request::create('http://example.com/jsonrpc', 'POST', array(), array(), array(), array(), $json);
 176:         $this->assertEquals($json, $request->getContent());
 177:         $this->assertFalse($request->isSecure());
 178: 
 179:         $request = Request::create('http://test.com');
 180:         $this->assertEquals('http://test.com/', $request->getUri());
 181:         $this->assertEquals('/', $request->getPathInfo());
 182:         $this->assertEquals('', $request->getQueryString());
 183:         $this->assertEquals(80, $request->getPort());
 184:         $this->assertEquals('test.com', $request->getHttpHost());
 185:         $this->assertFalse($request->isSecure());
 186: 
 187:         $request = Request::create('http://test.com?test=1');
 188:         $this->assertEquals('http://test.com/?test=1', $request->getUri());
 189:         $this->assertEquals('/', $request->getPathInfo());
 190:         $this->assertEquals('test=1', $request->getQueryString());
 191:         $this->assertEquals(80, $request->getPort());
 192:         $this->assertEquals('test.com', $request->getHttpHost());
 193:         $this->assertFalse($request->isSecure());
 194: 
 195:         $request = Request::create('http://test.com:90/?test=1');
 196:         $this->assertEquals('http://test.com:90/?test=1', $request->getUri());
 197:         $this->assertEquals('/', $request->getPathInfo());
 198:         $this->assertEquals('test=1', $request->getQueryString());
 199:         $this->assertEquals(90, $request->getPort());
 200:         $this->assertEquals('test.com:90', $request->getHttpHost());
 201:         $this->assertFalse($request->isSecure());
 202: 
 203:         $request = Request::create('http://username:password@test.com');
 204:         $this->assertEquals('http://test.com/', $request->getUri());
 205:         $this->assertEquals('/', $request->getPathInfo());
 206:         $this->assertEquals('', $request->getQueryString());
 207:         $this->assertEquals(80, $request->getPort());
 208:         $this->assertEquals('test.com', $request->getHttpHost());
 209:         $this->assertEquals('username', $request->getUser());
 210:         $this->assertEquals('password', $request->getPassword());
 211:         $this->assertFalse($request->isSecure());
 212: 
 213:         $request = Request::create('http://username@test.com');
 214:         $this->assertEquals('http://test.com/', $request->getUri());
 215:         $this->assertEquals('/', $request->getPathInfo());
 216:         $this->assertEquals('', $request->getQueryString());
 217:         $this->assertEquals(80, $request->getPort());
 218:         $this->assertEquals('test.com', $request->getHttpHost());
 219:         $this->assertEquals('username', $request->getUser());
 220:         $this->assertSame('', $request->getPassword());
 221:         $this->assertFalse($request->isSecure());
 222: 
 223:         $request = Request::create('http://test.com/?foo');
 224:         $this->assertEquals('/?foo', $request->getRequestUri());
 225:         $this->assertEquals(array('foo' => ''), $request->query->all());
 226: 
 227:         ## assume rewrite rule: (.*) --> app/app.php ; app/ is a symlink to a symfony web/ directory
 228:         $request = Request::create('http://test.com/apparthotel-1234', 'GET', array(), array(), array(),
 229:             array(
 230:                 'DOCUMENT_ROOT' => '/var/www/www.test.com',
 231:                 'SCRIPT_FILENAME' => '/var/www/www.test.com/app/app.php',
 232:                 'SCRIPT_NAME' => '/app/app.php',
 233:                 'PHP_SELF' => '/app/app.php/apparthotel-1234',
 234:             ));
 235:         $this->assertEquals('http://test.com/apparthotel-1234', $request->getUri());
 236:         $this->assertEquals('/apparthotel-1234', $request->getPathInfo());
 237:         $this->assertEquals('', $request->getQueryString());
 238:         $this->assertEquals(80, $request->getPort());
 239:         $this->assertEquals('test.com', $request->getHttpHost());
 240:         $this->assertFalse($request->isSecure());
 241:     }
 242: 
 243:     /**
 244:      * @covers Symfony\Component\HttpFoundation\Request::create
 245:      */
 246:     public function testCreateCheckPrecedence()
 247:     {
 248:         // server is used by default
 249:         $request = Request::create('/', 'DELETE', array(), array(), array(), array(
 250:             'HTTP_HOST' => 'example.com',
 251:             'HTTPS' => 'on',
 252:             'SERVER_PORT' => 443,
 253:             'PHP_AUTH_USER' => 'fabien',
 254:             'PHP_AUTH_PW' => 'pa$$',
 255:             'QUERY_STRING' => 'foo=bar',
 256:             'CONTENT_TYPE' => 'application/json',
 257:         ));
 258:         $this->assertEquals('example.com', $request->getHost());
 259:         $this->assertEquals(443, $request->getPort());
 260:         $this->assertTrue($request->isSecure());
 261:         $this->assertEquals('fabien', $request->getUser());
 262:         $this->assertEquals('pa$$', $request->getPassword());
 263:         $this->assertEquals('', $request->getQueryString());
 264:         $this->assertEquals('application/json', $request->headers->get('CONTENT_TYPE'));
 265: 
 266:         // URI has precedence over server
 267:         $request = Request::create('http://thomas:pokemon@example.net:8080/?foo=bar', 'GET', array(), array(), array(), array(
 268:             'HTTP_HOST' => 'example.com',
 269:             'HTTPS' => 'on',
 270:             'SERVER_PORT' => 443,
 271:         ));
 272:         $this->assertEquals('example.net', $request->getHost());
 273:         $this->assertEquals(8080, $request->getPort());
 274:         $this->assertFalse($request->isSecure());
 275:         $this->assertEquals('thomas', $request->getUser());
 276:         $this->assertEquals('pokemon', $request->getPassword());
 277:         $this->assertEquals('foo=bar', $request->getQueryString());
 278:     }
 279: 
 280:     public function testDuplicate()
 281:     {
 282:         $request = new Request(array('foo' => 'bar'), array('foo' => 'bar'), array('foo' => 'bar'), array(), array(), array('HTTP_FOO' => 'bar'));
 283:         $dup = $request->duplicate();
 284: 
 285:         $this->assertEquals($request->query->all(), $dup->query->all(), '->duplicate() duplicates a request an copy the current query parameters');
 286:         $this->assertEquals($request->request->all(), $dup->request->all(), '->duplicate() duplicates a request an copy the current request parameters');
 287:         $this->assertEquals($request->attributes->all(), $dup->attributes->all(), '->duplicate() duplicates a request an copy the current attributes');
 288:         $this->assertEquals($request->headers->all(), $dup->headers->all(), '->duplicate() duplicates a request an copy the current HTTP headers');
 289: 
 290:         $dup = $request->duplicate(array('foo' => 'foobar'), array('foo' => 'foobar'), array('foo' => 'foobar'), array(), array(), array('HTTP_FOO' => 'foobar'));
 291: 
 292:         $this->assertEquals(array('foo' => 'foobar'), $dup->query->all(), '->duplicate() overrides the query parameters if provided');
 293:         $this->assertEquals(array('foo' => 'foobar'), $dup->request->all(), '->duplicate() overrides the request parameters if provided');
 294:         $this->assertEquals(array('foo' => 'foobar'), $dup->attributes->all(), '->duplicate() overrides the attributes if provided');
 295:         $this->assertEquals(array('foo' => array('foobar')), $dup->headers->all(), '->duplicate() overrides the HTTP header if provided');
 296:     }
 297: 
 298:     public function testDuplicateWithFormat()
 299:     {
 300:         $request = new Request(array(), array(), array('_format' => 'json'));
 301:         $dup = $request->duplicate();
 302: 
 303:         $this->assertEquals('json', $dup->getRequestFormat());
 304:         $this->assertEquals('json', $dup->attributes->get('_format'));
 305: 
 306:         $request = new Request();
 307:         $request->setRequestFormat('xml');
 308:         $dup = $request->duplicate();
 309: 
 310:         $this->assertEquals('xml', $dup->getRequestFormat());
 311:     }
 312: 
 313:     /**
 314:      * @covers Symfony\Component\HttpFoundation\Request::getFormat
 315:      * @covers Symfony\Component\HttpFoundation\Request::setFormat
 316:      * @dataProvider getFormatToMimeTypeMapProvider
 317:      */
 318:     public function testGetFormatFromMimeType($format, $mimeTypes)
 319:     {
 320:         $request = new Request();
 321:         foreach ($mimeTypes as $mime) {
 322:             $this->assertEquals($format, $request->getFormat($mime));
 323:         }
 324:         $request->setFormat($format, $mimeTypes);
 325:         foreach ($mimeTypes as $mime) {
 326:             $this->assertEquals($format, $request->getFormat($mime));
 327:         }
 328:     }
 329: 
 330:     /**
 331:      * @covers Symfony\Component\HttpFoundation\Request::getFormat
 332:      */
 333:     public function testGetFormatFromMimeTypeWithParameters()
 334:     {
 335:         $request = new Request();
 336:         $this->assertEquals('json', $request->getFormat('application/json; charset=utf-8'));
 337:     }
 338: 
 339:     /**
 340:      * @covers Symfony\Component\HttpFoundation\Request::getMimeType
 341:      * @dataProvider getFormatToMimeTypeMapProvider
 342:      */
 343:     public function testGetMimeTypeFromFormat($format, $mimeTypes)
 344:     {
 345:         if (null !== $format) {
 346:             $request = new Request();
 347:             $this->assertEquals($mimeTypes[0], $request->getMimeType($format));
 348:         }
 349:     }
 350: 
 351:     public function getFormatToMimeTypeMapProvider()
 352:     {
 353:         return array(
 354:             array(null, array(null, 'unexistent-mime-type')),
 355:             array('txt', array('text/plain')),
 356:             array('js', array('application/javascript', 'application/x-javascript', 'text/javascript')),
 357:             array('css', array('text/css')),
 358:             array('json', array('application/json', 'application/x-json')),
 359:             array('xml', array('text/xml', 'application/xml', 'application/x-xml')),
 360:             array('rdf', array('application/rdf+xml')),
 361:             array('atom',array('application/atom+xml')),
 362:         );
 363:     }
 364: 
 365:     /**
 366:      * @covers Symfony\Component\HttpFoundation\Request::getUri
 367:      */
 368:     public function testGetUri()
 369:     {
 370:         $server = array();
 371: 
 372:         // Standard Request on non default PORT
 373:         // http://host:8080/index.php/path/info?query=string
 374: 
 375:         $server['HTTP_HOST'] = 'host:8080';
 376:         $server['SERVER_NAME'] = 'servername';
 377:         $server['SERVER_PORT'] = '8080';
 378: 
 379:         $server['QUERY_STRING'] = 'query=string';
 380:         $server['REQUEST_URI'] = '/index.php/path/info?query=string';
 381:         $server['SCRIPT_NAME'] = '/index.php';
 382:         $server['PATH_INFO'] = '/path/info';
 383:         $server['PATH_TRANSLATED'] = 'redirect:/index.php/path/info';
 384:         $server['PHP_SELF'] = '/index_dev.php/path/info';
 385:         $server['SCRIPT_FILENAME'] = '/some/where/index.php';
 386: 
 387:         $request = new Request();
 388: 
 389:         $request->initialize(array(), array(), array(), array(), array(), $server);
 390: 
 391:         $this->assertEquals('http://host:8080/index.php/path/info?query=string', $request->getUri(), '->getUri() with non default port');
 392: 
 393:         // Use std port number
 394:         $server['HTTP_HOST'] = 'host';
 395:         $server['SERVER_NAME'] = 'servername';
 396:         $server['SERVER_PORT'] = '80';
 397: 
 398:         $request->initialize(array(), array(), array(), array(), array(), $server);
 399: 
 400:         $this->assertEquals('http://host/index.php/path/info?query=string', $request->getUri(), '->getUri() with default port');
 401: 
 402:         // Without HOST HEADER
 403:         unset($server['HTTP_HOST']);
 404:         $server['SERVER_NAME'] = 'servername';
 405:         $server['SERVER_PORT'] = '80';
 406: 
 407:         $request->initialize(array(), array(), array(), array(), array(), $server);
 408: 
 409:         $this->assertEquals('http://servername/index.php/path/info?query=string', $request->getUri(), '->getUri() with default port without HOST_HEADER');
 410: 
 411:         // Request with URL REWRITING (hide index.php)
 412:         //   RewriteCond %{REQUEST_FILENAME} !-f
 413:         //   RewriteRule ^(.*)$ index.php [QSA,L]
 414:         // http://host:8080/path/info?query=string
 415:         $server = array();
 416:         $server['HTTP_HOST'] = 'host:8080';
 417:         $server['SERVER_NAME'] = 'servername';
 418:         $server['SERVER_PORT'] = '8080';
 419: 
 420:         $server['REDIRECT_QUERY_STRING'] = 'query=string';
 421:         $server['REDIRECT_URL'] = '/path/info';
 422:         $server['SCRIPT_NAME'] = '/index.php';
 423:         $server['QUERY_STRING'] = 'query=string';
 424:         $server['REQUEST_URI'] = '/path/info?toto=test&1=1';
 425:         $server['SCRIPT_NAME'] = '/index.php';
 426:         $server['PHP_SELF'] = '/index.php';
 427:         $server['SCRIPT_FILENAME'] = '/some/where/index.php';
 428: 
 429:         $request->initialize(array(), array(), array(), array(), array(), $server);
 430:         $this->assertEquals('http://host:8080/path/info?query=string', $request->getUri(), '->getUri() with rewrite');
 431: 
 432:         // Use std port number
 433:         //  http://host/path/info?query=string
 434:         $server['HTTP_HOST'] = 'host';
 435:         $server['SERVER_NAME'] = 'servername';
 436:         $server['SERVER_PORT'] = '80';
 437: 
 438:         $request->initialize(array(), array(), array(), array(), array(), $server);
 439: 
 440:         $this->assertEquals('http://host/path/info?query=string', $request->getUri(), '->getUri() with rewrite and default port');
 441: 
 442:         // Without HOST HEADER
 443:         unset($server['HTTP_HOST']);
 444:         $server['SERVER_NAME'] = 'servername';
 445:         $server['SERVER_PORT'] = '80';
 446: 
 447:         $request->initialize(array(), array(), array(), array(), array(), $server);
 448: 
 449:         $this->assertEquals('http://servername/path/info?query=string', $request->getUri(), '->getUri() with rewrite, default port without HOST_HEADER');
 450: 
 451:         // With encoded characters
 452: 
 453:         $server = array(
 454:             'HTTP_HOST' => 'host:8080',
 455:             'SERVER_NAME' => 'servername',
 456:             'SERVER_PORT' => '8080',
 457:             'QUERY_STRING' => 'query=string',
 458:             'REQUEST_URI' => '/ba%20se/index_dev.php/foo%20bar/in+fo?query=string',
 459:             'SCRIPT_NAME' => '/ba se/index_dev.php',
 460:             'PATH_TRANSLATED' => 'redirect:/index.php/foo bar/in+fo',
 461:             'PHP_SELF' => '/ba se/index_dev.php/path/info',
 462:             'SCRIPT_FILENAME' => '/some/where/ba se/index_dev.php',
 463:         );
 464: 
 465:         $request->initialize(array(), array(), array(), array(), array(), $server);
 466: 
 467:         $this->assertEquals(
 468:             'http://host:8080/ba%20se/index_dev.php/foo%20bar/in+fo?query=string',
 469:             $request->getUri()
 470:         );
 471: 
 472:         // with user info
 473: 
 474:         $server['PHP_AUTH_USER'] = 'fabien';
 475:         $request->initialize(array(), array(), array(), array(), array(), $server);
 476:         $this->assertEquals('http://host:8080/ba%20se/index_dev.php/foo%20bar/in+fo?query=string', $request->getUri());
 477: 
 478:         $server['PHP_AUTH_PW'] = 'symfony';
 479:         $request->initialize(array(), array(), array(), array(), array(), $server);
 480:         $this->assertEquals('http://host:8080/ba%20se/index_dev.php/foo%20bar/in+fo?query=string', $request->getUri());
 481:     }
 482: 
 483:     /**
 484:      * @covers Symfony\Component\HttpFoundation\Request::getUriForPath
 485:      */
 486:     public function testGetUriForPath()
 487:     {
 488:         $request = Request::create('http://test.com/foo?bar=baz');
 489:         $this->assertEquals('http://test.com/some/path', $request->getUriForPath('/some/path'));
 490: 
 491:         $request = Request::create('http://test.com:90/foo?bar=baz');
 492:         $this->assertEquals('http://test.com:90/some/path', $request->getUriForPath('/some/path'));
 493: 
 494:         $request = Request::create('https://test.com/foo?bar=baz');
 495:         $this->assertEquals('https://test.com/some/path', $request->getUriForPath('/some/path'));
 496: 
 497:         $request = Request::create('https://test.com:90/foo?bar=baz');
 498:         $this->assertEquals('https://test.com:90/some/path', $request->getUriForPath('/some/path'));
 499: 
 500:         $server = array();
 501: 
 502:         // Standard Request on non default PORT
 503:         // http://host:8080/index.php/path/info?query=string
 504: 
 505:         $server['HTTP_HOST'] = 'host:8080';
 506:         $server['SERVER_NAME'] = 'servername';
 507:         $server['SERVER_PORT'] = '8080';
 508: 
 509:         $server['QUERY_STRING'] = 'query=string';
 510:         $server['REQUEST_URI'] = '/index.php/path/info?query=string';
 511:         $server['SCRIPT_NAME'] = '/index.php';
 512:         $server['PATH_INFO'] = '/path/info';
 513:         $server['PATH_TRANSLATED'] = 'redirect:/index.php/path/info';
 514:         $server['PHP_SELF'] = '/index_dev.php/path/info';
 515:         $server['SCRIPT_FILENAME'] = '/some/where/index.php';
 516: 
 517:         $request = new Request();
 518: 
 519:         $request->initialize(array(), array(), array(), array(), array(), $server);
 520: 
 521:         $this->assertEquals('http://host:8080/index.php/some/path', $request->getUriForPath('/some/path'), '->getUriForPath() with non default port');
 522: 
 523:         // Use std port number
 524:         $server['HTTP_HOST'] = 'host';
 525:         $server['SERVER_NAME'] = 'servername';
 526:         $server['SERVER_PORT'] = '80';
 527: 
 528:         $request->initialize(array(), array(), array(), array(), array(), $server);
 529: 
 530:         $this->assertEquals('http://host/index.php/some/path', $request->getUriForPath('/some/path'), '->getUriForPath() with default port');
 531: 
 532:         // Without HOST HEADER
 533:         unset($server['HTTP_HOST']);
 534:         $server['SERVER_NAME'] = 'servername';
 535:         $server['SERVER_PORT'] = '80';
 536: 
 537:         $request->initialize(array(), array(), array(), array(), array(), $server);
 538: 
 539:         $this->assertEquals('http://servername/index.php/some/path', $request->getUriForPath('/some/path'), '->getUriForPath() with default port without HOST_HEADER');
 540: 
 541:         // Request with URL REWRITING (hide index.php)
 542:         //   RewriteCond %{REQUEST_FILENAME} !-f
 543:         //   RewriteRule ^(.*)$ index.php [QSA,L]
 544:         // http://host:8080/path/info?query=string
 545:         $server = array();
 546:         $server['HTTP_HOST'] = 'host:8080';
 547:         $server['SERVER_NAME'] = 'servername';
 548:         $server['SERVER_PORT'] = '8080';
 549: 
 550:         $server['REDIRECT_QUERY_STRING'] = 'query=string';
 551:         $server['REDIRECT_URL'] = '/path/info';
 552:         $server['SCRIPT_NAME'] = '/index.php';
 553:         $server['QUERY_STRING'] = 'query=string';
 554:         $server['REQUEST_URI'] = '/path/info?toto=test&1=1';
 555:         $server['SCRIPT_NAME'] = '/index.php';
 556:         $server['PHP_SELF'] = '/index.php';
 557:         $server['SCRIPT_FILENAME'] = '/some/where/index.php';
 558: 
 559:         $request->initialize(array(), array(), array(), array(), array(), $server);
 560:         $this->assertEquals('http://host:8080/some/path', $request->getUriForPath('/some/path'), '->getUri() with rewrite');
 561: 
 562:         // Use std port number
 563:         //  http://host/path/info?query=string
 564:         $server['HTTP_HOST'] = 'host';
 565:         $server['SERVER_NAME'] = 'servername';
 566:         $server['SERVER_PORT'] = '80';
 567: 
 568:         $request->initialize(array(), array(), array(), array(), array(), $server);
 569: 
 570:         $this->assertEquals('http://host/some/path', $request->getUriForPath('/some/path'), '->getUriForPath() with rewrite and default port');
 571: 
 572:         // Without HOST HEADER
 573:         unset($server['HTTP_HOST']);
 574:         $server['SERVER_NAME'] = 'servername';
 575:         $server['SERVER_PORT'] = '80';
 576: 
 577:         $request->initialize(array(), array(), array(), array(), array(), $server);
 578: 
 579:         $this->assertEquals('http://servername/some/path', $request->getUriForPath('/some/path'), '->getUriForPath() with rewrite, default port without HOST_HEADER');
 580:         $this->assertEquals('servername', $request->getHttpHost());
 581: 
 582:         // with user info
 583: 
 584:         $server['PHP_AUTH_USER'] = 'fabien';
 585:         $request->initialize(array(), array(), array(), array(), array(), $server);
 586:         $this->assertEquals('http://servername/some/path', $request->getUriForPath('/some/path'));
 587: 
 588:         $server['PHP_AUTH_PW'] = 'symfony';
 589:         $request->initialize(array(), array(), array(), array(), array(), $server);
 590:         $this->assertEquals('http://servername/some/path', $request->getUriForPath('/some/path'));
 591:     }
 592: 
 593:     /**
 594:      * @covers Symfony\Component\HttpFoundation\Request::getUserInfo
 595:      */
 596:     public function testGetUserInfo()
 597:     {
 598:         $request = new Request();
 599: 
 600:         $server['PHP_AUTH_USER'] = 'fabien';
 601:         $request->initialize(array(), array(), array(), array(), array(), $server);
 602:         $this->assertEquals('fabien', $request->getUserInfo());
 603: 
 604:         $server['PHP_AUTH_USER'] = '0';
 605:         $request->initialize(array(), array(), array(), array(), array(), $server);
 606:         $this->assertEquals('0', $request->getUserInfo());
 607: 
 608:         $server['PHP_AUTH_PW'] = '0';
 609:         $request->initialize(array(), array(), array(), array(), array(), $server);
 610:         $this->assertEquals('0:0', $request->getUserInfo());
 611:     }
 612: 
 613:     /**
 614:      * @covers Symfony\Component\HttpFoundation\Request::getSchemeAndHttpHost
 615:      */
 616:     public function testGetSchemeAndHttpHost()
 617:     {
 618:         $request = new Request();
 619: 
 620:         $server = array();
 621:         $server['SERVER_NAME'] = 'servername';
 622:         $server['SERVER_PORT'] = '90';
 623:         $request->initialize(array(), array(), array(), array(), array(), $server);
 624:         $this->assertEquals('http://servername:90', $request->getSchemeAndHttpHost());
 625: 
 626:         $server['PHP_AUTH_USER'] = 'fabien';
 627:         $request->initialize(array(), array(), array(), array(), array(), $server);
 628:         $this->assertEquals('http://servername:90', $request->getSchemeAndHttpHost());
 629: 
 630:         $server['PHP_AUTH_USER'] = '0';
 631:         $request->initialize(array(), array(), array(), array(), array(), $server);
 632:         $this->assertEquals('http://servername:90', $request->getSchemeAndHttpHost());
 633: 
 634:         $server['PHP_AUTH_PW'] = '0';
 635:         $request->initialize(array(), array(), array(), array(), array(), $server);
 636:         $this->assertEquals('http://servername:90', $request->getSchemeAndHttpHost());
 637:     }
 638: 
 639:     /**
 640:      * @covers Symfony\Component\HttpFoundation\Request::getQueryString
 641:      * @covers Symfony\Component\HttpFoundation\Request::normalizeQueryString
 642:      * @dataProvider getQueryStringNormalizationData
 643:      */
 644:     public function testGetQueryString($query, $expectedQuery, $msg)
 645:     {
 646:         $request = new Request();
 647: 
 648:         $request->server->set('QUERY_STRING', $query);
 649:         $this->assertSame($expectedQuery, $request->getQueryString(), $msg);
 650:     }
 651: 
 652:     public function getQueryStringNormalizationData()
 653:     {
 654:         return array(
 655:             array('foo', 'foo', 'works with valueless parameters'),
 656:             array('foo=', 'foo=', 'includes a dangling equal sign'),
 657:             array('bar=&foo=bar', 'bar=&foo=bar', '->works with empty parameters'),
 658:             array('foo=bar&bar=', 'bar=&foo=bar', 'sorts keys alphabetically'),
 659: 
 660:             // GET parameters, that are submitted from a HTML form, encode spaces as "+" by default (as defined in enctype application/x-www-form-urlencoded).
 661:             // PHP also converts "+" to spaces when filling the global _GET or when using the function parse_str.
 662:             array('him=John%20Doe&her=Jane+Doe', 'her=Jane%20Doe&him=John%20Doe', 'normalizes spaces in both encodings "%20" and "+"'),
 663: 
 664:             array('foo[]=1&foo[]=2', 'foo%5B%5D=1&foo%5B%5D=2', 'allows array notation'),
 665:             array('foo=1&foo=2', 'foo=1&foo=2', 'allows repeated parameters'),
 666:             array('pa%3Dram=foo%26bar%3Dbaz&test=test', 'pa%3Dram=foo%26bar%3Dbaz&test=test', 'works with encoded delimiters'),
 667:             array('0', '0', 'allows "0"'),
 668:             array('Jane Doe&John%20Doe', 'Jane%20Doe&John%20Doe', 'normalizes encoding in keys'),
 669:             array('her=Jane Doe&him=John%20Doe', 'her=Jane%20Doe&him=John%20Doe', 'normalizes encoding in values'),
 670:             array('foo=bar&&&test&&', 'foo=bar&test', 'removes unneeded delimiters'),
 671:             array('formula=e=m*c^2', 'formula=e%3Dm%2Ac%5E2', 'correctly treats only the first "=" as delimiter and the next as value'),
 672: 
 673:             // Ignore pairs with empty key, even if there was a value, e.g. "=value", as such nameless values cannot be retrieved anyway.
 674:             // PHP also does not include them when building _GET.
 675:             array('foo=bar&=a=b&=x=y', 'foo=bar', 'removes params with empty key'),
 676:         );
 677:     }
 678: 
 679:     public function testGetQueryStringReturnsNull()
 680:     {
 681:         $request = new Request();
 682: 
 683:         $this->assertNull($request->getQueryString(), '->getQueryString() returns null for non-existent query string');
 684: 
 685:         $request->server->set('QUERY_STRING', '');
 686:         $this->assertNull($request->getQueryString(), '->getQueryString() returns null for empty query string');
 687:     }
 688: 
 689:     public function testGetHost()
 690:     {
 691:         $request = new Request();
 692: 
 693:         $request->initialize(array('foo' => 'bar'));
 694:         $this->assertEquals('', $request->getHost(), '->getHost() return empty string if not initialized');
 695: 
 696:         $request->initialize(array(), array(), array(), array(), array(), array('HTTP_HOST' => 'www.example.com'));
 697:         $this->assertEquals('www.example.com', $request->getHost(), '->getHost() from Host Header');
 698: 
 699:         // Host header with port number
 700:         $request->initialize(array(), array(), array(), array(), array(), array('HTTP_HOST' => 'www.example.com:8080'));
 701:         $this->assertEquals('www.example.com', $request->getHost(), '->getHost() from Host Header with port number');
 702: 
 703:         // Server values
 704:         $request->initialize(array(), array(), array(), array(), array(), array('SERVER_NAME' => 'www.example.com'));
 705:         $this->assertEquals('www.example.com', $request->getHost(), '->getHost() from server name');
 706: 
 707:         $request->initialize(array(), array(), array(), array(), array(), array('SERVER_NAME' => 'www.example.com', 'HTTP_HOST' => 'www.host.com'));
 708:         $this->assertEquals('www.host.com', $request->getHost(), '->getHost() value from Host header has priority over SERVER_NAME ');
 709:     }
 710: 
 711:     public function testGetPort()
 712:     {
 713:         $request = Request::create('http://example.com', 'GET', array(), array(), array(), array(
 714:             'HTTP_X_FORWARDED_PROTO' => 'https',
 715:             'HTTP_X_FORWARDED_PORT' => '443',
 716:         ));
 717:         $port = $request->getPort();
 718: 
 719:         $this->assertEquals(80, $port, 'Without trusted proxies FORWARDED_PROTO and FORWARDED_PORT are ignored.');
 720: 
 721:         Request::setTrustedProxies(array('1.1.1.1'));
 722:         $request = Request::create('http://example.com', 'GET', array(), array(), array(), array(
 723:             'HTTP_X_FORWARDED_PROTO' => 'https',
 724:             'HTTP_X_FORWARDED_PORT' => '8443',
 725:         ));
 726:         $port = $request->getPort();
 727: 
 728:         $this->assertEquals(8443, $port, 'With PROTO and PORT set PORT takes precedence.');
 729: 
 730:         $request = Request::create('http://example.com', 'GET', array(), array(), array(), array(
 731:             'HTTP_X_FORWARDED_PROTO' => 'https',
 732:         ));
 733:         $port = $request->getPort();
 734: 
 735:         $this->assertEquals(443, $port, 'With only PROTO set getPort() defaults to 443.');
 736: 
 737:         $request = Request::create('http://example.com', 'GET', array(), array(), array(), array(
 738:             'HTTP_X_FORWARDED_PROTO' => 'http',
 739:         ));
 740:         $port = $request->getPort();
 741: 
 742:         $this->assertEquals(80, $port, 'If X_FORWARDED_PROTO is set to HTTP return 80.');
 743: 
 744:         $request = Request::create('http://example.com', 'GET', array(), array(), array(), array(
 745:             'HTTP_X_FORWARDED_PROTO' => 'On',
 746:         ));
 747:         $port = $request->getPort();
 748:         $this->assertEquals(443, $port, 'With only PROTO set and value is On, getPort() defaults to 443.');
 749: 
 750:         $request = Request::create('http://example.com', 'GET', array(), array(), array(), array(
 751:             'HTTP_X_FORWARDED_PROTO' => '1',
 752:         ));
 753:         $port = $request->getPort();
 754:         $this->assertEquals(443, $port, 'With only PROTO set and value is 1, getPort() defaults to 443.');
 755: 
 756:         $request = Request::create('http://example.com', 'GET', array(), array(), array(), array(
 757:             'HTTP_X_FORWARDED_PROTO' => 'something-else',
 758:         ));
 759:         $port = $request->getPort();
 760:         $this->assertEquals(80, $port, 'With only PROTO set and value is not recognized, getPort() defaults to 80.');
 761: 
 762:         Request::setTrustedProxies(array());
 763:     }
 764: 
 765:     /**
 766:      * @expectedException \RuntimeException
 767:      */
 768:     public function testGetHostWithFakeHttpHostValue()
 769:     {
 770:         $request = new Request();
 771:         $request->initialize(array(), array(), array(), array(), array(), array('HTTP_HOST' => 'www.host.com?query=string'));
 772:         $request->getHost();
 773:     }
 774: 
 775:     /**
 776:      * @covers Symfony\Component\HttpFoundation\Request::setMethod
 777:      * @covers Symfony\Component\HttpFoundation\Request::getMethod
 778:      */
 779:     public function testGetSetMethod()
 780:     {
 781:         $request = new Request();
 782: 
 783:         $this->assertEquals('GET', $request->getMethod(), '->getMethod() returns GET if no method is defined');
 784: 
 785:         $request->setMethod('get');
 786:         $this->assertEquals('GET', $request->getMethod(), '->getMethod() returns an uppercased string');
 787: 
 788:         $request->setMethod('PURGE');
 789:         $this->assertEquals('PURGE', $request->getMethod(), '->getMethod() returns the method even if it is not a standard one');
 790: 
 791:         $request->setMethod('POST');
 792:         $this->assertEquals('POST', $request->getMethod(), '->getMethod() returns the method POST if no _method is defined');
 793: 
 794:         $request->setMethod('POST');
 795:         $request->request->set('_method', 'purge');
 796:         $this->assertEquals('POST', $request->getMethod(), '->getMethod() does not return the method from _method if defined and POST but support not enabled');
 797: 
 798:         $request = new Request();
 799:         $request->setMethod('POST');
 800:         $request->request->set('_method', 'purge');
 801: 
 802:         $this->assertFalse(Request::getHttpMethodParameterOverride(), 'httpMethodParameterOverride should be disabled by default');
 803: 
 804:         Request::enableHttpMethodParameterOverride();
 805: 
 806:         $this->assertTrue(Request::getHttpMethodParameterOverride(), 'httpMethodParameterOverride should be enabled now but it is not');
 807: 
 808:         $this->assertEquals('PURGE', $request->getMethod(), '->getMethod() returns the method from _method if defined and POST');
 809:         $this->disableHttpMethodParameterOverride();
 810: 
 811:         $request = new Request();
 812:         $request->setMethod('POST');
 813:         $request->query->set('_method', 'purge');
 814:         $this->assertEquals('POST', $request->getMethod(), '->getMethod() does not return the method from _method if defined and POST but support not enabled');
 815: 
 816:         $request = new Request();
 817:         $request->setMethod('POST');
 818:         $request->query->set('_method', 'purge');
 819:         Request::enableHttpMethodParameterOverride();
 820:         $this->assertEquals('PURGE', $request->getMethod(), '->getMethod() returns the method from _method if defined and POST');
 821:         $this->disableHttpMethodParameterOverride();
 822: 
 823:         $request = new Request();
 824:         $request->setMethod('POST');
 825:         $request->headers->set('X-HTTP-METHOD-OVERRIDE', 'delete');
 826:         $this->assertEquals('DELETE', $request->getMethod(), '->getMethod() returns the method from X-HTTP-Method-Override even though _method is set if defined and POST');
 827: 
 828:         $request = new Request();
 829:         $request->setMethod('POST');
 830:         $request->headers->set('X-HTTP-METHOD-OVERRIDE', 'delete');
 831:         $this->assertEquals('DELETE', $request->getMethod(), '->getMethod() returns the method from X-HTTP-Method-Override if defined and POST');
 832:     }
 833: 
 834:     /**
 835:      * @dataProvider testGetClientIpsProvider
 836:      */
 837:     public function testGetClientIp($expected, $remoteAddr, $httpForwardedFor, $trustedProxies)
 838:     {
 839:         $request = $this->getRequestInstanceForClientIpTests($remoteAddr, $httpForwardedFor, $trustedProxies);
 840: 
 841:         $this->assertEquals($expected[0], $request->getClientIp());
 842: 
 843:         Request::setTrustedProxies(array());
 844:     }
 845: 
 846:     /**
 847:      * @dataProvider testGetClientIpsProvider
 848:      */
 849:     public function testGetClientIps($expected, $remoteAddr, $httpForwardedFor, $trustedProxies)
 850:     {
 851:         $request = $this->getRequestInstanceForClientIpTests($remoteAddr, $httpForwardedFor, $trustedProxies);
 852: 
 853:         $this->assertEquals($expected, $request->getClientIps());
 854: 
 855:         Request::setTrustedProxies(array());
 856:     }
 857: 
 858:     public function testGetClientIpsProvider()
 859:     {
 860:         //        $expected                   $remoteAddr                $httpForwardedFor            $trustedProxies
 861:         return array(
 862:             // simple IPv4
 863:             array(array('88.88.88.88'),              '88.88.88.88',              null,                        null),
 864:             // trust the IPv4 remote addr
 865:             array(array('88.88.88.88'),              '88.88.88.88',              null,                        array('88.88.88.88')),
 866: 
 867:             // simple IPv6
 868:             array(array('::1'),                      '::1',                      null,                        null),
 869:             // trust the IPv6 remote addr
 870:             array(array('::1'),                      '::1',                      null,                        array('::1')),
 871: 
 872:             // forwarded for with remote IPv4 addr not trusted
 873:             array(array('127.0.0.1'),                '127.0.0.1',                '88.88.88.88',               null),
 874:             // forwarded for with remote IPv4 addr trusted
 875:             array(array('88.88.88.88'),              '127.0.0.1',                '88.88.88.88',               array('127.0.0.1')),
 876:             // forwarded for with remote IPv4 and all FF addrs trusted
 877:             array(array('88.88.88.88'),              '127.0.0.1',                '88.88.88.88',               array('127.0.0.1', '88.88.88.88')),
 878:             // forwarded for with remote IPv4 range trusted
 879:             array(array('88.88.88.88'),              '123.45.67.89',             '88.88.88.88',               array('123.45.67.0/24')),
 880: 
 881:             // forwarded for with remote IPv6 addr not trusted
 882:             array(array('1620:0:1cfe:face:b00c::3'), '1620:0:1cfe:face:b00c::3', '2620:0:1cfe:face:b00c::3',  null),
 883:             // forwarded for with remote IPv6 addr trusted
 884:             array(array('2620:0:1cfe:face:b00c::3'), '1620:0:1cfe:face:b00c::3', '2620:0:1cfe:face:b00c::3',  array('1620:0:1cfe:face:b00c::3')),
 885:             // forwarded for with remote IPv6 range trusted
 886:             array(array('88.88.88.88'),              '2a01:198:603:0:396e:4789:8e99:890f', '88.88.88.88',     array('2a01:198:603:0::/65')),
 887: 
 888:             // multiple forwarded for with remote IPv4 addr trusted
 889:             array(array('88.88.88.88', '87.65.43.21', '127.0.0.1'), '123.45.67.89', '127.0.0.1, 87.65.43.21, 88.88.88.88', array('123.45.67.89')),
 890:             // multiple forwarded for with remote IPv4 addr and some reverse proxies trusted
 891:             array(array('87.65.43.21', '127.0.0.1'), '123.45.67.89',             '127.0.0.1, 87.65.43.21, 88.88.88.88', array('123.45.67.89', '88.88.88.88')),
 892:             // multiple forwarded for with remote IPv4 addr and some reverse proxies trusted but in the middle
 893:             array(array('88.88.88.88', '127.0.0.1'), '123.45.67.89',             '127.0.0.1, 87.65.43.21, 88.88.88.88', array('123.45.67.89', '87.65.43.21')),
 894:             // multiple forwarded for with remote IPv4 addr and all reverse proxies trusted
 895:             array(array('127.0.0.1'),                '123.45.67.89',             '127.0.0.1, 87.65.43.21, 88.88.88.88', array('123.45.67.89', '87.65.43.21', '88.88.88.88', '127.0.0.1')),
 896: 
 897:             // multiple forwarded for with remote IPv6 addr trusted
 898:             array(array('2620:0:1cfe:face:b00c::3', '3620:0:1cfe:face:b00c::3'), '1620:0:1cfe:face:b00c::3', '3620:0:1cfe:face:b00c::3,2620:0:1cfe:face:b00c::3', array('1620:0:1cfe:face:b00c::3')),
 899:             // multiple forwarded for with remote IPv6 addr and some reverse proxies trusted
 900:             array(array('3620:0:1cfe:face:b00c::3'), '1620:0:1cfe:face:b00c::3', '3620:0:1cfe:face:b00c::3,2620:0:1cfe:face:b00c::3', array('1620:0:1cfe:face:b00c::3', '2620:0:1cfe:face:b00c::3')),
 901:             // multiple forwarded for with remote IPv4 addr and some reverse proxies trusted but in the middle
 902:             array(array('2620:0:1cfe:face:b00c::3', '4620:0:1cfe:face:b00c::3'), '1620:0:1cfe:face:b00c::3', '4620:0:1cfe:face:b00c::3,3620:0:1cfe:face:b00c::3,2620:0:1cfe:face:b00c::3', array('1620:0:1cfe:face:b00c::3', '3620:0:1cfe:face:b00c::3')),
 903: 
 904:             // client IP with port
 905:             array(array('88.88.88.88'), '127.0.0.1', '88.88.88.88:12345, 127.0.0.1', array('127.0.0.1')),
 906:         );
 907:     }
 908: 
 909:     public function testGetContentWorksTwiceInDefaultMode()
 910:     {
 911:         $req = new Request();
 912:         $this->assertEquals('', $req->getContent());
 913:         $this->assertEquals('', $req->getContent());
 914:     }
 915: 
 916:     public function testGetContentReturnsResource()
 917:     {
 918:         $req = new Request();
 919:         $retval = $req->getContent(true);
 920:         $this->assertInternalType('resource', $retval);
 921:         $this->assertEquals("", fread($retval, 1));
 922:         $this->assertTrue(feof($retval));
 923:     }
 924: 
 925:     /**
 926:      * @expectedException \LogicException
 927:      * @dataProvider getContentCantBeCalledTwiceWithResourcesProvider
 928:      */
 929:     public function testGetContentCantBeCalledTwiceWithResources($first, $second)
 930:     {
 931:         $req = new Request();
 932:         $req->getContent($first);
 933:         $req->getContent($second);
 934:     }
 935: 
 936:     public function getContentCantBeCalledTwiceWithResourcesProvider()
 937:     {
 938:         return array(
 939:             'Resource then fetch' => array(true, false),
 940:             'Resource then resource' => array(true, true),
 941:             'Fetch then resource' => array(false, true),
 942:         );
 943:     }
 944: 
 945:     public function provideOverloadedMethods()
 946:     {
 947:         return array(
 948:             array('PUT'),
 949:             array('DELETE'),
 950:             array('PATCH'),
 951:             array('put'),
 952:             array('delete'),
 953:             array('patch'),
 954: 
 955:         );
 956:     }
 957: 
 958:     /**
 959:      * @dataProvider provideOverloadedMethods
 960:      */
 961:     public function testCreateFromGlobals($method)
 962:     {
 963:         $normalizedMethod = strtoupper($method);
 964: 
 965:         $_GET['foo1'] = 'bar1';
 966:         $_POST['foo2'] = 'bar2';
 967:         $_COOKIE['foo3'] = 'bar3';
 968:         $_FILES['foo4'] = array('bar4');
 969:         $_SERVER['foo5'] = 'bar5';
 970: 
 971:         $request = Request::createFromGlobals();
 972:         $this->assertEquals('bar1', $request->query->get('foo1'), '::fromGlobals() uses values from $_GET');
 973:         $this->assertEquals('bar2', $request->request->get('foo2'), '::fromGlobals() uses values from $_POST');
 974:         $this->assertEquals('bar3', $request->cookies->get('foo3'), '::fromGlobals() uses values from $_COOKIE');
 975:         $this->assertEquals(array('bar4'), $request->files->get('foo4'), '::fromGlobals() uses values from $_FILES');
 976:         $this->assertEquals('bar5', $request->server->get('foo5'), '::fromGlobals() uses values from $_SERVER');
 977: 
 978:         unset($_GET['foo1'], $_POST['foo2'], $_COOKIE['foo3'], $_FILES['foo4'], $_SERVER['foo5']);
 979: 
 980:         $_SERVER['REQUEST_METHOD'] = $method;
 981:         $_SERVER['CONTENT_TYPE'] = 'application/x-www-form-urlencoded';
 982:         $request = RequestContentProxy::createFromGlobals();
 983:         $this->assertEquals($normalizedMethod, $request->getMethod());
 984:         $this->assertEquals('mycontent', $request->request->get('content'));
 985: 
 986:         unset($_SERVER['REQUEST_METHOD'], $_SERVER['CONTENT_TYPE']);
 987: 
 988:         Request::createFromGlobals();
 989:         Request::enableHttpMethodParameterOverride();
 990:         $_POST['_method'] = $method;
 991:         $_POST['foo6'] = 'bar6';
 992:         $_SERVER['REQUEST_METHOD'] = 'PoSt';
 993:         $request = Request::createFromGlobals();
 994:         $this->assertEquals($normalizedMethod, $request->getMethod());
 995:         $this->assertEquals('POST', $request->getRealMethod());
 996:         $this->assertEquals('bar6', $request->request->get('foo6'));
 997: 
 998:         unset($_POST['_method'], $_POST['foo6'], $_SERVER['REQUEST_METHOD']);
 999:         $this->disableHttpMethodParameterOverride();
1000:     }
1001: 
1002:     public function testOverrideGlobals()
1003:     {
1004:         $request = new Request();
1005:         $request->initialize(array('foo' => 'bar'));
1006: 
1007:         // as the Request::overrideGlobals really work, it erase $_SERVER, so we must backup it
1008:         $server = $_SERVER;
1009: 
1010:         $request->overrideGlobals();
1011: 
1012:         $this->assertEquals(array('foo' => 'bar'), $_GET);
1013: 
1014:         $request->initialize(array(), array('foo' => 'bar'));
1015:         $request->overrideGlobals();
1016: 
1017:         $this->assertEquals(array('foo' => 'bar'), $_POST);
1018: 
1019:         $this->assertArrayNotHasKey('HTTP_X_FORWARDED_PROTO', $_SERVER);
1020: 
1021:         $request->headers->set('X_FORWARDED_PROTO', 'https');
1022: 
1023:         Request::setTrustedProxies(array('1.1.1.1'));
1024:         $this->assertTrue($request->isSecure());
1025:         Request::setTrustedProxies(array());
1026: 
1027:         $request->overrideGlobals();
1028: 
1029:         $this->assertArrayHasKey('HTTP_X_FORWARDED_PROTO', $_SERVER);
1030: 
1031:         $request->headers->set('CONTENT_TYPE', 'multipart/form-data');
1032:         $request->headers->set('CONTENT_LENGTH', 12345);
1033: 
1034:         $request->overrideGlobals();
1035: 
1036:         $this->assertArrayHasKey('CONTENT_TYPE', $_SERVER);
1037:         $this->assertArrayHasKey('CONTENT_LENGTH', $_SERVER);
1038: 
1039:         $request->initialize(array('foo' => 'bar', 'baz' => 'foo'));
1040:         $request->query->remove('baz');
1041: 
1042:         $request->overrideGlobals();
1043: 
1044:         $this->assertEquals(array('foo' => 'bar'), $_GET);
1045:         $this->assertEquals('foo=bar', $_SERVER['QUERY_STRING']);
1046:         $this->assertEquals('foo=bar', $request->server->get('QUERY_STRING'));
1047: 
1048:         // restore initial $_SERVER array
1049:         $_SERVER = $server;
1050:     }
1051: 
1052:     public function testGetScriptName()
1053:     {
1054:         $request = new Request();
1055:         $this->assertEquals('', $request->getScriptName());
1056: 
1057:         $server = array();
1058:         $server['SCRIPT_NAME'] = '/index.php';
1059: 
1060:         $request->initialize(array(), array(), array(), array(), array(), $server);
1061: 
1062:         $this->assertEquals('/index.php', $request->getScriptName());
1063: 
1064:         $server = array();
1065:         $server['ORIG_SCRIPT_NAME'] = '/frontend.php';
1066:         $request->initialize(array(), array(), array(), array(), array(), $server);
1067: 
1068:         $this->assertEquals('/frontend.php', $request->getScriptName());
1069: 
1070:         $server = array();
1071:         $server['SCRIPT_NAME'] = '/index.php';
1072:         $server['ORIG_SCRIPT_NAME'] = '/frontend.php';
1073:         $request->initialize(array(), array(), array(), array(), array(), $server);
1074: 
1075:         $this->assertEquals('/index.php', $request->getScriptName());
1076:     }
1077: 
1078:     public function testGetBasePath()
1079:     {
1080:         $request = new Request();
1081:         $this->assertEquals('', $request->getBasePath());
1082: 
1083:         $server = array();
1084:         $server['SCRIPT_FILENAME'] = '/some/where/index.php';
1085:         $request->initialize(array(), array(), array(), array(), array(), $server);
1086:         $this->assertEquals('', $request->getBasePath());
1087: 
1088:         $server = array();
1089:         $server['SCRIPT_FILENAME'] = '/some/where/index.php';
1090:         $server['SCRIPT_NAME'] = '/index.php';
1091:         $request->initialize(array(), array(), array(), array(), array(), $server);
1092: 
1093:         $this->assertEquals('', $request->getBasePath());
1094: 
1095:         $server = array();
1096:         $server['SCRIPT_FILENAME'] = '/some/where/index.php';
1097:         $server['PHP_SELF'] = '/index.php';
1098:         $request->initialize(array(), array(), array(), array(), array(), $server);
1099: 
1100:         $this->assertEquals('', $request->getBasePath());
1101: 
1102:         $server = array();
1103:         $server['SCRIPT_FILENAME'] = '/some/where/index.php';
1104:         $server['ORIG_SCRIPT_NAME'] = '/index.php';
1105:         $request->initialize(array(), array(), array(), array(), array(), $server);
1106: 
1107:         $this->assertEquals('', $request->getBasePath());
1108:     }
1109: 
1110:     public function testGetPathInfo()
1111:     {
1112:         $request = new Request();
1113:         $this->assertEquals('/', $request->getPathInfo());
1114: 
1115:         $server = array();
1116:         $server['REQUEST_URI'] = '/path/info';
1117:         $request->initialize(array(), array(), array(), array(), array(), $server);
1118: 
1119:         $this->assertEquals('/path/info', $request->getPathInfo());
1120: 
1121:         $server = array();
1122:         $server['REQUEST_URI'] = '/path%20test/info';
1123:         $request->initialize(array(), array(), array(), array(), array(), $server);
1124: 
1125:         $this->assertEquals('/path%20test/info', $request->getPathInfo());
1126:     }
1127: 
1128:     public function testGetPreferredLanguage()
1129:     {
1130:         $request = new Request();
1131:         $this->assertNull($request->getPreferredLanguage());
1132:         $this->assertNull($request->getPreferredLanguage(array()));
1133:         $this->assertEquals('fr', $request->getPreferredLanguage(array('fr')));
1134:         $this->assertEquals('fr', $request->getPreferredLanguage(array('fr', 'en')));
1135:         $this->assertEquals('en', $request->getPreferredLanguage(array('en', 'fr')));
1136:         $this->assertEquals('fr-ch', $request->getPreferredLanguage(array('fr-ch', 'fr-fr')));
1137: 
1138:         $request = new Request();
1139:         $request->headers->set('Accept-language', 'zh, en-us; q=0.8, en; q=0.6');
1140:         $this->assertEquals('en', $request->getPreferredLanguage(array('en', 'en-us')));
1141: 
1142:         $request = new Request();
1143:         $request->headers->set('Accept-language', 'zh, en-us; q=0.8, en; q=0.6');
1144:         $this->assertEquals('en', $request->getPreferredLanguage(array('fr', 'en')));
1145: 
1146:         $request = new Request();
1147:         $request->headers->set('Accept-language', 'zh, en-us; q=0.8');
1148:         $this->assertEquals('en', $request->getPreferredLanguage(array('fr', 'en')));
1149: 
1150:         $request = new Request();
1151:         $request->headers->set('Accept-language', 'zh, en-us; q=0.8, fr-fr; q=0.6, fr; q=0.5');
1152:         $this->assertEquals('en', $request->getPreferredLanguage(array('fr', 'en')));
1153:     }
1154: 
1155:     public function testIsXmlHttpRequest()
1156:     {
1157:         $request = new Request();
1158:         $this->assertFalse($request->isXmlHttpRequest());
1159: 
1160:         $request->headers->set('X-Requested-With', 'XMLHttpRequest');
1161:         $this->assertTrue($request->isXmlHttpRequest());
1162: 
1163:         $request->headers->remove('X-Requested-With');
1164:         $this->assertFalse($request->isXmlHttpRequest());
1165:     }
1166: 
1167:     public function testIntlLocale()
1168:     {
1169:         if (!extension_loaded('intl')) {
1170:             $this->markTestSkipped('The intl extension is needed to run this test.');
1171:         }
1172: 
1173:         $request = new Request();
1174: 
1175:         $request->setDefaultLocale('fr');
1176:         $this->assertEquals('fr', $request->getLocale());
1177:         $this->assertEquals('fr', \Locale::getDefault());
1178: 
1179:         $request->setLocale('en');
1180:         $this->assertEquals('en', $request->getLocale());
1181:         $this->assertEquals('en', \Locale::getDefault());
1182: 
1183:         $request->setDefaultLocale('de');
1184:         $this->assertEquals('en', $request->getLocale());
1185:         $this->assertEquals('en', \Locale::getDefault());
1186:     }
1187: 
1188:     public function testGetCharsets()
1189:     {
1190:         $request = new Request();
1191:         $this->assertEquals(array(), $request->getCharsets());
1192:         $request->headers->set('Accept-Charset', 'ISO-8859-1, US-ASCII, UTF-8; q=0.8, ISO-10646-UCS-2; q=0.6');
1193:         $this->assertEquals(array(), $request->getCharsets()); // testing caching
1194: 
1195:         $request = new Request();
1196:         $request->headers->set('Accept-Charset', 'ISO-8859-1, US-ASCII, UTF-8; q=0.8, ISO-10646-UCS-2; q=0.6');
1197:         $this->assertEquals(array('ISO-8859-1', 'US-ASCII', 'UTF-8', 'ISO-10646-UCS-2'), $request->getCharsets());
1198: 
1199:         $request = new Request();
1200:         $request->headers->set('Accept-Charset', 'ISO-8859-1,utf-8;q=0.7,*;q=0.7');
1201:         $this->assertEquals(array('ISO-8859-1', 'utf-8', '*'), $request->getCharsets());
1202:     }
1203: 
1204:     public function testGetEncodings()
1205:     {
1206:         $request = new Request();
1207:         $this->assertEquals(array(), $request->getEncodings());
1208:         $request->headers->set('Accept-Encoding', 'gzip,deflate,sdch');
1209:         $this->assertEquals(array(), $request->getEncodings()); // testing caching
1210: 
1211:         $request = new Request();
1212:         $request->headers->set('Accept-Encoding', 'gzip,deflate,sdch');
1213:         $this->assertEquals(array('gzip', 'deflate', 'sdch'), $request->getEncodings());
1214: 
1215:         $request = new Request();
1216:         $request->headers->set('Accept-Encoding', 'gzip;q=0.4,deflate;q=0.9,compress;q=0.7');
1217:         $this->assertEquals(array('deflate', 'compress', 'gzip'), $request->getEncodings());
1218:     }
1219: 
1220:     public function testGetAcceptableContentTypes()
1221:     {
1222:         $request = new Request();
1223:         $this->assertEquals(array(), $request->getAcceptableContentTypes());
1224:         $request->headers->set('Accept', 'application/vnd.wap.wmlscriptc, text/vnd.wap.wml, application/vnd.wap.xhtml+xml, application/xhtml+xml, text/html, multipart/mixed, */*');
1225:         $this->assertEquals(array(), $request->getAcceptableContentTypes()); // testing caching
1226: 
1227:         $request = new Request();
1228:         $request->headers->set('Accept', 'application/vnd.wap.wmlscriptc, text/vnd.wap.wml, application/vnd.wap.xhtml+xml, application/xhtml+xml, text/html, multipart/mixed, */*');
1229:         $this->assertEquals(array('application/vnd.wap.wmlscriptc', 'text/vnd.wap.wml', 'application/vnd.wap.xhtml+xml', 'application/xhtml+xml', 'text/html', 'multipart/mixed', '*/*'), $request->getAcceptableContentTypes());
1230:     }
1231: 
1232:     public function testGetLanguages()
1233:     {
1234:         $request = new Request();
1235:         $this->assertEquals(array(), $request->getLanguages());
1236: 
1237:         $request = new Request();
1238:         $request->headers->set('Accept-language', 'zh, en-us; q=0.8, en; q=0.6');
1239:         $this->assertEquals(array('zh', 'en_US', 'en'), $request->getLanguages());
1240:         $this->assertEquals(array('zh', 'en_US', 'en'), $request->getLanguages());
1241: 
1242:         $request = new Request();
1243:         $request->headers->set('Accept-language', 'zh, en-us; q=0.6, en; q=0.8');
1244:         $this->assertEquals(array('zh', 'en', 'en_US'), $request->getLanguages()); // Test out of order qvalues
1245: 
1246:         $request = new Request();
1247:         $request->headers->set('Accept-language', 'zh, en, en-us');
1248:         $this->assertEquals(array('zh', 'en', 'en_US'), $request->getLanguages()); // Test equal weighting without qvalues
1249: 
1250:         $request = new Request();
1251:         $request->headers->set('Accept-language', 'zh; q=0.6, en, en-us; q=0.6');
1252:         $this->assertEquals(array('en', 'zh', 'en_US'), $request->getLanguages()); // Test equal weighting with qvalues
1253: 
1254:         $request = new Request();
1255:         $request->headers->set('Accept-language', 'zh, i-cherokee; q=0.6');
1256:         $this->assertEquals(array('zh', 'cherokee'), $request->getLanguages());
1257:     }
1258: 
1259:     public function testGetRequestFormat()
1260:     {
1261:         $request = new Request();
1262:         $this->assertEquals('html', $request->getRequestFormat());
1263: 
1264:         $request = new Request();
1265:         $this->assertNull($request->getRequestFormat(null));
1266: 
1267:         $request = new Request();
1268:         $this->assertNull($request->setRequestFormat('foo'));
1269:         $this->assertEquals('foo', $request->getRequestFormat(null));
1270:     }
1271: 
1272:     public function testHasSession()
1273:     {
1274:         $request = new Request();
1275: 
1276:         $this->assertFalse($request->hasSession());
1277:         $request->setSession(new Session(new MockArraySessionStorage()));
1278:         $this->assertTrue($request->hasSession());
1279:     }
1280: 
1281:     public function testGetSession()
1282:     {
1283:         $request = new Request();
1284: 
1285:         $request->setSession(new Session(new MockArraySessionStorage()));
1286:         $this->assertTrue($request->hasSession());
1287: 
1288:         $session = $request->getSession();
1289:         $this->assertObjectHasAttribute('storage', $session);
1290:         $this->assertObjectHasAttribute('flashName', $session);
1291:         $this->assertObjectHasAttribute('attributeName', $session);
1292:     }
1293: 
1294:     public function testHasPreviousSession()
1295:     {
1296:         $request = new Request();
1297: 
1298:         $this->assertFalse($request->hasPreviousSession());
1299:         $request->cookies->set('MOCKSESSID', 'foo');
1300:         $this->assertFalse($request->hasPreviousSession());
1301:         $request->setSession(new Session(new MockArraySessionStorage()));
1302:         $this->assertTrue($request->hasPreviousSession());
1303:     }
1304: 
1305:     public function testToString()
1306:     {
1307:         $request = new Request();
1308: 
1309:         $request->headers->set('Accept-language', 'zh, en-us; q=0.8, en; q=0.6');
1310: 
1311:         $this->assertContains('Accept-Language: zh, en-us; q=0.8, en; q=0.6', $request->__toString());
1312:     }
1313: 
1314:     public function testIsMethod()
1315:     {
1316:         $request = new Request();
1317:         $request->setMethod('POST');
1318:         $this->assertTrue($request->isMethod('POST'));
1319:         $this->assertTrue($request->isMethod('post'));
1320:         $this->assertFalse($request->isMethod('GET'));
1321:         $this->assertFalse($request->isMethod('get'));
1322: 
1323:         $request->setMethod('GET');
1324:         $this->assertTrue($request->isMethod('GET'));
1325:         $this->assertTrue($request->isMethod('get'));
1326:         $this->assertFalse($request->isMethod('POST'));
1327:         $this->assertFalse($request->isMethod('post'));
1328:     }
1329: 
1330:     /**
1331:      * @dataProvider getBaseUrlData
1332:      */
1333:     public function testGetBaseUrl($uri, $server, $expectedBaseUrl, $expectedPathInfo)
1334:     {
1335:         $request = Request::create($uri, 'GET', array(), array(), array(), $server);
1336: 
1337:         $this->assertSame($expectedBaseUrl, $request->getBaseUrl(), 'baseUrl');
1338:         $this->assertSame($expectedPathInfo, $request->getPathInfo(), 'pathInfo');
1339:     }
1340: 
1341:     public function getBaseUrlData()
1342:     {
1343:         return array(
1344:             array(
1345:                 '/foo%20bar/',
1346:                 array(
1347:                     'SCRIPT_FILENAME' => '/home/John Doe/public_html/foo bar/app.php',
1348:                     'SCRIPT_NAME' => '/foo bar/app.php',
1349:                     'PHP_SELF' => '/foo bar/app.php',
1350:                 ),
1351:                 '/foo%20bar',
1352:                 '/',
1353:             ),
1354:             array(
1355:                 '/foo%20bar/home',
1356:                 array(
1357:                     'SCRIPT_FILENAME' => '/home/John Doe/public_html/foo bar/app.php',
1358:                     'SCRIPT_NAME' => '/foo bar/app.php',
1359:                     'PHP_SELF' => '/foo bar/app.php',
1360:                 ),
1361:                 '/foo%20bar',
1362:                 '/home',
1363:             ),
1364:             array(
1365:                 '/foo%20bar/app.php/home',
1366:                 array(
1367:                     'SCRIPT_FILENAME' => '/home/John Doe/public_html/foo bar/app.php',
1368:                     'SCRIPT_NAME' => '/foo bar/app.php',
1369:                     'PHP_SELF' => '/foo bar/app.php',
1370:                 ),
1371:                 '/foo%20bar/app.php',
1372:                 '/home',
1373:             ),
1374:             array(
1375:                 '/foo%20bar/app.php/home%3Dbaz',
1376:                 array(
1377:                     'SCRIPT_FILENAME' => '/home/John Doe/public_html/foo bar/app.php',
1378:                     'SCRIPT_NAME' => '/foo bar/app.php',
1379:                     'PHP_SELF' => '/foo bar/app.php',
1380:                 ),
1381:                 '/foo%20bar/app.php',
1382:                 '/home%3Dbaz',
1383:             ),
1384:             array(
1385:                 '/foo/bar+baz',
1386:                 array(
1387:                     'SCRIPT_FILENAME' => '/home/John Doe/public_html/foo/app.php',
1388:                     'SCRIPT_NAME' => '/foo/app.php',
1389:                     'PHP_SELF' => '/foo/app.php',
1390:                 ),
1391:                 '/foo',
1392:                 '/bar+baz',
1393:             ),
1394:         );
1395:     }
1396: 
1397:     /**
1398:      * @dataProvider urlencodedStringPrefixData
1399:      */
1400:     public function testUrlencodedStringPrefix($string, $prefix, $expect)
1401:     {
1402:         $request = new Request();
1403: 
1404:         $me = new \ReflectionMethod($request, 'getUrlencodedPrefix');
1405:         $me->setAccessible(true);
1406: 
1407:         $this->assertSame($expect, $me->invoke($request, $string, $prefix));
1408:     }
1409: 
1410:     public function urlencodedStringPrefixData()
1411:     {
1412:         return array(
1413:             array('foo', 'foo', 'foo'),
1414:             array('fo%6f', 'foo', 'fo%6f'),
1415:             array('foo/bar', 'foo', 'foo'),
1416:             array('fo%6f/bar', 'foo', 'fo%6f'),
1417:             array('f%6f%6f/bar', 'foo', 'f%6f%6f'),
1418:             array('%66%6F%6F/bar', 'foo', '%66%6F%6F'),
1419:             array('fo+o/bar', 'fo+o', 'fo+o'),
1420:             array('fo%2Bo/bar', 'fo+o', 'fo%2Bo'),
1421:         );
1422:     }
1423: 
1424:     private function disableHttpMethodParameterOverride()
1425:     {
1426:         $class = new \ReflectionClass('Symfony\\Component\\HttpFoundation\\Request');
1427:         $property = $class->getProperty('httpMethodParameterOverride');
1428:         $property->setAccessible(true);
1429:         $property->setValue(false);
1430:     }
1431: 
1432:     private function getRequestInstanceForClientIpTests($remoteAddr, $httpForwardedFor, $trustedProxies)
1433:     {
1434:         $request = new Request();
1435: 
1436:         $server = array('REMOTE_ADDR' => $remoteAddr);
1437:         if (null !== $httpForwardedFor) {
1438:             $server['HTTP_X_FORWARDED_FOR'] = $httpForwardedFor;
1439:         }
1440: 
1441:         if ($trustedProxies) {
1442:             Request::setTrustedProxies($trustedProxies);
1443:         }
1444: 
1445:         $request->initialize(array(), array(), array(), array(), array(), $server);
1446: 
1447:         return $request;
1448:     }
1449: 
1450:     public function testTrustedProxies()
1451:     {
1452:         $request = Request::create('http://example.com/');
1453:         $request->server->set('REMOTE_ADDR', '3.3.3.3');
1454:         $request->headers->set('X_FORWARDED_FOR', '1.1.1.1, 2.2.2.2');
1455:         $request->headers->set('X_FORWARDED_HOST', 'foo.example.com, real.example.com:8080');
1456:         $request->headers->set('X_FORWARDED_PROTO', 'https');
1457:         $request->headers->set('X_FORWARDED_PORT', 443);
1458:         $request->headers->set('X_MY_FOR', '3.3.3.3, 4.4.4.4');
1459:         $request->headers->set('X_MY_HOST', 'my.example.com');
1460:         $request->headers->set('X_MY_PROTO', 'http');
1461:         $request->headers->set('X_MY_PORT', 81);
1462: 
1463:         // no trusted proxies
1464:         $this->assertEquals('3.3.3.3', $request->getClientIp());
1465:         $this->assertEquals('example.com', $request->getHost());
1466:         $this->assertEquals(80, $request->getPort());
1467:         $this->assertFalse($request->isSecure());
1468: 
1469:         // disabling proxy trusting
1470:         Request::setTrustedProxies(array());
1471:         $this->assertEquals('3.3.3.3', $request->getClientIp());
1472:         $this->assertEquals('example.com', $request->getHost());
1473:         $this->assertEquals(80, $request->getPort());
1474:         $this->assertFalse($request->isSecure());
1475: 
1476:         // trusted proxy via setTrustedProxies()
1477:         Request::setTrustedProxies(array('3.3.3.3', '2.2.2.2'));
1478:         $this->assertEquals('1.1.1.1', $request->getClientIp());
1479:         $this->assertEquals('real.example.com', $request->getHost());
1480:         $this->assertEquals(443, $request->getPort());
1481:         $this->assertTrue($request->isSecure());
1482: 
1483:         // check various X_FORWARDED_PROTO header values
1484:         $request->headers->set('X_FORWARDED_PROTO', 'ssl');
1485:         $this->assertTrue($request->isSecure());
1486: 
1487:         $request->headers->set('X_FORWARDED_PROTO', 'https, http');
1488:         $this->assertTrue($request->isSecure());
1489: 
1490:         // custom header names
1491:         Request::setTrustedHeaderName(Request::HEADER_CLIENT_IP, 'X_MY_FOR');
1492:         Request::setTrustedHeaderName(Request::HEADER_CLIENT_HOST, 'X_MY_HOST');
1493:         Request::setTrustedHeaderName(Request::HEADER_CLIENT_PORT, 'X_MY_PORT');
1494:         Request::setTrustedHeaderName(Request::HEADER_CLIENT_PROTO, 'X_MY_PROTO');
1495:         $this->assertEquals('4.4.4.4', $request->getClientIp());
1496:         $this->assertEquals('my.example.com', $request->getHost());
1497:         $this->assertEquals(81, $request->getPort());
1498:         $this->assertFalse($request->isSecure());
1499: 
1500:         // disabling via empty header names
1501:         Request::setTrustedHeaderName(Request::HEADER_CLIENT_IP, null);
1502:         Request::setTrustedHeaderName(Request::HEADER_CLIENT_HOST, null);
1503:         Request::setTrustedHeaderName(Request::HEADER_CLIENT_PORT, null);
1504:         Request::setTrustedHeaderName(Request::HEADER_CLIENT_PROTO, null);
1505:         $this->assertEquals('3.3.3.3', $request->getClientIp());
1506:         $this->assertEquals('example.com', $request->getHost());
1507:         $this->assertEquals(80, $request->getPort());
1508:         $this->assertFalse($request->isSecure());
1509: 
1510:         // reset
1511:         Request::setTrustedProxies(array());
1512:         Request::setTrustedHeaderName(Request::HEADER_CLIENT_IP, 'X_FORWARDED_FOR');
1513:         Request::setTrustedHeaderName(Request::HEADER_CLIENT_HOST, 'X_FORWARDED_HOST');
1514:         Request::setTrustedHeaderName(Request::HEADER_CLIENT_PORT, 'X_FORWARDED_PORT');
1515:         Request::setTrustedHeaderName(Request::HEADER_CLIENT_PROTO, 'X_FORWARDED_PROTO');
1516:     }
1517: 
1518:     /**
1519:      * @expectedException \InvalidArgumentException
1520:      */
1521:     public function testSetTrustedProxiesInvalidHeaderName()
1522:     {
1523:         Request::create('http://example.com/');
1524:         Request::setTrustedHeaderName('bogus name', 'X_MY_FOR');
1525:     }
1526: 
1527:     /**
1528:      * @expectedException \InvalidArgumentException
1529:      */
1530:     public function testGetTrustedProxiesInvalidHeaderName()
1531:     {
1532:         Request::create('http://example.com/');
1533:         Request::getTrustedHeaderName('bogus name');
1534:     }
1535: 
1536:     /**
1537:      * @dataProvider iisRequestUriProvider
1538:      */
1539:     public function testIISRequestUri($headers, $server, $expectedRequestUri)
1540:     {
1541:         $request = new Request();
1542:         $request->headers->replace($headers);
1543:         $request->server->replace($server);
1544: 
1545:         $this->assertEquals($expectedRequestUri, $request->getRequestUri(), '->getRequestUri() is correct');
1546: 
1547:         $subRequestUri = '/bar/foo';
1548:         $subRequest = Request::create($subRequestUri, 'get', array(), array(), array(), $request->server->all());
1549:         $this->assertEquals($subRequestUri, $subRequest->getRequestUri(), '->getRequestUri() is correct in sub request');
1550:     }
1551: 
1552:     public function iisRequestUriProvider()
1553:     {
1554:         return array(
1555:             array(
1556:                 array(
1557:                     'X_ORIGINAL_URL' => '/foo/bar',
1558:                 ),
1559:                 array(),
1560:                 '/foo/bar',
1561:             ),
1562:             array(
1563:                 array(
1564:                     'X_REWRITE_URL' => '/foo/bar',
1565:                 ),
1566:                 array(),
1567:                 '/foo/bar',
1568:             ),
1569:             array(
1570:                 array(),
1571:                 array(
1572:                     'IIS_WasUrlRewritten' => '1',
1573:                     'UNENCODED_URL' => '/foo/bar',
1574:                 ),
1575:                 '/foo/bar',
1576:             ),
1577:             array(
1578:                 array(
1579:                     'X_ORIGINAL_URL' => '/foo/bar',
1580:                 ),
1581:                 array(
1582:                     'HTTP_X_ORIGINAL_URL' => '/foo/bar',
1583:                 ),
1584:                 '/foo/bar',
1585:             ),
1586:             array(
1587:                 array(
1588:                     'X_ORIGINAL_URL' => '/foo/bar',
1589:                 ),
1590:                 array(
1591:                     'IIS_WasUrlRewritten' => '1',
1592:                     'UNENCODED_URL' => '/foo/bar',
1593:                 ),
1594:                 '/foo/bar',
1595:             ),
1596:             array(
1597:                 array(
1598:                     'X_ORIGINAL_URL' => '/foo/bar',
1599:                 ),
1600:                 array(
1601:                     'HTTP_X_ORIGINAL_URL' => '/foo/bar',
1602:                     'IIS_WasUrlRewritten' => '1',
1603:                     'UNENCODED_URL' => '/foo/bar',
1604:                 ),
1605:                 '/foo/bar',
1606:             ),
1607:             array(
1608:                 array(),
1609:                 array(
1610:                     'ORIG_PATH_INFO' => '/foo/bar',
1611:                 ),
1612:                 '/foo/bar',
1613:             ),
1614:             array(
1615:                 array(),
1616:                 array(
1617:                     'ORIG_PATH_INFO' => '/foo/bar',
1618:                     'QUERY_STRING' => 'foo=bar',
1619:                 ),
1620:                 '/foo/bar?foo=bar',
1621:             ),
1622:         );
1623:     }
1624: 
1625:     public function testTrustedHosts()
1626:     {
1627:         // create a request
1628:         $request = Request::create('/');
1629: 
1630:         // no trusted host set -> no host check
1631:         $request->headers->set('host', 'evil.com');
1632:         $this->assertEquals('evil.com', $request->getHost());
1633: 
1634:         // add a trusted domain and all its subdomains
1635:         Request::setTrustedHosts(array('.*\.?trusted.com$'));
1636: 
1637:         // untrusted host
1638:         $request->headers->set('host', 'evil.com');
1639:         try {
1640:             $request->getHost();
1641:             $this->fail('Request::getHost() should throw an exception when host is not trusted.');
1642:         } catch (\UnexpectedValueException $e) {
1643:             $this->assertEquals('Untrusted Host "evil.com"', $e->getMessage());
1644:         }
1645: 
1646:         // trusted hosts
1647:         $request->headers->set('host', 'trusted.com');
1648:         $this->assertEquals('trusted.com', $request->getHost());
1649:         $this->assertEquals(80, $request->getPort());
1650: 
1651:         $request->server->set('HTTPS', true);
1652:         $request->headers->set('host', 'trusted.com');
1653:         $this->assertEquals('trusted.com', $request->getHost());
1654:         $this->assertEquals(443, $request->getPort());
1655:         $request->server->set('HTTPS', false);
1656: 
1657:         $request->headers->set('host', 'trusted.com:8000');
1658:         $this->assertEquals('trusted.com', $request->getHost());
1659:         $this->assertEquals(8000, $request->getPort());
1660: 
1661:         $request->headers->set('host', 'subdomain.trusted.com');
1662:         $this->assertEquals('subdomain.trusted.com', $request->getHost());
1663: 
1664:         // reset request for following tests
1665:         Request::setTrustedHosts(array());
1666:     }
1667: 
1668:     public function testFactory()
1669:     {
1670:         Request::setFactory(function (array $query = array(), array $request = array(), array $attributes = array(), array $cookies = array(), array $files = array(), array $server = array(), $content = null) {
1671:             return new NewRequest();
1672:         });
1673: 
1674:         $this->assertEquals('foo', Request::create('/')->getFoo());
1675: 
1676:         Request::setFactory(null);
1677:     }
1678: 
1679:     /**
1680:      * @dataProvider getLongHostNames
1681:      */
1682:     public function testVeryLongHosts($host)
1683:     {
1684:         $start = microtime(true);
1685: 
1686:         $request = Request::create('/');
1687:         $request->headers->set('host', $host);
1688:         $this->assertEquals($host, $request->getHost());
1689:         $this->assertLessThan(1, microtime(true) - $start);
1690:     }
1691: 
1692:     /**
1693:      * @dataProvider getHostValidities
1694:      */
1695:     public function testHostValidity($host, $isValid, $expectedHost = null, $expectedPort = null)
1696:     {
1697:         $request = Request::create('/');
1698:         $request->headers->set('host', $host);
1699: 
1700:         if ($isValid) {
1701:             $this->assertSame($expectedHost ?: $host, $request->getHost());
1702:             if ($expectedPort) {
1703:                 $this->assertSame($expectedPort, $request->getPort());
1704:             }
1705:         } else {
1706:             $this->setExpectedException('UnexpectedValueException', 'Invalid Host');
1707:             $request->getHost();
1708:         }
1709:     }
1710: 
1711:     public function getHostValidities()
1712:     {
1713:         return array(
1714:             array('.a', false),
1715:             array('a..', false),
1716:             array('a.', true),
1717:             array("\xE9", false),
1718:             array('[::1]', true),
1719:             array('[::1]:80', true, '[::1]', 80),
1720:             array(str_repeat('.', 101), false),
1721:         );
1722:     }
1723: 
1724:     public function getLongHostNames()
1725:     {
1726:         return array(
1727:             array('a'.str_repeat('.a', 40000)),
1728:             array(str_repeat(':', 101)),
1729:         );
1730:     }
1731: }
1732: 
1733: class RequestContentProxy extends Request
1734: {
1735:     public function getContent($asResource = false)
1736:     {
1737:         return http_build_query(array('_method' => 'PUT', 'content' => 'mycontent'));
1738:     }
1739: }
1740: 
1741: class NewRequest extends Request
1742: {
1743:     public function getFoo()
1744:     {
1745:         return 'foo';
1746:     }
1747: }
1748: