Merge branch '2.3'

* 2.3: (33 commits)
  Revert "[Console] ensure exit code between 0-254"
  Added missing galician (gl) translations
  fix many-to-many Propel1 ModelChoiceList
  [Console] ensure exit code between 0-254
  Added Greek translation
  [DomCrawler] Fixed a fatal error when setting a value in a malformed field name.
  [FrameworkBundle] Fixed OutOfBoundException when session handler_id is null
  [DependencyInjection] Add support for aliases of aliases + regression test
  [Console] fix status code when Exception::getCode returns something like 0.1
  Fixed doc block on Filesystem::rename
  Fixed exit code for exceptions with error code 0
  [DependencyInjection] Rename ContainerBuilder::$aliases to avoid conflicting with the parent class
  [DependencyInjection] Remove get*Alias*Service methods from compiled containers
  [DependencyInjection] Fix aliased access of shared services, fixes #8096
  instantiate valid commands only
  bumped Symfony version to -DEV
  updated VERSION for 2.3.0
  updated CHANGELOG for 2.3.0
  [Config] Added tests for the FileResource and DirectoryResource.
  [Config] Fixed @covers annotation which ignored some of the methods from the code coverage.
  ...

Conflicts:
	src/Symfony/Component/HttpKernel/Kernel.php

1 files changed, 127 insertions, 18 deletions

diff --git a/Tests/Http/HttpUtilsTest.php b/Tests/Http/HttpUtilsTest.php
index bf078da..db1aa4b 100644
--- a/Tests/Http/HttpUtilsTest.php
+++ b/Tests/Http/HttpUtilsTest.php
@@ -12,8 +12,10 @@
 namespace Symfony\Component\Security\Tests\Http;
 
 use Symfony\Component\HttpFoundation\Request;
-use Symfony\Component\Security\Http\HttpUtils;
+use Symfony\Component\Routing\Exception\MethodNotAllowedException;
 use Symfony\Component\Routing\Exception\ResourceNotFoundException;
+use Symfony\Component\Security\Core\SecurityContextInterface;
+use Symfony\Component\Security\Http\HttpUtils;
 
 class HttpUtilsTest extends \PHPUnit_Framework_TestCase
 {
@@ -28,21 +30,27 @@ class HttpUtilsTest extends \PHPUnit_Framework_TestCase
         }
     }
 
-    public function testCreateRedirectResponse()
+    public function testCreateRedirectResponseWithPath()
     {
         $utils = new HttpUtils($this->getUrlGenerator());
-
-        // absolute path
         $response = $utils->createRedirectResponse($this->getRequest(), '/foobar');
+
         $this->assertTrue($response->isRedirect('http://localhost/foobar'));
         $this->assertEquals(302, $response->getStatusCode());
+    }
 
-        // absolute URL
+    public function testCreateRedirectResponseWithAbsoluteUrl()
+    {
+        $utils = new HttpUtils($this->getUrlGenerator());
         $response = $utils->createRedirectResponse($this->getRequest(), 'http://symfony.com/');
+
         $this->assertTrue($response->isRedirect('http://symfony.com/'));
+    }
 
-        // route name
+    public function testCreateRedirectResponseWithRouteName()
+    {
         $utils = new HttpUtils($urlGenerator = $this->getMock('Symfony\Component\Routing\Generator\UrlGeneratorInterface'));
+
         $urlGenerator
             ->expects($this->any())
             ->method('generate')
@@ -54,25 +62,29 @@ class HttpUtilsTest extends \PHPUnit_Framework_TestCase
             ->method('getContext')
             ->will($this->returnValue($this->getMock('Symfony\Component\Routing\RequestContext')))
         ;
+
         $response = $utils->createRedirectResponse($this->getRequest(), 'foobar');
+
         $this->assertTrue($response->isRedirect('http://localhost/foo/bar'));
     }
 
-    public function testCreateRequest()
+    public function testCreateRequestWithPath()
     {
-        $utils = new HttpUtils($this->getUrlGenerator());
-
-        // absolute path
         $request = $this->getRequest();
         $request->server->set('Foo', 'bar');
+
+        $utils = new HttpUtils($this->getUrlGenerator());
         $subRequest = $utils->createRequest($request, '/foobar');
 
         $this->assertEquals('GET', $subRequest->getMethod());
         $this->assertEquals('/foobar', $subRequest->getPathInfo());
         $this->assertEquals('bar', $subRequest->server->get('Foo'));
+    }
 
-        // route name
+    public function testCreateRequestWithRouteName()
+    {
         $utils = new HttpUtils($urlGenerator = $this->getMock('Symfony\Component\Routing\Generator\UrlGeneratorInterface'));
+
         $urlGenerator
             ->expects($this->once())
             ->method('generate')
@@ -83,14 +95,54 @@ class HttpUtilsTest extends \PHPUnit_Framework_TestCase
             ->method('getContext')
             ->will($this->returnValue($this->getMock('Symfony\Component\Routing\RequestContext')))
         ;
+
         $subRequest = $utils->createRequest($this->getRequest(), 'foobar');
+
         $this->assertEquals('/foo/bar', $subRequest->getPathInfo());
+    }
 
-        // absolute URL
+    public function testCreateRequestWithAbsoluteUrl()
+    {
+        $utils = new HttpUtils($this->getMock('Symfony\Component\Routing\Generator\UrlGeneratorInterface'));
         $subRequest = $utils->createRequest($this->getRequest(), 'http://symfony.com/');
+
         $this->assertEquals('/', $subRequest->getPathInfo());
     }
 
+    public function testCreateRequestPassesSessionToTheNewRequest()
+    {
+        $request = $this->getRequest();
+        $request->setSession($session = $this->getMock('Symfony\Component\HttpFoundation\Session\SessionInterface'));
+
+        $utils = new HttpUtils($this->getUrlGenerator());
+        $subRequest = $utils->createRequest($request, '/foobar');
+
+        $this->assertSame($session, $subRequest->getSession());
+    }
+
+    /**
+     * @dataProvider provideSecurityContextAttributes
+     */
+    public function testCreateRequestPassesSecurityContextAttributesToTheNewRequest($attribute)
+    {
+        $request = $this->getRequest();
+        $request->attributes->set($attribute, 'foo');
+
+        $utils = new HttpUtils($this->getUrlGenerator());
+        $subRequest = $utils->createRequest($request, '/foobar');
+
+        $this->assertSame('foo', $subRequest->attributes->get($attribute));
+    }
+
+    public function provideSecurityContextAttributes()
+    {
+        return array(
+            array(SecurityContextInterface::AUTHENTICATION_ERROR),
+            array(SecurityContextInterface::ACCESS_DENIED_ERROR),
+            array(SecurityContextInterface::LAST_USERNAME)
+        );
+    }
+
     public function testCheckRequestPath()
     {
         $utils = new HttpUtils($this->getUrlGenerator());
@@ -102,26 +154,66 @@ class HttpUtilsTest extends \PHPUnit_Framework_TestCase
         $this->assertTrue($utils->checkRequestPath($this->getRequest('/foo+bar'), '/foo+bar'));
         // Checking unicode
         $this->assertTrue($utils->checkRequestPath($this->getRequest(urlencode('/вход')), '/вход'));
+    }
 
+    public function testCheckRequestPathWithUrlMatcherAndResourceNotFound()
+    {
         $urlMatcher = $this->getMock('Symfony\Component\Routing\Matcher\UrlMatcherInterface');
         $urlMatcher
             ->expects($this->any())
             ->method('match')
+            ->with('/')
             ->will($this->throwException(new ResourceNotFoundException()))
         ;
+
         $utils = new HttpUtils(null, $urlMatcher);
         $this->assertFalse($utils->checkRequestPath($this->getRequest(), 'foobar'));
+    }
 
+    public function testCheckRequestPathWithUrlMatcherAndMethodNotAllowed()
+    {
+        $request = $this->getRequest();
+        $urlMatcher = $this->getMock('Symfony\Component\Routing\Matcher\RequestMatcherInterface');
+        $urlMatcher
+            ->expects($this->any())
+            ->method('matchRequest')
+            ->with($request)
+            ->will($this->throwException(new MethodNotAllowedException(array())))
+        ;
+
+        $utils = new HttpUtils(null, $urlMatcher);
+        $this->assertFalse($utils->checkRequestPath($request, 'foobar'));
+    }
+
+    public function testCheckRequestPathWithUrlMatcherAndResourceFoundByUrl()
+    {
         $urlMatcher = $this->getMock('Symfony\Component\Routing\Matcher\UrlMatcherInterface');
         $urlMatcher
             ->expects($this->any())
             ->method('match')
+            ->with('/foo/bar')
             ->will($this->returnValue(array('_route' => 'foobar')))
         ;
+
         $utils = new HttpUtils(null, $urlMatcher);
         $this->assertTrue($utils->checkRequestPath($this->getRequest('/foo/bar'), 'foobar'));
     }
 
+    public function testCheckRequestPathWithUrlMatcherAndResourceFoundByRequest()
+    {
+        $request = $this->getRequest();
+        $urlMatcher = $this->getMock('Symfony\Component\Routing\Matcher\RequestMatcherInterface');
+        $urlMatcher
+            ->expects($this->any())
+            ->method('matchRequest')
+            ->with($request)
+            ->will($this->returnValue(array('_route' => 'foobar')))
+        ;
+
+        $utils = new HttpUtils(null, $urlMatcher);
+        $this->assertTrue($utils->checkRequestPath($request, 'foobar'));
+    }
+
     /**
      * @expectedException \RuntimeException
      */
@@ -133,20 +225,37 @@ class HttpUtilsTest extends \PHPUnit_Framework_TestCase
             ->method('match')
             ->will($this->throwException(new \RuntimeException()))
         ;
+
         $utils = new HttpUtils(null, $urlMatcher);
         $utils->checkRequestPath($this->getRequest(), 'foobar');
     }
 
-    public function testGenerateUriRemovesQueryString()
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage Matcher must either implement UrlMatcherInterface or RequestMatcherInterface
+     */
+    public function testUrlMatcher()
     {
-        $method = new \ReflectionMethod('Symfony\Component\Security\Http\HttpUtils', 'generateUri');
-        $method->setAccessible(true);
+        new HttpUtils($this->getUrlGenerator(), new \stdClass());
+    }
 
-        $utils = new HttpUtils($this->getUrlGenerator());
-        $this->assertEquals('/foo/bar', $method->invoke($utils, new Request(), 'route_name'));
+    public function testGenerateUriRemovesQueryString()
+    {
+        $utils = new HttpUtils($this->getUrlGenerator('/foo/bar'));
+        $this->assertEquals('/foo/bar', $utils->generateUri(new Request(), 'route_name'));
 
         $utils = new HttpUtils($this->getUrlGenerator('/foo/bar?param=value'));
-        $this->assertEquals('/foo/bar', $method->invoke($utils, new Request(), 'route_name'));
+        $this->assertEquals('/foo/bar', $utils->generateUri(new Request(), 'route_name'));
+    }
+
+    /**
+     * @expectedException \LogicException
+     * @expectedExceptionMessage You must provide a UrlGeneratorInterface instance to be able to use routes.
+     */
+    public function testUrlGeneratorIsRequiredToGenerateUrl()
+    {
+        $utils = new HttpUtils();
+        $utils->generateUri(new Request(), 'route_name');
     }
 
     private function getUrlGenerator($generatedUrl = '/foo/bar')