www.aleph1.co.uk Git - yaffs-website/blob - vendor/symfony/http-kernel/Tests/Controller/ControllerResolverTest.php

   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\HttpKernel\Tests\Controller;
  13
  14 use PHPUnit\Framework\TestCase;
  15 use Psr\Log\LoggerInterface;
  16 use Symfony\Component\HttpFoundation\Request;
  17 use Symfony\Component\HttpKernel\Controller\ControllerResolver;
  18 use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\NullableController;
  19 use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\VariadicController;
  20
  21 class ControllerResolverTest extends TestCase
  22 {
  23     public function testGetControllerWithoutControllerParameter()
  24     {
  25         $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
  26         $logger->expects($this->once())->method('warning')->with('Unable to look for the controller as the "_controller" parameter is missing.');
  27         $resolver = $this->createControllerResolver($logger);
  28
  29         $request = Request::create('/');
  30         $this->assertFalse($resolver->getController($request), '->getController() returns false when the request has no _controller attribute');
  31     }
  32
  33     public function testGetControllerWithLambda()
  34     {
  35         $resolver = $this->createControllerResolver();
  36
  37         $request = Request::create('/');
  38         $request->attributes->set('_controller', $lambda = function () {});
  39         $controller = $resolver->getController($request);
  40         $this->assertSame($lambda, $controller);
  41     }
  42
  43     public function testGetControllerWithObjectAndInvokeMethod()
  44     {
  45         $resolver = $this->createControllerResolver();
  46
  47         $request = Request::create('/');
  48         $request->attributes->set('_controller', $this);
  49         $controller = $resolver->getController($request);
  50         $this->assertSame($this, $controller);
  51     }
  52
  53     public function testGetControllerWithObjectAndMethod()
  54     {
  55         $resolver = $this->createControllerResolver();
  56
  57         $request = Request::create('/');
  58         $request->attributes->set('_controller', array($this, 'controllerMethod1'));
  59         $controller = $resolver->getController($request);
  60         $this->assertSame(array($this, 'controllerMethod1'), $controller);
  61     }
  62
  63     public function testGetControllerWithClassAndMethod()
  64     {
  65         $resolver = $this->createControllerResolver();
  66
  67         $request = Request::create('/');
  68         $request->attributes->set('_controller', array('Symfony\Component\HttpKernel\Tests\Controller\ControllerResolverTest', 'controllerMethod4'));
  69         $controller = $resolver->getController($request);
  70         $this->assertSame(array('Symfony\Component\HttpKernel\Tests\Controller\ControllerResolverTest', 'controllerMethod4'), $controller);
  71     }
  72
  73     public function testGetControllerWithObjectAndMethodAsString()
  74     {
  75         $resolver = $this->createControllerResolver();
  76
  77         $request = Request::create('/');
  78         $request->attributes->set('_controller', 'Symfony\Component\HttpKernel\Tests\Controller\ControllerResolverTest::controllerMethod1');
  79         $controller = $resolver->getController($request);
  80         $this->assertInstanceOf('Symfony\Component\HttpKernel\Tests\Controller\ControllerResolverTest', $controller[0], '->getController() returns a PHP callable');
  81     }
  82
  83     public function testGetControllerWithClassAndInvokeMethod()
  84     {
  85         $resolver = $this->createControllerResolver();
  86
  87         $request = Request::create('/');
  88         $request->attributes->set('_controller', 'Symfony\Component\HttpKernel\Tests\Controller\ControllerResolverTest');
  89         $controller = $resolver->getController($request);
  90         $this->assertInstanceOf('Symfony\Component\HttpKernel\Tests\Controller\ControllerResolverTest', $controller);
  91     }
  92
  93     /**
  94      * @expectedException \InvalidArgumentException
  95      */
  96     public function testGetControllerOnObjectWithoutInvokeMethod()
  97     {
  98         $resolver = $this->createControllerResolver();
  99
 100         $request = Request::create('/');
 101         $request->attributes->set('_controller', new \stdClass());
 102         $resolver->getController($request);
 103     }
 104
 105     public function testGetControllerWithFunction()
 106     {
 107         $resolver = $this->createControllerResolver();
 108
 109         $request = Request::create('/');
 110         $request->attributes->set('_controller', 'Symfony\Component\HttpKernel\Tests\Controller\some_controller_function');
 111         $controller = $resolver->getController($request);
 112         $this->assertSame('Symfony\Component\HttpKernel\Tests\Controller\some_controller_function', $controller);
 113     }
 114
 115     /**
 116      * @dataProvider getUndefinedControllers
 117      */
 118     public function testGetControllerOnNonUndefinedFunction($controller, $exceptionName = null, $exceptionMessage = null)
 119     {
 120         $resolver = $this->createControllerResolver();
 121         if (method_exists($this, 'expectException')) {
 122             $this->expectException($exceptionName);
 123             $this->expectExceptionMessage($exceptionMessage);
 124         } else {
 125             $this->setExpectedException($exceptionName, $exceptionMessage);
 126         }
 127
 128         $request = Request::create('/');
 129         $request->attributes->set('_controller', $controller);
 130         $resolver->getController($request);
 131     }
 132
 133     public function getUndefinedControllers()
 134     {
 135         return array(
 136             array(1, 'InvalidArgumentException', 'Unable to find controller "1".'),
 137             array('foo', 'InvalidArgumentException', 'Unable to find controller "foo".'),
 138             array('oof::bar', 'InvalidArgumentException', 'Class "oof" does not exist.'),
 139             array('stdClass', 'InvalidArgumentException', 'Unable to find controller "stdClass".'),
 140             array('Symfony\Component\HttpKernel\Tests\Controller\ControllerTest::staticsAction', 'InvalidArgumentException', 'The controller for URI "/" is not callable. Expected method "staticsAction" on class "Symfony\Component\HttpKernel\Tests\Controller\ControllerTest", did you mean "staticAction"?'),
 141             array('Symfony\Component\HttpKernel\Tests\Controller\ControllerTest::privateAction', 'InvalidArgumentException', 'The controller for URI "/" is not callable. Method "privateAction" on class "Symfony\Component\HttpKernel\Tests\Controller\ControllerTest" should be public and non-abstract'),
 142             array('Symfony\Component\HttpKernel\Tests\Controller\ControllerTest::protectedAction', 'InvalidArgumentException', 'The controller for URI "/" is not callable. Method "protectedAction" on class "Symfony\Component\HttpKernel\Tests\Controller\ControllerTest" should be public and non-abstract'),
 143             array('Symfony\Component\HttpKernel\Tests\Controller\ControllerTest::undefinedAction', 'InvalidArgumentException', 'The controller for URI "/" is not callable. Expected method "undefinedAction" on class "Symfony\Component\HttpKernel\Tests\Controller\ControllerTest". Available methods: "publicAction", "staticAction"'),
 144         );
 145     }
 146
 147     /**
 148      * @group legacy
 149      */
 150     public function testGetArguments()
 151     {
 152         $resolver = $this->createControllerResolver();
 153
 154         $request = Request::create('/');
 155         $controller = array(new self(), 'testGetArguments');
 156         $this->assertEquals(array(), $resolver->getArguments($request, $controller), '->getArguments() returns an empty array if the method takes no arguments');
 157
 158         $request = Request::create('/');
 159         $request->attributes->set('foo', 'foo');
 160         $controller = array(new self(), 'controllerMethod1');
 161         $this->assertEquals(array('foo'), $resolver->getArguments($request, $controller), '->getArguments() returns an array of arguments for the controller method');
 162
 163         $request = Request::create('/');
 164         $request->attributes->set('foo', 'foo');
 165         $controller = array(new self(), 'controllerMethod2');
 166         $this->assertEquals(array('foo', null), $resolver->getArguments($request, $controller), '->getArguments() uses default values if present');
 167
 168         $request->attributes->set('bar', 'bar');
 169         $this->assertEquals(array('foo', 'bar'), $resolver->getArguments($request, $controller), '->getArguments() overrides default values if provided in the request attributes');
 170
 171         $request = Request::create('/');
 172         $request->attributes->set('foo', 'foo');
 173         $controller = function ($foo) {};
 174         $this->assertEquals(array('foo'), $resolver->getArguments($request, $controller));
 175
 176         $request = Request::create('/');
 177         $request->attributes->set('foo', 'foo');
 178         $controller = function ($foo, $bar = 'bar') {};
 179         $this->assertEquals(array('foo', 'bar'), $resolver->getArguments($request, $controller));
 180
 181         $request = Request::create('/');
 182         $request->attributes->set('foo', 'foo');
 183         $controller = new self();
 184         $this->assertEquals(array('foo', null), $resolver->getArguments($request, $controller));
 185         $request->attributes->set('bar', 'bar');
 186         $this->assertEquals(array('foo', 'bar'), $resolver->getArguments($request, $controller));
 187
 188         $request = Request::create('/');
 189         $request->attributes->set('foo', 'foo');
 190         $request->attributes->set('foobar', 'foobar');
 191         $controller = 'Symfony\Component\HttpKernel\Tests\Controller\some_controller_function';
 192         $this->assertEquals(array('foo', 'foobar'), $resolver->getArguments($request, $controller));
 193
 194         $request = Request::create('/');
 195         $request->attributes->set('foo', 'foo');
 196         $request->attributes->set('foobar', 'foobar');
 197         $controller = array(new self(), 'controllerMethod3');
 198
 199         try {
 200             $resolver->getArguments($request, $controller);
 201             $this->fail('->getArguments() throws a \RuntimeException exception if it cannot determine the argument value');
 202         } catch (\Exception $e) {
 203             $this->assertInstanceOf('\RuntimeException', $e, '->getArguments() throws a \RuntimeException exception if it cannot determine the argument value');
 204         }
 205
 206         $request = Request::create('/');
 207         $controller = array(new self(), 'controllerMethod5');
 208         $this->assertEquals(array($request), $resolver->getArguments($request, $controller), '->getArguments() injects the request');
 209     }
 210
 211     /**
 212      * @requires PHP 5.6
 213      * @group legacy
 214      */
 215     public function testGetVariadicArguments()
 216     {
 217         $resolver = new ControllerResolver();
 218
 219         $request = Request::create('/');
 220         $request->attributes->set('foo', 'foo');
 221         $request->attributes->set('bar', array('foo', 'bar'));
 222         $controller = array(new VariadicController(), 'action');
 223         $this->assertEquals(array('foo', 'foo', 'bar'), $resolver->getArguments($request, $controller));
 224     }
 225
 226     public function testCreateControllerCanReturnAnyCallable()
 227     {
 228         $mock = $this->getMockBuilder('Symfony\Component\HttpKernel\Controller\ControllerResolver')->setMethods(array('createController'))->getMock();
 229         $mock->expects($this->once())->method('createController')->will($this->returnValue('Symfony\Component\HttpKernel\Tests\Controller\some_controller_function'));
 230
 231         $request = Request::create('/');
 232         $request->attributes->set('_controller', 'foobar');
 233         $mock->getController($request);
 234     }
 235
 236     /**
 237      * @expectedException \RuntimeException
 238      * @group legacy
 239      */
 240     public function testIfExceptionIsThrownWhenMissingAnArgument()
 241     {
 242         $resolver = new ControllerResolver();
 243         $request = Request::create('/');
 244
 245         $controller = array($this, 'controllerMethod1');
 246
 247         $resolver->getArguments($request, $controller);
 248     }
 249
 250     /**
 251      * @requires PHP 7.1
 252      * @group legacy
 253      */
 254     public function testGetNullableArguments()
 255     {
 256         $resolver = new ControllerResolver();
 257
 258         $request = Request::create('/');
 259         $request->attributes->set('foo', 'foo');
 260         $request->attributes->set('bar', new \stdClass());
 261         $request->attributes->set('mandatory', 'mandatory');
 262         $controller = array(new NullableController(), 'action');
 263         $this->assertEquals(array('foo', new \stdClass(), 'value', 'mandatory'), $resolver->getArguments($request, $controller));
 264     }
 265
 266     /**
 267      * @requires PHP 7.1
 268      * @group legacy
 269      */
 270     public function testGetNullableArgumentsWithDefaults()
 271     {
 272         $resolver = new ControllerResolver();
 273
 274         $request = Request::create('/');
 275         $request->attributes->set('mandatory', 'mandatory');
 276         $controller = array(new NullableController(), 'action');
 277         $this->assertEquals(array(null, null, 'value', 'mandatory'), $resolver->getArguments($request, $controller));
 278     }
 279
 280     protected function createControllerResolver(LoggerInterface $logger = null)
 281     {
 282         return new ControllerResolver($logger);
 283     }
 284
 285     public function __invoke($foo, $bar = null)
 286     {
 287     }
 288
 289     public function controllerMethod1($foo)
 290     {
 291     }
 292
 293     protected function controllerMethod2($foo, $bar = null)
 294     {
 295     }
 296
 297     protected function controllerMethod3($foo, $bar, $foobar)
 298     {
 299     }
 300
 301     protected static function controllerMethod4()
 302     {
 303     }
 304
 305     protected function controllerMethod5(Request $request)
 306     {
 307     }
 308 }
 309
 310 function some_controller_function($foo, $foobar)
 311 {
 312 }
 313
 314 class ControllerTest
 315 {
 316     public function publicAction()
 317     {
 318     }
 319
 320     private function privateAction()
 321     {
 322     }
 323
 324     protected function protectedAction()
 325     {
 326     }
 327
 328     public static function staticAction()
 329     {
 330     }
 331 }