diff options
author | Nicolas LÅ“uillet <nicolas.loeuillet@gmail.com> | 2013-08-03 19:26:54 +0200 |
---|---|---|
committer | Nicolas LÅ“uillet <nicolas.loeuillet@gmail.com> | 2013-08-03 19:26:54 +0200 |
commit | 4f5b44bd3bd490309eb2ba7b44df4769816ba729 (patch) | |
tree | 6cefe170dfe0a5a361cb1e2d1fc4d580a3316d02 /vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher | |
parent | 2b840e0cfb63a453bea67a98541f3df9c273c5f5 (diff) | |
download | wallabag-4f5b44bd3bd490309eb2ba7b44df4769816ba729.tar.gz wallabag-4f5b44bd3bd490309eb2ba7b44df4769816ba729.tar.zst wallabag-4f5b44bd3bd490309eb2ba7b44df4769816ba729.zip |
twig implementation
Diffstat (limited to 'vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher')
8 files changed, 1257 insertions, 0 deletions
diff --git a/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/ApacheUrlMatcherTest.php b/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/ApacheUrlMatcherTest.php new file mode 100644 index 00000000..6550911e --- /dev/null +++ b/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/ApacheUrlMatcherTest.php | |||
@@ -0,0 +1,137 @@ | |||
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\Matcher; | ||
13 | |||
14 | use Symfony\Component\Routing\RouteCollection; | ||
15 | use Symfony\Component\Routing\RequestContext; | ||
16 | use Symfony\Component\Routing\Matcher\ApacheUrlMatcher; | ||
17 | |||
18 | class ApacheUrlMatcherTest extends \PHPUnit_Framework_TestCase | ||
19 | { | ||
20 | protected $server; | ||
21 | |||
22 | protected function setUp() | ||
23 | { | ||
24 | $this->server = $_SERVER; | ||
25 | } | ||
26 | |||
27 | protected function tearDown() | ||
28 | { | ||
29 | $_SERVER = $this->server; | ||
30 | } | ||
31 | |||
32 | /** | ||
33 | * @dataProvider getMatchData | ||
34 | */ | ||
35 | public function testMatch($name, $pathinfo, $server, $expect) | ||
36 | { | ||
37 | $collection = new RouteCollection(); | ||
38 | $context = new RequestContext(); | ||
39 | $matcher = new ApacheUrlMatcher($collection, $context); | ||
40 | |||
41 | $_SERVER = $server; | ||
42 | |||
43 | $result = $matcher->match($pathinfo, $server); | ||
44 | $this->assertSame(var_export($expect, true), var_export($result, true)); | ||
45 | } | ||
46 | |||
47 | public function getMatchData() | ||
48 | { | ||
49 | return array( | ||
50 | array( | ||
51 | 'Simple route', | ||
52 | '/hello/world', | ||
53 | array( | ||
54 | '_ROUTING_route' => 'hello', | ||
55 | '_ROUTING_param__controller' => 'AcmeBundle:Default:index', | ||
56 | '_ROUTING_param_name' => 'world', | ||
57 | ), | ||
58 | array( | ||
59 | '_controller' => 'AcmeBundle:Default:index', | ||
60 | 'name' => 'world', | ||
61 | '_route' => 'hello', | ||
62 | ), | ||
63 | ), | ||
64 | array( | ||
65 | 'Route with params and defaults', | ||
66 | '/hello/hugo', | ||
67 | array( | ||
68 | '_ROUTING_route' => 'hello', | ||
69 | '_ROUTING_param__controller' => 'AcmeBundle:Default:index', | ||
70 | '_ROUTING_param_name' => 'hugo', | ||
71 | '_ROUTING_default_name' => 'world', | ||
72 | ), | ||
73 | array( | ||
74 | 'name' => 'hugo', | ||
75 | '_controller' => 'AcmeBundle:Default:index', | ||
76 | '_route' => 'hello', | ||
77 | ), | ||
78 | ), | ||
79 | array( | ||
80 | 'Route with defaults only', | ||
81 | '/hello', | ||
82 | array( | ||
83 | '_ROUTING_route' => 'hello', | ||
84 | '_ROUTING_param__controller' => 'AcmeBundle:Default:index', | ||
85 | '_ROUTING_default_name' => 'world', | ||
86 | ), | ||
87 | array( | ||
88 | 'name' => 'world', | ||
89 | '_controller' => 'AcmeBundle:Default:index', | ||
90 | '_route' => 'hello', | ||
91 | ), | ||
92 | ), | ||
93 | array( | ||
94 | 'REDIRECT_ envs', | ||
95 | '/hello/world', | ||
96 | array( | ||
97 | 'REDIRECT__ROUTING_route' => 'hello', | ||
98 | 'REDIRECT__ROUTING_param__controller' => 'AcmeBundle:Default:index', | ||
99 | 'REDIRECT__ROUTING_param_name' => 'world', | ||
100 | ), | ||
101 | array( | ||
102 | '_controller' => 'AcmeBundle:Default:index', | ||
103 | 'name' => 'world', | ||
104 | '_route' => 'hello', | ||
105 | ), | ||
106 | ), | ||
107 | array( | ||
108 | 'REDIRECT_REDIRECT_ envs', | ||
109 | '/hello/world', | ||
110 | array( | ||
111 | 'REDIRECT_REDIRECT__ROUTING_route' => 'hello', | ||
112 | 'REDIRECT_REDIRECT__ROUTING_param__controller' => 'AcmeBundle:Default:index', | ||
113 | 'REDIRECT_REDIRECT__ROUTING_param_name' => 'world', | ||
114 | ), | ||
115 | array( | ||
116 | '_controller' => 'AcmeBundle:Default:index', | ||
117 | 'name' => 'world', | ||
118 | '_route' => 'hello', | ||
119 | ), | ||
120 | ), | ||
121 | array( | ||
122 | 'REDIRECT_REDIRECT_ envs', | ||
123 | '/hello/world', | ||
124 | array( | ||
125 | 'REDIRECT_REDIRECT__ROUTING_route' => 'hello', | ||
126 | 'REDIRECT_REDIRECT__ROUTING_param__controller' => 'AcmeBundle:Default:index', | ||
127 | 'REDIRECT_REDIRECT__ROUTING_param_name' => 'world', | ||
128 | ), | ||
129 | array( | ||
130 | '_controller' => 'AcmeBundle:Default:index', | ||
131 | 'name' => 'world', | ||
132 | '_route' => 'hello', | ||
133 | ), | ||
134 | ), | ||
135 | ); | ||
136 | } | ||
137 | } | ||
diff --git a/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/Dumper/ApacheMatcherDumperTest.php b/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/Dumper/ApacheMatcherDumperTest.php new file mode 100644 index 00000000..72bee710 --- /dev/null +++ b/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/Dumper/ApacheMatcherDumperTest.php | |||
@@ -0,0 +1,196 @@ | |||
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\Matcher\Dumper; | ||
13 | |||
14 | use Symfony\Component\Routing\Route; | ||
15 | use Symfony\Component\Routing\RouteCollection; | ||
16 | use Symfony\Component\Routing\Matcher\Dumper\ApacheMatcherDumper; | ||
17 | |||
18 | class ApacheMatcherDumperTest extends \PHPUnit_Framework_TestCase | ||
19 | { | ||
20 | protected static $fixturesPath; | ||
21 | |||
22 | public static function setUpBeforeClass() | ||
23 | { | ||
24 | self::$fixturesPath = realpath(__DIR__.'/../../Fixtures/'); | ||
25 | } | ||
26 | |||
27 | public function testDump() | ||
28 | { | ||
29 | $dumper = new ApacheMatcherDumper($this->getRouteCollection()); | ||
30 | |||
31 | $this->assertStringEqualsFile(self::$fixturesPath.'/dumper/url_matcher1.apache', $dumper->dump(), '->dump() dumps basic routes to the correct apache format.'); | ||
32 | } | ||
33 | |||
34 | /** | ||
35 | * @dataProvider provideEscapeFixtures | ||
36 | */ | ||
37 | public function testEscapePattern($src, $dest, $char, $with, $message) | ||
38 | { | ||
39 | $r = new \ReflectionMethod(new ApacheMatcherDumper($this->getRouteCollection()), 'escape'); | ||
40 | $r->setAccessible(true); | ||
41 | $this->assertEquals($dest, $r->invoke(null, $src, $char, $with), $message); | ||
42 | } | ||
43 | |||
44 | public function provideEscapeFixtures() | ||
45 | { | ||
46 | return array( | ||
47 | array('foo', 'foo', ' ', '-', 'Preserve string that should not be escaped'), | ||
48 | array('fo-o', 'fo-o', ' ', '-', 'Preserve string that should not be escaped'), | ||
49 | array('fo o', 'fo- o', ' ', '-', 'Escape special characters'), | ||
50 | array('fo-- o', 'fo--- o', ' ', '-', 'Escape special characters'), | ||
51 | array('fo- o', 'fo- o', ' ', '-', 'Do not escape already escaped string'), | ||
52 | ); | ||
53 | } | ||
54 | |||
55 | public function testEscapeScriptName() | ||
56 | { | ||
57 | $collection = new RouteCollection(); | ||
58 | $collection->add('foo', new Route('/foo')); | ||
59 | $dumper = new ApacheMatcherDumper($collection); | ||
60 | $this->assertStringEqualsFile(self::$fixturesPath.'/dumper/url_matcher2.apache', $dumper->dump(array('script_name' => 'ap p_d\ ev.php'))); | ||
61 | } | ||
62 | |||
63 | private function getRouteCollection() | ||
64 | { | ||
65 | $collection = new RouteCollection(); | ||
66 | |||
67 | // defaults and requirements | ||
68 | $collection->add('foo', new Route( | ||
69 | '/foo/{bar}', | ||
70 | array('def' => 'test'), | ||
71 | array('bar' => 'baz|symfony') | ||
72 | )); | ||
73 | // defaults parameters in pattern | ||
74 | $collection->add('foobar', new Route( | ||
75 | '/foo/{bar}', | ||
76 | array('bar' => 'toto') | ||
77 | )); | ||
78 | // method requirement | ||
79 | $collection->add('bar', new Route( | ||
80 | '/bar/{foo}', | ||
81 | array(), | ||
82 | array('_method' => 'GET|head') | ||
83 | )); | ||
84 | // method requirement (again) | ||
85 | $collection->add('baragain', new Route( | ||
86 | '/baragain/{foo}', | ||
87 | array(), | ||
88 | array('_method' => 'get|post') | ||
89 | )); | ||
90 | // simple | ||
91 | $collection->add('baz', new Route( | ||
92 | '/test/baz' | ||
93 | )); | ||
94 | // simple with extension | ||
95 | $collection->add('baz2', new Route( | ||
96 | '/test/baz.html' | ||
97 | )); | ||
98 | // trailing slash | ||
99 | $collection->add('baz3', new Route( | ||
100 | '/test/baz3/' | ||
101 | )); | ||
102 | // trailing slash with variable | ||
103 | $collection->add('baz4', new Route( | ||
104 | '/test/{foo}/' | ||
105 | )); | ||
106 | // trailing slash and safe method | ||
107 | $collection->add('baz5', new Route( | ||
108 | '/test/{foo}/', | ||
109 | array(), | ||
110 | array('_method' => 'get') | ||
111 | )); | ||
112 | // trailing slash and unsafe method | ||
113 | $collection->add('baz5unsafe', new Route( | ||
114 | '/testunsafe/{foo}/', | ||
115 | array(), | ||
116 | array('_method' => 'post') | ||
117 | )); | ||
118 | // complex | ||
119 | $collection->add('baz6', new Route( | ||
120 | '/test/baz', | ||
121 | array('foo' => 'bar baz') | ||
122 | )); | ||
123 | // space in path | ||
124 | $collection->add('baz7', new Route( | ||
125 | '/te st/baz' | ||
126 | )); | ||
127 | // space preceded with \ in path | ||
128 | $collection->add('baz8', new Route( | ||
129 | '/te\\ st/baz' | ||
130 | )); | ||
131 | // space preceded with \ in requirement | ||
132 | $collection->add('baz9', new Route( | ||
133 | '/test/{baz}', | ||
134 | array(), | ||
135 | array( | ||
136 | 'baz' => 'te\\\\ st', | ||
137 | ) | ||
138 | )); | ||
139 | |||
140 | $collection1 = new RouteCollection(); | ||
141 | |||
142 | $route1 = new Route('/route1', array(), array(), array(), 'a.example.com'); | ||
143 | $collection1->add('route1', $route1); | ||
144 | |||
145 | $collection2 = new RouteCollection(); | ||
146 | |||
147 | $route2 = new Route('/route2', array(), array(), array(), 'a.example.com'); | ||
148 | $collection2->add('route2', $route2); | ||
149 | |||
150 | $route3 = new Route('/route3', array(), array(), array(), 'b.example.com'); | ||
151 | $collection2->add('route3', $route3); | ||
152 | |||
153 | $collection2->addPrefix('/c2'); | ||
154 | $collection1->addCollection($collection2); | ||
155 | |||
156 | $route4 = new Route('/route4', array(), array(), array(), 'a.example.com'); | ||
157 | $collection1->add('route4', $route4); | ||
158 | |||
159 | $route5 = new Route('/route5', array(), array(), array(), 'c.example.com'); | ||
160 | $collection1->add('route5', $route5); | ||
161 | |||
162 | $route6 = new Route('/route6', array(), array(), array(), null); | ||
163 | $collection1->add('route6', $route6); | ||
164 | |||
165 | $collection->addCollection($collection1); | ||
166 | |||
167 | // host and variables | ||
168 | |||
169 | $collection1 = new RouteCollection(); | ||
170 | |||
171 | $route11 = new Route('/route11', array(), array(), array(), '{var1}.example.com'); | ||
172 | $collection1->add('route11', $route11); | ||
173 | |||
174 | $route12 = new Route('/route12', array('var1' => 'val'), array(), array(), '{var1}.example.com'); | ||
175 | $collection1->add('route12', $route12); | ||
176 | |||
177 | $route13 = new Route('/route13/{name}', array(), array(), array(), '{var1}.example.com'); | ||
178 | $collection1->add('route13', $route13); | ||
179 | |||
180 | $route14 = new Route('/route14/{name}', array('var1' => 'val'), array(), array(), '{var1}.example.com'); | ||
181 | $collection1->add('route14', $route14); | ||
182 | |||
183 | $route15 = new Route('/route15/{name}', array(), array(), array(), 'c.example.com'); | ||
184 | $collection1->add('route15', $route15); | ||
185 | |||
186 | $route16 = new Route('/route16/{name}', array('var1' => 'val'), array(), array(), null); | ||
187 | $collection1->add('route16', $route16); | ||
188 | |||
189 | $route17 = new Route('/route17', array(), array(), array(), null); | ||
190 | $collection1->add('route17', $route17); | ||
191 | |||
192 | $collection->addCollection($collection1); | ||
193 | |||
194 | return $collection; | ||
195 | } | ||
196 | } | ||
diff --git a/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/Dumper/DumperCollectionTest.php b/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/Dumper/DumperCollectionTest.php new file mode 100644 index 00000000..54b37727 --- /dev/null +++ b/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/Dumper/DumperCollectionTest.php | |||
@@ -0,0 +1,33 @@ | |||
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\Test\Matcher\Dumper; | ||
13 | |||
14 | use Symfony\Component\Routing\Matcher\Dumper\DumperCollection; | ||
15 | |||
16 | class DumperCollectionTest extends \PHPUnit_Framework_TestCase | ||
17 | { | ||
18 | public function testGetRoot() | ||
19 | { | ||
20 | $a = new DumperCollection(); | ||
21 | |||
22 | $b = new DumperCollection(); | ||
23 | $a->add($b); | ||
24 | |||
25 | $c = new DumperCollection(); | ||
26 | $b->add($c); | ||
27 | |||
28 | $d = new DumperCollection(); | ||
29 | $c->add($d); | ||
30 | |||
31 | $this->assertSame($a, $c->getRoot()); | ||
32 | } | ||
33 | } | ||
diff --git a/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/Dumper/DumperPrefixCollectionTest.php b/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/Dumper/DumperPrefixCollectionTest.php new file mode 100644 index 00000000..7b4565c4 --- /dev/null +++ b/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/Dumper/DumperPrefixCollectionTest.php | |||
@@ -0,0 +1,123 @@ | |||
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\Matcher\Dumper; | ||
13 | |||
14 | use Symfony\Component\Routing\Route; | ||
15 | use Symfony\Component\Routing\Matcher\Dumper\DumperPrefixCollection; | ||
16 | use Symfony\Component\Routing\Matcher\Dumper\DumperRoute; | ||
17 | use Symfony\Component\Routing\Matcher\Dumper\DumperCollection; | ||
18 | |||
19 | class DumperPrefixCollectionTest extends \PHPUnit_Framework_TestCase | ||
20 | { | ||
21 | public function testAddPrefixRoute() | ||
22 | { | ||
23 | $coll = new DumperPrefixCollection; | ||
24 | $coll->setPrefix(''); | ||
25 | |||
26 | $route = new DumperRoute('bar', new Route('/foo/bar')); | ||
27 | $coll = $coll->addPrefixRoute($route); | ||
28 | |||
29 | $route = new DumperRoute('bar2', new Route('/foo/bar')); | ||
30 | $coll = $coll->addPrefixRoute($route); | ||
31 | |||
32 | $route = new DumperRoute('qux', new Route('/foo/qux')); | ||
33 | $coll = $coll->addPrefixRoute($route); | ||
34 | |||
35 | $route = new DumperRoute('bar3', new Route('/foo/bar')); | ||
36 | $coll = $coll->addPrefixRoute($route); | ||
37 | |||
38 | $route = new DumperRoute('bar4', new Route('')); | ||
39 | $result = $coll->addPrefixRoute($route); | ||
40 | |||
41 | $expect = <<<'EOF' | ||
42 | |-coll / | ||
43 | | |-coll /f | ||
44 | | | |-coll /fo | ||
45 | | | | |-coll /foo | ||
46 | | | | | |-coll /foo/ | ||
47 | | | | | | |-coll /foo/b | ||
48 | | | | | | | |-coll /foo/ba | ||
49 | | | | | | | | |-coll /foo/bar | ||
50 | | | | | | | | | |-route bar /foo/bar | ||
51 | | | | | | | | | |-route bar2 /foo/bar | ||
52 | | | | | | |-coll /foo/q | ||
53 | | | | | | | |-coll /foo/qu | ||
54 | | | | | | | | |-coll /foo/qux | ||
55 | | | | | | | | | |-route qux /foo/qux | ||
56 | | | | | | |-coll /foo/b | ||
57 | | | | | | | |-coll /foo/ba | ||
58 | | | | | | | | |-coll /foo/bar | ||
59 | | | | | | | | | |-route bar3 /foo/bar | ||
60 | | |-route bar4 / | ||
61 | |||
62 | EOF; | ||
63 | |||
64 | $this->assertSame($expect, $this->collectionToString($result->getRoot(), ' ')); | ||
65 | } | ||
66 | |||
67 | public function testMergeSlashNodes() | ||
68 | { | ||
69 | $coll = new DumperPrefixCollection; | ||
70 | $coll->setPrefix(''); | ||
71 | |||
72 | $route = new DumperRoute('bar', new Route('/foo/bar')); | ||
73 | $coll = $coll->addPrefixRoute($route); | ||
74 | |||
75 | $route = new DumperRoute('bar2', new Route('/foo/bar')); | ||
76 | $coll = $coll->addPrefixRoute($route); | ||
77 | |||
78 | $route = new DumperRoute('qux', new Route('/foo/qux')); | ||
79 | $coll = $coll->addPrefixRoute($route); | ||
80 | |||
81 | $route = new DumperRoute('bar3', new Route('/foo/bar')); | ||
82 | $result = $coll->addPrefixRoute($route); | ||
83 | |||
84 | $result->getRoot()->mergeSlashNodes(); | ||
85 | |||
86 | $expect = <<<'EOF' | ||
87 | |-coll /f | ||
88 | | |-coll /fo | ||
89 | | | |-coll /foo | ||
90 | | | | |-coll /foo/b | ||
91 | | | | | |-coll /foo/ba | ||
92 | | | | | | |-coll /foo/bar | ||
93 | | | | | | | |-route bar /foo/bar | ||
94 | | | | | | | |-route bar2 /foo/bar | ||
95 | | | | |-coll /foo/q | ||
96 | | | | | |-coll /foo/qu | ||
97 | | | | | | |-coll /foo/qux | ||
98 | | | | | | | |-route qux /foo/qux | ||
99 | | | | |-coll /foo/b | ||
100 | | | | | |-coll /foo/ba | ||
101 | | | | | | |-coll /foo/bar | ||
102 | | | | | | | |-route bar3 /foo/bar | ||
103 | |||
104 | EOF; | ||
105 | |||
106 | $this->assertSame($expect, $this->collectionToString($result->getRoot(), ' ')); | ||
107 | } | ||
108 | |||
109 | private function collectionToString(DumperCollection $collection, $prefix) | ||
110 | { | ||
111 | $string = ''; | ||
112 | foreach ($collection as $route) { | ||
113 | if ($route instanceof DumperCollection) { | ||
114 | $string .= sprintf("%s|-coll %s\n", $prefix, $route->getPrefix()); | ||
115 | $string .= $this->collectionToString($route, $prefix.'| '); | ||
116 | } else { | ||
117 | $string .= sprintf("%s|-route %s %s\n", $prefix, $route->getName(), $route->getRoute()->getPath()); | ||
118 | } | ||
119 | } | ||
120 | |||
121 | return $string; | ||
122 | } | ||
123 | } | ||
diff --git a/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/Dumper/PhpMatcherDumperTest.php b/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/Dumper/PhpMatcherDumperTest.php new file mode 100644 index 00000000..542ede85 --- /dev/null +++ b/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/Dumper/PhpMatcherDumperTest.php | |||
@@ -0,0 +1,261 @@ | |||
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\Matcher\Dumper; | ||
13 | |||
14 | use Symfony\Component\Routing\Matcher\Dumper\PhpMatcherDumper; | ||
15 | use Symfony\Component\Routing\Route; | ||
16 | use Symfony\Component\Routing\RouteCollection; | ||
17 | |||
18 | class PhpMatcherDumperTest extends \PHPUnit_Framework_TestCase | ||
19 | { | ||
20 | /** | ||
21 | * @expectedException \LogicException | ||
22 | */ | ||
23 | public function testDumpWhenSchemeIsUsedWithoutAProperDumper() | ||
24 | { | ||
25 | $collection = new RouteCollection(); | ||
26 | $collection->add('secure', new Route( | ||
27 | '/secure', | ||
28 | array(), | ||
29 | array('_scheme' => 'https') | ||
30 | )); | ||
31 | $dumper = new PhpMatcherDumper($collection); | ||
32 | $dumper->dump(); | ||
33 | } | ||
34 | |||
35 | /** | ||
36 | * @dataProvider getRouteCollections | ||
37 | */ | ||
38 | public function testDump(RouteCollection $collection, $fixture, $options = array()) | ||
39 | { | ||
40 | $basePath = __DIR__.'/../../Fixtures/dumper/'; | ||
41 | |||
42 | $dumper = new PhpMatcherDumper($collection); | ||
43 | $this->assertStringEqualsFile($basePath.$fixture, $dumper->dump($options), '->dump() correctly dumps routes as optimized PHP code.'); | ||
44 | } | ||
45 | |||
46 | public function getRouteCollections() | ||
47 | { | ||
48 | /* test case 1 */ | ||
49 | |||
50 | $collection = new RouteCollection(); | ||
51 | |||
52 | $collection->add('overridden', new Route('/overridden')); | ||
53 | |||
54 | // defaults and requirements | ||
55 | $collection->add('foo', new Route( | ||
56 | '/foo/{bar}', | ||
57 | array('def' => 'test'), | ||
58 | array('bar' => 'baz|symfony') | ||
59 | )); | ||
60 | // method requirement | ||
61 | $collection->add('bar', new Route( | ||
62 | '/bar/{foo}', | ||
63 | array(), | ||
64 | array('_method' => 'GET|head') | ||
65 | )); | ||
66 | // GET method requirement automatically adds HEAD as valid | ||
67 | $collection->add('barhead', new Route( | ||
68 | '/barhead/{foo}', | ||
69 | array(), | ||
70 | array('_method' => 'GET') | ||
71 | )); | ||
72 | // simple | ||
73 | $collection->add('baz', new Route( | ||
74 | '/test/baz' | ||
75 | )); | ||
76 | // simple with extension | ||
77 | $collection->add('baz2', new Route( | ||
78 | '/test/baz.html' | ||
79 | )); | ||
80 | // trailing slash | ||
81 | $collection->add('baz3', new Route( | ||
82 | '/test/baz3/' | ||
83 | )); | ||
84 | // trailing slash with variable | ||
85 | $collection->add('baz4', new Route( | ||
86 | '/test/{foo}/' | ||
87 | )); | ||
88 | // trailing slash and method | ||
89 | $collection->add('baz5', new Route( | ||
90 | '/test/{foo}/', | ||
91 | array(), | ||
92 | array('_method' => 'post') | ||
93 | )); | ||
94 | // complex name | ||
95 | $collection->add('baz.baz6', new Route( | ||
96 | '/test/{foo}/', | ||
97 | array(), | ||
98 | array('_method' => 'put') | ||
99 | )); | ||
100 | // defaults without variable | ||
101 | $collection->add('foofoo', new Route( | ||
102 | '/foofoo', | ||
103 | array('def' => 'test') | ||
104 | )); | ||
105 | // pattern with quotes | ||
106 | $collection->add('quoter', new Route( | ||
107 | '/{quoter}', | ||
108 | array(), | ||
109 | array('quoter' => '[\']+') | ||
110 | )); | ||
111 | // space in pattern | ||
112 | $collection->add('space', new Route( | ||
113 | '/spa ce' | ||
114 | )); | ||
115 | |||
116 | // prefixes | ||
117 | $collection1 = new RouteCollection(); | ||
118 | $collection1->add('overridden', new Route('/overridden1')); | ||
119 | $collection1->add('foo1', new Route('/{foo}')); | ||
120 | $collection1->add('bar1', new Route('/{bar}')); | ||
121 | $collection1->addPrefix('/b\'b'); | ||
122 | $collection2 = new RouteCollection(); | ||
123 | $collection2->addCollection($collection1); | ||
124 | $collection2->add('overridden', new Route('/{var}', array(), array('var' => '.*'))); | ||
125 | $collection1 = new RouteCollection(); | ||
126 | $collection1->add('foo2', new Route('/{foo1}')); | ||
127 | $collection1->add('bar2', new Route('/{bar1}')); | ||
128 | $collection1->addPrefix('/b\'b'); | ||
129 | $collection2->addCollection($collection1); | ||
130 | $collection2->addPrefix('/a'); | ||
131 | $collection->addCollection($collection2); | ||
132 | |||
133 | // overridden through addCollection() and multiple sub-collections with no own prefix | ||
134 | $collection1 = new RouteCollection(); | ||
135 | $collection1->add('overridden2', new Route('/old')); | ||
136 | $collection1->add('helloWorld', new Route('/hello/{who}', array('who' => 'World!'))); | ||
137 | $collection2 = new RouteCollection(); | ||
138 | $collection3 = new RouteCollection(); | ||
139 | $collection3->add('overridden2', new Route('/new')); | ||
140 | $collection3->add('hey', new Route('/hey/')); | ||
141 | $collection2->addCollection($collection3); | ||
142 | $collection1->addCollection($collection2); | ||
143 | $collection1->addPrefix('/multi'); | ||
144 | $collection->addCollection($collection1); | ||
145 | |||
146 | // "dynamic" prefix | ||
147 | $collection1 = new RouteCollection(); | ||
148 | $collection1->add('foo3', new Route('/{foo}')); | ||
149 | $collection1->add('bar3', new Route('/{bar}')); | ||
150 | $collection1->addPrefix('/b'); | ||
151 | $collection1->addPrefix('{_locale}'); | ||
152 | $collection->addCollection($collection1); | ||
153 | |||
154 | // route between collections | ||
155 | $collection->add('ababa', new Route('/ababa')); | ||
156 | |||
157 | // collection with static prefix but only one route | ||
158 | $collection1 = new RouteCollection(); | ||
159 | $collection1->add('foo4', new Route('/{foo}')); | ||
160 | $collection1->addPrefix('/aba'); | ||
161 | $collection->addCollection($collection1); | ||
162 | |||
163 | // prefix and host | ||
164 | |||
165 | $collection1 = new RouteCollection(); | ||
166 | |||
167 | $route1 = new Route('/route1', array(), array(), array(), 'a.example.com'); | ||
168 | $collection1->add('route1', $route1); | ||
169 | |||
170 | $collection2 = new RouteCollection(); | ||
171 | |||
172 | $route2 = new Route('/c2/route2', array(), array(), array(), 'a.example.com'); | ||
173 | $collection1->add('route2', $route2); | ||
174 | |||
175 | $route3 = new Route('/c2/route3', array(), array(), array(), 'b.example.com'); | ||
176 | $collection1->add('route3', $route3); | ||
177 | |||
178 | $route4 = new Route('/route4', array(), array(), array(), 'a.example.com'); | ||
179 | $collection1->add('route4', $route4); | ||
180 | |||
181 | $route5 = new Route('/route5', array(), array(), array(), 'c.example.com'); | ||
182 | $collection1->add('route5', $route5); | ||
183 | |||
184 | $route6 = new Route('/route6', array(), array(), array(), null); | ||
185 | $collection1->add('route6', $route6); | ||
186 | |||
187 | $collection->addCollection($collection1); | ||
188 | |||
189 | // host and variables | ||
190 | |||
191 | $collection1 = new RouteCollection(); | ||
192 | |||
193 | $route11 = new Route('/route11', array(), array(), array(), '{var1}.example.com'); | ||
194 | $collection1->add('route11', $route11); | ||
195 | |||
196 | $route12 = new Route('/route12', array('var1' => 'val'), array(), array(), '{var1}.example.com'); | ||
197 | $collection1->add('route12', $route12); | ||
198 | |||
199 | $route13 = new Route('/route13/{name}', array(), array(), array(), '{var1}.example.com'); | ||
200 | $collection1->add('route13', $route13); | ||
201 | |||
202 | $route14 = new Route('/route14/{name}', array('var1' => 'val'), array(), array(), '{var1}.example.com'); | ||
203 | $collection1->add('route14', $route14); | ||
204 | |||
205 | $route15 = new Route('/route15/{name}', array(), array(), array(), 'c.example.com'); | ||
206 | $collection1->add('route15', $route15); | ||
207 | |||
208 | $route16 = new Route('/route16/{name}', array('var1' => 'val'), array(), array(), null); | ||
209 | $collection1->add('route16', $route16); | ||
210 | |||
211 | $route17 = new Route('/route17', array(), array(), array(), null); | ||
212 | $collection1->add('route17', $route17); | ||
213 | |||
214 | $collection->addCollection($collection1); | ||
215 | |||
216 | // multiple sub-collections with a single route and a prefix each | ||
217 | $collection1 = new RouteCollection(); | ||
218 | $collection1->add('a', new Route('/a...')); | ||
219 | $collection2 = new RouteCollection(); | ||
220 | $collection2->add('b', new Route('/{var}')); | ||
221 | $collection3 = new RouteCollection(); | ||
222 | $collection3->add('c', new Route('/{var}')); | ||
223 | $collection3->addPrefix('/c'); | ||
224 | $collection2->addCollection($collection3); | ||
225 | $collection2->addPrefix('/b'); | ||
226 | $collection1->addCollection($collection2); | ||
227 | $collection1->addPrefix('/a'); | ||
228 | $collection->addCollection($collection1); | ||
229 | |||
230 | /* test case 2 */ | ||
231 | |||
232 | $redirectCollection = clone $collection; | ||
233 | |||
234 | // force HTTPS redirection | ||
235 | $redirectCollection->add('secure', new Route( | ||
236 | '/secure', | ||
237 | array(), | ||
238 | array('_scheme' => 'https') | ||
239 | )); | ||
240 | |||
241 | // force HTTP redirection | ||
242 | $redirectCollection->add('nonsecure', new Route( | ||
243 | '/nonsecure', | ||
244 | array(), | ||
245 | array('_scheme' => 'http') | ||
246 | )); | ||
247 | |||
248 | /* test case 3 */ | ||
249 | |||
250 | $rootprefixCollection = new RouteCollection(); | ||
251 | $rootprefixCollection->add('static', new Route('/test')); | ||
252 | $rootprefixCollection->add('dynamic', new Route('/{var}')); | ||
253 | $rootprefixCollection->addPrefix('rootprefix'); | ||
254 | |||
255 | return array( | ||
256 | array($collection, 'url_matcher1.php', array()), | ||
257 | array($redirectCollection, 'url_matcher2.php', array('base_class' => 'Symfony\Component\Routing\Tests\Fixtures\RedirectableUrlMatcher')), | ||
258 | array($rootprefixCollection, 'url_matcher3.php', array()) | ||
259 | ); | ||
260 | } | ||
261 | } | ||
diff --git a/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/RedirectableUrlMatcherTest.php b/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/RedirectableUrlMatcherTest.php new file mode 100644 index 00000000..2ad4fc87 --- /dev/null +++ b/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/RedirectableUrlMatcherTest.php | |||
@@ -0,0 +1,58 @@ | |||
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\Matcher; | ||
13 | |||
14 | use Symfony\Component\Routing\Route; | ||
15 | use Symfony\Component\Routing\RouteCollection; | ||
16 | use Symfony\Component\Routing\RequestContext; | ||
17 | |||
18 | class RedirectableUrlMatcherTest extends \PHPUnit_Framework_TestCase | ||
19 | { | ||
20 | public function testRedirectWhenNoSlash() | ||
21 | { | ||
22 | $coll = new RouteCollection(); | ||
23 | $coll->add('foo', new Route('/foo/')); | ||
24 | |||
25 | $matcher = $this->getMockForAbstractClass('Symfony\Component\Routing\Matcher\RedirectableUrlMatcher', array($coll, new RequestContext())); | ||
26 | $matcher->expects($this->once())->method('redirect'); | ||
27 | $matcher->match('/foo'); | ||
28 | } | ||
29 | |||
30 | /** | ||
31 | * @expectedException \Symfony\Component\Routing\Exception\ResourceNotFoundException | ||
32 | */ | ||
33 | public function testRedirectWhenNoSlashForNonSafeMethod() | ||
34 | { | ||
35 | $coll = new RouteCollection(); | ||
36 | $coll->add('foo', new Route('/foo/')); | ||
37 | |||
38 | $context = new RequestContext(); | ||
39 | $context->setMethod('POST'); | ||
40 | $matcher = $this->getMockForAbstractClass('Symfony\Component\Routing\Matcher\RedirectableUrlMatcher', array($coll, $context)); | ||
41 | $matcher->match('/foo'); | ||
42 | } | ||
43 | |||
44 | public function testSchemeRedirect() | ||
45 | { | ||
46 | $coll = new RouteCollection(); | ||
47 | $coll->add('foo', new Route('/foo', array(), array('_scheme' => 'https'))); | ||
48 | |||
49 | $matcher = $this->getMockForAbstractClass('Symfony\Component\Routing\Matcher\RedirectableUrlMatcher', array($coll, new RequestContext())); | ||
50 | $matcher | ||
51 | ->expects($this->once()) | ||
52 | ->method('redirect') | ||
53 | ->with('/foo', 'foo', 'https') | ||
54 | ->will($this->returnValue(array('_route' => 'foo'))) | ||
55 | ; | ||
56 | $matcher->match('/foo'); | ||
57 | } | ||
58 | } | ||
diff --git a/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/TraceableUrlMatcherTest.php b/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/TraceableUrlMatcherTest.php new file mode 100644 index 00000000..86d8d954 --- /dev/null +++ b/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/TraceableUrlMatcherTest.php | |||
@@ -0,0 +1,66 @@ | |||
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\Matcher; | ||
13 | |||
14 | use Symfony\Component\Routing\Route; | ||
15 | use Symfony\Component\Routing\RouteCollection; | ||
16 | use Symfony\Component\Routing\RequestContext; | ||
17 | use Symfony\Component\Routing\Matcher\TraceableUrlMatcher; | ||
18 | |||
19 | class TraceableUrlMatcherTest extends \PHPUnit_Framework_TestCase | ||
20 | { | ||
21 | public function test() | ||
22 | { | ||
23 | $coll = new RouteCollection(); | ||
24 | $coll->add('foo', new Route('/foo', array(), array('_method' => 'POST'))); | ||
25 | $coll->add('bar', new Route('/bar/{id}', array(), array('id' => '\d+'))); | ||
26 | $coll->add('bar1', new Route('/bar/{name}', array(), array('id' => '\w+', '_method' => 'POST'))); | ||
27 | $coll->add('bar2', new Route('/foo', array(), array(), array(), 'baz')); | ||
28 | $coll->add('bar3', new Route('/foo1', array(), array(), array(), 'baz')); | ||
29 | |||
30 | $context = new RequestContext(); | ||
31 | $context->setHost('baz'); | ||
32 | |||
33 | $matcher = new TraceableUrlMatcher($coll, $context); | ||
34 | $traces = $matcher->getTraces('/babar'); | ||
35 | $this->assertEquals(array(0, 0, 0, 0, 0), $this->getLevels($traces)); | ||
36 | |||
37 | $traces = $matcher->getTraces('/foo'); | ||
38 | $this->assertEquals(array(1, 0, 0, 2), $this->getLevels($traces)); | ||
39 | |||
40 | $traces = $matcher->getTraces('/bar/12'); | ||
41 | $this->assertEquals(array(0, 2), $this->getLevels($traces)); | ||
42 | |||
43 | $traces = $matcher->getTraces('/bar/dd'); | ||
44 | $this->assertEquals(array(0, 1, 1, 0, 0), $this->getLevels($traces)); | ||
45 | |||
46 | $traces = $matcher->getTraces('/foo1'); | ||
47 | $this->assertEquals(array(0, 0, 0, 0, 2), $this->getLevels($traces)); | ||
48 | |||
49 | $context->setMethod('POST'); | ||
50 | $traces = $matcher->getTraces('/foo'); | ||
51 | $this->assertEquals(array(2), $this->getLevels($traces)); | ||
52 | |||
53 | $traces = $matcher->getTraces('/bar/dd'); | ||
54 | $this->assertEquals(array(0, 1, 2), $this->getLevels($traces)); | ||
55 | } | ||
56 | |||
57 | public function getLevels($traces) | ||
58 | { | ||
59 | $levels = array(); | ||
60 | foreach ($traces as $trace) { | ||
61 | $levels[] = $trace['level']; | ||
62 | } | ||
63 | |||
64 | return $levels; | ||
65 | } | ||
66 | } | ||
diff --git a/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/UrlMatcherTest.php b/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/UrlMatcherTest.php new file mode 100644 index 00000000..8a1428f1 --- /dev/null +++ b/vendor/symfony/routing/Symfony/Component/Routing/Tests/Matcher/UrlMatcherTest.php | |||
@@ -0,0 +1,383 @@ | |||
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\Matcher; | ||
13 | |||
14 | use Symfony\Component\Routing\Exception\MethodNotAllowedException; | ||
15 | use Symfony\Component\Routing\Exception\ResourceNotFoundException; | ||
16 | use Symfony\Component\Routing\Matcher\UrlMatcher; | ||
17 | use Symfony\Component\Routing\Route; | ||
18 | use Symfony\Component\Routing\RouteCollection; | ||
19 | use Symfony\Component\Routing\RequestContext; | ||
20 | |||
21 | class UrlMatcherTest extends \PHPUnit_Framework_TestCase | ||
22 | { | ||
23 | public function testNoMethodSoAllowed() | ||
24 | { | ||
25 | $coll = new RouteCollection(); | ||
26 | $coll->add('foo', new Route('/foo')); | ||
27 | |||
28 | $matcher = new UrlMatcher($coll, new RequestContext()); | ||
29 | $matcher->match('/foo'); | ||
30 | } | ||
31 | |||
32 | public function testMethodNotAllowed() | ||
33 | { | ||
34 | $coll = new RouteCollection(); | ||
35 | $coll->add('foo', new Route('/foo', array(), array('_method' => 'post'))); | ||
36 | |||
37 | $matcher = new UrlMatcher($coll, new RequestContext()); | ||
38 | |||
39 | try { | ||
40 | $matcher->match('/foo'); | ||
41 | $this->fail(); | ||
42 | } catch (MethodNotAllowedException $e) { | ||
43 | $this->assertEquals(array('POST'), $e->getAllowedMethods()); | ||
44 | } | ||
45 | } | ||
46 | |||
47 | public function testHeadAllowedWhenRequirementContainsGet() | ||
48 | { | ||
49 | $coll = new RouteCollection(); | ||
50 | $coll->add('foo', new Route('/foo', array(), array('_method' => 'get'))); | ||
51 | |||
52 | $matcher = new UrlMatcher($coll, new RequestContext('', 'head')); | ||
53 | $matcher->match('/foo'); | ||
54 | } | ||
55 | |||
56 | public function testMethodNotAllowedAggregatesAllowedMethods() | ||
57 | { | ||
58 | $coll = new RouteCollection(); | ||
59 | $coll->add('foo1', new Route('/foo', array(), array('_method' => 'post'))); | ||
60 | $coll->add('foo2', new Route('/foo', array(), array('_method' => 'put|delete'))); | ||
61 | |||
62 | $matcher = new UrlMatcher($coll, new RequestContext()); | ||
63 | |||
64 | try { | ||
65 | $matcher->match('/foo'); | ||
66 | $this->fail(); | ||
67 | } catch (MethodNotAllowedException $e) { | ||
68 | $this->assertEquals(array('POST', 'PUT', 'DELETE'), $e->getAllowedMethods()); | ||
69 | } | ||
70 | } | ||
71 | |||
72 | public function testMatch() | ||
73 | { | ||
74 | // test the patterns are matched and parameters are returned | ||
75 | $collection = new RouteCollection(); | ||
76 | $collection->add('foo', new Route('/foo/{bar}')); | ||
77 | $matcher = new UrlMatcher($collection, new RequestContext()); | ||
78 | try { | ||
79 | $matcher->match('/no-match'); | ||
80 | $this->fail(); | ||
81 | } catch (ResourceNotFoundException $e) {} | ||
82 | $this->assertEquals(array('_route' => 'foo', 'bar' => 'baz'), $matcher->match('/foo/baz')); | ||
83 | |||
84 | // test that defaults are merged | ||
85 | $collection = new RouteCollection(); | ||
86 | $collection->add('foo', new Route('/foo/{bar}', array('def' => 'test'))); | ||
87 | $matcher = new UrlMatcher($collection, new RequestContext()); | ||
88 | $this->assertEquals(array('_route' => 'foo', 'bar' => 'baz', 'def' => 'test'), $matcher->match('/foo/baz')); | ||
89 | |||
90 | // test that route "method" is ignored if no method is given in the context | ||
91 | $collection = new RouteCollection(); | ||
92 | $collection->add('foo', new Route('/foo', array(), array('_method' => 'GET|head'))); | ||
93 | $matcher = new UrlMatcher($collection, new RequestContext()); | ||
94 | $this->assertInternalType('array', $matcher->match('/foo')); | ||
95 | |||
96 | // route does not match with POST method context | ||
97 | $matcher = new UrlMatcher($collection, new RequestContext('', 'post')); | ||
98 | try { | ||
99 | $matcher->match('/foo'); | ||
100 | $this->fail(); | ||
101 | } catch (MethodNotAllowedException $e) {} | ||
102 | |||
103 | // route does match with GET or HEAD method context | ||
104 | $matcher = new UrlMatcher($collection, new RequestContext()); | ||
105 | $this->assertInternalType('array', $matcher->match('/foo')); | ||
106 | $matcher = new UrlMatcher($collection, new RequestContext('', 'head')); | ||
107 | $this->assertInternalType('array', $matcher->match('/foo')); | ||
108 | |||
109 | // route with an optional variable as the first segment | ||
110 | $collection = new RouteCollection(); | ||
111 | $collection->add('bar', new Route('/{bar}/foo', array('bar' => 'bar'), array('bar' => 'foo|bar'))); | ||
112 | $matcher = new UrlMatcher($collection, new RequestContext()); | ||
113 | $this->assertEquals(array('_route' => 'bar', 'bar' => 'bar'), $matcher->match('/bar/foo')); | ||
114 | $this->assertEquals(array('_route' => 'bar', 'bar' => 'foo'), $matcher->match('/foo/foo')); | ||
115 | |||
116 | $collection = new RouteCollection(); | ||
117 | $collection->add('bar', new Route('/{bar}', array('bar' => 'bar'), array('bar' => 'foo|bar'))); | ||
118 | $matcher = new UrlMatcher($collection, new RequestContext()); | ||
119 | $this->assertEquals(array('_route' => 'bar', 'bar' => 'foo'), $matcher->match('/foo')); | ||
120 | $this->assertEquals(array('_route' => 'bar', 'bar' => 'bar'), $matcher->match('/')); | ||
121 | |||
122 | // route with only optional variables | ||
123 | $collection = new RouteCollection(); | ||
124 | $collection->add('bar', new Route('/{foo}/{bar}', array('foo' => 'foo', 'bar' => 'bar'), array())); | ||
125 | $matcher = new UrlMatcher($collection, new RequestContext()); | ||
126 | $this->assertEquals(array('_route' => 'bar', 'foo' => 'foo', 'bar' => 'bar'), $matcher->match('/')); | ||
127 | $this->assertEquals(array('_route' => 'bar', 'foo' => 'a', 'bar' => 'bar'), $matcher->match('/a')); | ||
128 | $this->assertEquals(array('_route' => 'bar', 'foo' => 'a', 'bar' => 'b'), $matcher->match('/a/b')); | ||
129 | } | ||
130 | |||
131 | public function testMatchWithPrefixes() | ||
132 | { | ||
133 | $collection = new RouteCollection(); | ||
134 | $collection->add('foo', new Route('/{foo}')); | ||
135 | $collection->addPrefix('/b'); | ||
136 | $collection->addPrefix('/a'); | ||
137 | |||
138 | $matcher = new UrlMatcher($collection, new RequestContext()); | ||
139 | $this->assertEquals(array('_route' => 'foo', 'foo' => 'foo'), $matcher->match('/a/b/foo')); | ||
140 | } | ||
141 | |||
142 | public function testMatchWithDynamicPrefix() | ||
143 | { | ||
144 | $collection = new RouteCollection(); | ||
145 | $collection->add('foo', new Route('/{foo}')); | ||
146 | $collection->addPrefix('/b'); | ||
147 | $collection->addPrefix('/{_locale}'); | ||
148 | |||
149 | $matcher = new UrlMatcher($collection, new RequestContext()); | ||
150 | $this->assertEquals(array('_locale' => 'fr', '_route' => 'foo', 'foo' => 'foo'), $matcher->match('/fr/b/foo')); | ||
151 | } | ||
152 | |||
153 | public function testMatchSpecialRouteName() | ||
154 | { | ||
155 | $collection = new RouteCollection(); | ||
156 | $collection->add('$péß^a|', new Route('/bar')); | ||
157 | |||
158 | $matcher = new UrlMatcher($collection, new RequestContext()); | ||
159 | $this->assertEquals(array('_route' => '$péß^a|'), $matcher->match('/bar')); | ||
160 | } | ||
161 | |||
162 | public function testMatchNonAlpha() | ||
163 | { | ||
164 | $collection = new RouteCollection(); | ||
165 | $chars = '!"$%éà &\'()*+,./:;<=>@ABCDEFGHIJKLMNOPQRSTUVWXYZ\\[]^_`abcdefghijklmnopqrstuvwxyz{|}~-'; | ||
166 | $collection->add('foo', new Route('/{foo}/bar', array(), array('foo' => '['.preg_quote($chars).']+'))); | ||
167 | |||
168 | $matcher = new UrlMatcher($collection, new RequestContext()); | ||
169 | $this->assertEquals(array('_route' => 'foo', 'foo' => $chars), $matcher->match('/'.rawurlencode($chars).'/bar')); | ||
170 | $this->assertEquals(array('_route' => 'foo', 'foo' => $chars), $matcher->match('/'.strtr($chars, array('%' => '%25')).'/bar')); | ||
171 | } | ||
172 | |||
173 | public function testMatchWithDotMetacharacterInRequirements() | ||
174 | { | ||
175 | $collection = new RouteCollection(); | ||
176 | $collection->add('foo', new Route('/{foo}/bar', array(), array('foo' => '.+'))); | ||
177 | |||
178 | $matcher = new UrlMatcher($collection, new RequestContext()); | ||
179 | $this->assertEquals(array('_route' => 'foo', 'foo' => "\n"), $matcher->match('/'.urlencode("\n").'/bar'), 'linefeed character is matched'); | ||
180 | } | ||
181 | |||
182 | public function testMatchOverriddenRoute() | ||
183 | { | ||
184 | $collection = new RouteCollection(); | ||
185 | $collection->add('foo', new Route('/foo')); | ||
186 | |||
187 | $collection1 = new RouteCollection(); | ||
188 | $collection1->add('foo', new Route('/foo1')); | ||
189 | |||
190 | $collection->addCollection($collection1); | ||
191 | |||
192 | $matcher = new UrlMatcher($collection, new RequestContext()); | ||
193 | |||
194 | $this->assertEquals(array('_route' => 'foo'), $matcher->match('/foo1')); | ||
195 | $this->setExpectedException('Symfony\Component\Routing\Exception\ResourceNotFoundException'); | ||
196 | $this->assertEquals(array(), $matcher->match('/foo')); | ||
197 | } | ||
198 | |||
199 | public function testMatchRegression() | ||
200 | { | ||
201 | $coll = new RouteCollection(); | ||
202 | $coll->add('foo', new Route('/foo/{foo}')); | ||
203 | $coll->add('bar', new Route('/foo/bar/{foo}')); | ||
204 | |||
205 | $matcher = new UrlMatcher($coll, new RequestContext()); | ||
206 | $this->assertEquals(array('foo' => 'bar', '_route' => 'bar'), $matcher->match('/foo/bar/bar')); | ||
207 | |||
208 | $collection = new RouteCollection(); | ||
209 | $collection->add('foo', new Route('/{bar}')); | ||
210 | $matcher = new UrlMatcher($collection, new RequestContext()); | ||
211 | try { | ||
212 | $matcher->match('/'); | ||
213 | $this->fail(); | ||
214 | } catch (ResourceNotFoundException $e) { | ||
215 | } | ||
216 | } | ||
217 | |||
218 | public function testDefaultRequirementForOptionalVariables() | ||
219 | { | ||
220 | $coll = new RouteCollection(); | ||
221 | $coll->add('test', new Route('/{page}.{_format}', array('page' => 'index', '_format' => 'html'))); | ||
222 | |||
223 | $matcher = new UrlMatcher($coll, new RequestContext()); | ||
224 | $this->assertEquals(array('page' => 'my-page', '_format' => 'xml', '_route' => 'test'), $matcher->match('/my-page.xml')); | ||
225 | } | ||
226 | |||
227 | public function testMatchingIsEager() | ||
228 | { | ||
229 | $coll = new RouteCollection(); | ||
230 | $coll->add('test', new Route('/{foo}-{bar}-', array(), array('foo' => '.+', 'bar' => '.+'))); | ||
231 | |||
232 | $matcher = new UrlMatcher($coll, new RequestContext()); | ||
233 | $this->assertEquals(array('foo' => 'text1-text2-text3', 'bar' => 'text4', '_route' => 'test'), $matcher->match('/text1-text2-text3-text4-')); | ||
234 | } | ||
235 | |||
236 | public function testAdjacentVariables() | ||
237 | { | ||
238 | $coll = new RouteCollection(); | ||
239 | $coll->add('test', new Route('/{w}{x}{y}{z}.{_format}', array('z' => 'default-z', '_format' => 'html'), array('y' => 'y|Y'))); | ||
240 | |||
241 | $matcher = new UrlMatcher($coll, new RequestContext()); | ||
242 | // 'w' eagerly matches as much as possible and the other variables match the remaining chars. | ||
243 | // This also shows that the variables w-z must all exclude the separating char (the dot '.' in this case) by default requirement. | ||
244 | // Otherwise they would also consume '.xml' and _format would never match as it's an optional variable. | ||
245 | $this->assertEquals(array('w' => 'wwwww', 'x' => 'x', 'y' => 'Y', 'z' => 'Z','_format' => 'xml', '_route' => 'test'), $matcher->match('/wwwwwxYZ.xml')); | ||
246 | // As 'y' has custom requirement and can only be of value 'y|Y', it will leave 'ZZZ' to variable z. | ||
247 | // So with carefully chosen requirements adjacent variables, can be useful. | ||
248 | $this->assertEquals(array('w' => 'wwwww', 'x' => 'x', 'y' => 'y', 'z' => 'ZZZ','_format' => 'html', '_route' => 'test'), $matcher->match('/wwwwwxyZZZ')); | ||
249 | // z and _format are optional. | ||
250 | $this->assertEquals(array('w' => 'wwwww', 'x' => 'x', 'y' => 'y', 'z' => 'default-z','_format' => 'html', '_route' => 'test'), $matcher->match('/wwwwwxy')); | ||
251 | |||
252 | $this->setExpectedException('Symfony\Component\Routing\Exception\ResourceNotFoundException'); | ||
253 | $matcher->match('/wxy.html'); | ||
254 | } | ||
255 | |||
256 | public function testOptionalVariableWithNoRealSeparator() | ||
257 | { | ||
258 | $coll = new RouteCollection(); | ||
259 | $coll->add('test', new Route('/get{what}', array('what' => 'All'))); | ||
260 | $matcher = new UrlMatcher($coll, new RequestContext()); | ||
261 | |||
262 | $this->assertEquals(array('what' => 'All', '_route' => 'test'), $matcher->match('/get')); | ||
263 | $this->assertEquals(array('what' => 'Sites', '_route' => 'test'), $matcher->match('/getSites')); | ||
264 | |||
265 | // Usually the character in front of an optional parameter can be left out, e.g. with pattern '/get/{what}' just '/get' would match. | ||
266 | // But here the 't' in 'get' is not a separating character, so it makes no sense to match without it. | ||
267 | $this->setExpectedException('Symfony\Component\Routing\Exception\ResourceNotFoundException'); | ||
268 | $matcher->match('/ge'); | ||
269 | } | ||
270 | |||
271 | public function testRequiredVariableWithNoRealSeparator() | ||
272 | { | ||
273 | $coll = new RouteCollection(); | ||
274 | $coll->add('test', new Route('/get{what}Suffix')); | ||
275 | $matcher = new UrlMatcher($coll, new RequestContext()); | ||
276 | |||
277 | $this->assertEquals(array('what' => 'Sites', '_route' => 'test'), $matcher->match('/getSitesSuffix')); | ||
278 | } | ||
279 | |||
280 | public function testDefaultRequirementOfVariable() | ||
281 | { | ||
282 | $coll = new RouteCollection(); | ||
283 | $coll->add('test', new Route('/{page}.{_format}')); | ||
284 | $matcher = new UrlMatcher($coll, new RequestContext()); | ||
285 | |||
286 | $this->assertEquals(array('page' => 'index', '_format' => 'mobile.html', '_route' => 'test'), $matcher->match('/index.mobile.html')); | ||
287 | } | ||
288 | |||
289 | /** | ||
290 | * @expectedException \Symfony\Component\Routing\Exception\ResourceNotFoundException | ||
291 | */ | ||
292 | public function testDefaultRequirementOfVariableDisallowsSlash() | ||
293 | { | ||
294 | $coll = new RouteCollection(); | ||
295 | $coll->add('test', new Route('/{page}.{_format}')); | ||
296 | $matcher = new UrlMatcher($coll, new RequestContext()); | ||
297 | |||
298 | $matcher->match('/index.sl/ash'); | ||
299 | } | ||
300 | |||
301 | /** | ||
302 | * @expectedException \Symfony\Component\Routing\Exception\ResourceNotFoundException | ||
303 | */ | ||
304 | public function testDefaultRequirementOfVariableDisallowsNextSeparator() | ||
305 | { | ||
306 | $coll = new RouteCollection(); | ||
307 | $coll->add('test', new Route('/{page}.{_format}', array(), array('_format' => 'html|xml'))); | ||
308 | $matcher = new UrlMatcher($coll, new RequestContext()); | ||
309 | |||
310 | $matcher->match('/do.t.html'); | ||
311 | } | ||
312 | |||
313 | /** | ||
314 | * @expectedException \Symfony\Component\Routing\Exception\ResourceNotFoundException | ||
315 | */ | ||
316 | public function testSchemeRequirement() | ||
317 | { | ||
318 | $coll = new RouteCollection(); | ||
319 | $coll->add('foo', new Route('/foo', array(), array('_scheme' => 'https'))); | ||
320 | $matcher = new UrlMatcher($coll, new RequestContext()); | ||
321 | $matcher->match('/foo'); | ||
322 | } | ||
323 | |||
324 | public function testDecodeOnce() | ||
325 | { | ||
326 | $coll = new RouteCollection(); | ||
327 | $coll->add('foo', new Route('/foo/{foo}')); | ||
328 | |||
329 | $matcher = new UrlMatcher($coll, new RequestContext()); | ||
330 | $this->assertEquals(array('foo' => 'bar%23', '_route' => 'foo'), $matcher->match('/foo/bar%2523')); | ||
331 | } | ||
332 | |||
333 | public function testCannotRelyOnPrefix() | ||
334 | { | ||
335 | $coll = new RouteCollection(); | ||
336 | |||
337 | $subColl = new RouteCollection(); | ||
338 | $subColl->add('bar', new Route('/bar')); | ||
339 | $subColl->addPrefix('/prefix'); | ||
340 | // overwrite the pattern, so the prefix is not valid anymore for this route in the collection | ||
341 | $subColl->get('bar')->setPattern('/new'); | ||
342 | |||
343 | $coll->addCollection($subColl); | ||
344 | |||
345 | $matcher = new UrlMatcher($coll, new RequestContext()); | ||
346 | $this->assertEquals(array('_route' => 'bar'), $matcher->match('/new')); | ||
347 | } | ||
348 | |||
349 | public function testWithHost() | ||
350 | { | ||
351 | $coll = new RouteCollection(); | ||
352 | $coll->add('foo', new Route('/foo/{foo}', array(), array(), array(), '{locale}.example.com')); | ||
353 | |||
354 | $matcher = new UrlMatcher($coll, new RequestContext('', 'GET', 'en.example.com')); | ||
355 | $this->assertEquals(array('foo' => 'bar', '_route' => 'foo', 'locale' => 'en'), $matcher->match('/foo/bar')); | ||
356 | } | ||
357 | |||
358 | public function testWithHostOnRouteCollection() | ||
359 | { | ||
360 | $coll = new RouteCollection(); | ||
361 | $coll->add('foo', new Route('/foo/{foo}')); | ||
362 | $coll->add('bar', new Route('/bar/{foo}', array(), array(), array(), '{locale}.example.net')); | ||
363 | $coll->setHost('{locale}.example.com'); | ||
364 | |||
365 | $matcher = new UrlMatcher($coll, new RequestContext('', 'GET', 'en.example.com')); | ||
366 | $this->assertEquals(array('foo' => 'bar', '_route' => 'foo', 'locale' => 'en'), $matcher->match('/foo/bar')); | ||
367 | |||
368 | $matcher = new UrlMatcher($coll, new RequestContext('', 'GET', 'en.example.com')); | ||
369 | $this->assertEquals(array('foo' => 'bar', '_route' => 'bar', 'locale' => 'en'), $matcher->match('/bar/bar')); | ||
370 | } | ||
371 | |||
372 | /** | ||
373 | * @expectedException \Symfony\Component\Routing\Exception\ResourceNotFoundException | ||
374 | */ | ||
375 | public function testWithOutHostHostDoesNotMatch() | ||
376 | { | ||
377 | $coll = new RouteCollection(); | ||
378 | $coll->add('foo', new Route('/foo/{foo}', array(), array(), array(), '{locale}.example.com')); | ||
379 | |||
380 | $matcher = new UrlMatcher($coll, new RequestContext('', 'GET', 'example.com')); | ||
381 | $matcher->match('/foo/bar'); | ||
382 | } | ||
383 | } | ||