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\HttpKernel\Controller\ControllerResolver;
  17 use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\NullableController;
  18 use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\VariadicController;
  19 use Symfony\Component\HttpFoundation\Request;
  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      * @expectedException \InvalidArgumentException
 118      */
 119     public function testGetControllerOnNonUndefinedFunction($controller)
 120     {
 121         $resolver = $this->createControllerResolver();
 122
 123         $request = Request::create('/');
 124         $request->attributes->set('_controller', $controller);
 125         $resolver->getController($request);
 126     }
 127
 128     public function getUndefinedControllers()
 129     {
 130         return array(
 131             array('foo'),
 132             array('oof::bar'),
 133             array('stdClass'),
 134             array('Symfony\Component\HttpKernel\Tests\Controller\ControllerResolverTest::bar'),
 135         );
 136     }
 137
 138     public function testGetArguments()
 139     {
 140         $resolver = $this->createControllerResolver();
 141
 142         $request = Request::create('/');
 143         $controller = array(new self(), 'testGetArguments');
 144         $this->assertEquals(array(), $resolver->getArguments($request, $controller), '->getArguments() returns an empty array if the method takes no arguments');
 145
 146         $request = Request::create('/');
 147         $request->attributes->set('foo', 'foo');
 148         $controller = array(new self(), 'controllerMethod1');
 149         $this->assertEquals(array('foo'), $resolver->getArguments($request, $controller), '->getArguments() returns an array of arguments for the controller method');
 150
 151         $request = Request::create('/');
 152         $request->attributes->set('foo', 'foo');
 153         $controller = array(new self(), 'controllerMethod2');
 154         $this->assertEquals(array('foo', null), $resolver->getArguments($request, $controller), '->getArguments() uses default values if present');
 155
 156         $request->attributes->set('bar', 'bar');
 157         $this->assertEquals(array('foo', 'bar'), $resolver->getArguments($request, $controller), '->getArguments() overrides default values if provided in the request attributes');
 158
 159         $request = Request::create('/');
 160         $request->attributes->set('foo', 'foo');
 161         $controller = function ($foo) {};
 162         $this->assertEquals(array('foo'), $resolver->getArguments($request, $controller));
 163
 164         $request = Request::create('/');
 165         $request->attributes->set('foo', 'foo');
 166         $controller = function ($foo, $bar = 'bar') {};
 167         $this->assertEquals(array('foo', 'bar'), $resolver->getArguments($request, $controller));
 168
 169         $request = Request::create('/');
 170         $request->attributes->set('foo', 'foo');
 171         $controller = new self();
 172         $this->assertEquals(array('foo', null), $resolver->getArguments($request, $controller));
 173         $request->attributes->set('bar', 'bar');
 174         $this->assertEquals(array('foo', 'bar'), $resolver->getArguments($request, $controller));
 175
 176         $request = Request::create('/');
 177         $request->attributes->set('foo', 'foo');
 178         $request->attributes->set('foobar', 'foobar');
 179         $controller = 'Symfony\Component\HttpKernel\Tests\Controller\some_controller_function';
 180         $this->assertEquals(array('foo', 'foobar'), $resolver->getArguments($request, $controller));
 181
 182         $request = Request::create('/');
 183         $request->attributes->set('foo', 'foo');
 184         $request->attributes->set('foobar', 'foobar');
 185         $controller = array(new self(), 'controllerMethod3');
 186
 187         if (\PHP_VERSION_ID === 50316) {
 188             $this->markTestSkipped('PHP 5.3.16 has a major bug in the Reflection sub-system');
 189         } else {
 190             try {
 191                 $resolver->getArguments($request, $controller);
 192                 $this->fail('->getArguments() throws a \RuntimeException exception if it cannot determine the argument value');
 193             } catch (\Exception $e) {
 194                 $this->assertInstanceOf('\RuntimeException', $e, '->getArguments() throws a \RuntimeException exception if it cannot determine the argument value');
 195             }
 196         }
 197
 198         $request = Request::create('/');
 199         $controller = array(new self(), 'controllerMethod5');
 200         $this->assertEquals(array($request), $resolver->getArguments($request, $controller), '->getArguments() injects the request');
 201     }
 202
 203     /**
 204      * @requires PHP 5.6
 205      */
 206     public function testGetVariadicArguments()
 207     {
 208         $resolver = new ControllerResolver();
 209
 210         $request = Request::create('/');
 211         $request->attributes->set('foo', 'foo');
 212         $request->attributes->set('bar', array('foo', 'bar'));
 213         $controller = array(new VariadicController(), 'action');
 214         $this->assertEquals(array('foo', 'foo', 'bar'), $resolver->getArguments($request, $controller));
 215     }
 216
 217     public function testCreateControllerCanReturnAnyCallable()
 218     {
 219         $mock = $this->getMockBuilder('Symfony\Component\HttpKernel\Controller\ControllerResolver')->setMethods(array('createController'))->getMock();
 220         $mock->expects($this->once())->method('createController')->will($this->returnValue('Symfony\Component\HttpKernel\Tests\Controller\some_controller_function'));
 221
 222         $request = Request::create('/');
 223         $request->attributes->set('_controller', 'foobar');
 224         $mock->getController($request);
 225     }
 226
 227     /**
 228      * @expectedException \RuntimeException
 229      */
 230     public function testIfExceptionIsThrownWhenMissingAnArgument()
 231     {
 232         $resolver = new ControllerResolver();
 233         $request = Request::create('/');
 234
 235         $controller = array($this, 'controllerMethod1');
 236
 237         $resolver->getArguments($request, $controller);
 238     }
 239
 240     /**
 241      * @requires PHP 7.1
 242      */
 243     public function testGetNullableArguments()
 244     {
 245         $resolver = new ControllerResolver();
 246
 247         $request = Request::create('/');
 248         $request->attributes->set('foo', 'foo');
 249         $request->attributes->set('bar', new \stdClass());
 250         $request->attributes->set('mandatory', 'mandatory');
 251         $controller = array(new NullableController(), 'action');
 252         $this->assertEquals(array('foo', new \stdClass(), 'value', 'mandatory'), $resolver->getArguments($request, $controller));
 253     }
 254
 255     /**
 256      * @requires PHP 7.1
 257      */
 258     public function testGetNullableArgumentsWithDefaults()
 259     {
 260         $resolver = new ControllerResolver();
 261
 262         $request = Request::create('/');
 263         $request->attributes->set('mandatory', 'mandatory');
 264         $controller = array(new NullableController(), 'action');
 265         $this->assertEquals(array(null, null, 'value', 'mandatory'), $resolver->getArguments($request, $controller));
 266     }
 267
 268     protected function createControllerResolver(LoggerInterface $logger = null)
 269     {
 270         return new ControllerResolver($logger);
 271     }
 272
 273     public function __invoke($foo, $bar = null)
 274     {
 275     }
 276
 277     public function controllerMethod1($foo)
 278     {
 279     }
 280
 281     protected function controllerMethod2($foo, $bar = null)
 282     {
 283     }
 284
 285     protected function controllerMethod3($foo, $bar, $foobar)
 286     {
 287     }
 288
 289     protected static function controllerMethod4()
 290     {
 291     }
 292
 293     protected function controllerMethod5(Request $request)
 294     {
 295     }
 296 }
 297
 298 function some_controller_function($foo, $foobar)
 299 {
 300 }