www.aleph1.co.uk 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\HttpKernel\Controller\ArgumentResolver;
  16 use Symfony\Component\HttpKernel\Controller\ArgumentResolver\DefaultValueResolver;
  17 use Symfony\Component\HttpKernel\Controller\ArgumentResolver\RequestAttributeValueResolver;
  18 use Symfony\Component\HttpKernel\Controller\ArgumentResolver\RequestValueResolver;
  19 use Symfony\Component\HttpKernel\Controller\ArgumentResolver\VariadicValueResolver;
  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\NullableController;
  24 use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\VariadicController;
  25 use Symfony\Component\HttpFoundation\Request;
  26
  27 class ArgumentResolverTest extends TestCase
  28 {
  29     /** @var ArgumentResolver */
  30     private static $resolver;
  31
  32     public static function setUpBeforeClass()
  33     {
  34         $factory = new ArgumentMetadataFactory();
  35         $argumentValueResolvers = array(
  36             new RequestAttributeValueResolver(),
  37             new RequestValueResolver(),
  38             new DefaultValueResolver(),
  39             new VariadicValueResolver(),
  40         );
  41
  42         self::$resolver = new ArgumentResolver($factory, $argumentValueResolvers);
  43     }
  44
  45     public function testDefaultState()
  46     {
  47         $this->assertEquals(self::$resolver, new ArgumentResolver());
  48         $this->assertNotEquals(self::$resolver, new ArgumentResolver(null, array(new RequestAttributeValueResolver())));
  49     }
  50
  51     public function testGetArguments()
  52     {
  53         $request = Request::create('/');
  54         $request->attributes->set('foo', 'foo');
  55         $controller = array(new self(), 'controllerWithFoo');
  56
  57         $this->assertEquals(array('foo'), self::$resolver->getArguments($request, $controller), '->getArguments() returns an array of arguments for the controller method');
  58     }
  59
  60     public function testGetArgumentsReturnsEmptyArrayWhenNoArguments()
  61     {
  62         $request = Request::create('/');
  63         $controller = array(new self(), 'controllerWithoutArguments');
  64
  65         $this->assertEquals(array(), self::$resolver->getArguments($request, $controller), '->getArguments() returns an empty array if the method takes no arguments');
  66     }
  67
  68     public function testGetArgumentsUsesDefaultValue()
  69     {
  70         $request = Request::create('/');
  71         $request->attributes->set('foo', 'foo');
  72         $controller = array(new self(), 'controllerWithFooAndDefaultBar');
  73
  74         $this->assertEquals(array('foo', null), self::$resolver->getArguments($request, $controller), '->getArguments() uses default values if present');
  75     }
  76
  77     public function testGetArgumentsOverrideDefaultValueByRequestAttribute()
  78     {
  79         $request = Request::create('/');
  80         $request->attributes->set('foo', 'foo');
  81         $request->attributes->set('bar', 'bar');
  82         $controller = array(new self(), 'controllerWithFooAndDefaultBar');
  83
  84         $this->assertEquals(array('foo', 'bar'), self::$resolver->getArguments($request, $controller), '->getArguments() overrides default values if provided in the request attributes');
  85     }
  86
  87     public function testGetArgumentsFromClosure()
  88     {
  89         $request = Request::create('/');
  90         $request->attributes->set('foo', 'foo');
  91         $controller = function ($foo) {};
  92
  93         $this->assertEquals(array('foo'), self::$resolver->getArguments($request, $controller));
  94     }
  95
  96     public function testGetArgumentsUsesDefaultValueFromClosure()
  97     {
  98         $request = Request::create('/');
  99         $request->attributes->set('foo', 'foo');
 100         $controller = function ($foo, $bar = 'bar') {};
 101
 102         $this->assertEquals(array('foo', 'bar'), self::$resolver->getArguments($request, $controller));
 103     }
 104
 105     public function testGetArgumentsFromInvokableObject()
 106     {
 107         $request = Request::create('/');
 108         $request->attributes->set('foo', 'foo');
 109         $controller = new self();
 110
 111         $this->assertEquals(array('foo', null), self::$resolver->getArguments($request, $controller));
 112
 113         // Test default bar overridden by request attribute
 114         $request->attributes->set('bar', 'bar');
 115
 116         $this->assertEquals(array('foo', 'bar'), self::$resolver->getArguments($request, $controller));
 117     }
 118
 119     public function testGetArgumentsFromFunctionName()
 120     {
 121         $request = Request::create('/');
 122         $request->attributes->set('foo', 'foo');
 123         $request->attributes->set('foobar', 'foobar');
 124         $controller = __NAMESPACE__.'\controller_function';
 125
 126         $this->assertEquals(array('foo', 'foobar'), self::$resolver->getArguments($request, $controller));
 127     }
 128
 129     public function testGetArgumentsFailsOnUnresolvedValue()
 130     {
 131         $request = Request::create('/');
 132         $request->attributes->set('foo', 'foo');
 133         $request->attributes->set('foobar', 'foobar');
 134         $controller = array(new self(), 'controllerWithFooBarFoobar');
 135
 136         try {
 137             self::$resolver->getArguments($request, $controller);
 138             $this->fail('->getArguments() throws a \RuntimeException exception if it cannot determine the argument value');
 139         } catch (\Exception $e) {
 140             $this->assertInstanceOf('\RuntimeException', $e, '->getArguments() throws a \RuntimeException exception if it cannot determine the argument value');
 141         }
 142     }
 143
 144     public function testGetArgumentsInjectsRequest()
 145     {
 146         $request = Request::create('/');
 147         $controller = array(new self(), 'controllerWithRequest');
 148
 149         $this->assertEquals(array($request), self::$resolver->getArguments($request, $controller), '->getArguments() injects the request');
 150     }
 151
 152     public function testGetArgumentsInjectsExtendingRequest()
 153     {
 154         $request = ExtendingRequest::create('/');
 155         $controller = array(new self(), 'controllerWithExtendingRequest');
 156
 157         $this->assertEquals(array($request), self::$resolver->getArguments($request, $controller), '->getArguments() injects the request when extended');
 158     }
 159
 160     /**
 161      * @requires PHP 5.6
 162      */
 163     public function testGetVariadicArguments()
 164     {
 165         $request = Request::create('/');
 166         $request->attributes->set('foo', 'foo');
 167         $request->attributes->set('bar', array('foo', 'bar'));
 168         $controller = array(new VariadicController(), 'action');
 169
 170         $this->assertEquals(array('foo', 'foo', 'bar'), self::$resolver->getArguments($request, $controller));
 171     }
 172
 173     /**
 174      * @requires PHP 5.6
 175      * @expectedException \InvalidArgumentException
 176      */
 177     public function testGetVariadicArgumentsWithoutArrayInRequest()
 178     {
 179         $request = Request::create('/');
 180         $request->attributes->set('foo', 'foo');
 181         $request->attributes->set('bar', 'foo');
 182         $controller = array(new VariadicController(), 'action');
 183
 184         self::$resolver->getArguments($request, $controller);
 185     }
 186
 187     /**
 188      * @requires PHP 5.6
 189      * @expectedException \InvalidArgumentException
 190      */
 191     public function testGetArgumentWithoutArray()
 192     {
 193         $factory = new ArgumentMetadataFactory();
 194         $valueResolver = $this->getMockBuilder(ArgumentValueResolverInterface::class)->getMock();
 195         $resolver = new ArgumentResolver($factory, array($valueResolver));
 196
 197         $valueResolver->expects($this->any())->method('supports')->willReturn(true);
 198         $valueResolver->expects($this->any())->method('resolve')->willReturn('foo');
 199
 200         $request = Request::create('/');
 201         $request->attributes->set('foo', 'foo');
 202         $request->attributes->set('bar', 'foo');
 203         $controller = array($this, 'controllerWithFooAndDefaultBar');
 204         $resolver->getArguments($request, $controller);
 205     }
 206
 207     /**
 208      * @expectedException \RuntimeException
 209      */
 210     public function testIfExceptionIsThrownWhenMissingAnArgument()
 211     {
 212         $request = Request::create('/');
 213         $controller = array($this, 'controllerWithFoo');
 214
 215         self::$resolver->getArguments($request, $controller);
 216     }
 217
 218     /**
 219      * @requires PHP 7.1
 220      */
 221     public function testGetNullableArguments()
 222     {
 223         $request = Request::create('/');
 224         $request->attributes->set('foo', 'foo');
 225         $request->attributes->set('bar', new \stdClass());
 226         $request->attributes->set('mandatory', 'mandatory');
 227         $controller = array(new NullableController(), 'action');
 228
 229         $this->assertEquals(array('foo', new \stdClass(), 'value', 'mandatory'), self::$resolver->getArguments($request, $controller));
 230     }
 231
 232     /**
 233      * @requires PHP 7.1
 234      */
 235     public function testGetNullableArgumentsWithDefaults()
 236     {
 237         $request = Request::create('/');
 238         $request->attributes->set('mandatory', 'mandatory');
 239         $controller = array(new NullableController(), 'action');
 240
 241         $this->assertEquals(array(null, null, 'value', 'mandatory'), self::$resolver->getArguments($request, $controller));
 242     }
 243
 244     public function __invoke($foo, $bar = null)
 245     {
 246     }
 247
 248     public function controllerWithFoo($foo)
 249     {
 250     }
 251
 252     public function controllerWithoutArguments()
 253     {
 254     }
 255
 256     protected function controllerWithFooAndDefaultBar($foo, $bar = null)
 257     {
 258     }
 259
 260     protected function controllerWithFooBarFoobar($foo, $bar, $foobar)
 261     {
 262     }
 263
 264     protected function controllerWithRequest(Request $request)
 265     {
 266     }
 267
 268     protected function controllerWithExtendingRequest(ExtendingRequest $request)
 269     {
 270     }
 271 }
 272
 273 function controller_function($foo, $foobar)
 274 {
 275 }