www.aleph1.co.uk Git - yaffs-website/blob - vendor/symfony/routing/Tests/RouteTest.php

   1 <?php
   2
   3 /*
   4  * This file is part of the Symfony package.
   5  *
   6  * (c) Fabien Potencier <fabien@symfony.com>
   7  *
   8  * For the full copyright and license information, please view the LICENSE
   9  * file that was distributed with this source code.
  10  */
  11
  12 namespace Symfony\Component\Routing\Tests;
  13
  14 use PHPUnit\Framework\TestCase;
  15 use Symfony\Component\Routing\Route;
  16
  17 class RouteTest extends TestCase
  18 {
  19     public function testConstructor()
  20     {
  21         $route = new Route('/{foo}', array('foo' => 'bar'), array('foo' => '\d+'), array('foo' => 'bar'), '{locale}.example.com');
  22         $this->assertEquals('/{foo}', $route->getPath(), '__construct() takes a path as its first argument');
  23         $this->assertEquals(array('foo' => 'bar'), $route->getDefaults(), '__construct() takes defaults as its second argument');
  24         $this->assertEquals(array('foo' => '\d+'), $route->getRequirements(), '__construct() takes requirements as its third argument');
  25         $this->assertEquals('bar', $route->getOption('foo'), '__construct() takes options as its fourth argument');
  26         $this->assertEquals('{locale}.example.com', $route->getHost(), '__construct() takes a host pattern as its fifth argument');
  27
  28         $route = new Route('/', array(), array(), array(), '', array('Https'), array('POST', 'put'), 'context.getMethod() == "GET"');
  29         $this->assertEquals(array('https'), $route->getSchemes(), '__construct() takes schemes as its sixth argument and lowercases it');
  30         $this->assertEquals(array('POST', 'PUT'), $route->getMethods(), '__construct() takes methods as its seventh argument and uppercases it');
  31         $this->assertEquals('context.getMethod() == "GET"', $route->getCondition(), '__construct() takes a condition as its eight argument');
  32
  33         $route = new Route('/', array(), array(), array(), '', 'Https', 'Post');
  34         $this->assertEquals(array('https'), $route->getSchemes(), '__construct() takes a single scheme as its sixth argument');
  35         $this->assertEquals(array('POST'), $route->getMethods(), '__construct() takes a single method as its seventh argument');
  36     }
  37
  38     public function testPath()
  39     {
  40         $route = new Route('/{foo}');
  41         $route->setPath('/{bar}');
  42         $this->assertEquals('/{bar}', $route->getPath(), '->setPath() sets the path');
  43         $route->setPath('');
  44         $this->assertEquals('/', $route->getPath(), '->setPath() adds a / at the beginning of the path if needed');
  45         $route->setPath('bar');
  46         $this->assertEquals('/bar', $route->getPath(), '->setPath() adds a / at the beginning of the path if needed');
  47         $this->assertEquals($route, $route->setPath(''), '->setPath() implements a fluent interface');
  48         $route->setPath('//path');
  49         $this->assertEquals('/path', $route->getPath(), '->setPath() does not allow two slashes "//" at the beginning of the path as it would be confused with a network path when generating the path from the route');
  50     }
  51
  52     public function testOptions()
  53     {
  54         $route = new Route('/{foo}');
  55         $route->setOptions(array('foo' => 'bar'));
  56         $this->assertEquals(array_merge(array(
  57         'compiler_class' => 'Symfony\\Component\\Routing\\RouteCompiler',
  58         ), array('foo' => 'bar')), $route->getOptions(), '->setOptions() sets the options');
  59         $this->assertEquals($route, $route->setOptions(array()), '->setOptions() implements a fluent interface');
  60
  61         $route->setOptions(array('foo' => 'foo'));
  62         $route->addOptions(array('bar' => 'bar'));
  63         $this->assertEquals($route, $route->addOptions(array()), '->addOptions() implements a fluent interface');
  64         $this->assertEquals(array('foo' => 'foo', 'bar' => 'bar', 'compiler_class' => 'Symfony\\Component\\Routing\\RouteCompiler'), $route->getOptions(), '->addDefaults() keep previous defaults');
  65     }
  66
  67     public function testOption()
  68     {
  69         $route = new Route('/{foo}');
  70         $this->assertFalse($route->hasOption('foo'), '->hasOption() return false if option is not set');
  71         $this->assertEquals($route, $route->setOption('foo', 'bar'), '->setOption() implements a fluent interface');
  72         $this->assertEquals('bar', $route->getOption('foo'), '->setOption() sets the option');
  73         $this->assertTrue($route->hasOption('foo'), '->hasOption() return true if option is set');
  74     }
  75
  76     public function testDefaults()
  77     {
  78         $route = new Route('/{foo}');
  79         $route->setDefaults(array('foo' => 'bar'));
  80         $this->assertEquals(array('foo' => 'bar'), $route->getDefaults(), '->setDefaults() sets the defaults');
  81         $this->assertEquals($route, $route->setDefaults(array()), '->setDefaults() implements a fluent interface');
  82
  83         $route->setDefault('foo', 'bar');
  84         $this->assertEquals('bar', $route->getDefault('foo'), '->setDefault() sets a default value');
  85
  86         $route->setDefault('foo2', 'bar2');
  87         $this->assertEquals('bar2', $route->getDefault('foo2'), '->getDefault() return the default value');
  88         $this->assertNull($route->getDefault('not_defined'), '->getDefault() return null if default value is not set');
  89
  90         $route->setDefault('_controller', $closure = function () { return 'Hello'; });
  91         $this->assertEquals($closure, $route->getDefault('_controller'), '->setDefault() sets a default value');
  92
  93         $route->setDefaults(array('foo' => 'foo'));
  94         $route->addDefaults(array('bar' => 'bar'));
  95         $this->assertEquals($route, $route->addDefaults(array()), '->addDefaults() implements a fluent interface');
  96         $this->assertEquals(array('foo' => 'foo', 'bar' => 'bar'), $route->getDefaults(), '->addDefaults() keep previous defaults');
  97     }
  98
  99     public function testRequirements()
 100     {
 101         $route = new Route('/{foo}');
 102         $route->setRequirements(array('foo' => '\d+'));
 103         $this->assertEquals(array('foo' => '\d+'), $route->getRequirements(), '->setRequirements() sets the requirements');
 104         $this->assertEquals('\d+', $route->getRequirement('foo'), '->getRequirement() returns a requirement');
 105         $this->assertNull($route->getRequirement('bar'), '->getRequirement() returns null if a requirement is not defined');
 106         $route->setRequirements(array('foo' => '^\d+$'));
 107         $this->assertEquals('\d+', $route->getRequirement('foo'), '->getRequirement() removes ^ and $ from the path');
 108         $this->assertEquals($route, $route->setRequirements(array()), '->setRequirements() implements a fluent interface');
 109
 110         $route->setRequirements(array('foo' => '\d+'));
 111         $route->addRequirements(array('bar' => '\d+'));
 112         $this->assertEquals($route, $route->addRequirements(array()), '->addRequirements() implements a fluent interface');
 113         $this->assertEquals(array('foo' => '\d+', 'bar' => '\d+'), $route->getRequirements(), '->addRequirement() keep previous requirements');
 114     }
 115
 116     public function testRequirement()
 117     {
 118         $route = new Route('/{foo}');
 119         $this->assertFalse($route->hasRequirement('foo'), '->hasRequirement() return false if requirement is not set');
 120         $route->setRequirement('foo', '^\d+$');
 121         $this->assertEquals('\d+', $route->getRequirement('foo'), '->setRequirement() removes ^ and $ from the path');
 122         $this->assertTrue($route->hasRequirement('foo'), '->hasRequirement() return true if requirement is set');
 123     }
 124
 125     /**
 126      * @dataProvider getInvalidRequirements
 127      * @expectedException \InvalidArgumentException
 128      */
 129     public function testSetInvalidRequirement($req)
 130     {
 131         $route = new Route('/{foo}');
 132         $route->setRequirement('foo', $req);
 133     }
 134
 135     public function getInvalidRequirements()
 136     {
 137         return array(
 138            array(''),
 139            array(array()),
 140            array('^$'),
 141            array('^'),
 142            array('$'),
 143         );
 144     }
 145
 146     public function testHost()
 147     {
 148         $route = new Route('/');
 149         $route->setHost('{locale}.example.net');
 150         $this->assertEquals('{locale}.example.net', $route->getHost(), '->setHost() sets the host pattern');
 151     }
 152
 153     public function testScheme()
 154     {
 155         $route = new Route('/');
 156         $this->assertEquals(array(), $route->getSchemes(), 'schemes is initialized with array()');
 157         $this->assertFalse($route->hasScheme('http'));
 158         $route->setSchemes('hTTp');
 159         $this->assertEquals(array('http'), $route->getSchemes(), '->setSchemes() accepts a single scheme string and lowercases it');
 160         $this->assertTrue($route->hasScheme('htTp'));
 161         $this->assertFalse($route->hasScheme('httpS'));
 162         $route->setSchemes(array('HttpS', 'hTTp'));
 163         $this->assertEquals(array('https', 'http'), $route->getSchemes(), '->setSchemes() accepts an array of schemes and lowercases them');
 164         $this->assertTrue($route->hasScheme('htTp'));
 165         $this->assertTrue($route->hasScheme('httpS'));
 166     }
 167
 168     public function testMethod()
 169     {
 170         $route = new Route('/');
 171         $this->assertEquals(array(), $route->getMethods(), 'methods is initialized with array()');
 172         $route->setMethods('gEt');
 173         $this->assertEquals(array('GET'), $route->getMethods(), '->setMethods() accepts a single method string and uppercases it');
 174         $route->setMethods(array('gEt', 'PosT'));
 175         $this->assertEquals(array('GET', 'POST'), $route->getMethods(), '->setMethods() accepts an array of methods and uppercases them');
 176     }
 177
 178     public function testCondition()
 179     {
 180         $route = new Route('/');
 181         $this->assertSame('', $route->getCondition());
 182         $route->setCondition('context.getMethod() == "GET"');
 183         $this->assertSame('context.getMethod() == "GET"', $route->getCondition());
 184     }
 185
 186     public function testCompile()
 187     {
 188         $route = new Route('/{foo}');
 189         $this->assertInstanceOf('Symfony\Component\Routing\CompiledRoute', $compiled = $route->compile(), '->compile() returns a compiled route');
 190         $this->assertSame($compiled, $route->compile(), '->compile() only compiled the route once if unchanged');
 191         $route->setRequirement('foo', '.*');
 192         $this->assertNotSame($compiled, $route->compile(), '->compile() recompiles if the route was modified');
 193     }
 194
 195     public function testSerialize()
 196     {
 197         $route = new Route('/prefix/{foo}', array('foo' => 'default'), array('foo' => '\d+'));
 198
 199         $serialized = serialize($route);
 200         $unserialized = unserialize($serialized);
 201
 202         $this->assertEquals($route, $unserialized);
 203         $this->assertNotSame($route, $unserialized);
 204     }
 205
 206     /**
 207      * Tests that the compiled version is also serialized to prevent the overhead
 208      * of compiling it again after unserialize.
 209      */
 210     public function testSerializeWhenCompiled()
 211     {
 212         $route = new Route('/prefix/{foo}', array('foo' => 'default'), array('foo' => '\d+'));
 213         $route->setHost('{locale}.example.net');
 214         $route->compile();
 215
 216         $serialized = serialize($route);
 217         $unserialized = unserialize($serialized);
 218
 219         $this->assertEquals($route, $unserialized);
 220         $this->assertNotSame($route, $unserialized);
 221     }
 222
 223     /**
 224      * Tests that the serialized representation of a route in one symfony version
 225      * also works in later symfony versions, i.e. the unserialized route is in the
 226      * same state as another, semantically equivalent, route.
 227      */
 228     public function testSerializedRepresentationKeepsWorking()
 229     {
 230         $serialized = 'C:31:"Symfony\Component\Routing\Route":934:{a:8:{s:4:"path";s:13:"/prefix/{foo}";s:4:"host";s:20:"{locale}.example.net";s:8:"defaults";a:1:{s:3:"foo";s:7:"default";}s:12:"requirements";a:1:{s:3:"foo";s:3:"\d+";}s:7:"options";a:1:{s:14:"compiler_class";s:39:"Symfony\Component\Routing\RouteCompiler";}s:7:"schemes";a:0:{}s:7:"methods";a:0:{}s:8:"compiled";C:39:"Symfony\Component\Routing\CompiledRoute":569:{a:8:{s:4:"vars";a:2:{i:0;s:6:"locale";i:1;s:3:"foo";}s:11:"path_prefix";s:7:"/prefix";s:10:"path_regex";s:30:"#^/prefix(?:/(?P<foo>\d+))?$#s";s:11:"path_tokens";a:2:{i:0;a:4:{i:0;s:8:"variable";i:1;s:1:"/";i:2;s:3:"\d+";i:3;s:3:"foo";}i:1;a:2:{i:0;s:4:"text";i:1;s:7:"/prefix";}}s:9:"path_vars";a:1:{i:0;s:3:"foo";}s:10:"host_regex";s:39:"#^(?P<locale>[^\.]++)\.example\.net$#si";s:11:"host_tokens";a:2:{i:0;a:2:{i:0;s:4:"text";i:1;s:12:".example.net";}i:1;a:4:{i:0;s:8:"variable";i:1;s:0:"";i:2;s:7:"[^\.]++";i:3;s:6:"locale";}}s:9:"host_vars";a:1:{i:0;s:6:"locale";}}}}}';
 231         $unserialized = unserialize($serialized);
 232
 233         $route = new Route('/prefix/{foo}', array('foo' => 'default'), array('foo' => '\d+'));
 234         $route->setHost('{locale}.example.net');
 235         $route->compile();
 236
 237         $this->assertEquals($route, $unserialized);
 238         $this->assertNotSame($route, $unserialized);
 239     }
 240 }