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
12namespace Symfony\Component\Routing\Tests;
13
14use PHPUnit\Framework\TestCase;
15use Symfony\Component\Routing\Route;
16
17class RouteTest extends TestCase
18{
19    public function testConstructor()
20    {
21        $route = new Route('/{foo}', ['foo' => 'bar'], ['foo' => '\d+'], ['foo' => 'bar'], '{locale}.example.com');
22        $this->assertEquals('/{foo}', $route->getPath(), '__construct() takes a path as its first argument');
23        $this->assertEquals(['foo' => 'bar'], $route->getDefaults(), '__construct() takes defaults as its second argument');
24        $this->assertEquals(['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('/', [], [], [], '', ['Https'], ['POST', 'put'], 'context.getMethod() == "GET"');
29        $this->assertEquals(['https'], $route->getSchemes(), '__construct() takes schemes as its sixth argument and lowercases it');
30        $this->assertEquals(['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('/', [], [], [], '', 'Https', 'Post');
34        $this->assertEquals(['https'], $route->getSchemes(), '__construct() takes a single scheme as its sixth argument');
35        $this->assertEquals(['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(['foo' => 'bar']);
56        $this->assertEquals(array_merge([
57        'compiler_class' => 'Symfony\\Component\\Routing\\RouteCompiler',
58        ], ['foo' => 'bar']), $route->getOptions(), '->setOptions() sets the options');
59        $this->assertEquals($route, $route->setOptions([]), '->setOptions() implements a fluent interface');
60
61        $route->setOptions(['foo' => 'foo']);
62        $route->addOptions(['bar' => 'bar']);
63        $this->assertEquals($route, $route->addOptions([]), '->addOptions() implements a fluent interface');
64        $this->assertEquals(['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(['foo' => 'bar']);
80        $this->assertEquals(['foo' => 'bar'], $route->getDefaults(), '->setDefaults() sets the defaults');
81        $this->assertEquals($route, $route->setDefaults([]), '->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(['foo' => 'foo']);
94        $route->addDefaults(['bar' => 'bar']);
95        $this->assertEquals($route, $route->addDefaults([]), '->addDefaults() implements a fluent interface');
96        $this->assertEquals(['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(['foo' => '\d+']);
103        $this->assertEquals(['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(['foo' => '^\d+$']);
107        $this->assertEquals('\d+', $route->getRequirement('foo'), '->getRequirement() removes ^ and $ from the path');
108        $this->assertEquals($route, $route->setRequirements([]), '->setRequirements() implements a fluent interface');
109
110        $route->setRequirements(['foo' => '\d+']);
111        $route->addRequirements(['bar' => '\d+']);
112        $this->assertEquals($route, $route->addRequirements([]), '->addRequirements() implements a fluent interface');
113        $this->assertEquals(['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     */
128    public function testSetInvalidRequirement($req)
129    {
130        $this->expectException('InvalidArgumentException');
131        $route = new Route('/{foo}');
132        $route->setRequirement('foo', $req);
133    }
134
135    public function getInvalidRequirements()
136    {
137        return [
138           [''],
139           [[]],
140           ['^$'],
141           ['^'],
142           ['$'],
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([], $route->getSchemes(), 'schemes is initialized with []');
157        $this->assertFalse($route->hasScheme('http'));
158        $route->setSchemes('hTTp');
159        $this->assertEquals(['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(['HttpS', 'hTTp']);
163        $this->assertEquals(['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([], $route->getMethods(), 'methods is initialized with []');
172        $route->setMethods('gEt');
173        $this->assertEquals(['GET'], $route->getMethods(), '->setMethods() accepts a single method string and uppercases it');
174        $route->setMethods(['gEt', 'PosT']);
175        $this->assertEquals(['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}', ['foo' => 'default'], ['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    public function testInlineDefaultAndRequirement()
207    {
208        $this->assertEquals((new Route('/foo/{bar}'))->setDefault('bar', null), new Route('/foo/{bar?}'));
209        $this->assertEquals((new Route('/foo/{bar}'))->setDefault('bar', 'baz'), new Route('/foo/{bar?baz}'));
210        $this->assertEquals((new Route('/foo/{bar}'))->setDefault('bar', 'baz<buz>'), new Route('/foo/{bar?baz<buz>}'));
211        $this->assertEquals((new Route('/foo/{bar}'))->setDefault('bar', 'baz'), new Route('/foo/{bar?}', ['bar' => 'baz']));
212
213        $this->assertEquals((new Route('/foo/{bar}'))->setRequirement('bar', '.*'), new Route('/foo/{bar<.*>}'));
214        $this->assertEquals((new Route('/foo/{bar}'))->setRequirement('bar', '>'), new Route('/foo/{bar<>>}'));
215        $this->assertEquals((new Route('/foo/{bar}'))->setRequirement('bar', '\d+'), new Route('/foo/{bar<.*>}', [], ['bar' => '\d+']));
216        $this->assertEquals((new Route('/foo/{bar}'))->setRequirement('bar', '[a-z]{2}'), new Route('/foo/{bar<[a-z]{2}>}'));
217
218        $this->assertEquals((new Route('/foo/{bar}'))->setDefault('bar', null)->setRequirement('bar', '.*'), new Route('/foo/{bar<.*>?}'));
219        $this->assertEquals((new Route('/foo/{bar}'))->setDefault('bar', '<>')->setRequirement('bar', '>'), new Route('/foo/{bar<>>?<>}'));
220    }
221
222    /**
223     * Tests that the compiled version is also serialized to prevent the overhead
224     * of compiling it again after unserialize.
225     */
226    public function testSerializeWhenCompiled()
227    {
228        $route = new Route('/prefix/{foo}', ['foo' => 'default'], ['foo' => '\d+']);
229        $route->setHost('{locale}.example.net');
230        $route->compile();
231
232        $serialized = serialize($route);
233        $unserialized = unserialize($serialized);
234
235        $this->assertEquals($route, $unserialized);
236        $this->assertNotSame($route, $unserialized);
237    }
238
239    /**
240     * Tests that unserialization does not fail when the compiled Route is of a
241     * class other than CompiledRoute, such as a subclass of it.
242     */
243    public function testSerializeWhenCompiledWithClass()
244    {
245        $route = new Route('/', [], [], ['compiler_class' => '\Symfony\Component\Routing\Tests\Fixtures\CustomRouteCompiler']);
246        $this->assertInstanceOf('\Symfony\Component\Routing\Tests\Fixtures\CustomCompiledRoute', $route->compile(), '->compile() returned a proper route');
247
248        $serialized = serialize($route);
249        try {
250            $unserialized = unserialize($serialized);
251            $this->assertInstanceOf('\Symfony\Component\Routing\Tests\Fixtures\CustomCompiledRoute', $unserialized->compile(), 'the unserialized route compiled successfully');
252        } catch (\Exception $e) {
253            $this->fail('unserializing a route which uses a custom compiled route class');
254        }
255    }
256
257    /**
258     * Tests that the serialized representation of a route in one symfony version
259     * also works in later symfony versions, i.e. the unserialized route is in the
260     * same state as another, semantically equivalent, route.
261     */
262    public function testSerializedRepresentationKeepsWorking()
263    {
264        $serialized = 'C:31:"Symfony\Component\Routing\Route":936:{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":571:{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:31:"#^/prefix(?:/(?P<foo>\d+))?$#sD";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:40:"#^(?P<locale>[^\.]++)\.example\.net$#sDi";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";}}}}}';
265        $unserialized = unserialize($serialized);
266
267        $route = new Route('/prefix/{foo}', ['foo' => 'default'], ['foo' => '\d+']);
268        $route->setHost('{locale}.example.net');
269        $route->compile();
270
271        $this->assertEquals($route, $unserialized);
272        $this->assertNotSame($route, $unserialized);
273    }
274
275    /**
276     * @dataProvider provideNonLocalizedRoutes
277     */
278    public function testLocaleDefaultWithNonLocalizedRoutes(Route $route)
279    {
280        $this->assertNotSame('fr', $route->getDefault('_locale'));
281        $route->setDefault('_locale', 'fr');
282        $this->assertSame('fr', $route->getDefault('_locale'));
283    }
284
285    /**
286     * @dataProvider provideLocalizedRoutes
287     */
288    public function testLocaleDefaultWithLocalizedRoutes(Route $route)
289    {
290        $expected = $route->getDefault('_locale');
291        $this->assertIsString($expected);
292        $this->assertNotSame('fr', $expected);
293        $route->setDefault('_locale', 'fr');
294        $this->assertSame($expected, $route->getDefault('_locale'));
295    }
296
297    /**
298     * @dataProvider provideNonLocalizedRoutes
299     */
300    public function testLocaleRequirementWithNonLocalizedRoutes(Route $route)
301    {
302        $this->assertNotSame('fr', $route->getRequirement('_locale'));
303        $route->setRequirement('_locale', 'fr');
304        $this->assertSame('fr', $route->getRequirement('_locale'));
305    }
306
307    /**
308     * @dataProvider provideLocalizedRoutes
309     */
310    public function testLocaleRequirementWithLocalizedRoutes(Route $route)
311    {
312        $expected = $route->getRequirement('_locale');
313        $this->assertIsString($expected);
314        $this->assertNotSame('fr', $expected);
315        $route->setRequirement('_locale', 'fr');
316        $this->assertSame($expected, $route->getRequirement('_locale'));
317    }
318
319    public function provideNonLocalizedRoutes()
320    {
321        return [
322            [(new Route('/foo'))],
323            [(new Route('/foo'))->setDefault('_locale', 'en')],
324            [(new Route('/foo'))->setDefault('_locale', 'en')->setDefault('_canonical_route', 'foo')],
325            [(new Route('/foo'))->setDefault('_locale', 'en')->setDefault('_canonical_route', 'foo')->setRequirement('_locale', 'foobar')],
326        ];
327    }
328
329    public function provideLocalizedRoutes()
330    {
331        return [
332            [(new Route('/foo'))->setDefault('_locale', 'en')->setDefault('_canonical_route', 'foo')->setRequirement('_locale', 'en')],
333        ];
334    }
335}
336