UrlMatcherTest - Code Metrics - Inspection of "Fix route injection, add tests" - yiisoft/router-fastroute - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#25)

by Dmitriy

created 2020-02-17 12:38 UTC

UrlMatcherTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	263
Duplicated Lines	0 %

Importance

Changes	4
Bugs	1	Features	1

Metric	Value
eloc	142
dl	0
loc	263
rs	10
c	4
b	1
f	1
wmc	15

15 Methods

Rating	Name	Size	Complexity
A	testDefaultsAreInResult()	16	1
A	testDisallowedHEADMethod()	15	1
A	testSimpleRouteWithDifferentMethods()	15	1
A	createUrlMatcher()	7	1
A	testSimpleRouteWithOptionalPartFailed()	13	1
A	testSimpleRouteWithParam()	16	1
A	testSimpleRouteWithOptionalPartSuccess()	16	1
A	testSimpleRouteWithNestedOptionalParamsSuccess()	30	1
A	testSimpleRouteWithOptionalParam()	21	1
A	testGetCurrentRoute()	13	1
A	testGetLastMatchedRequest()	13	1
A	testGetRouteCollection()	13	1
A	testDisallowedMethod()	14	1
A	testSimpleRouteWithNestedOptionalParts()	19	1
A	testSimpleRoute()	12	1

<?php


namespace Yiisoft\Router\FastRoute\Tests;

use Nyholm\Psr7\ServerRequest;
use PHPUnit\Framework\TestCase;
use Yiisoft\Router\RouteCollection;
use Yiisoft\Router\FastRoute\UrlMatcher;
use Yiisoft\Router\Group;
use Yiisoft\Router\Route;
use Yiisoft\Router\UrlMatcherInterface;

class UrlMatcherTest extends TestCase
{
    private function createUrlMatcher(array $routes): UrlMatcherInterface
    {
        $container = new DummyContainer();
        $collector = new Group();
        $rootGroup = Group::create(null, $routes, $container);
        $collector->addGroup($rootGroup);
        return new UrlMatcher(new RouteCollection($collector));
    }

    public function testDefaultsAreInResult(): void
    {
        $routes = [
            Route::get('/[{name}]')->defaults(['name' => 'test']),
        ];

        $urlMatcher = $this->createUrlMatcher($routes);

        $request = new ServerRequest('GET', '/');

        $result = $urlMatcher->match($request);
        $parameters = $result->parameters();

        $this->assertTrue($result->isSuccess());
        $this->assertArrayHasKey('name', $parameters);
        $this->assertSame('test', $parameters['name']);
    }

    public function testSimpleRoute(): void
    {
        $routes = [
            Route::get('/site/index'),
        ];

        $urlMatcher = $this->createUrlMatcher($routes);

        $request = new ServerRequest('GET', '/site/index');

        $result = $urlMatcher->match($request);
        $this->assertTrue($result->isSuccess());
    }

    public function testSimpleRouteWithDifferentMethods(): void
    {
        $routes = [
            Route::methods(['GET', 'POST'], '/site/index'),
        ];

        $urlMatcher = $this->createUrlMatcher($routes);

        $request1 = new ServerRequest('GET', '/site/index');
        $request2 = new ServerRequest('POST', '/site/index');

        $result1 = $urlMatcher->match($request1);
        $result2 = $urlMatcher->match($request2);
        $this->assertTrue($result1->isSuccess());
        $this->assertTrue($result2->isSuccess());
    }

    public function testSimpleRouteWithParam(): void
    {
        $routes = [
            Route::get('/site/post/{id}'),
        ];

        $urlMatcher = $this->createUrlMatcher($routes);

        $request = new ServerRequest('GET', '/site/post/23');

        $result = $urlMatcher->match($request);
        $parameters = $result->parameters();

        $this->assertTrue($result->isSuccess());
        $this->assertArrayHasKey('id', $parameters);
        $this->assertSame('23', $parameters['id']);
    }

    public function testSimpleRouteWithOptionalPartSuccess(): void
    {
        $routes = [
            Route::get('/site/post[/view]'),
        ];

        $urlMatcher = $this->createUrlMatcher($routes);

        $request1 = new ServerRequest('GET', '/site/post/view');
        $request2 = new ServerRequest('GET', '/site/post');

        $result1 = $urlMatcher->match($request1);
        $result2 = $urlMatcher->match($request2);

        $this->assertTrue($result1->isSuccess());
        $this->assertTrue($result2->isSuccess());
    }

    public function testSimpleRouteWithOptionalPartFailed(): void
    {
        $routes = [
            Route::get('/site/post[/view]'),
        ];

        $urlMatcher = $this->createUrlMatcher($routes);

        $request = new ServerRequest('GET', '/site/post/index');

        $result = $urlMatcher->match($request);

        $this->assertFalse($result->isSuccess());
    }

    public function testSimpleRouteWithOptionalParam(): void
    {
        $routes = [
            Route::get('/site/post[/{id}]'),
        ];

        $urlMatcher = $this->createUrlMatcher($routes);

        $request1 = new ServerRequest('GET', '/site/post/23');
        $request2 = new ServerRequest('GET', '/site/post');

        $result1 = $urlMatcher->match($request1);
        $parameters1 = $result1->parameters();
        $result2 = $urlMatcher->match($request2);
        $parameters2 = $result2->parameters();

        $this->assertTrue($result1->isSuccess());
        $this->assertArrayHasKey('id', $parameters1);
        $this->assertSame('23', $parameters1['id']);
        $this->assertTrue($result2->isSuccess());
        $this->assertArrayNotHasKey('id', $parameters2);
    }

    public function testSimpleRouteWithNestedOptionalParts(): void
    {
        $routes = [
            Route::get('/site[/post[/view]]'),
        ];

        $urlMatcher = $this->createUrlMatcher($routes);

        $request1 = new ServerRequest('GET', '/site/post/view');
        $request2 = new ServerRequest('GET', '/site/post');
        $request3 = new ServerRequest('GET', '/site');

        $result1 = $urlMatcher->match($request1);
        $result2 = $urlMatcher->match($request2);
        $result3 = $urlMatcher->match($request3);

        $this->assertTrue($result1->isSuccess());
        $this->assertTrue($result2->isSuccess());
        $this->assertTrue($result3->isSuccess());
    }

    public function testSimpleRouteWithNestedOptionalParamsSuccess(): void
    {
        $routes = [
            Route::get('/site[/{name}[/{id}]]'),
        ];

        $urlMatcher = $this->createUrlMatcher($routes);

        $request1 = new ServerRequest('GET', '/site/post/23');
        $request2 = new ServerRequest('GET', '/site/post');
        $request3 = new ServerRequest('GET', '/site');

        $result1 = $urlMatcher->match($request1);
        $parameters1 = $result1->parameters();
        $result2 = $urlMatcher->match($request2);
        $parameters2 = $result2->parameters();
        $result3 = $urlMatcher->match($request3);
        $parameters3 = $result3->parameters();

        $this->assertTrue($result1->isSuccess());
        $this->assertArrayHasKey('id', $parameters1);
        $this->assertArrayHasKey('name', $parameters1);
        $this->assertSame('23', $parameters1['id']);
        $this->assertSame('post', $parameters1['name']);
        $this->assertTrue($result2->isSuccess());
        $this->assertArrayHasKey('name', $parameters2);
        $this->assertSame('post', $parameters2['name']);
        $this->assertTrue($result3->isSuccess());
        $this->assertArrayNotHasKey('id', $parameters3);
        $this->assertArrayNotHasKey('name', $parameters3);
    }

    public function testDisallowedMethod(): void
    {
        $routes = [
            Route::get('/site/index'),
        ];

        $urlMatcher = $this->createUrlMatcher($routes);

        $request = new ServerRequest('POST', '/site/index');

        $result = $urlMatcher->match($request);
        $this->assertFalse($result->isSuccess());
        $this->assertTrue($result->isMethodFailure());
        $this->assertSame(['GET'], $result->methods());
    }

    public function testDisallowedHEADMethod(): void
    {
        $routes = [
            Route::get('/site/index'),
            Route::post('/site/index'),
        ];

        $urlMatcher = $this->createUrlMatcher($routes);

        $request = new ServerRequest('HEAD', '/site/index');

        $result = $urlMatcher->match($request);
        $this->assertFalse($result->isSuccess());
        $this->assertTrue($result->isMethodFailure());
        $this->assertSame(['GET', 'POST'], $result->methods());
    }

    public function testGetCurrentRoute(): void
    {
        $routes = [
            Route::get('/site/index')->name('request1'),
            Route::post('/site/index')->name('request2'),
        ];

        $urlMatcher = $this->createUrlMatcher($routes);

        $request = new ServerRequest('GET', '/site/index');

        $urlMatcher->match($request);
        $this->assertSame($routes[0]->getName(), $urlMatcher->getCurrentRoute()->getName());
    }

    public function testGetLastMatchedRequest(): void
    {
        $routes = [
            Route::get('/site/index')->name('request1'),
            Route::post('/site/index')->name('request2'),
        ];

        $urlMatcher = $this->createUrlMatcher($routes);

        $request = new ServerRequest('GET', '/site/index');

        $urlMatcher->match($request);
        $this->assertSame($request, $urlMatcher->getLastMatchedRequest());
    }

    public function testGetRouteCollection(): void
    {
        $routes = [
            Route::get('/site/index')->name('request1'),
            Route::post('/site/index')->name('request2'),
        ];

        $collector = new Group();
        $collector->addGroup(Group::create(null, $routes));
        $routeCollection = new RouteCollection($collector);
        $urlMatcher = new UrlMatcher($routeCollection);

        $this->assertSame($routeCollection, $urlMatcher->getRouteCollection());
    }
}


1			<?php
2
3
4			namespace Yiisoft\Router\FastRoute\Tests;
5
6			use Nyholm\Psr7\ServerRequest;
7			use PHPUnit\Framework\TestCase;
8			use Yiisoft\Router\RouteCollection;
9			use Yiisoft\Router\FastRoute\UrlMatcher;
10			use Yiisoft\Router\Group;
11			use Yiisoft\Router\Route;
12			use Yiisoft\Router\UrlMatcherInterface;
13
14			class UrlMatcherTest extends TestCase
15			{
16			private function createUrlMatcher(array $routes): UrlMatcherInterface
17			{
18			$container = new DummyContainer();
19			$collector = new Group();
20			$rootGroup = Group::create(null, $routes, $container);
21			$collector->addGroup($rootGroup);
22			return new UrlMatcher(new RouteCollection($collector));
23			}
24
25			public function testDefaultsAreInResult(): void
26			{
27			$routes = [
28			Route::get('/[{name}]')->defaults(['name' => 'test']),
29			];
30
31			$urlMatcher = $this->createUrlMatcher($routes);
32
33			$request = new ServerRequest('GET', '/');
34
35			$result = $urlMatcher->match($request);
36			$parameters = $result->parameters();
37
38			$this->assertTrue($result->isSuccess());
39			$this->assertArrayHasKey('name', $parameters);
40			$this->assertSame('test', $parameters['name']);
41			}
42
43			public function testSimpleRoute(): void
44			{
45			$routes = [
46			Route::get('/site/index'),
47			];
48
49			$urlMatcher = $this->createUrlMatcher($routes);
50
51			$request = new ServerRequest('GET', '/site/index');
52
53			$result = $urlMatcher->match($request);
54			$this->assertTrue($result->isSuccess());
55			}
56
57			public function testSimpleRouteWithDifferentMethods(): void
58			{
59			$routes = [
60			Route::methods(['GET', 'POST'], '/site/index'),
61			];
62
63			$urlMatcher = $this->createUrlMatcher($routes);
64
65			$request1 = new ServerRequest('GET', '/site/index');
66			$request2 = new ServerRequest('POST', '/site/index');
67
68			$result1 = $urlMatcher->match($request1);
69			$result2 = $urlMatcher->match($request2);
70			$this->assertTrue($result1->isSuccess());
71			$this->assertTrue($result2->isSuccess());
72			}
73
74			public function testSimpleRouteWithParam(): void
75			{
76			$routes = [
77			Route::get('/site/post/{id}'),
78			];
79
80			$urlMatcher = $this->createUrlMatcher($routes);
81
82			$request = new ServerRequest('GET', '/site/post/23');
83
84			$result = $urlMatcher->match($request);
85			$parameters = $result->parameters();
86
87			$this->assertTrue($result->isSuccess());
88			$this->assertArrayHasKey('id', $parameters);
89			$this->assertSame('23', $parameters['id']);
90			}
91
92			public function testSimpleRouteWithOptionalPartSuccess(): void
93			{
94			$routes = [
95			Route::get('/site/post[/view]'),
96			];
97
98			$urlMatcher = $this->createUrlMatcher($routes);
99
100			$request1 = new ServerRequest('GET', '/site/post/view');
101			$request2 = new ServerRequest('GET', '/site/post');
102
103			$result1 = $urlMatcher->match($request1);
104			$result2 = $urlMatcher->match($request2);
105
106			$this->assertTrue($result1->isSuccess());
107			$this->assertTrue($result2->isSuccess());
108			}
109
110			public function testSimpleRouteWithOptionalPartFailed(): void
111			{
112			$routes = [
113			Route::get('/site/post[/view]'),
114			];
115
116			$urlMatcher = $this->createUrlMatcher($routes);
117
118			$request = new ServerRequest('GET', '/site/post/index');
119
120			$result = $urlMatcher->match($request);
121
122			$this->assertFalse($result->isSuccess());
123			}
124
125			public function testSimpleRouteWithOptionalParam(): void
126			{
127			$routes = [
128			Route::get('/site/post[/{id}]'),
129			];
130
131			$urlMatcher = $this->createUrlMatcher($routes);
132
133			$request1 = new ServerRequest('GET', '/site/post/23');
134			$request2 = new ServerRequest('GET', '/site/post');
135
136			$result1 = $urlMatcher->match($request1);
137			$parameters1 = $result1->parameters();
138			$result2 = $urlMatcher->match($request2);
139			$parameters2 = $result2->parameters();
140
141			$this->assertTrue($result1->isSuccess());
142			$this->assertArrayHasKey('id', $parameters1);
143			$this->assertSame('23', $parameters1['id']);
144			$this->assertTrue($result2->isSuccess());
145			$this->assertArrayNotHasKey('id', $parameters2);
146			}
147
148			public function testSimpleRouteWithNestedOptionalParts(): void
149			{
150			$routes = [
151			Route::get('/site[/post[/view]]'),
152			];
153
154			$urlMatcher = $this->createUrlMatcher($routes);
155
156			$request1 = new ServerRequest('GET', '/site/post/view');
157			$request2 = new ServerRequest('GET', '/site/post');
158			$request3 = new ServerRequest('GET', '/site');
159
160			$result1 = $urlMatcher->match($request1);
161			$result2 = $urlMatcher->match($request2);
162			$result3 = $urlMatcher->match($request3);
163
164			$this->assertTrue($result1->isSuccess());
165			$this->assertTrue($result2->isSuccess());
166			$this->assertTrue($result3->isSuccess());
167			}
168
169			public function testSimpleRouteWithNestedOptionalParamsSuccess(): void
170			{
171			$routes = [
172			Route::get('/site[/{name}[/{id}]]'),
173			];
174
175			$urlMatcher = $this->createUrlMatcher($routes);
176
177			$request1 = new ServerRequest('GET', '/site/post/23');
178			$request2 = new ServerRequest('GET', '/site/post');
179			$request3 = new ServerRequest('GET', '/site');
180
181			$result1 = $urlMatcher->match($request1);
182			$parameters1 = $result1->parameters();
183			$result2 = $urlMatcher->match($request2);
184			$parameters2 = $result2->parameters();
185			$result3 = $urlMatcher->match($request3);
186			$parameters3 = $result3->parameters();
187
188			$this->assertTrue($result1->isSuccess());
189			$this->assertArrayHasKey('id', $parameters1);
190			$this->assertArrayHasKey('name', $parameters1);
191			$this->assertSame('23', $parameters1['id']);
192			$this->assertSame('post', $parameters1['name']);
193			$this->assertTrue($result2->isSuccess());
194			$this->assertArrayHasKey('name', $parameters2);
195			$this->assertSame('post', $parameters2['name']);
196			$this->assertTrue($result3->isSuccess());
197			$this->assertArrayNotHasKey('id', $parameters3);
198			$this->assertArrayNotHasKey('name', $parameters3);
199			}
200
201			public function testDisallowedMethod(): void
202			{
203			$routes = [
204			Route::get('/site/index'),
205			];
206
207			$urlMatcher = $this->createUrlMatcher($routes);
208
209			$request = new ServerRequest('POST', '/site/index');
210
211			$result = $urlMatcher->match($request);
212			$this->assertFalse($result->isSuccess());
213			$this->assertTrue($result->isMethodFailure());
214			$this->assertSame(['GET'], $result->methods());
215			}
216
217			public function testDisallowedHEADMethod(): void
218			{
219			$routes = [
220			Route::get('/site/index'),
221			Route::post('/site/index'),
222			];
223
224			$urlMatcher = $this->createUrlMatcher($routes);
225
226			$request = new ServerRequest('HEAD', '/site/index');
227
228			$result = $urlMatcher->match($request);
229			$this->assertFalse($result->isSuccess());
230			$this->assertTrue($result->isMethodFailure());
231			$this->assertSame(['GET', 'POST'], $result->methods());
232			}
233
234			public function testGetCurrentRoute(): void
235			{
236			$routes = [
237			Route::get('/site/index')->name('request1'),
238			Route::post('/site/index')->name('request2'),
239			];
240
241			$urlMatcher = $this->createUrlMatcher($routes);
242
243			$request = new ServerRequest('GET', '/site/index');
244
245			$urlMatcher->match($request);
246			$this->assertSame($routes[0]->getName(), $urlMatcher->getCurrentRoute()->getName());
247			}
248
249			public function testGetLastMatchedRequest(): void
250			{
251			$routes = [
252			Route::get('/site/index')->name('request1'),
253			Route::post('/site/index')->name('request2'),
254			];
255
256			$urlMatcher = $this->createUrlMatcher($routes);
257
258			$request = new ServerRequest('GET', '/site/index');
259
260			$urlMatcher->match($request);
261			$this->assertSame($request, $urlMatcher->getLastMatchedRequest());
262			}
263
264			public function testGetRouteCollection(): void
265			{
266			$routes = [
267			Route::get('/site/index')->name('request1'),
268			Route::post('/site/index')->name('request2'),
269			];
270
271			$collector = new Group();
272			$collector->addGroup(Group::create(null, $routes));
273			$routeCollection = new RouteCollection($collector);
274			$urlMatcher = new UrlMatcher($routeCollection);
275
276			$this->assertSame($routeCollection, $urlMatcher->getRouteCollection());
277			}
278			}
279

yiisoft / router-fastroute

Pull Request — master (#25)

UrlMatcherTest A

Complexity

Size/Duplication

Importance

15 Methods

Duplication Side-by-Side

Filter issues like