8000 [WIP] Refactored argument resolving out of the ControllerResolver by wouterj · Pull Request #11457 · symfony/symfony · GitHub
[go: up one dir, main page]
Skip to content

[WIP] Refactored argument resolving out of the ControllerResolver #11457

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
wants to merge 5 commits into from
Closed

[WIP] Refactored argument resolving out of the ControllerResolver #11457

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
0743526
Refactored argument resolving out of the ControllerResolver
wouterj Feb 28, 2014
667e141
Revisit PR
wouterj Feb 19, 2015
966ffe6
Make fabbot happy
wouterj Feb 19, 2015
416a33e
Cleanup tests
wouterj Apr 6, 2015
1a34c33
Fix dep version
wouterj May 8, 2015
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Prev Previous commit
Next Next commit
Cleanup tests
  • Loading branch information
@wouterj
wouterj committed Apr 9, 2015
commit 416a33edff373c52020f7de583b45e1a34cf7fd2
4 changes: 2 additions & 2 deletions src/Symfony/Bundle/FrameworkBundle/Tests/Controller/ControllerResolverTest.php
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -65,12 +65,12 @@ public function testGetControllerService()

$resolver = $this->createControllerResolver(null, null, $container);
$request = Request::create('/');
$request->attributes->set('_controller', 'foo:controllerMethod1');
$request->attributes->set('_controller', 'foo:controllerMethod');

$controller = $resolver->getController($request);

$this->assertInstanceOf(get_class($this), $controller[0]);
$this->assertSame('controllerMethod1', $controller[1]);
$this->assertSame('controllerMethod', $controller[1]);
}

public function testGetControllerInvokableService()
Expand Down
94 changes: 54 additions & 40 deletions src/Symfony/Component/HttpKernel/Tests/Controller/ArgumentResolverManagerTest.php
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -22,96 +22,110 @@ class ArgumentResolverManagerTest extends \PHPUnit_Framework_TestCase

public function setUp()
{
$this->manager = new ArgumentResolverManager();
$this->resolver1 = $this->getMock('Symfony\Component\HttpKernel\Controller\ArgumentResolverInterface');
$this->resolver2 = $this->getMock('Symfony\Component\HttpKernel\Controller\ArgumentResolverInterface');

$this->manager = new ArgumentResolverManager();
$this->manager->add($this->resolver1);
$this->manager->add($this->resolver2);

$this->request = $this->getMock('Symfony\Component\HttpFoundation\Request');
}

public function testGetArgumentsFirstResolverAccepts()
public function testGetArgumentsWithoutControllerParameters()
{
$this->resolver1->expects($this->any())->method('accepts')->will($this->returnValue(true));
$this->resolver1->expects($this->any())
->method('resolve')
->will($this->returnValue('resolved_value'));
$this->assertArguments(array(), function () { });
}

$controller = $this->getControllerWithOneArgument();
public function testGetArgumentsFirstResolverAccepts()
{
$this->promiseResolverToMatch($this->resolver1, 'resolved_value');

$arguments = $this->manager->getArguments($this->request, $controller);
$this->assertEquals(array('resolved_value'), $arguments);
$this->assertArguments(array('resolved_value'), $this->getControllerWithOneParameter());
}

public function testGetArgumentsSecondResolverAccepts()
{
$this->resolver1->expects($this->any())->method('accepts')->will($this->returnValue(false));
$this->resolver2->expects($this->any())->method('accepts')->will($this->returnValue(true));
$this->resolver2->expects($this->any())
->method('resolve')
->will($this->returnValue('resolved_value'));

$controller = $this->getControllerWithOneArgument();
$this->promiseResolverToNotMatch($this->resolver1);
$this->promiseResolverToMatch($this->resolver2, 'resolved_value');

$arguments = $this->manager->getArguments($this->request, $controller);
$this->assertEquals(array('resolved_value'), $arguments);
$this->assertArguments(array('resolved_value'), $this->getControllerWithOneParameter());
}

/**
* @expectedException RuntimeException
*/
public function testGetArgumentsFailsIfNoResolverAccepts()
{
$this->resolver1->expects($this->any())->method('accepts')->will($this->returnValue(false));
$this->resolver2->expects($this->any())->method('accepts')->will($this->returnValue(false));
$this->promiseResolverToNotMatch($this->resolver1);
$this->promiseResolverToNotMatch($this->resolver2);

$controller = $this->getControllerWithOneArgument();
$this->manager->getArguments($this->request, $controller);
$this->manager->getArguments($this->request, $this->getControllerWithOneParameter());
}

public function testGetArgumentResolvingMultipleArguments()
public function testGetArgumentResolvingMultipleParameters()
{
$this->resolver1->expects($this->any())
->method('accepts')
->method('supports')
->will($this->onConsecutiveCalls(false, true, true));
$this->resolver1->expects($this->any())
->method('resolve')
->will($this->onConsecutiveCalls('1st resolved by 1', '2nd resolved by 1'));

$this->resolver2->expects($this->any())
->method('accepts')
->method('supports')
->will($this->onConsecutiveCalls(true, false, true));
$this->resolver2->expects($this->any())
->method('resolve')
->will($this->onConsecutiveCalls('1st resolved by 2', '2nd resolved by 2'));

$controller = function ($a, $b, $c) { };
$this->assertArguments(
array('1st resolved by 2', '1st resolved by 1', '2nd resolved by 1'),
function ($a, $b, $c) { }
);
}

public function testControllerWithOneOptionalParameterWhichDoesNotMatch()
{
$this->promiseResolverToNotMatch($this->resolver1);
$this->promiseResolverToNotMatch($this->resolver2);

$this->assertArguments(array('default'), function ($a = 'default') { });
}

public function testControllerWithOneOptionalParameterWhichDoesMatch()
{
$this->promiseResolverToMatch($this->resolver1, 'resolved by 1');
$this->promiseResolverToNotMatch($this->resolver2);

$arguments = $this->manager->getArguments($this->request, $controller);
$this->assertEquals(array('1st resolved by 2', '1st resolved by 1', '2nd resolved by 1'), $arguments);
$this->assertArguments(array('resolved by 1'), function ($a = 'default') { });
}

public function testControllerWithOneOptionalArgumentWhichDoesNotMatch()
public function testControllerWithOneParameterWithNullDefault()
{
$this->resolver1->expects($this->any())->method('accepts')->will($this->returnValue(false));
$this->resolver2->expects($this->any())->method('accepts')->will($this->returnValue(false));
$this->promiseResolverToNotMatch($this->resolver1);
$this->promiseResolverToNotMatch($this->resolver2);

$this->assertArguments(array(null), function ($a = null) { });
}

$arguments = $this->manager->getArguments($this->request, function ($a = 'default') { });
$this->assertEquals(array('default'), $ar 8000 guments);
private function assertArguments(array $expected, $controller)
{
$this->assertEquals($expected, $this->manager->getArguments($this->request, $controller));
}

public function testControllerWithOneOptionalArgumentWhichDoMatch()
private function promiseResolverToMatch($resolver, $return)
{
$this->resolver1->expects($this->any())->method('accepts')->will($this->returnValue(true));
$this->resolver1->expects($this->any())->method('resolve')->will($this->returnValue('resolved by 1'));
$this->resolver2->expects($this->any())->method('accepts')->will($this->returnValue(false));
$resolver->expects($this->any())->method('supports')->will($this->returnValue(true));
$resolver->expects($this->any())->method('resolve')->will($this->returnValue($return));
}

$arguments = $this->manager->getArguments($this->request, function ($a = 'default') { });
$this->assertEquals(array('resolved by 1'), $arguments);
private function promiseResolverToNotMatch($resolver)
{
$resolver->expects($this->any())->method('supports')->will($this->returnValue(false));
}

protected function getControllerWithOneArgument()
private function getControllerWithOneParameter()
{
return function ($a) { };
}
Expand Down
87 changes: 7 additions & 80 deletions src/Symfony/Component/HttpKernel/Tests/Controller/ControllerResolverTest.php
View file
Open in desktop
8000
Original file line number Diff line number Diff line change
Expand Up @@ -52,27 +52,27 @@ public function testGetControllerWithObjectAndMethod()
$resolver = $this->createControllerResolver();

$request = Request::create('/');
$request->attributes->set('_controller', array($this, 'controllerMethod1'));
$request->attributes->set('_controller', array($this, 'controllerMethod'));
$controller = $resolver->getController($request);
$this->assertSame(array($this, 'controllerMethod1'), $controller);
$this->assertSame(array($this, 'controllerMethod'), $controller);
}

public function testGetControllerWithClassAndMethod()
{
$resolver = $this->createControllerResolver();

$request = Request::create('/');
$request->attributes->set('_controller', array('Symfony\Component\HttpKernel\Tests\Controller\ControllerResolverTest', 'controllerMethod4'));
$request->attributes->set('_controller', array('Symfony\Component\HttpKernel\Tests\Controller\ControllerResolverTest', 'staticControllerMethod'));
$controller = $resolver->getController($request);
$this->assertSame(array('Symfony\Component\HttpKernel\Tests\Controller\ControllerResolverTest', 'controllerMethod4'), $controller);
$this->assertSame(array('Symfony\Component\HttpKernel\Tests\Controller\ControllerResolverTest', 'staticControllerMethod'), $controller);
}

public function testGetControllerWithObjectAndMethodAsString()
{
$resolver = $this->createControllerResolver();

$request = Request::create('/');
$request->attributes->set('_controller', 'Symfony\Component\HttpKernel\Tests\Controller\ControllerResolverTest::controllerMethod1');
$request->attributes->set('_controller', 'Symfony\Component\HttpKernel\Tests\Controller\ControllerResolverTest::controllerMethod');
$controller = $resolver->getController($request);
$this->assertInstanceOf('Symfony\Component\HttpKernel\Tests\Controller\ControllerResolverTest', $controller[0], '->getController() returns a PHP callable');
}
Expand Down Expand Up @@ -132,67 +132,6 @@ public function getUndefinedControllers()
);
}

public function testGetArguments()
{
$resolver = $this->createControllerResolver();

$request = Request::create('/');
$controller = array(new self(), 'testGetArguments');
$this->assertEquals(array(), $resolver->getArguments($request, $controller), '->getArguments() returns an empty array if the method takes no arguments');

$request = Request::create('/');
$request->attributes->set('foo', 'foo');
$controller = array(new self(), 'controllerMethod1');
$this->assertEquals(array('foo'), $resolver->getArguments($request, $controller), '->getArguments() returns an array of arguments for the controller method');

$request = Request::create('/');
$request->attributes->set('foo', 'foo');
$controller = array(new self(), 'controllerMethod2');
$this->assertEquals(array('foo', null), $resolver->getArguments($request, $controller), '->getArguments() uses default values if present');

$request->attributes->set('bar', 'bar');
$this->assertEquals(array('foo', 'bar'), $resolver->getArguments($request, $controller), '->getArguments() overrides default values if provided in the request attributes');

$request = Request::create('/');
$request->attributes->set('foo', 'foo');
$controller = function ($foo) {};
$this->assertEquals(array('foo'), $resolver->getArguments($request, $controller));

$request = Request::create('/');
$request->attributes->set('foo', 'foo');
$controller = function ($foo, $bar = 'bar') {};
$this->assertEquals(array('foo', 'bar'), $resolver->getArguments($request, $controller));

$request = Request::create('/');
$request->attributes->set('foo', 'foo');
$controller = new self();
$this->assertEquals(array('foo', null), $resolver->getArguments($request, $controller));
$request->attributes->set('bar', 'bar');
$this->assertEquals(array('foo', 'bar'), $resolver->getArguments($request, $controller));

$request = Request::create('/');
$request->attributes->set('foo', 'foo');
$request->attributes->set('foobar', 'foobar');
$controller = 'Symfony\Component\HttpKernel\Tests\Controller\some_controller_function';
$this->assertEquals(array('foo', 'foobar'), $resolver->getArguments($request, $controller));

$request = Request::create('/');
$request->attributes->set('foo', 'foo');
$request->attributes->set('foobar', 'foobar');
$controller = array(new self(), 'controllerMethod3');

try {
$resolver->getArguments($request, $controller);
$this->fail('->getArguments() throws a \RuntimeException exception if it cannot determine the argument value');
} catch (\Exception $e) {
$this->assertInstanceOf('\RuntimeException', $e, '->getArguments() throws a \RuntimeException exception if it cannot determine the argument value');
}

$request = Request::create('/');
$controller = array(new self(), 'controllerMethod5');
$this->assertEquals(array($request), $resolver->getArguments($request, $controller), '->getArguments() injects the request');
}

public function testCreateControllerCanReturnAnyCallable()
{
$mock = $this->getMock('Symfony\Component\HttpKernel\Controller\ControllerResolver', array('createController'));
Expand All @@ -212,23 +151,11 @@ public function __invoke($foo, $bar = null)
{
}

public function controllerMethod1($foo)
{
}

protected function controllerMethod2($foo, $bar = null)
{
}

protected function controllerMethod3($foo, $bar = null, $foobar)
{
}

protected static function controllerMethod4()
public function controllerMethod($foo)
{
}

protected function controllerMethod5(Request $request)
protected static function staticControllerMethod()
{
}
}
Expand Down
FF
0