yaffs.net Git - yaffs-website/blob - vendor/symfony/http-kernel/Tests/Controller/ArgumentResolverTest.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 Symfony\Component\HttpFoundation\Session\Session;
  16 use Symfony\Component\HttpFoundation\Session\SessionInterface;
  17 use Symfony\Component\HttpFoundation\Session\Storage\MockArraySessionStorage;
  18 use Symfony\Component\HttpKernel\Controller\ArgumentResolver;
  19 use Symfony\Component\HttpKernel\Controller\ArgumentResolver\RequestAttributeValueResolver;
  20 use Symfony\Component\HttpKernel\Controller\ArgumentValueResolverInterface;
  21 use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadataFactory;
  22 use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\ExtendingRequest;
  23 use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\ExtendingSession;
  24 use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\NullableController;
  25 use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\VariadicController;
  26 use Symfony\Component\HttpFoundation\Request;
  27
  28 class ArgumentResolverTest extends TestCase
  29 {
  30     /** @var ArgumentResolver */
  31     private static $resolver;
  32
  33     public static function setUpBeforeClass()
  34     {
  35         $factory = new ArgumentMetadataFactory();
  36
  37         self::$resolver = new ArgumentResolver($factory);
  38     }
  39
  40     public function testDefaultState()
  41     {
  42         $this->assertEquals(self::$resolver, new ArgumentResolver());
  43         $this->assertNotEquals(self::$resolver, new ArgumentResolver(null, array(new RequestAttributeValueResolver())));
  44     }
  45
  46     public function testGetArguments()
  47     {
  48         $request = Request::create('/');
  49         $request->attributes->set('foo', 'foo');
  50         $controller = array(new self(), 'controllerWithFoo');
  51
  52         $this->assertEquals(array('foo'), self::$resolver->getArguments($request, $controller), '->getArguments() returns an array of arguments for the controller method');
  53     }
  54
  55     public function testGetArgumentsReturnsEmptyArrayWhenNoArguments()
  56     {
  57         $request = Request::create('/');
  58         $controller = array(new self(), 'controllerWithoutArguments');
  59
  60         $this->assertEquals(array(), self::$resolver->getArguments($request, $controller), '->getArguments() returns an empty array if the method takes no arguments');
  61     }
  62
  63     public function testGetArgumentsUsesDefaultValue()
  64     {
  65         $request = Request::create('/');
  66         $request->attributes->set('foo', 'foo');
  67         $controller = array(new self(), 'controllerWithFooAndDefaultBar');
  68
  69         $this->assertEquals(array('foo', null), self::$resolver->getArguments($request, $controller), '->getArguments() uses default values if present');
  70     }
  71
  72     public function testGetArgumentsOverrideDefaultValueByRequestAttribute()
  73     {
  74         $request = Request::create('/');
  75         $request->attributes->set('foo', 'foo');
  76         $request->attributes->set('bar', 'bar');
  77         $controller = array(new self(), 'controllerWithFooAndDefaultBar');
  78
  79         $this->assertEquals(array('foo', 'bar'), self::$resolver->getArguments($request, $controller), '->getArguments() overrides default values if provided in the request attributes');
  80     }
  81
  82     public function testGetArgumentsFromClosure()
  83     {
  84         $request = Request::create('/');
  85         $request->attributes->set('foo', 'foo');
  86         $controller = function ($foo) {};
  87
  88         $this->assertEquals(array('foo'), self::$resolver->getArguments($request, $controller));
  89     }
  90
  91     public function testGetArgumentsUsesDefaultValueFromClosure()
  92     {
  93         $request = Request::create('/');
  94         $request->attributes->set('foo', 'foo');
  95         $controller = function ($foo, $bar = 'bar') {};
  96
  97         $this->assertEquals(array('foo', 'bar'), self::$resolver->getArguments($request, $controller));
  98     }
  99
 100     public function testGetArgumentsFromInvokableObject()
 101     {
 102         $request = Request::create('/');
 103         $request->attributes->set('foo', 'foo');
 104         $controller = new self();
 105
 106         $this->assertEquals(array('foo', null), self::$resolver->getArguments($request, $controller));
 107
 108         // Test default bar overridden by request attribute
 109         $request->attributes->set('bar', 'bar');
 110
 111         $this->assertEquals(array('foo', 'bar'), self::$resolver->getArguments($request, $controller));
 112     }
 113
 114     public function testGetArgumentsFromFunctionName()
 115     {
 116         $request = Request::create('/');
 117         $request->attributes->set('foo', 'foo');
 118         $request->attributes->set('foobar', 'foobar');
 119         $controller = __NAMESPACE__.'\controller_function';
 120
 121         $this->assertEquals(array('foo', 'foobar'), self::$resolver->getArguments($request, $controller));
 122     }
 123
 124     public function testGetArgumentsFailsOnUnresolvedValue()
 125     {
 126         $request = Request::create('/');
 127         $request->attributes->set('foo', 'foo');
 128         $request->attributes->set('foobar', 'foobar');
 129         $controller = array(new self(), 'controllerWithFooBarFoobar');
 130
 131         try {
 132             self::$resolver->getArguments($request, $controller);
 133             $this->fail('->getArguments() throws a \RuntimeException exception if it cannot determine the argument value');
 134         } catch (\Exception $e) {
 135             $this->assertInstanceOf('\RuntimeException', $e, '->getArguments() throws a \RuntimeException exception if it cannot determine the argument value');
 136         }
 137     }
 138
 139     public function testGetArgumentsInjectsRequest()
 140     {
 141         $request = Request::create('/');
 142         $controller = array(new self(), 'controllerWithRequest');
 143
 144         $this->assertEquals(array($request), self::$resolver->getArguments($request, $controller), '->getArguments() injects the request');
 145     }
 146
 147     public function testGetArgumentsInjectsExtendingRequest()
 148     {
 149         $request = ExtendingRequest::create('/');
 150         $controller = array(new self(), 'controllerWithExtendingRequest');
 151
 152         $this->assertEquals(array($request), self::$resolver->getArguments($request, $controller), '->getArguments() injects the request when extended');
 153     }
 154
 155     /**
 156      * @requires PHP 5.6
 157      */
 158     public function testGetVariadicArguments()
 159     {
 160         $request = Request::create('/');
 161         $request->attributes->set('foo', 'foo');
 162         $request->attributes->set('bar', array('foo', 'bar'));
 163         $controller = array(new VariadicController(), 'action');
 164
 165         $this->assertEquals(array('foo', 'foo', 'bar'), self::$resolver->getArguments($request, $controller));
 166     }
 167
 168     /**
 169      * @requires PHP 5.6
 170      * @expectedException \InvalidArgumentException
 171      */
 172     public function testGetVariadicArgumentsWithoutArrayInRequest()
 173     {
 174         $request = Request::create('/');
 175         $request->attributes->set('foo', 'foo');
 176         $request->attributes->set('bar', 'foo');
 177         $controller = array(new VariadicController(), 'action');
 178
 179         self::$resolver->getArguments($request, $controller);
 180     }
 181
 182     /**
 183      * @requires PHP 5.6
 184      * @expectedException \InvalidArgumentException
 185      */
 186     public function testGetArgumentWithoutArray()
 187     {
 188         $factory = new ArgumentMetadataFactory();
 189         $valueResolver = $this->getMockBuilder(ArgumentValueResolverInterface::class)->getMock();
 190         $resolver = new ArgumentResolver($factory, array($valueResolver));
 191
 192         $valueResolver->expects($this->any())->method('supports')->willReturn(true);
 193         $valueResolver->expects($this->any())->method('resolve')->willReturn('foo');
 194
 195         $request = Request::create('/');
 196         $request->attributes->set('foo', 'foo');
 197         $request->attributes->set('bar', 'foo');
 198         $controller = array($this, 'controllerWithFooAndDefaultBar');
 199         $resolver->getArguments($request, $controller);
 200     }
 201
 202     /**
 203      * @expectedException \RuntimeException
 204      */
 205     public function testIfExceptionIsThrownWhenMissingAnArgument()
 206     {
 207         $request = Request::create('/');
 208         $controller = array($this, 'controllerWithFoo');
 209
 210         self::$resolver->getArguments($request, $controller);
 211     }
 212
 213     /**
 214      * @requires PHP 7.1
 215      */
 216     public function testGetNullableArguments()
 217     {
 218         $request = Request::create('/');
 219         $request->attributes->set('foo', 'foo');
 220         $request->attributes->set('bar', new \stdClass());
 221         $request->attributes->set('mandatory', 'mandatory');
 222         $controller = array(new NullableController(), 'action');
 223
 224         $this->assertEquals(array('foo', new \stdClass(), 'value', 'mandatory'), self::$resolver->getArguments($request, $controller));
 225     }
 226
 227     /**
 228      * @requires PHP 7.1
 229      */
 230     public function testGetNullableArgumentsWithDefaults()
 231     {
 232         $request = Request::create('/');
 233         $request->attributes->set('mandatory', 'mandatory');
 234         $controller = array(new NullableController(), 'action');
 235
 236         $this->assertEquals(array(null, null, 'value', 'mandatory'), self::$resolver->getArguments($request, $controller));
 237     }
 238
 239     public function testGetSessionArguments()
 240     {
 241         $session = new Session(new MockArraySessionStorage());
 242         $request = Request::create('/');
 243         $request->setSession($session);
 244         $controller = array($this, 'controllerWithSession');
 245
 246         $this->assertEquals(array($session), self::$resolver->getArguments($request, $controller));
 247     }
 248
 249     public function testGetSessionArgumentsWithExtendedSession()
 250     {
 251         $session = new ExtendingSession(new MockArraySessionStorage());
 252         $request = Request::create('/');
 253         $request->setSession($session);
 254         $controller = array($this, 'controllerWithExtendingSession');
 255
 256         $this->assertEquals(array($session), self::$resolver->getArguments($request, $controller));
 257     }
 258
 259     public function testGetSessionArgumentsWithInterface()
 260     {
 261         $session = $this->getMockBuilder(SessionInterface::class)->getMock();
 262         $request = Request::create('/');
 263         $request->setSession($session);
 264         $controller = array($this, 'controllerWithSessionInterface');
 265
 266         $this->assertEquals(array($session), self::$resolver->getArguments($request, $controller));
 267     }
 268
 269     /**
 270      * @expectedException \RuntimeException
 271      */
 272     public function testGetSessionMissMatchWithInterface()
 273     {
 274         $session = $this->getMockBuilder(SessionInterface::class)->getMock();
 275         $request = Request::create('/');
 276         $request->setSession($session);
 277         $controller = array($this, 'controllerWithExtendingSession');
 278
 279         self::$resolver->getArguments($request, $controller);
 280     }
 281
 282     /**
 283      * @expectedException \RuntimeException
 284      */
 285     public function testGetSessionMissMatchWithImplementation()
 286     {
 287         $session = new Session(new MockArraySessionStorage());
 288         $request = Request::create('/');
 289         $request->setSession($session);
 290         $controller = array($this, 'controllerWithExtendingSession');
 291
 292         self::$resolver->getArguments($request, $controller);
 293     }
 294
 295     /**
 296      * @expectedException \RuntimeException
 297      */
 298     public function testGetSessionMissMatchOnNull()
 299     {
 300         $request = Request::create('/');
 301         $controller = array($this, 'controllerWithExtendingSession');
 302
 303         self::$resolver->getArguments($request, $controller);
 304     }
 305
 306     public function __invoke($foo, $bar = null)
 307     {
 308     }
 309
 310     public function controllerWithFoo($foo)
 311     {
 312     }
 313
 314     public function controllerWithoutArguments()
 315     {
 316     }
 317
 318     protected function controllerWithFooAndDefaultBar($foo, $bar = null)
 319     {
 320     }
 321
 322     protected function controllerWithFooBarFoobar($foo, $bar, $foobar)
 323     {
 324     }
 325
 326     protected function controllerWithRequest(Request $request)
 327     {
 328     }
 329
 330     protected function controllerWithExtendingRequest(ExtendingRequest $request)
 331     {
 332     }
 333
 334     protected function controllerWithSession(Session $session)
 335     {
 336     }
 337
 338     protected function controllerWithSessionInterface(SessionInterface $session)
 339     {
 340     }
 341
 342     protected function controllerWithExtendingSession(ExtendingSession $session)
 343     {
 344     }
 345 }
 346
 347 function controller_function($foo, $foobar)
 348 {
 349 }