diogo
/
symfony
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch '3.4' into 4.3 

* 3.4:
  Re-enable previously failing PHP 7.4 test cases
  Revert "bug #33618 fix tests depending on other components' tests (xabbuh)"
  install from source to include components tests
This commit is contained in:
Nicolas Grekas 2019-09-19 17:49:01 +02:00
parent 2f6dc5eed1 1ab8fff4f2
commit 627833b5e6
29 changed files with 614 additions and 711 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
.travis.yml
View File

@ -79,12 +79,6 @@ before_install:
export COMPONENTS=$(find src/Symfony -mindepth 2 -type f -name phpunit.xml.dist -printf '%h\n' | sort)
find ~/.phpenv -name xdebug.ini -delete
if [[ $TRAVIS_PHP_VERSION = 7.4* && $deps ]]; then
export PHPUNIT_X="$PHPUNIT_X,issue-32995"
elif [[ $TRAVIS_PHP_VERSION = 7.4* ]]; then
export PHPUNIT_X="$PHPUNIT --group issue-32995"
fi
nanoseconds () {
local cmd="date"
local format="+%s%N"
@ -271,12 +265,12 @@ install:
tfold 'composer update' $COMPOSER_UP
tfold 'phpunit install' ./phpunit install
if [[ $deps = high ]]; then
echo "$COMPONENTS" | parallel --gnu "tfold {} 'cd {} && $COMPOSER_UP && $PHPUNIT_X$LEGACY'"
echo "$COMPONENTS" | parallel --gnu "tfold {} 'cd {} && $COMPOSER_UP --prefer-source && $PHPUNIT_X$LEGACY'"
elif [[ $deps = low ]]; then
[[ -e ~/php-ext/composer-lowest.lock.tar ]] && tar -xf ~/php-ext/composer-lowest.lock.tar
tar -cf ~/php-ext/composer-lowest.lock.tar --files-from /dev/null
php .github/rm-invalid-lowest-lock-files.php $COMPONENTS
echo "$COMPONENTS" | parallel --gnu "tfold {} 'cd {} && ([ -e composer.lock ] && ${COMPOSER_UP/update/install} || $COMPOSER_UP --prefer-lowest --prefer-stable) && $PHPUNIT_X'"
echo "$COMPONENTS" | parallel --gnu "tfold {} 'cd {} && ([ -e composer.lock ] && ${COMPOSER_UP/update/install} || $COMPOSER_UP --prefer-lowest --prefer-stable --prefer-source) && $PHPUNIT_X'"
echo "$COMPONENTS" | xargs -n1 -I{} tar --append -f ~/php-ext/composer-lowest.lock.tar {}/composer.lock
else
echo "$COMPONENTS" | parallel --gnu "tfold {} $PHPUNIT_X {}"

2
src/Symfony/Bridge/Doctrine/composer.json
View File

@ -27,7 +27,7 @@
"symfony/stopwatch": "~3.4|~4.0",
"symfony/config": "^4.2",
"symfony/dependency-injection": "~3.4|~4.0",
"symfony/form": "^4.3.5",
"symfony/form": "~4.3",
"symfony/http-kernel": "~3.4|~4.0",
"symfony/messenger": "~4.3",
"symfony/property-access": "~3.4|~4.0",

4
src/Symfony/Bridge/PhpUnit/DeprecationErrorHandler.php
View File

@ -98,7 +98,7 @@ class DeprecationErrorHandler
{
$deprecations = [];
$previousErrorHandler = set_error_handler(function ($type, $msg, $file, $line, $context = []) use (&$deprecations, &$previousErrorHandler) {
if (E_USER_DEPRECATED !== $type && E_DEPRECATED !== $type) {
if (E_USER_DEPRECATED !== $type && E_DEPRECATED !== $type && (E_WARNING !== $type || false === strpos($msg, '" targeting switch is equivalent to "break')) {
if ($previousErrorHandler) {
return $previousErrorHandler($type, $msg, $file, $line, $context);
}
@ -121,7 +121,7 @@ class DeprecationErrorHandler
*/
public function handleError($type, $msg, $file, $line, $context = [])
{
if ((E_USER_DEPRECATED !== $type && E_DEPRECATED !== $type) || !$this->getConfiguration()->isEnabled()) {
if ((E_USER_DEPRECATED !== $type && E_DEPRECATED !== $type && (E_WARNING !== $type || false === strpos($msg, '" targeting switch is equivalent to "break')) || !$this->getConfiguration()->isEnabled()) {
return \call_user_func(self::getPhpUnitErrorHandler(), $type, $msg, $file, $line, $context);
}

5
src/Symfony/Bundle/FrameworkBundle/Tests/CacheWarmer/ValidatorCacheWarmerTest.php
View File

@ -20,11 +20,6 @@ use Symfony\Component\Validator\ValidatorBuilder;
class ValidatorCacheWarmerTest extends TestCase
{
/**
* @group issue-32995
*
* @runInSeparateProcess https://github.com/symfony/symfony/issues/32995
*/
public function testWarmUp()
{
$validatorBuilder = new ValidatorBuilder();

18
src/Symfony/Bundle/FrameworkBundle/Tests/Command/XliffLintCommandTest.php
View File

@ -35,29 +35,13 @@ class XliffLintCommandTest extends TestCase
{
$command = new XliffLintCommand();
$expected = <<<EOF
The <info>%command.name%</info> command lints a XLIFF file and outputs to STDOUT
the first encountered syntax error.
You can validates XLIFF contents passed from STDIN:
<info>cat filename | php %command.full_name%</info>
You can also validate the syntax of a file:
<info>php %command.full_name% filename</info>
Or of a whole directory:
<info>php %command.full_name% dirname</info>
<info>php %command.full_name% dirname --format=json</info>
Or find all files in a bundle:
<info>php %command.full_name% @AcmeDemoBundle</info>
EOF;
$this->assertEquals($expected, $command->getHelp());
$this->assertStringContainsString($expected, $command->getHelp());
}
public function testLintFilesFromBundleDirectory()

19
src/Symfony/Bundle/FrameworkBundle/Tests/Command/YamlLintCommandTest.php
View File

@ -72,29 +72,12 @@ bar';
{
$command = new YamlLintCommand();
$expected = <<<EOF
The <info>%command.name%</info> command lints a YAML file and outputs to STDOUT
the first encountered syntax error.
You can validates YAML contents passed from STDIN:
<info>cat filename | php %command.full_name%</info>
You can also validate the syntax of a file:
<info>php %command.full_name% filename</info>
Or of a whole directory:
<info>php %command.full_name% dirname</info>
<info>php %command.full_name% dirname --format=json</info>
Or find all files in a bundle:
<info>php %command.full_name% @AcmeDemoBundle</info>
EOF;
$this->assertEquals($expected, $command->getHelp());
$this->assertStringContainsString($expected, $command->getHelp());
}
public function testLintFilesFromBundleDirectory()

4
src/Symfony/Bundle/FrameworkBundle/Tests/Controller/ControllerResolverTest.php
View File

@ -20,9 +20,9 @@ use Symfony\Component\DependencyInjection\Container;
use Symfony\Component\DependencyInjection\ContainerAwareInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpKernel\Test\Controller\ContainerControllerResolverTestCase;
use Symfony\Component\HttpKernel\Tests\Controller\ContainerControllerResolverTest;
class ControllerResolverTest extends ContainerControllerResolverTestCase
class ControllerResolverTest extends ContainerControllerResolverTest
{
public function testGetControllerOnContainerAware()
{

2
src/Symfony/Bundle/FrameworkBundle/composer.json
View File

@ -23,7 +23,7 @@
"symfony/debug": "~4.0",
"symfony/dependency-injection": "^4.3",
"symfony/http-foundation": "^4.3",
"symfony/http-kernel": "^4.3.5",
"symfony/http-kernel": "^4.3.4",
"symfony/polyfill-mbstring": "~1.0",
"symfony/filesystem": "~3.4|~4.0",
"symfony/finder": "~3.4|~4.0",

10
src/Symfony/Component/Cache/Tests/Adapter/AdapterTestCase.php
View File

@ -252,16 +252,6 @@ abstract class AdapterTestCase extends CachePoolTest
$this->assertFalse($this->isPruned($cache, 'foo'));
$this->assertTrue($this->isPruned($cache, 'qux'));
}
/**
* @group issue-32995
*
* @runInSeparateProcess https://github.com/symfony/symfony/issues/32995
*/
public function testSavingObject()
{
parent::testSavingObject();
}
}
class NotUnserializable

10
src/Symfony/Component/Config/Tests/Resource/ClassExistenceResourceTest.php
View File

@ -75,22 +75,12 @@ EOF
}
}
/**
* @group issue-32995
*
* @runInSeparateProcess https://github.com/symfony/symfony/issues/32995
*/
public function testBadParentWithTimestamp()
{
$res = new ClassExistenceResource(BadParent::class, false);
$this->assertTrue($res->isFresh(time()));
}
/**
* @group issue-32995
*
* @runInSeparateProcess https://github.com/symfony/symfony/issues/32995
*/
public function testBadParentWithNoTimestamp()
{
$this->expectException('ReflectionException');

3
src/Symfony/Component/Debug/ErrorHandler.php
View File

@ -382,8 +382,7 @@ class ErrorHandler
*/
public function handleError($type, $message, $file, $line)
{
// @deprecated to be removed in Symfony 5.0
if (\PHP_VERSION_ID >= 70300 && $message && '"' === $message[0] && 0 === strpos($message, '"continue') && preg_match('/^"continue(?: \d++)?" targeting switch is equivalent to "break(?: \d++)?"\. Did you mean to use "continue(?: \d++)?"\?$/', $message)) {
if (\PHP_VERSION_ID >= 70300 && E_WARNING === $type && '"' === $message[0] && false !== strpos($message, '" targeting switch is equivalent to "break')) {
$type = E_DEPRECATED;
}

15
src/Symfony/Component/DependencyInjection/Tests/Compiler/AutowirePassTest.php
View File

@ -349,11 +349,6 @@ class AutowirePassTest extends TestCase
}
}
/**
* @group issue-32995
*
* @runInSeparateProcess https://github.com/symfony/symfony/issues/32995
*/
public function testParentClassNotFoundThrowsException()
{
$container = new ContainerBuilder();
@ -627,11 +622,6 @@ class AutowirePassTest extends TestCase
];
}
/**
* @group issue-32995
*
* @runInSeparateProcess https://github.com/symfony/symfony/issues/32995
*/
public function testIgnoreServiceWithClassNotExisting()
{
$container = new ContainerBuilder();
@ -834,11 +824,6 @@ class AutowirePassTest extends TestCase
}
}
/**
* @group issue-32995
*
* @runInSeparateProcess https://github.com/symfony/symfony/issues/32995
*/
public function testExceptionWhenAliasDoesNotExist()
{
$container = new ContainerBuilder();

5
src/Symfony/Component/DependencyInjection/Tests/Compiler/ResolveBindingsPassTest.php
View File

@ -61,11 +61,6 @@ class ResolveBindingsPassTest extends TestCase
$pass->process($container);
}
/**
* @group issue-32995
*
* @runInSeparateProcess https://github.com/symfony/symfony/issues/32995
*/
public function testMissingParent()
{
$this->expectException('Symfony\Component\DependencyInjection\Exception\InvalidArgumentException');

5
src/Symfony/Component/DependencyInjection/Tests/Dumper/PhpDumperTest.php
View File

@ -1043,11 +1043,6 @@ class PhpDumperTest extends TestCase
$this->assertStringEqualsFile(self::$fixturesPath.'/php/services_inline_self_ref.php', $dumper->dump(['class' => 'Symfony_DI_PhpDumper_Test_Inline_Self_Ref']));
}
/**
* @group issue-32995
*
* @runInSeparateProcess https://github.com/symfony/symfony/issues/32995
*/
public function testHotPathOptimizations()
{
$container = include self::$fixturesPath.'/containers/container_inline_requires.php';

20
src/Symfony/Component/DependencyInjection/Tests/Loader/FileLoaderTest.php
View File

@ -106,11 +106,6 @@ class FileLoaderTest extends TestCase
);
}
/**
* @group issue-32995
*
* @runInSeparateProcess https://github.com/symfony/symfony/issues/32995
*/
public function testRegisterClassesWithExclude()
{
$container = new ContainerBuilder();
@ -140,11 +135,6 @@ class FileLoaderTest extends TestCase
);
}
/**
* @group issue-32995
*
* @runInSeparateProcess https://github.com/symfony/symfony/issues/32995
*/
public function testRegisterClassesWithExcludeAsArray()
{
$container = new ContainerBuilder();
@ -164,11 +154,6 @@ class FileLoaderTest extends TestCase
$this->assertFalse($container->has(DeeperBaz::class));
}
/**
* @group issue-32995
*
* @runInSeparateProcess https://github.com/symfony/symfony/issues/32995
*/
public function testNestedRegisterClasses()
{
$container = new ContainerBuilder();
@ -197,11 +182,6 @@ class FileLoaderTest extends TestCase
$this->assertFalse($alias->isPrivate());
}
/**
* @group issue-32995
*
* @runInSeparateProcess https://github.com/symfony/symfony/issues/32995
*/
public function testMissingParentClass()
{
$container = new ContainerBuilder();

2
src/Symfony/Component/Form/Test/FormPerformanceTestCase.php
View File

@ -11,6 +11,8 @@
namespace Symfony\Component\Form\Test;
use Symfony\Component\Form\Tests\VersionAwareTest;
/**
* Base class for performance tests.
*

1
src/Symfony/Component/Form/Tests/AbstractLayoutTest.php
View File

@ -17,7 +17,6 @@ use Symfony\Component\Form\Extension\Csrf\CsrfExtension;
use Symfony\Component\Form\FormError;
use Symfony\Component\Form\FormView;
use Symfony\Component\Form\Test\FormIntegrationTestCase;
use Symfony\Component\Form\Test\VersionAwareTest;
abstract class AbstractLayoutTest extends FormIntegrationTestCase
{

2
src/Symfony/Component/Form/Tests/Extension/Core/Type/BaseTypeTest.php
View File

@ -12,7 +12,7 @@
namespace Symfony\Component\Form\Tests\Extension\Core\Type;
use Symfony\Component\Form\Test\TypeTestCase;
use Symfony\Component\Form\Test\VersionAwareTest;
use Symfony\Component\Form\Tests\VersionAwareTest;
/**
* @author Bernhard Schussek <bschussek@gmail.com>

5
src/Symfony/Component/Form/Test/VersionAwareTest.php → src/Symfony/Component/Form/Tests/VersionAwareTest.php
View File

@ -9,11 +9,8 @@
* file that was distributed with this source code.
*/
namespace Symfony\Component\Form\Test;
namespace Symfony\Component\Form\Tests;
/**
* @internal
*/
trait VersionAwareTest
{
protected static $supportedFeatureSetVersion = 304;

263
src/Symfony/Component/HttpKernel/Test/Controller/ContainerControllerResolverTestCase.php
View File

@ -1,263 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\HttpKernel\Test\Controller;
use Psr\Container\ContainerInterface;
use Psr\Log\LoggerInterface;
use Symfony\Component\Debug\ErrorHandler;
use Symfony\Component\DependencyInjection\Container;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpKernel\Controller\ContainerControllerResolver;
/**
* @internal
*/
class ContainerControllerResolverTestCase extends ControllerResolverTestCase
{
public function testGetControllerServiceWithSingleColon()
{
$service = new ControllerTestService('foo');
$container = $this->createMockContainer();
$container->expects($this->once())
->method('has')
->with('foo')
->willReturn(true);
$container->expects($this->once())
->method('get')
->with('foo')
->willReturn($service)
;
$resolver = $this->createControllerResolver(null, $container);
$request = Request::create('/');
$request->attributes->set('_controller', 'foo:action');
$controller = $resolver->getController($request);
$this->assertSame($service, $controller[0]);
$this->assertSame('action', $controller[1]);
}
public function testGetControllerService()
{
$service = new ControllerTestService('foo');
$container = $this->createMockContainer();
$container->expects($this->once())
->method('has')
->with('foo')
->willReturn(true);
$container->expects($this->once())
->method('get')
->with('foo')
->willReturn($service)
;
$resolver = $this->createControllerResolver(null, $container);
$request = Request::create('/');
$request->attributes->set('_controller', 'foo::action');
$controller = $resolver->getController($request);
$this->assertSame($service, $controller[0]);
$this->assertSame('action', $controller[1]);
}
public function testGetControllerInvokableService()
{
$service = new InvokableControllerService('bar');
$container = $this->createMockContainer();
$container->expects($this->once())
->method('has')
->with('foo')
->willReturn(true)
;
$container->expects($this->once())
->method('get')
->with('foo')
->willReturn($service)
;
$resolver = $this->createControllerResolver(null, $container);
$request = Request::create('/');
$request->attributes->set('_controller', 'foo');
$controller = $resolver->getController($request);
$this->assertSame($service, $controller);
}
public function testGetControllerInvokableServiceWithClassNameAsName()
{
$service = new InvokableControllerService('bar');
$container = $this->createMockContainer();
$container->expects($this->once())
->method('has')
->with(InvokableControllerService::class)
->willReturn(true)
;
$container->expects($this->once())
->method('get')
->with(InvokableControllerService::class)
->willReturn($service)
;
$resolver = $this->createControllerResolver(null, $container);
$request = Request::create('/');
$request->attributes->set('_controller', InvokableControllerService::class);
$controller = $resolver->getController($request);
$this->assertSame($service, $controller);
}
/**
* @dataProvider getControllers
*/
public function testInstantiateControllerWhenControllerStartsWithABackslash($controller)
{
$service = new ControllerTestService('foo');
$class = ControllerTestService::class;
$container = $this->createMockContainer();
$container->expects($this->once())->method('has')->with($class)->willReturn(true);
$container->expects($this->once())->method('get')->with($class)->willReturn($service);
$resolver = $this->createControllerResolver(null, $container);
$request = Request::create('/');
$request->attributes->set('_controller', $controller);
$controller = $resolver->getController($request);
$this->assertInstanceOf(ControllerTestService::class, $controller[0]);
$this->assertSame('action', $controller[1]);
}
public function getControllers()
{
return [
['\\'.ControllerTestService::class.'::action'],
['\\'.ControllerTestService::class.':action'],
];
}
public function testExceptionWhenUsingRemovedControllerServiceWithClassNameAsName()
{
$this->expectException('InvalidArgumentException');
$this->expectExceptionMessage('Controller "Symfony\Component\HttpKernel\Test\Controller\ControllerTestService" cannot be fetched from the container because it is private. Did you forget to tag the service with "controller.service_arguments"?');
$container = $this->getMockBuilder(Container::class)->getMock();
$container->expects($this->once())
->method('has')
->with(ControllerTestService::class)
->willReturn(false)
;
$container->expects($this->atLeastOnce())
->method('getRemovedIds')
->with()
->willReturn([ControllerTestService::class => true])
;
$resolver = $this->createControllerResolver(null, $container);
$request = Request::create('/');
$request->attributes->set('_controller', [ControllerTestService::class, 'action']);
$resolver->getController($request);
}
public function testExceptionWhenUsingRemovedControllerService()
{
$this->expectException('InvalidArgumentException');
$this->expectExceptionMessage('Controller "app.my_controller" cannot be fetched from the container because it is private. Did you forget to tag the service with "controller.service_arguments"?');
$container = $this->getMockBuilder(Container::class)->getMock();
$container->expects($this->once())
->method('has')
->with('app.my_controller')
->willReturn(false)
;
$container->expects($this->atLeastOnce())
->method('getRemovedIds')
->with()
->willReturn(['app.my_controller' => true])
;
$resolver = $this->createControllerResolver(null, $container);
$request = Request::create('/');
$request->attributes->set('_controller', 'app.my_controller');
$resolver->getController($request);
}
public function getUndefinedControllers()
{
$tests = parent::getUndefinedControllers();
$tests[0] = ['foo', \InvalidArgumentException::class, 'Controller "foo" does neither exist as service nor as class'];
$tests[1] = ['oof::bar', \InvalidArgumentException::class, 'Controller "oof" does neither exist as service nor as class'];
$tests[2] = [['oof', 'bar'], \InvalidArgumentException::class, 'Controller "oof" does neither exist as service nor as class'];
$tests[] = [
[ControllerTestService::class, 'action'],
\InvalidArgumentException::class,
'Controller "Symfony\Component\HttpKernel\Test\Controller\ControllerTestService" has required constructor arguments and does not exist in the container. Did you forget to define such a service?',
];
$tests[] = [
ControllerTestService::class.'::action',
\InvalidArgumentException::class, 'Controller "Symfony\Component\HttpKernel\Test\Controller\ControllerTestService" has required constructor arguments and does not exist in the container. Did you forget to define such a service?',
];
$tests[] = [
InvokableControllerService::class,
\InvalidArgumentException::class,
'Controller "Symfony\Component\HttpKernel\Test\Controller\InvokableControllerService" has required constructor arguments and does not exist in the container. Did you forget to define such a service?',
];
return $tests;
}
protected function createControllerResolver(LoggerInterface $logger = null, ContainerInterface $container = null)
{
if (!$container) {
$container = $this->createMockContainer();
}
return new ContainerControllerResolver($container, $logger);
}
protected function createMockContainer()
{
return $this->getMockBuilder(ContainerInterface::class)->getMock();
}
}
class InvokableControllerService
{
public function __construct($bar) // mandatory argument to prevent automatic instantiation
{
}
public function __invoke()
{
}
}
class ControllerTestService
{
public function __construct($foo)
{
}
public function action()
{
}
}

292
src/Symfony/Component/HttpKernel/Test/Controller/ControllerResolverTestCase.php
View File

@ -1,292 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\HttpKernel\Test\Controller;
use PHPUnit\Framework\TestCase;
use Psr\Log\LoggerInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpKernel\Controller\ControllerResolver;
use Symfony\Component\HttpKernel\Test\Fixtures\Controller\NullableController;
use Symfony\Component\HttpKernel\Test\Fixtures\Controller\VariadicController;
/**
* @internal
*/
class ControllerResolverTestCase extends TestCase
{
public function testGetControllerWithoutControllerParameter()
{
$logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
$logger->expects($this->once())->method('warning')->with('Unable to look for the controller as the "_controller" parameter is missing.');
$resolver = $this->createControllerResolver($logger);
$request = Request::create('/');
$this->assertFalse($resolver->getController($request), '->getController() returns false when the request has no _controller attribute');
}
public function testGetControllerWithLambda()
{
$resolver = $this->createControllerResolver();
$request = Request::create('/');
$request->attributes->set('_controller', $lambda = function () {});
$controller = $resolver->getController($request);
$this->assertSame($lambda, $controller);
}
public function testGetControllerWithObjectAndInvokeMethod()
{
$resolver = $this->createControllerResolver();
$object = new InvokableController();
$request = Request::create('/');
$request->attributes->set('_controller', $object);
$controller = $resolver->getController($request);
$this->assertSame($object, $controller);
}
public function testGetControllerWithObjectAndMethod()
{
$resolver = $this->createControllerResolver();
$object = new ControllerTest();
$request = Request::create('/');
$request->attributes->set('_controller', [$object, 'publicAction']);
$controller = $resolver->getController($request);
$this->assertSame([$object, 'publicAction'], $controller);
}
public function testGetControllerWithClassAndMethodAsArray()
{
$resolver = $this->createControllerResolver();
$request = Request::create('/');
$request->attributes->set('_controller', [ControllerTest::class, 'publicAction']);
$controller = $resolver->getController($request);
$this->assertInstanceOf(ControllerTest::class, $controller[0]);
$this->assertSame('publicAction', $controller[1]);
}
public function testGetControllerWithClassAndMethodAsString()
{
$resolver = $this->createControllerResolver();
$request = Request::create('/');
$request->attributes->set('_controller', ControllerTest::class.'::publicAction');
$controller = $resolver->getController($request);
$this->assertInstanceOf(ControllerTest::class, $controller[0]);
$this->assertSame('publicAction', $controller[1]);
}
public function testGetControllerWithInvokableClass()
{
$resolver = $this->createControllerResolver();
$request = Request::create('/');
$request->attributes->set('_controller', InvokableController::class);
$controller = $resolver->getController($request);
$this->assertInstanceOf(InvokableController::class, $controller);
}
public function testGetControllerOnObjectWithoutInvokeMethod()
{
$this->expectException('InvalidArgumentException');
$resolver = $this->createControllerResolver();
$request = Request::create('/');
$request->attributes->set('_controller', new \stdClass());
$resolver->getController($request);
}
public function testGetControllerWithFunction()
{
$resolver = $this->createControllerResolver();
$request = Request::create('/');
$request->attributes->set('_controller', 'Symfony\Component\HttpKernel\Test\Controller\some_controller_function');
$controller = $resolver->getController($request);
$this->assertSame('Symfony\Component\HttpKernel\Test\Controller\some_controller_function', $controller);
}
public function testGetControllerWithClosure()
{
$resolver = $this->createControllerResolver();
$closure = function () {
return 'test';
};
$request = Request::create('/');
$request->attributes->set('_controller', $closure);
$controller = $resolver->getController($request);
$this->assertInstanceOf(\Closure::class, $controller);
$this->assertSame('test', $controller());
}
/**
* @dataProvider getStaticControllers
*/
public function testGetControllerWithStaticController($staticController, $returnValue)
{
$resolver = $this->createControllerResolver();
$request = Request::create('/');
$request->attributes->set('_controller', $staticController);
$controller = $resolver->getController($request);
$this->assertSame($staticController, $controller);
$this->assertSame($returnValue, $controller());
}
public function getStaticControllers()
{
return [
[TestAbstractController::class.'::staticAction', 'foo'],
[[TestAbstractController::class, 'staticAction'], 'foo'],
[PrivateConstructorController::class.'::staticAction', 'bar'],
[[PrivateConstructorController::class, 'staticAction'], 'bar'],
];
}
/**
* @dataProvider getUndefinedControllers
*/
public function testGetControllerWithUndefinedController($controller, $exceptionName = null, $exceptionMessage = null)
{
$resolver = $this->createControllerResolver();
$this->expectException($exceptionName);
$this->expectExceptionMessage($exceptionMessage);
$request = Request::create('/');
$request->attributes->set('_controller', $controller);
$resolver->getController($request);
}
public function getUndefinedControllers()
{
$controller = new ControllerTest();
return [
['foo', \Error::class, 'Class \'foo\' not found'],
['oof::bar', \Error::class, 'Class \'oof\' not found'],
[['oof', 'bar'], \Error::class, 'Class \'oof\' not found'],
['Symfony\Component\HttpKernel\Test\Controller\ControllerTest::staticsAction', \InvalidArgumentException::class, 'The controller for URI "/" is not callable. Expected method "staticsAction" on class "Symfony\Component\HttpKernel\Test\Controller\ControllerTest", did you mean "staticAction"?'],
['Symfony\Component\HttpKernel\Test\Controller\ControllerTest::privateAction', \InvalidArgumentException::class, 'The controller for URI "/" is not callable. Method "privateAction" on class "Symfony\Component\HttpKernel\Test\Controller\ControllerTest" should be public and non-abstract'],
['Symfony\Component\HttpKernel\Test\Controller\ControllerTest::protectedAction', \InvalidArgumentException::class, 'The controller for URI "/" is not callable. Method "protectedAction" on class "Symfony\Component\HttpKernel\Test\Controller\ControllerTest" should be public and non-abstract'],
['Symfony\Component\HttpKernel\Test\Controller\ControllerTest::undefinedAction', \InvalidArgumentException::class, 'The controller for URI "/" is not callable. Expected method "undefinedAction" on class "Symfony\Component\HttpKernel\Test\Controller\ControllerTest". Available methods: "publicAction", "staticAction"'],
['Symfony\Component\HttpKernel\Test\Controller\ControllerTest', \InvalidArgumentException::class, 'The controller for URI "/" is not callable. Controller class "Symfony\Component\HttpKernel\Test\Controller\ControllerTest" cannot be called without a method name. You need to implement "__invoke" or use one of the available methods: "publicAction", "staticAction".'],
[[$controller, 'staticsAction'], \InvalidArgumentException::class, 'The controller for URI "/" is not callable. Expected method "staticsAction" on class "Symfony\Component\HttpKernel\Test\Controller\ControllerTest", did you mean "staticAction"?'],
[[$controller, 'privateAction'], \InvalidArgumentException::class, 'The controller for URI "/" is not callable. Method "privateAction" on class "Symfony\Component\HttpKernel\Test\Controller\ControllerTest" should be public and non-abstract'],
[[$controller, 'protectedAction'], \InvalidArgumentException::class, 'The controller for URI "/" is not callable. Method "protectedAction" on class "Symfony\Component\HttpKernel\Test\Controller\ControllerTest" should be public and non-abstract'],
[[$controller, 'undefinedAction'], \InvalidArgumentException::class, 'The controller for URI "/" is not callable. Expected method "undefinedAction" on class "Symfony\Component\HttpKernel\Test\Controller\ControllerTest". Available methods: "publicAction", "staticAction"'],
[$controller, \InvalidArgumentException::class, 'The controller for URI "/" is not callable. Controller class "Symfony\Component\HttpKernel\Test\Controller\ControllerTest" cannot be called without a method name. You need to implement "__invoke" or use one of the available methods: "publicAction", "staticAction".'],
[['a' => 'foo', 'b' => 'bar'], \InvalidArgumentException::class, 'The controller for URI "/" is not callable. Invalid array callable, expected [controller, method].'],
];
}
public function testCreateControllerCanReturnAnyCallable()
{
$mock = $this->getMockBuilder('Symfony\Component\HttpKernel\Controller\ControllerResolver')->setMethods(['createController'])->getMock();
$mock->expects($this->once())->method('createController')->willReturn('Symfony\Component\HttpKernel\Test\Controller\some_controller_function');
$request = Request::create('/');
$request->attributes->set('_controller', 'foobar');
$mock->getController($request);
}
protected function createControllerResolver(LoggerInterface $logger = null)
{
return new ControllerResolver($logger);
}
public function __invoke($foo, $bar = null)
{
}
public function controllerMethod1($foo)
{
}
protected function controllerMethod2($foo, $bar = null)
{
}
protected function controllerMethod3($foo, $bar, $foobar)
{
}
protected static function controllerMethod4()
{
}
protected function controllerMethod5(Request $request)
{
}
}
function some_controller_function($foo, $foobar)
{
}
class ControllerTest
{
public function __construct()
{
}
public function __toString()
{
return '';
}
public function publicAction()
{
}
private function privateAction()
{
}
protected function protectedAction()
{
}
public static function staticAction()
{
}
}
class InvokableController
{
public function __invoke($foo, $bar = null)
{
}
}
abstract class TestAbstractController
{
public static function staticAction()
{
return 'foo';
}
}
class PrivateConstructorController
{
private function __construct()
{
}
public static function staticAction()
{
return 'bar';
}
}

4
src/Symfony/Component/HttpKernel/Tests/Controller/ArgumentResolverTest.php
View File

@ -20,10 +20,10 @@ use Symfony\Component\HttpKernel\Controller\ArgumentResolver;
use Symfony\Component\HttpKernel\Controller\ArgumentResolver\RequestAttributeValueResolver;
use Symfony\Component\HttpKernel\Controller\ArgumentValueResolverInterface;
use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadataFactory;
use Symfony\Component\HttpKernel\Test\Fixtures\Controller\NullableController;
use Symfony\Component\HttpKernel\Test\Fixtures\Controller\VariadicController;
use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\ExtendingRequest;
use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\ExtendingSession;
use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\NullableController;
use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\VariadicController;
class ArgumentResolverTest extends TestCase
{

284
src/Symfony/Component/HttpKernel/Tests/Controller/ContainerControllerResolverTest.php
View File

@ -11,8 +11,288 @@
namespace Symfony\Component\HttpKernel\Tests\Controller;
use Symfony\Component\HttpKernel\Test\Controller\ContainerControllerResolverTestCase;
use Psr\Container\ContainerInterface;
use Psr\Log\LoggerInterface;
use Symfony\Component\Debug\ErrorHandler;
use Symfony\Component\DependencyInjection\Container;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpKernel\Controller\ContainerControllerResolver;
class ContainerControllerResolverTest extends ContainerControllerResolverTestCase
class ContainerControllerResolverTest extends ControllerResolverTest
{
public function testGetControllerService()
{
$container = $this->createMockContainer();
$container->expects($this->once())
->method('has')
->with('foo')
->willReturn(true);
$container->expects($this->once())
->method('get')
->with('foo')
->willReturn($this)
;
$resolver = $this->createControllerResolver(null, $container);
$request = Request::create('/');
$request->attributes->set('_controller', 'foo:controllerMethod1');
$controller = $resolver->getController($request);
$this->assertInstanceOf(\get_class($this), $controller[0]);
$this->assertSame('controllerMethod1', $controller[1]);
}
public function testGetControllerInvokableService()
{
$invokableController = new InvokableController('bar');
$container = $this->createMockContainer();
$container->expects($this->once())
->method('has')
->with('foo')
->willReturn(true)
;
$container->expects($this->once())
->method('get')
->with('foo')
->willReturn($invokableController)
;
$resolver = $this->createControllerResolver(null, $container);
$request = Request::create('/');
$request->attributes->set('_controller', 'foo');
$controller = $resolver->getController($request);
$this->assertEquals($invokableController, $controller);
}
public function testGetControllerInvokableServiceWithClassNameAsName()
{
$invokableController = new InvokableController('bar');
$className = __NAMESPACE__.'\InvokableController';
$container = $this->createMockContainer();
$container->expects($this->once())
->method('has')
->with($className)
->willReturn(true)
;
$container->expects($this->once())
->method('get')
->with($className)
->willReturn($invokableController)
;
$resolver = $this->createControllerResolver(null, $container);
$request = Request::create('/');
$request->attributes->set('_controller', $className);
$controller = $resolver->getController($request);
$this->assertEquals($invokableController, $controller);
}
public function testNonInstantiableController()
{
$container = $this->createMockContainer();
$container->expects($this->once())
->method('has')
->with(NonInstantiableController::class)
->willReturn(false)
;
$resolver = $this->createControllerResolver(null, $container);
$request = Request::create('/');
$request->attributes->set('_controller', [NonInstantiableController::class, 'action']);
$controller = $resolver->getController($request);
$this->assertSame([NonInstantiableController::class, 'action'], $controller);
}
public function testNonConstructController()
{
$this->expectException('LogicException');
$this->expectExceptionMessage('Controller "Symfony\Component\HttpKernel\Tests\Controller\ImpossibleConstructController" cannot be fetched from the container because it is private. Did you forget to tag the service with "controller.service_arguments"?');
$container = $this->getMockBuilder(Container::class)->getMock();
$container->expects($this->at(0))
->method('has')
->with(ImpossibleConstructController::class)
->willReturn(true)
;
$container->expects($this->at(1))
->method('has')
->with(ImpossibleConstructController::class)
->willReturn(false)
;
$container->expects($this->atLeastOnce())
->method('getRemovedIds')
->with()
->willReturn([ImpossibleConstructController::class => true])
;
$resolver = $this->createControllerResolver(null, $container);
$request = Request::create('/');
$request->attributes->set('_controller', [ImpossibleConstructController::class, 'action']);
if (\PHP_VERSION_ID < 70100) {
ErrorHandler::register();
try {
$resolver->getController($request);
} finally {
restore_error_handler();
restore_exception_handler();
}
} else {
$resolver->getController($request);
}
}
public function testNonInstantiableControllerWithCorrespondingService()
{
$service = new \stdClass();
$container = $this->createMockContainer();
$container->expects($this->atLeastOnce())
->method('has')
->with(NonInstantiableController::class)
->willReturn(true)
;
$container->expects($this->atLeastOnce())
->method('get')
->with(NonInstantiableController::class)
->willReturn($service)
;
$resolver = $this->createControllerResolver(null, $container);
$request = Request::create('/');
$request->attributes->set('_controller', [NonInstantiableController::class, 'action']);
$controller = $resolver->getController($request);
$this->assertSame([$service, 'action'], $controller);
}
public function testExceptionWhenUsingRemovedControllerService()
{
$this->expectException('LogicException');
$this->expectExceptionMessage('Controller "app.my_controller" cannot be fetched from the container because it is private. Did you forget to tag the service with "controller.service_arguments"?');
$container = $this->getMockBuilder(Container::class)->getMock();
$container->expects($this->at(0))
->method('has')
->with('app.my_controller')
->willReturn(false)
;
$container->expects($this->atLeastOnce())
->method('getRemovedIds')
->with()
->willReturn(['app.my_controller' => true])
;
$resolver = $this->createControllerResolver(null, $container);
$request = Request::create('/');
$request->attributes->set('_controller', 'app.my_controller');
$resolver->getController($request);
}
public function testExceptionWhenUsingControllerWithoutAnInvokeMethod()
{
$this->expectException('LogicException');
$this->expectExceptionMessage('Controller "app.my_controller" cannot be called without a method name. Did you forget an "__invoke" method?');
$container = $this->getMockBuilder(Container::class)->getMock();
$container->expects($this->once())
->method('has')
->with('app.my_controller')
->willReturn(true)
;
$container->expects($this->once())
->method('get')
->with('app.my_controller')
->willReturn(new ImpossibleConstructController('toto', 'controller'))
;
$resolver = $this->createControllerResolver(null, $container);
$request = Request::create('/');
$request->attributes->set('_controller', 'app.my_controller');
$resolver->getController($request);
}
/**
* @dataProvider getUndefinedControllers
*/
public function testGetControllerOnNonUndefinedFunction($controller, $exceptionName = null, $exceptionMessage = null)
{
// All this logic needs to be duplicated, since calling parent::testGetControllerOnNonUndefinedFunction will override the expected excetion and not use the regex
$resolver = $this->createControllerResolver();
$this->expectException($exceptionName);
$this->expectExceptionMessageRegExp($exceptionMessage);
$request = Request::create('/');
$request->attributes->set('_controller', $controller);
$resolver->getController($request);
}
public function getUndefinedControllers()
{
return [
['foo', \LogicException::class, '/Controller not found: service "foo" does not exist\./'],
['oof::bar', \InvalidArgumentException::class, '/Class "oof" does not exist\./'],
['stdClass', \LogicException::class, '/Controller not found: service "stdClass" does not exist\./'],
[
'Symfony\Component\HttpKernel\Tests\Controller\ControllerResolverTest::bar',
\InvalidArgumentException::class,
'/.?[cC]ontroller(.*?) for URI "\/" is not callable\.( Expected method(.*) Available methods)?/',
],
];
}
protected function createControllerResolver(LoggerInterface $logger = null, ContainerInterface $container = null)
{
if (!$container) {
$container = $this->createMockContainer();
}
return new ContainerControllerResolver($container, $logger);
}
protected function createMockContainer()
{
return $this->getMockBuilder(ContainerInterface::class)->getMock();
}
}
class InvokableController
{
public function __construct($bar) // mandatory argument to prevent automatic instantiation
{
}
public function __invoke()
{
}
}
abstract class NonInstantiableController
{
public static function action()
{
}
}
class ImpossibleConstructController
{
public function __construct($toto, $controller)
{
}
public function action()
{
}
}

311
src/Symfony/Component/HttpKernel/Tests/Controller/ControllerResolverTest.php
View File

@ -11,8 +11,315 @@
namespace Symfony\Component\HttpKernel\Tests\Controller;
use Symfony\Component\HttpKernel\Test\Controller\ControllerResolverTestCase;
use PHPUnit\Framework\TestCase;
use Psr\Log\LoggerInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpKernel\Controller\ControllerResolver;
use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\NullableController;
use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\VariadicController;
class ControllerResolverTest extends ControllerResolverTestCase
class ControllerResolverTest extends TestCase
{
public function testGetControllerWithoutControllerParameter()
{
$logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
$logger->expects($this->once())->method('warning')->with('Unable to look for the controller as the "_controller" parameter is missing.');
$resolver = $this->createControllerResolver($logger);
$request = Request::create('/');
$this->assertFalse($resolver->getController($request), '->getController() returns false when the request has no _controller attribute');
}
public function testGetControllerWithLambda()
{
$resolver = $this->createControllerResolver();
$request = Request::create('/');
$request->attributes->set('_controller', $lambda = function () {});
$controller = $resolver->getController($request);
$this->assertSame($lambda, $controller);
}
public function testGetControllerWithObjectAndInvokeMethod()
{
$resolver = $this->createControllerResolver();
$request = Request::create('/');
$request->attributes->set('_controller', $this);
$controller = $resolver->getController($request);
$this->assertSame($this, $controller);
}
public function testGetControllerWithObjectAndMethod()
{
$resolver = $this->createControllerResolver();
$request = Request::create('/');
$request->attributes->set('_controller', [$this, 'controllerMethod1']);
$controller = $resolver->getController($request);
$this->assertSame([$this, 'controllerMethod1'], $controller);
}
public function testGetControllerWithClassAndMethod()
{
$resolver = $this->createControllerResolver();
$request = Request::create('/');
$request->attributes->set('_controller', ['Symfony\Component\HttpKernel\Tests\Controller\ControllerResolverTest', 'controllerMethod4']);
$controller = $resolver->getController($request);
$this->assertSame(['Symfony\Component\HttpKernel\Tests\Controller\ControllerResolverTest', 'controllerMethod4'], $controller);
}
public function testGetControllerWithObjectAndMethodAsString()
{
$resolver = $this->createControllerResolver();
$request = Request::create('/');
$request->attributes->set('_controller', 'Symfony\Component\HttpKernel\Tests\Controller\ControllerResolverTest::controllerMethod1');
$controller = $resolver->getController($request);
$this->assertInstanceOf('Symfony\Component\HttpKernel\Tests\Controller\ControllerResolverTest', $controller[0], '->getController() returns a PHP callable');
}
public function testGetControllerWithClassAndInvokeMethod()
{
$resolver = $this->createControllerResolver();
$request = Request::create('/');
$request->attributes->set('_controller', 'Symfony\Component\HttpKernel\Tests\Controller\ControllerResolverTest');
$controller = $resolver->getController($request);
$this->assertInstanceOf('Symfony\Component\HttpKernel\Tests\Controller\ControllerResolverTest', $controller);
}
public function testGetControllerOnObjectWithoutInvokeMethod()
{
$this->expectException('InvalidArgumentException');
$resolver = $this->createControllerResolver();
$request = Request::create('/');
$request->attributes->set('_controller', new \stdClass());
$resolver->getController($request);
}
public function testGetControllerWithFunction()
{
$resolver = $this->createControllerResolver();
$request = Request::create('/');
$request->attributes->set('_controller', 'Symfony\Component\HttpKernel\Tests\Controller\some_controller_function');
$controller = $resolver->getController($request);
$this->assertSame('Symfony\Component\HttpKernel\Tests\Controller\some_controller_function', $controller);
}
/**
* @dataProvider getUndefinedControllers
*/
public function testGetControllerOnNonUndefinedFunction($controller, $exceptionName = null, $exceptionMessage = null)
{
$resolver = $this->createControllerResolver();
$this->expectException($exceptionName);
$this->expectExceptionMessage($exceptionMessage);
$request = Request::create('/');
$request->attributes->set('_controller', $controller);
$resolver->getController($request);
}
public function getUndefinedControllers()
{
return [
[1, 'InvalidArgumentException', 'Unable to find controller "1".'],
['foo', 'InvalidArgumentException', 'Unable to find controller "foo".'],
['oof::bar', 'InvalidArgumentException', 'Class "oof" does not exist.'],
['stdClass', 'InvalidArgumentException', 'Unable to find controller "stdClass".'],
['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"?'],
['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'],
['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'],
['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"'],
];
}
/**
* @group legacy
*/
public function testGetArguments()
{
$resolver = $this->createControllerResolver();
$request = Request::create('/');
$controller = [new self(), 'testGetArguments'];
$this->assertEquals([], $resolver->getArguments($request, $controller), '->getArguments() returns an empty array if the method takes no arguments');
$request = Request::create('/');
$request->attributes->set('foo', 'foo');
$controller = [new self(), 'controllerMethod1'];
$this->assertEquals(['foo'], $resolver->getArguments($request, $controller), '->getArguments() returns an array of arguments for the controller method');
$request = Request::create('/');
$request->attributes->set('foo', 'foo');
$controller = [new self(), 'controllerMethod2'];
$this->assertEquals(['foo', null], $resolver->getArguments($request, $controller), '->getArguments() uses default values if present');
$request->attributes->set('bar', 'bar');
$this->assertEquals(['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(['foo'], $resolver->getArguments($request, $controller));
$request = Request::create('/');
$request->attributes->set('foo', 'foo');
$controller = function ($foo, $bar = 'bar') {};
$this->assertEquals(['foo', 'bar'], $resolver->getArguments($request, $controller));
$request = Request::create('/');
$request->attributes->set('foo', 'foo');
$controller = new self();
$this->assertEquals(['foo', null], $resolver->getArguments($request, $controller));
$request->attributes->set('bar', 'bar');
$this->assertEquals(['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(['foo', 'foobar'], $resolver->getArguments($request, $controller));
$request = Request::create('/');
$request->attributes->set('foo', 'foo');
$request->attributes->set('foobar', 'foobar');
$controller = [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 = [new self(), 'controllerMethod5'];
$this->assertEquals([$request], $resolver->getArguments($request, $controller), '->getArguments() injects the request');
}
/**
* @requires PHP 5.6
* @group legacy
*/
public function testGetVariadicArguments()
{
$resolver = new ControllerResolver();
$request = Request::create('/');
$request->attributes->set('foo', 'foo');
$request->attributes->set('bar', ['foo', 'bar']);
$controller = [new VariadicController(), 'action'];
$this->assertEquals(['foo', 'foo', 'bar'], $resolver->getArguments($request, $controller));
}
public function testCreateControllerCanReturnAnyCallable()
{
$mock = $this->getMockBuilder('Symfony\Component\HttpKernel\Controller\ControllerResolver')->setMethods(['createController'])->getMock();
$mock->expects($this->once())->method('createController')->willReturn('Symfony\Component\HttpKernel\Tests\Controller\some_controller_function');
$request = Request::create('/');
$request->attributes->set('_controller', 'foobar');
$mock->getController($request);
}
/**
* @group legacy
*/
public function testIfExceptionIsThrownWhenMissingAnArgument()
{
$this->expectException('RuntimeException');
$resolver = new ControllerResolver();
$request = Request::create('/');
$controller = [$this, 'controllerMethod1'];
$resolver->getArguments($request, $controller);
}
/**
* @requires PHP 7.1
* @group legacy
*/
public function testGetNullableArguments()
{
$resolver = new ControllerResolver();
$request = Request::create('/');
$request->attributes->set('foo', 'foo');
$request->attributes->set('bar', new \stdClass());
$request->attributes->set('mandatory', 'mandatory');
$controller = [new NullableController(), 'action'];
$this->assertEquals(['foo', new \stdClass(), 'value', 'mandatory'], $resolver->getArguments($request, $controller));
}
/**
* @requires PHP 7.1
* @group legacy
*/
public function testGetNullableArgumentsWithDefaults()
{
$resolver = new ControllerResolver();
$request = Request::create('/');
$request->attributes->set('mandatory', 'mandatory');
$controller = [new NullableController(), 'action'];
$this->assertEquals([null, null, 'value', 'mandatory'], $resolver->getArguments($request, $controller));
}
protected function createControllerResolver(LoggerInterface $logger = null)
{
return new ControllerResolver($logger);
}
public function __invoke($foo, $bar = null)
{
}
public function controllerMethod1($foo)
{
}
protected function controllerMethod2($foo, $bar = null)
{
}
protected function controllerMethod3($foo, $bar, $foobar)
{
}
protected static function controllerMethod4()
{
}
protected function controllerMethod5(Request $request)
{
}
}
function some_controller_function($foo, $foobar)
{
}
class ControllerTest
{
public function publicAction()
{
}
private function privateAction()
{
}
protected function protectedAction()
{
}
public static function staticAction()
{
}
}

4
src/Symfony/Component/HttpKernel/Tests/ControllerMetadata/ArgumentMetadataFactoryTest.php
View File

@ -15,9 +15,9 @@ use Fake\ImportedAndFake;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadata;
use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadataFactory;
use Symfony\Component\HttpKernel\Test\Fixtures\Controller\NullableController;
use Symfony\Component\HttpKernel\Test\Fixtures\Controller\VariadicController;
use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\BasicTypesController;
use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\NullableController;
use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\VariadicController;
class ArgumentMetadataFactoryTest extends TestCase
{

5
src/Symfony/Component/HttpKernel/Test/Fixtures/Controller/NullableController.php → src/Symfony/Component/HttpKernel/Tests/Fixtures/Controller/NullableController.php
View File

@ -9,11 +9,8 @@
* file that was distributed with this source code.
*/
namespace Symfony\Component\HttpKernel\Test\Fixtures\Controller;
namespace Symfony\Component\HttpKernel\Tests\Fixtures\Controller;
/**
* @internal
*/
class NullableController
{
public function action(?string $foo, ?\stdClass $bar, ?string $baz = 'value', $mandatory)

5
src/Symfony/Component/HttpKernel/Test/Fixtures/Controller/VariadicController.php → src/Symfony/Component/HttpKernel/Tests/Fixtures/Controller/VariadicController.php
View File

@ -9,11 +9,8 @@
* file that was distributed with this source code.
*/
namespace Symfony\Component\HttpKernel\Test\Fixtures\Controller;
namespace Symfony\Component\HttpKernel\Tests\Fixtures\Controller;
/**
* @internal
*/
class VariadicController
{
public function action($foo, ...$bar)

2
src/Symfony/Component/Process/Tests/ProcessTest.php
View File

@ -72,7 +72,7 @@ class ProcessTest extends TestCase
$process = $this->getProcessForCode('sleep(3)');
$process->run();
$actualError = error_get_last();
$this->assertEquals('Test Error', $actualError['message']);
$this->assertEquals('Test Error', $actualError['message'], print_r($actualError, true));
$this->assertEquals(E_USER_NOTICE, $actualError['type']);
}

13
src/Symfony/Component/Translation/Tests/Command/XliffLintCommandTest.php
View File

@ -119,17 +119,6 @@ class XliffLintCommandTest extends TestCase
{
$command = new XliffLintCommand();
$expected = <<<EOF
The <info>%command.name%</info> command lints a XLIFF file and outputs to STDOUT
the first encountered syntax error.
You can validates XLIFF contents passed from STDIN:
<info>cat filename | php %command.full_name%</info>
You can also validate the syntax of a file:
<info>php %command.full_name% filename</info>
Or of a whole directory:
<info>php %command.full_name% dirname</info>
@ -137,7 +126,7 @@ Or of a whole directory:
EOF;
$this->assertEquals($expected, $command->getHelp());
$this->assertStringContainsString($expected, $command->getHelp());
}
/**