Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • dmj/selbstzeugnisse-hab
  • goermar/selbstzeugnisse-hab
2 results
Show changes
Showing
with 1609 additions and 0 deletions
<?php
/*
* This file is part of the Silex framework.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace Silex\Tests\Provider;
use PHPUnit\Framework\TestCase;
use Pimple\Container;
use Silex\Application;
use Silex\Provider\DoctrineServiceProvider;
/**
* DoctrineProvider test cases.
*
* Fabien Potencier <fabien@symfony.com>
*/
class DoctrineServiceProviderTest extends TestCase
{
public function testOptionsInitializer()
{
$app = new Application();
$app->register(new DoctrineServiceProvider());
$this->assertEquals($app['db.default_options'], $app['db']->getParams());
}
public function testSingleConnection()
{
if (!in_array('sqlite', \PDO::getAvailableDrivers())) {
$this->markTestSkipped('pdo_sqlite is not available');
}
$app = new Application();
$app->register(new DoctrineServiceProvider(), [
'db.options' => ['driver' => 'pdo_sqlite', 'memory' => true],
]);
$db = $app['db'];
$params = $db->getParams();
$this->assertArrayHasKey('memory', $params);
$this->assertTrue($params['memory']);
$this->assertInstanceof('Doctrine\DBAL\Driver\PDOSqlite\Driver', $db->getDriver());
$this->assertEquals(22, $app['db']->fetchColumn('SELECT 22'));
$this->assertSame($app['dbs']['default'], $db);
}
public function testMultipleConnections()
{
if (!in_array('sqlite', \PDO::getAvailableDrivers())) {
$this->markTestSkipped('pdo_sqlite is not available');
}
$app = new Application();
$app->register(new DoctrineServiceProvider(), [
'dbs.options' => [
'sqlite1' => ['driver' => 'pdo_sqlite', 'memory' => true],
'sqlite2' => ['driver' => 'pdo_sqlite', 'path' => sys_get_temp_dir().'/silex'],
],
]);
$db = $app['db'];
$params = $db->getParams();
$this->assertArrayHasKey('memory', $params);
$this->assertTrue($params['memory']);
$this->assertInstanceof('Doctrine\DBAL\Driver\PDOSqlite\Driver', $db->getDriver());
$this->assertEquals(22, $app['db']->fetchColumn('SELECT 22'));
$this->assertSame($app['dbs']['sqlite1'], $db);
$db2 = $app['dbs']['sqlite2'];
$params = $db2->getParams();
$this->assertArrayHasKey('path', $params);
$this->assertEquals(sys_get_temp_dir().'/silex', $params['path']);
}
public function testLoggerLoading()
{
if (!in_array('sqlite', \PDO::getAvailableDrivers())) {
$this->markTestSkipped('pdo_sqlite is not available');
}
$app = new Application();
$this->assertArrayHasKey('logger', $app);
$this->assertNull($app['logger']);
$app->register(new DoctrineServiceProvider(), [
'dbs.options' => [
'sqlite1' => ['driver' => 'pdo_sqlite', 'memory' => true],
],
]);
$this->assertEquals(22, $app['db']->fetchColumn('SELECT 22'));
$this->assertNull($app['db']->getConfiguration()->getSQLLogger());
}
public function testLoggerNotLoaded()
{
if (!in_array('sqlite', \PDO::getAvailableDrivers())) {
$this->markTestSkipped('pdo_sqlite is not available');
}
$app = new Container();
$app->register(new DoctrineServiceProvider(), [
'dbs.options' => [
'sqlite1' => ['driver' => 'pdo_sqlite', 'memory' => true],
],
]);
$this->assertEquals(22, $app['db']->fetchColumn('SELECT 22'));
$this->assertNull($app['db']->getConfiguration()->getSQLLogger());
}
}
<?php
/*
* This file is part of the Silex framework.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace Silex\Tests\Provider;
use PHPUnit\Framework\TestCase;
use Silex\Application;
use Silex\Provider\FormServiceProvider;
use Silex\Provider\CsrfServiceProvider;
use Silex\Provider\SessionServiceProvider;
use Silex\Provider\TranslationServiceProvider;
use Silex\Provider\ValidatorServiceProvider;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\AbstractTypeExtension;
use Symfony\Component\Form\FormTypeGuesserChain;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Symfony\Component\Translation\Exception\NotFoundResourceException;
class FormServiceProviderTest extends TestCase
{
public function testFormFactoryServiceIsFormFactory()
{
$app = new Application();
$app->register(new FormServiceProvider());
$this->assertInstanceOf('Symfony\Component\Form\FormFactory', $app['form.factory']);
}
public function testFormRegistryServiceIsFormRegistry()
{
$app = new Application();
$app->register(new FormServiceProvider());
$this->assertInstanceOf('Symfony\Component\Form\FormRegistry', $app['form.registry']);
}
public function testFormServiceProviderWillLoadTypes()
{
$app = new Application();
$app->register(new FormServiceProvider());
$app->extend('form.types', function ($extensions) {
$extensions[] = new DummyFormType();
return $extensions;
});
$form = $app['form.factory']->createBuilder('Symfony\Component\Form\Extension\Core\Type\FormType', [])
->add('dummy', 'Silex\Tests\Provider\DummyFormType')
->getForm();
$this->assertInstanceOf('Symfony\Component\Form\Form', $form);
}
public function testFormServiceProviderWillLoadTypesServices()
{
$app = new Application();
$app->register(new FormServiceProvider());
$app['dummy'] = function () {
return new DummyFormType();
};
$app->extend('form.types', function ($extensions) {
$extensions[] = 'dummy';
return $extensions;
});
$form = $app['form.factory']
->createBuilder('Symfony\Component\Form\Extension\Core\Type\FormType', [])
->add('dummy', 'dummy')
->getForm();
$this->assertInstanceOf('Symfony\Component\Form\Form', $form);
}
/**
* @expectedException \Symfony\Component\Form\Exception\InvalidArgumentException
* @expectedExceptionMessage Invalid form type. The silex service "dummy" does not exist.
*/
public function testNonExistentTypeService()
{
$app = new Application();
$app->register(new FormServiceProvider());
$app->extend('form.types', function ($extensions) {
$extensions[] = 'dummy';
return $extensions;
});
$app['form.factory']
->createBuilder('Symfony\Component\Form\Extension\Core\Type\FormType', [])
->add('dummy', 'dummy')
->getForm();
}
public function testFormServiceProviderWillLoadTypeExtensions()
{
$app = new Application();
$app->register(new FormServiceProvider());
$app->extend('form.type.extensions', function ($extensions) {
$extensions[] = new DummyFormTypeExtension();
return $extensions;
});
$form = $app['form.factory']->createBuilder('Symfony\Component\Form\Extension\Core\Type\FormType', [])
->add('file', 'Symfony\Component\Form\Extension\Core\Type\FileType', ['image_path' => 'webPath'])
->getForm();
$this->assertInstanceOf('Symfony\Component\Form\Form', $form);
}
public function testFormServiceProviderWillLoadTypeExtensionsServices()
{
$app = new Application();
$app->register(new FormServiceProvider());
$app['dummy.form.type.extension'] = function () {
return new DummyFormTypeExtension();
};
$app->extend('form.type.extensions', function ($extensions) {
$extensions[] = 'dummy.form.type.extension';
return $extensions;
});
$form = $app['form.factory']
->createBuilder('Symfony\Component\Form\Extension\Core\Type\FormType', [])
->add('file', 'Symfony\Component\Form\Extension\Core\Type\FileType', ['image_path' => 'webPath'])
->getForm();
$this->assertInstanceOf('Symfony\Component\Form\Form', $form);
}
/**
* @expectedException \Symfony\Component\Form\Exception\InvalidArgumentException
* @expectedExceptionMessage Invalid form type extension. The silex service "dummy.form.type.extension" does not exist.
*/
public function testNonExistentTypeExtensionService()
{
$app = new Application();
$app->register(new FormServiceProvider());
$app->extend('form.type.extensions', function ($extensions) {
$extensions[] = 'dummy.form.type.extension';
return $extensions;
});
$app['form.factory']
->createBuilder('Symfony\Component\Form\Extension\Core\Type\FormType', [])
->add('dummy', 'dummy.form.type')
->getForm();
}
public function testFormServiceProviderWillLoadTypeGuessers()
{
$app = new Application();
$app->register(new FormServiceProvider());
$app->extend('form.type.guessers', function ($guessers) {
$guessers[] = new FormTypeGuesserChain([]);
return $guessers;
});
$this->assertInstanceOf('Symfony\Component\Form\FormFactory', $app['form.factory']);
}
public function testFormServiceProviderWillLoadTypeGuessersServices()
{
$app = new Application();
$app->register(new FormServiceProvider());
$app['dummy.form.type.guesser'] = function () {
return new FormTypeGuesserChain([]);
};
$app->extend('form.type.guessers', function ($guessers) {
$guessers[] = 'dummy.form.type.guesser';
return $guessers;
});
$this->assertInstanceOf('Symfony\Component\Form\FormFactory', $app['form.factory']);
}
/**
* @expectedException \Symfony\Component\Form\Exception\InvalidArgumentException
* @expectedExceptionMessage Invalid form type guesser. The silex service "dummy.form.type.guesser" does not exist.
*/
public function testNonExistentTypeGuesserService()
{
$app = new Application();
$app->register(new FormServiceProvider());
$app->extend('form.type.guessers', function ($extensions) {
$extensions[] = 'dummy.form.type.guesser';
return $extensions;
});
$factory = $app['form.factory'];
}
public function testFormServiceProviderWillUseTranslatorIfAvailable()
{
$app = new Application();
$app->register(new FormServiceProvider());
$app->register(new TranslationServiceProvider());
$app['translator.domains'] = [
'messages' => [
'de' => [
'The CSRF token is invalid. Please try to resubmit the form.' => 'German translation',
],
],
];
$app['locale'] = 'de';
$app['csrf.token_manager'] = function () {
return $this->getMockBuilder('Symfony\Component\Security\Csrf\CsrfTokenManagerInterface')->getMock();
};
$form = $app['form.factory']->createBuilder('Symfony\Component\Form\Extension\Core\Type\FormType', [])
->getForm();
$form->handleRequest($req = Request::create('/', 'POST', ['form' => [
'_token' => 'the wrong token',
]]));
$this->assertFalse($form->isValid());
$r = new \ReflectionMethod($form, 'getErrors');
if (!$r->getNumberOfParameters()) {
$this->assertContains('ERROR: German translation', $form->getErrorsAsString());
} else {
// as of 2.5
$this->assertContains('ERROR: German translation', (string) $form->getErrors(true, false));
}
}
public function testFormServiceProviderWillNotAddNonexistentTranslationFiles()
{
$app = new Application([
'locale' => 'nonexistent',
]);
$app->register(new FormServiceProvider());
$app->register(new ValidatorServiceProvider());
$app->register(new TranslationServiceProvider(), [
'locale_fallbacks' => [],
]);
$app['form.factory'];
$translator = $app['translator'];
try {
$translator->trans('test');
$this->addToAssertionCount(1);
} catch (NotFoundResourceException $e) {
$this->fail('Form factory should not add a translation resource that does not exist');
}
}
public function testFormCsrf()
{
$app = new Application();
$app->register(new FormServiceProvider());
$app->register(new SessionServiceProvider());
$app->register(new CsrfServiceProvider());
$app['session.test'] = true;
$form = $app['form.factory']->createBuilder('Symfony\Component\Form\Extension\Core\Type\FormType', [])->getForm();
$this->assertTrue(isset($form->createView()['_token']));
}
public function testUserExtensionCanConfigureDefaultExtensions()
{
$app = new Application();
$app->register(new FormServiceProvider());
$app->register(new SessionServiceProvider());
$app->register(new CsrfServiceProvider());
$app['session.test'] = true;
$app->extend('form.type.extensions', function ($extensions) {
$extensions[] = new FormServiceProviderTest\DisableCsrfExtension();
return $extensions;
});
$form = $app['form.factory']->createBuilder('Symfony\Component\Form\Extension\Core\Type\FormType', [])->getForm();
$this->assertFalse($form->getConfig()->getOption('csrf_protection'));
}
}
class DummyFormType extends AbstractType
{
}
class DummyFormTypeExtension extends AbstractTypeExtension
{
public function getExtendedType()
{
return 'Symfony\Component\Form\Extension\Core\Type\FileType';
}
public function configureOptions(OptionsResolver $resolver)
{
$resolver->setDefined(['image_path']);
}
}
<?php
namespace Silex\Tests\Provider\FormServiceProviderTest;
use Symfony\Component\Form\AbstractTypeExtension;
use Symfony\Component\Form\Extension\Core\Type\FormType;
use Symfony\Component\OptionsResolver\OptionsResolver;
class DisableCsrfExtension extends AbstractTypeExtension
{
public function configureOptions(OptionsResolver $resolver)
{
$resolver->setDefaults([
'csrf_protection' => false,
]);
}
public function getExtendedType()
{
return FormType::class;
}
}
<?php
/*
* This file is part of the Silex framework.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace Silex\Tests\Provider;
use PHPUnit\Framework\TestCase;
use Silex\Application;
use Silex\Provider\HttpCacheServiceProvider;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
/**
* HttpCacheProvider test cases.
*
* @author Igor Wiedler <igor@wiedler.ch>
*/
class HttpCacheServiceProviderTest extends TestCase
{
public function testRegister()
{
$app = new Application();
$app->register(new HttpCacheServiceProvider(), [
'http_cache.cache_dir' => sys_get_temp_dir().'/silex_http_cache_'.uniqid(),
]);
$this->assertInstanceOf('Silex\Provider\HttpCache\HttpCache', $app['http_cache']);
return $app;
}
/**
* @depends testRegister
*/
public function testRunCallsShutdown($app)
{
$finished = false;
$app->finish(function () use (&$finished) {
$finished = true;
});
$app->get('/', function () use ($app) {
return new UnsendableResponse('will do something after finish');
});
$request = Request::create('/');
$app['http_cache']->run($request);
$this->assertTrue($finished);
}
public function testDebugDefaultsToThatOfApp()
{
$app = new Application();
$app->register(new HttpCacheServiceProvider(), [
'http_cache.cache_dir' => sys_get_temp_dir().'/silex_http_cache_'.uniqid(),
]);
$app['debug'] = true;
$app['http_cache'];
$this->assertTrue($app['http_cache.options']['debug']);
}
}
class UnsendableResponse extends Response
{
public function send()
{
// do nothing
}
}
<?php
/*
* This file is part of the Silex framework.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace Silex\Tests\Provider;
use PHPUnit\Framework\TestCase;
use Silex\Application;
use Silex\Provider\HttpCacheServiceProvider;
use Silex\Provider\HttpFragmentServiceProvider;
use Silex\Provider\TwigServiceProvider;
use Symfony\Component\HttpFoundation\Request;
class HttpFragmentServiceProviderTest extends TestCase
{
public function testRenderFunction()
{
$app = new Application();
unset($app['exception_handler']);
$app->register(new HttpFragmentServiceProvider());
$app->register(new HttpCacheServiceProvider(), ['http_cache.cache_dir' => sys_get_temp_dir()]);
$app->register(new TwigServiceProvider(), [
'twig.templates' => [
'hello' => '{{ render("/foo") }}{{ render_esi("/foo") }}{{ render_hinclude("/foo") }}',
'foo' => 'foo',
],
]);
$app->get('/hello', function () use ($app) {
return $app['twig']->render('hello');
});
$app->get('/foo', function () use ($app) {
return $app['twig']->render('foo');
});
$response = $app['http_cache']->handle(Request::create('/hello'));
$this->assertEquals('foofoo<hx:include src="/foo"></hx:include>', $response->getContent());
}
}
<?php
/*
* This file is part of the Silex framework.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace Silex\Tests\Provider;
use PHPUnit\Framework\TestCase;
use Monolog\Formatter\JsonFormatter;
use Monolog\Handler\TestHandler;
use Monolog\Logger;
use Silex\Application;
use Silex\Provider\MonologServiceProvider;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
/**
* MonologProvider test cases.
*
* @author Igor Wiedler <igor@wiedler.ch>
*/
class MonologServiceProviderTest extends TestCase
{
private $currErrorHandler;
protected function setUp()
{
$this->currErrorHandler = set_error_handler('var_dump');
restore_error_handler();
}
protected function tearDown()
{
set_error_handler($this->currErrorHandler);
}
public function testRequestLogging()
{
$app = $this->getApplication();
$app->get('/foo', function () use ($app) {
return 'foo';
});
$this->assertFalse($app['monolog.handler']->hasInfoRecords());
$request = Request::create('/foo');
$app->handle($request);
$this->assertTrue($app['monolog.handler']->hasDebug('> GET /foo'));
$this->assertTrue($app['monolog.handler']->hasDebug('< 200'));
$records = $app['monolog.handler']->getRecords();
$this->assertContains('Matched route "{route}".', $records[0]['message']);
$this->assertSame('GET_foo', $records[0]['context']['route']);
}
public function testManualLogging()
{
$app = $this->getApplication();
$app->get('/log', function () use ($app) {
$app['monolog']->addDebug('logging a message');
});
$this->assertFalse($app['monolog.handler']->hasDebugRecords());
$request = Request::create('/log');
$app->handle($request);
$this->assertTrue($app['monolog.handler']->hasDebug('logging a message'));
}
public function testOverrideFormatter()
{
$app = new Application();
$app->register(new MonologServiceProvider(), [
'monolog.formatter' => new JsonFormatter(),
'monolog.logfile' => 'php://memory',
]);
$this->assertInstanceOf('Monolog\Formatter\JsonFormatter', $app['monolog.handler']->getFormatter());
}
public function testErrorLogging()
{
$app = $this->getApplication();
$app->error(function (\Exception $e) {
return 'error handled';
});
/*
* Simulate 404, logged to error level
*/
$this->assertFalse($app['monolog.handler']->hasErrorRecords());
$request = Request::create('/error');
$app->handle($request);
$pattern = "#Symfony\\\\Component\\\\HttpKernel\\\\Exception\\\\NotFoundHttpException: No route found for \"GET /error\" \(uncaught exception\) at .* line \d+#";
$this->assertMatchingRecord($pattern, Logger::ERROR, $app['monolog.handler']);
/*
* Simulate unhandled exception, logged to critical
*/
$app->get('/error', function () {
throw new \RuntimeException('very bad error');
});
$this->assertFalse($app['monolog.handler']->hasCriticalRecords());
$request = Request::create('/error');
$app->handle($request);
$pattern = "#RuntimeException: very bad error \(uncaught exception\) at .* line \d+#";
$this->assertMatchingRecord($pattern, Logger::CRITICAL, $app['monolog.handler']);
}
public function testRedirectLogging()
{
$app = $this->getApplication();
$app->get('/foo', function () use ($app) {
return new RedirectResponse('/bar', 302);
});
$this->assertFalse($app['monolog.handler']->hasInfoRecords());
$request = Request::create('/foo');
$app->handle($request);
$this->assertTrue($app['monolog.handler']->hasDebug('< 302 /bar'));
}
public function testErrorLoggingGivesWayToSecurityExceptionHandling()
{
$app = $this->getApplication();
$app['monolog.level'] = Logger::ERROR;
$app->register(new \Silex\Provider\SecurityServiceProvider(), [
'security.firewalls' => [
'admin' => [
'pattern' => '^/admin',
'http' => true,
'users' => [],
],
],
]);
$app->get('/admin', function () {
return 'SECURE!';
});
$request = Request::create('/admin');
$app->run($request);
$this->assertEmpty($app['monolog.handler']->getRecords(), 'Expected no logging to occur');
}
public function testStringErrorLevel()
{
$app = $this->getApplication();
$app['monolog.level'] = 'info';
$this->assertSame(Logger::INFO, $app['monolog.handler']->getLevel());
}
/**
* @expectedException \InvalidArgumentException
* @expectedExceptionMessage Provided logging level 'foo' does not exist. Must be a valid monolog logging level.
*/
public function testNonExistentStringErrorLevel()
{
$app = $this->getApplication();
$app['monolog.level'] = 'foo';
$app['monolog.handler']->getLevel();
}
public function testDisableListener()
{
$app = $this->getApplication();
unset($app['monolog.listener']);
$app->handle(Request::create('/404'));
$this->assertEmpty($app['monolog.handler']->getRecords(), 'Expected no logging to occur');
}
public function testExceptionFiltering()
{
$app = new Application();
$app->get('/foo', function () use ($app) {
throw new NotFoundHttpException();
});
$level = Logger::ERROR;
$app->register(new MonologServiceProvider(), [
'monolog.exception.logger_filter' => $app->protect(function () {
return Logger::DEBUG;
}),
'monolog.handler' => function () use ($app) {
return new TestHandler($app['monolog.level']);
},
'monolog.level' => $level,
'monolog.logfile' => 'php://memory',
]);
$request = Request::create('/foo');
$app->handle($request);
$this->assertCount(0, $app['monolog.handler']->getRecords(), 'Expected no logging to occur');
}
protected function assertMatchingRecord($pattern, $level, TestHandler $handler)
{
$found = false;
$records = $handler->getRecords();
foreach ($records as $record) {
if (preg_match($pattern, $record['message']) && $record['level'] == $level) {
$found = true;
continue;
}
}
$this->assertTrue($found, "Trying to find record matching $pattern with level $level");
}
protected function getApplication()
{
$app = new Application();
$app->register(new MonologServiceProvider(), [
'monolog.handler' => function () use ($app) {
$level = MonologServiceProvider::translateLevel($app['monolog.level']);
return new TestHandler($level);
},
'monolog.logfile' => 'php://memory',
]);
return $app;
}
}
<?php
/*
* This file is part of the Silex framework.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace Silex\Tests\Provider;
use Silex\Application;
use Silex\WebTestCase;
use Silex\Provider\RememberMeServiceProvider;
use Silex\Provider\SecurityServiceProvider;
use Silex\Provider\SessionServiceProvider;
use Symfony\Component\HttpKernel\Client;
use Symfony\Component\Security\Http\SecurityEvents;
/**
* SecurityServiceProvider.
*
* @author Fabien Potencier <fabien@symfony.com>
*/
class RememberMeServiceProviderTest extends WebTestCase
{
public function testRememberMeAuthentication()
{
$app = $this->createApplication();
$interactiveLogin = new InteractiveLoginTriggered();
$app->on(SecurityEvents::INTERACTIVE_LOGIN, [$interactiveLogin, 'onInteractiveLogin']);
$client = new Client($app);
$client->request('get', '/');
$this->assertFalse($interactiveLogin->triggered, 'The interactive login has not been triggered yet');
$client->request('post', '/login_check', ['_username' => 'fabien', '_password' => 'foo', '_remember_me' => 'true']);
$client->followRedirect();
$this->assertEquals('AUTHENTICATED_FULLY', $client->getResponse()->getContent());
$this->assertTrue($interactiveLogin->triggered, 'The interactive login has been triggered');
$this->assertNotNull($client->getCookiejar()->get('REMEMBERME'), 'The REMEMBERME cookie is set');
$event = false;
$client->getCookiejar()->expire('MOCKSESSID');
$client->request('get', '/');
$this->assertEquals('AUTHENTICATED_REMEMBERED', $client->getResponse()->getContent());
$this->assertTrue($interactiveLogin->triggered, 'The interactive login has been triggered');
$client->request('get', '/logout');
$client->followRedirect();
$this->assertNull($client->getCookiejar()->get('REMEMBERME'), 'The REMEMBERME cookie has been removed');
}
public function createApplication($authenticationMethod = 'form')
{
$app = new Application();
$app['debug'] = true;
unset($app['exception_handler']);
$app->register(new SessionServiceProvider(), [
'session.test' => true,
]);
$app->register(new SecurityServiceProvider());
$app->register(new RememberMeServiceProvider());
$app['security.firewalls'] = [
'http-auth' => [
'pattern' => '^.*$',
'form' => true,
'remember_me' => [],
'logout' => true,
'users' => [
'fabien' => ['ROLE_USER', '$2y$15$lzUNsTegNXvZW3qtfucV0erYBcEqWVeyOmjolB7R1uodsAVJ95vvu'],
],
],
];
$app->get('/', function () use ($app) {
if ($app['security.authorization_checker']->isGranted('IS_AUTHENTICATED_FULLY')) {
return 'AUTHENTICATED_FULLY';
} elseif ($app['security.authorization_checker']->isGranted('IS_AUTHENTICATED_REMEMBERED')) {
return 'AUTHENTICATED_REMEMBERED';
} else {
return 'AUTHENTICATED_ANONYMOUSLY';
}
});
return $app;
}
}
class InteractiveLoginTriggered
{
public $triggered = false;
public function onInteractiveLogin()
{
$this->triggered = true;
}
}
<?php
/*
* This file is part of the Silex framework.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace Silex\Tests\Provider;
use PHPUnit\Framework\TestCase;
use Pimple\Container;
use Silex\Application;
use Silex\Provider\RoutingServiceProvider;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
/**
* RoutingProvider test cases.
*
* @author Igor Wiedler <igor@wiedler.ch>
*/
class RoutingServiceProviderTest extends TestCase
{
public function testRegister()
{
$app = new Application();
$app->get('/hello/{name}', function ($name) {})
->bind('hello');
$app->get('/', function () {});
$request = Request::create('/');
$app->handle($request);
$this->assertInstanceOf('Symfony\Component\Routing\Generator\UrlGenerator', $app['url_generator']);
}
public function testUrlGeneration()
{
$app = new Application();
$app->get('/hello/{name}', function ($name) {})
->bind('hello');
$app->get('/', function () use ($app) {
return $app['url_generator']->generate('hello', ['name' => 'john']);
});
$request = Request::create('/');
$response = $app->handle($request);
$this->assertEquals('/hello/john', $response->getContent());
}
public function testAbsoluteUrlGeneration()
{
$app = new Application();
$app->get('/hello/{name}', function ($name) {})
->bind('hello');
$app->get('/', function () use ($app) {
return $app['url_generator']->generate('hello', ['name' => 'john'], UrlGeneratorInterface::ABSOLUTE_URL);
});
$request = Request::create('https://localhost:81/');
$response = $app->handle($request);
$this->assertEquals('https://localhost:81/hello/john', $response->getContent());
}
public function testUrlGenerationWithHttp()
{
$app = new Application();
$app->get('/insecure', function () {})
->bind('insecure_page')
->requireHttp();
$app->get('/', function () use ($app) {
return $app['url_generator']->generate('insecure_page');
});
$request = Request::create('https://localhost/');
$response = $app->handle($request);
$this->assertEquals('http://localhost/insecure', $response->getContent());
}
public function testUrlGenerationWithHttps()
{
$app = new Application();
$app->get('/secure', function () {})
->bind('secure_page')
->requireHttps();
$app->get('/', function () use ($app) {
return $app['url_generator']->generate('secure_page');
});
$request = Request::create('http://localhost/');
$response = $app->handle($request);
$this->assertEquals('https://localhost/secure', $response->getContent());
}
public function testControllersFactory()
{
$app = new Container();
$app->register(new RoutingServiceProvider());
$coll = $app['controllers_factory'];
$coll->mount('/blog', function ($blog) {
$this->assertInstanceOf('Silex\ControllerCollection', $blog);
});
}
}
<?php
/*
* This file is part of the Silex framework.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace Silex\Tests\Provider;
use Silex\Application;
use Silex\WebTestCase;
use Silex\Provider\SecurityServiceProvider;
use Silex\Provider\SessionServiceProvider;
use Silex\Provider\ValidatorServiceProvider;
use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
use Symfony\Component\Security\Core\Exception\AuthenticationException;
use Symfony\Component\HttpKernel\Client;
use Symfony\Component\HttpFoundation\Request;
/**
* SecurityServiceProvider.
*
* @author Fabien Potencier <fabien@symfony.com>
*/
class SecurityServiceProviderTest extends WebTestCase
{
/**
* @expectedException \LogicException
*/
public function testWrongAuthenticationType()
{
$app = new Application();
$app->register(new SecurityServiceProvider(), [
'security.firewalls' => [
'wrong' => [
'foobar' => true,
'users' => [],
],
],
]);
$app->get('/', function () {});
$app->handle(Request::create('/'));
}
public function testFormAuthentication()
{
$app = $this->createApplication('form');
$client = new Client($app);
$client->request('get', '/');
$this->assertEquals('ANONYMOUS', $client->getResponse()->getContent());
$client->request('post', '/login_check', ['_username' => 'fabien', '_password' => 'bar']);
$this->assertContains('Bad credentials', $app['security.last_error']($client->getRequest()));
// hack to re-close the session as the previous assertions re-opens it
$client->getRequest()->getSession()->save();
$client->request('post', '/login_check', ['_username' => 'fabien', '_password' => 'foo']);
$this->assertEquals('', $app['security.last_error']($client->getRequest()));
$client->getRequest()->getSession()->save();
$this->assertEquals(302, $client->getResponse()->getStatusCode());
$this->assertEquals('http://localhost/', $client->getResponse()->getTargetUrl());
$client->request('get', '/');
$this->assertEquals('fabienAUTHENTICATED', $client->getResponse()->getContent());
$client->request('get', '/admin');
$this->assertEquals(403, $client->getResponse()->getStatusCode());
$client->request('get', '/logout');
$this->assertEquals(302, $client->getResponse()->getStatusCode());
$this->assertEquals('http://localhost/', $client->getResponse()->getTargetUrl());
$client->request('get', '/');
$this->assertEquals('ANONYMOUS', $client->getResponse()->getContent());
$client->request('get', '/admin');
$this->assertEquals(302, $client->getResponse()->getStatusCode());
$this->assertEquals('http://localhost/login', $client->getResponse()->getTargetUrl());
$client->request('post', '/login_check', ['_username' => 'admin', '_password' => 'foo']);
$this->assertEquals('', $app['security.last_error']($client->getRequest()));
$client->getRequest()->getSession()->save();
$this->assertEquals(302, $client->getResponse()->getStatusCode());
$this->assertEquals('http://localhost/admin', $client->getResponse()->getTargetUrl());
$client->request('get', '/');
$this->assertEquals('adminAUTHENTICATEDADMIN', $client->getResponse()->getContent());
$client->request('get', '/admin');
$this->assertEquals('admin', $client->getResponse()->getContent());
}
public function testHttpAuthentication()
{
$app = $this->createApplication('http');
$client = new Client($app);
$client->request('get', '/');
$this->assertEquals(401, $client->getResponse()->getStatusCode());
$this->assertEquals('Basic realm="Secured"', $client->getResponse()->headers->get('www-authenticate'));
$client->request('get', '/', [], [], ['PHP_AUTH_USER' => 'dennis', 'PHP_AUTH_PW' => 'foo']);
$this->assertEquals('dennisAUTHENTICATED', $client->getResponse()->getContent());
$client->request('get', '/admin');
$this->assertEquals(403, $client->getResponse()->getStatusCode());
$client->restart();
$client->request('get', '/');
$this->assertEquals(401, $client->getResponse()->getStatusCode());
$this->assertEquals('Basic realm="Secured"', $client->getResponse()->headers->get('www-authenticate'));
$client->request('get', '/', [], [], ['PHP_AUTH_USER' => 'admin', 'PHP_AUTH_PW' => 'foo']);
$this->assertEquals('adminAUTHENTICATEDADMIN', $client->getResponse()->getContent());
$client->request('get', '/admin');
$this->assertEquals('admin', $client->getResponse()->getContent());
}
public function testGuardAuthentication()
{
$app = $this->createApplication('guard');
$client = new Client($app);
$client->request('get', '/');
$this->assertEquals(401, $client->getResponse()->getStatusCode(), 'The entry point is configured');
$this->assertEquals('{"message":"Authentication Required"}', $client->getResponse()->getContent());
$client->request('get', '/', [], [], ['HTTP_X_AUTH_TOKEN' => 'lili:not the secret']);
$this->assertEquals(403, $client->getResponse()->getStatusCode(), 'User not found');
$this->assertEquals('{"message":"Username could not be found."}', $client->getResponse()->getContent());
$client->request('get', '/', [], [], ['HTTP_X_AUTH_TOKEN' => 'victoria:not the secret']);
$this->assertEquals(403, $client->getResponse()->getStatusCode(), 'Invalid credentials');
$this->assertEquals('{"message":"Invalid credentials."}', $client->getResponse()->getContent());
$client->request('get', '/', [], [], ['HTTP_X_AUTH_TOKEN' => 'victoria:victoriasecret']);
$this->assertEquals('victoria', $client->getResponse()->getContent());
}
public function testUserPasswordValidatorIsRegistered()
{
$app = new Application();
$app->register(new SecurityServiceProvider(), [
'security.firewalls' => [
'admin' => [
'pattern' => '^/admin',
'http' => true,
'users' => [
'admin' => ['ROLE_ADMIN', '513aeb0121909'],
],
],
],
]);
$app->register(new ValidatorServiceProvider());
$app->boot();
$this->assertInstanceOf('Symfony\Component\Security\Core\Validator\Constraints\UserPasswordValidator', $app['security.validator.user_password_validator']);
}
public function testExposedExceptions()
{
$app = $this->createApplication('form');
$app['security.hide_user_not_found'] = false;
$client = new Client($app);
$client->request('get', '/');
$this->assertEquals('ANONYMOUS', $client->getResponse()->getContent());
$client->request('post', '/login_check', ['_username' => 'fabien', '_password' => 'bar']);
$this->assertEquals('The presented password is invalid.', $app['security.last_error']($client->getRequest()));
$client->getRequest()->getSession()->save();
$client->request('post', '/login_check', ['_username' => 'unknown', '_password' => 'bar']);
$this->assertEquals('Username "unknown" does not exist.', $app['security.last_error']($client->getRequest()));
$client->getRequest()->getSession()->save();
$client->request('post', '/login_check', ['_username' => 'unknown', '_password' => 'bar']);
$app['request_stack']->push($client->getRequest());
$authenticationException = $app['security.authentication_utils']->getLastAuthenticationError();
$this->assertInstanceOf(AuthenticationException::class, $authenticationException);
$this->assertEquals('Username "unknown" does not exist.', $authenticationException->getMessage());
$client->getRequest()->getSession()->save();
}
public function testFakeRoutesAreSerializable()
{
$app = new Application();
$app->register(new SecurityServiceProvider(), [
'security.firewalls' => [
'admin' => [
'logout' => true,
],
],
]);
$app->boot();
$app->flush();
$this->assertCount(1, unserialize(serialize($app['routes'])));
}
public function testFirewallWithMethod()
{
$app = new Application();
$app->register(new SecurityServiceProvider(), [
'security.firewalls' => [
'default' => [
'pattern' => '/',
'http' => true,
'methods' => ['POST'],
],
],
]);
$app->match('/', function () { return 'foo'; })
->method('POST|GET');
$request = Request::create('/', 'GET');
$response = $app->handle($request);
$this->assertEquals(200, $response->getStatusCode());
$request = Request::create('/', 'POST');
$response = $app->handle($request);
$this->assertEquals(401, $response->getStatusCode());
}
public function testFirewallWithHost()
{
$app = new Application();
$app->register(new SecurityServiceProvider(), [
'security.firewalls' => [
'default' => [
'pattern' => '/',
'http' => true,
'hosts' => 'localhost2',
],
],
]);
$app->get('/', function () { return 'foo'; })
->host('localhost2');
$app->get('/', function () { return 'foo'; })
->host('localhost1');
$request = Request::create('http://localhost2/');
$response = $app->handle($request);
$this->assertEquals(401, $response->getStatusCode());
$request = Request::create('http://localhost1/');
$response = $app->handle($request);
$this->assertEquals(200, $response->getStatusCode());
}
public function testUser()
{
$app = new Application();
$app->register(new SecurityServiceProvider(), [
'security.firewalls' => [
'default' => [
'http' => true,
'users' => [
'fabien' => ['ROLE_ADMIN', '$2y$15$lzUNsTegNXvZW3qtfucV0erYBcEqWVeyOmjolB7R1uodsAVJ95vvu'],
],
],
],
]);
$app->get('/', function () { return 'foo'; });
$request = Request::create('/');
$app->handle($request);
$this->assertNull($app['user']);
$request->headers->set('PHP_AUTH_USER', 'fabien');
$request->headers->set('PHP_AUTH_PW', 'foo');
$app->handle($request);
$this->assertInstanceOf('Symfony\Component\Security\Core\User\UserInterface', $app['user']);
$this->assertEquals('fabien', $app['user']->getUsername());
}
public function testUserAsServiceString()
{
$users = [
'fabien' => ['ROLE_ADMIN', '$2y$15$lzUNsTegNXvZW3qtfucV0erYBcEqWVeyOmjolB7R1uodsAVJ95vvu'],
];
$app = new Application();
$app->register(new SecurityServiceProvider(), [
'security.firewalls' => [
'default' => [
'http' => true,
'users' => 'my_user_provider',
],
],
]);
$app['my_user_provider'] = $app['security.user_provider.inmemory._proto']($users);
$app->get('/', function () { return 'foo'; });
$request = Request::create('/');
$app->handle($request);
$this->assertNull($app['user']);
$this->assertSame($app['my_user_provider'], $app['security.user_provider.default']);
$request->headers->set('PHP_AUTH_USER', 'fabien');
$request->headers->set('PHP_AUTH_PW', 'foo');
$app->handle($request);
$this->assertInstanceOf('Symfony\Component\Security\Core\User\UserInterface', $app['user']);
$this->assertEquals('fabien', $app['user']->getUsername());
}
public function testUserWithNoToken()
{
$app = new Application();
$app->register(new SecurityServiceProvider(), [
'security.firewalls' => [
'default' => [
'http' => true,
],
],
]);
$request = Request::create('/');
$app->get('/', function () { return 'foo'; });
$app->handle($request);
$this->assertNull($app['user']);
}
public function testUserWithInvalidUser()
{
$app = new Application();
$app->register(new SecurityServiceProvider(), [
'security.firewalls' => [
'default' => [
'http' => true,
],
],
]);
$request = Request::create('/');
$app->boot();
$app['security.token_storage']->setToken(new UsernamePasswordToken('foo', 'foo', 'foo'));
$app->get('/', function () { return 'foo'; });
$app->handle($request);
$this->assertNull($app['user']);
}
public function testAccessRulePathArray()
{
$app = new Application();
$app->register(new SecurityServiceProvider(), [
'security.firewalls' => [
'default' => [
'http' => true,
],
],
'security.access_rules' => [
[[
'path' => '^/admin',
], 'ROLE_ADMIN'],
],
]);
$request = Request::create('/admin');
$app->boot();
$accessMap = $app['security.access_map'];
$this->assertEquals($accessMap->getPatterns($request), [
['ROLE_ADMIN'],
'',
]);
}
public function createApplication($authenticationMethod = 'form')
{
$app = new Application();
$app->register(new SessionServiceProvider());
$app = call_user_func([$this, 'add'.ucfirst($authenticationMethod).'Authentication'], $app);
$app['session.test'] = true;
return $app;
}
private function addFormAuthentication($app)
{
$app->register(new SecurityServiceProvider(), [
'security.firewalls' => [
'login' => [
'pattern' => '^/login$',
],
'default' => [
'pattern' => '^.*$',
'anonymous' => true,
'form' => [
'require_previous_session' => false,
],
'logout' => true,
'users' => [
// password is foo
'fabien' => ['ROLE_USER', '$2y$15$lzUNsTegNXvZW3qtfucV0erYBcEqWVeyOmjolB7R1uodsAVJ95vvu'],
'admin' => ['ROLE_ADMIN', '$2y$15$lzUNsTegNXvZW3qtfucV0erYBcEqWVeyOmjolB7R1uodsAVJ95vvu'],
],
],
],
'security.access_rules' => [
['^/admin', 'ROLE_ADMIN'],
],
'security.role_hierarchy' => [
'ROLE_ADMIN' => ['ROLE_USER'],
],
]);
$app->get('/login', function (Request $request) use ($app) {
$app['session']->start();
return $app['security.last_error']($request);
});
$app->get('/', function () use ($app) {
$user = $app['security.token_storage']->getToken()->getUser();
$content = is_object($user) ? $user->getUsername() : 'ANONYMOUS';
if ($app['security.authorization_checker']->isGranted('IS_AUTHENTICATED_FULLY')) {
$content .= 'AUTHENTICATED';
}
if ($app['security.authorization_checker']->isGranted('ROLE_ADMIN')) {
$content .= 'ADMIN';
}
return $content;
});
$app->get('/admin', function () use ($app) {
return 'admin';
});
return $app;
}
private function addHttpAuthentication($app)
{
$app->register(new SecurityServiceProvider(), [
'security.firewalls' => [
'http-auth' => [
'pattern' => '^.*$',
'http' => true,
'users' => [
// password is foo
'dennis' => ['ROLE_USER', '$2y$15$lzUNsTegNXvZW3qtfucV0erYBcEqWVeyOmjolB7R1uodsAVJ95vvu'],
'admin' => ['ROLE_ADMIN', '$2y$15$lzUNsTegNXvZW3qtfucV0erYBcEqWVeyOmjolB7R1uodsAVJ95vvu'],
],
],
],
'security.access_rules' => [
['^/admin', 'ROLE_ADMIN'],
],
'security.role_hierarchy' => [
'ROLE_ADMIN' => ['ROLE_USER'],
],
]);
$app->get('/', function () use ($app) {
$user = $app['security.token_storage']->getToken()->getUser();
$content = is_object($user) ? $user->getUsername() : 'ANONYMOUS';
if ($app['security.authorization_checker']->isGranted('IS_AUTHENTICATED_FULLY')) {
$content .= 'AUTHENTICATED';
}
if ($app['security.authorization_checker']->isGranted('ROLE_ADMIN')) {
$content .= 'ADMIN';
}
return $content;
});
$app->get('/admin', function () use ($app) {
return 'admin';
});
return $app;
}
private function addGuardAuthentication($app)
{
$app['app.authenticator.token'] = function ($app) {
return new SecurityServiceProviderTest\TokenAuthenticator($app);
};
$app->register(new SecurityServiceProvider(), [
'security.firewalls' => [
'guard' => [
'pattern' => '^.*$',
'form' => true,
'guard' => [
'authenticators' => [
'app.authenticator.token',
],
],
'users' => [
'victoria' => ['ROLE_USER', 'victoriasecret'],
],
],
],
]);
$app->get('/', function () use ($app) {
$user = $app['security.token_storage']->getToken()->getUser();
$content = is_object($user) ? $user->getUsername() : 'ANONYMOUS';
return $content;
})->bind('homepage');
return $app;
}
}