RouterTest::testMatchPatterns() - Code Metrics - Inspection of "release/v2.0.0" - sunrise-php/http-router - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#32)

by Anatoly

created 2019-11-17 23:19 UTC

RouterTest::testMatchPatterns() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	28
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	19
nc	1
nop	0
dl	0
loc	28
rs	9.6333
c	0
b	0
f	0

<?php declare(strict_types=1);

namespace Sunrise\Http\Router\Tests;

/**
 * Import classes
 */
use PHPUnit\Framework\TestCase;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Sunrise\Http\Router\Exception\MethodNotAllowedException;
use Sunrise\Http\Router\Exception\RouteNotFoundException;
use Sunrise\Http\Router\RouteCollection;
use Sunrise\Http\Router\Router;
use Sunrise\Http\ServerRequest\ServerRequestFactory;

/**
 * Import functions
 */
use function array_merge;

/**
 * RouterTest
 */
class RouterTest extends TestCase
{

    /**
     * @return void
     */
    public function testConstructor() : void
    {
        $router = new Router();

        $this->assertInstanceOf(RouteCollection::class, $router);
        $this->assertInstanceOf(MiddlewareInterface::class, $router);
        $this->assertInstanceOf(RequestHandlerInterface::class, $router);
    }

    /**
     * @return void
     */
    public function testGetRoute() : void
    {
        $routes = [
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
        ];

        $router = new Router();
        $router->addRoutes(...$routes);

        $this->assertSame($routes[0], $router->getRoute($routes[0]->getName()));
        $this->assertSame($routes[1], $router->getRoute($routes[1]->getName()));
        $this->assertSame($routes[2], $router->getRoute($routes[2]->getName()));
    }

    /**
     * @return void
     */
    public function testGetUndefinedRoute() : void
    {
        $router = new Router();

        $this->expectException(RouteNotFoundException::class);
        $router->getRoute('foo');
    }

    /**
     * @return void
     */
    public function testMatch() : void
    {
        $routes = [
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
        ];

        $router = new Router();
        $router->addRoutes(...$routes);

        $request = (new ServerRequestFactory)
            ->createServerRequest(
                $routes[2]->getMethods()[1],
                $routes[2]->getPath()
            );

        $foundRoute = $router->match($request);

        $this->assertSame($routes[2]->getName(), $foundRoute->getName());
    }

    /**
     * @return void
     */
    public function testMatchForUnallowedMethod() : void
    {
        $routes = [
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
        ];

        $router = new Router();
        $router->addRoutes(...$routes);

        $request = (new ServerRequestFactory)
            ->createServerRequest('GET', $routes[0]->getPath());

        $this->expectException(MethodNotAllowedException::class);

        try {
            $router->match($request);
        } catch (MethodNotAllowedException $e) {
            $allowedMethods = array_merge(
                $routes[0]->getMethods(),
                $routes[1]->getMethods(),
                $routes[2]->getMethods()
            );

            $this->assertSame($allowedMethods, $e->getAllowedMethods());

            throw $e;
        }
    }

    /**
     * @return void
     */
    public function testMatchForUndefinedRoute() : void
    {
        $routes = [
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
        ];

        $router = new Router();
        $router->addRoutes(...$routes);

        $request = (new ServerRequestFactory)
            ->createServerRequest($routes[0]->getMethods()[0], '/');

        $this->expectException(RouteNotFoundException::class);
        $router->match($request);
    }

    /**
     * @return void
     */
    public function testHandle() : void
    {
        $routes = [
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
        ];

        $router = new Router();
        $router->addRoutes(...$routes);

        $request = (new ServerRequestFactory)
            ->createServerRequest(
                $routes[2]->getMethods()[1],
                $routes[2]->getPath()
            );

        $router->handle($request);

        $this->assertTrue($routes[2]->getRequestHandler()->isRunned());
    }

    /**
     * @return void
     */
    public function testHandleForUnallowedMethod() : void
    {
        $routes = [
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
        ];

        $router = new Router();
        $router->addRoutes(...$routes);

        $request = (new ServerRequestFactory)
            ->createServerRequest('GET', '/');

        $this->expectException(MethodNotAllowedException::class);

        try {
            $router->handle($request);
        } catch (MethodNotAllowedException $e) {
            $allowedMethods = array_merge(
                $routes[0]->getMethods(),
                $routes[1]->getMethods(),
                $routes[2]->getMethods()
            );

            $this->assertSame($allowedMethods, $e->getAllowedMethods());

            throw $e;
        }
    }

    /**
     * @return void
     */
    public function testHandleForUndefinedRoute() : void
    {
        $routes = [
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
        ];

        $router = new Router();
        $router->addRoutes(...$routes);

        $request = (new ServerRequestFactory)
            ->createServerRequest($routes[0]->getMethods()[0], '/');

        $this->expectException(RouteNotFoundException::class);
        $router->handle($request);
    }

    /**
     * @return void
     */
    public function testProcess() : void
    {
        $routes = [
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
        ];

        $router = new Router();
        $router->addRoutes(...$routes);

        $request = (new ServerRequestFactory)
            ->createServerRequest(
                $routes[2]->getMethods()[1],
                $routes[2]->getPath()
            );

        $fallback = new Fixture\BlankRequestHandler();

        $router->process($request, $fallback);

        $this->assertTrue($routes[2]->getRequestHandler()->isRunned());
        $this->assertFalse($fallback->isRunned());
    }

    /**
     * @return void
     */
    public function testProcessForUnallowedMethod() : void
    {
        $routes = [
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
        ];

        $router = new Router();
        $router->addRoutes(...$routes);

        $request = (new ServerRequestFactory)
            ->createServerRequest('GET', '/');

        $fallback = new Fixture\BlankRequestHandler();

        $router->process($request, $fallback);

        $this->assertInstanceOf(
            MethodNotAllowedException::class,
            $fallback->getAttribute(Router::ATTR_NAME_FOR_ROUTING_ERROR)
        );

        $this->assertTrue($fallback->isRunned());
    }

    /**
     * @return void
     */
    public function testProcessForUndefinedRoute() : void
    {
        $routes = [
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
            new Fixture\TestRoute(),
        ];

        $router = new Router();
        $router->addRoutes(...$routes);

        $request = (new ServerRequestFactory)
            ->createServerRequest($routes[0]->getMethods()[0], '/');

        $fallback = new Fixture\BlankRequestHandler();

        $router->process($request, $fallback);

        $this->assertInstanceOf(
            RouteNotFoundException::class,
            $fallback->getAttribute(Router::ATTR_NAME_FOR_ROUTING_ERROR)
        );

        $this->assertTrue($fallback->isRunned());
    }
}


1			<?php declare(strict_types=1);
2
3			namespace Sunrise\Http\Router\Tests;
4
5			/**
6			* Import classes
7			*/
8			use PHPUnit\Framework\TestCase;
9			use Psr\Http\Server\MiddlewareInterface;
10			use Psr\Http\Server\RequestHandlerInterface;
11			use Sunrise\Http\Router\Exception\MethodNotAllowedException;
12			use Sunrise\Http\Router\Exception\RouteNotFoundException;
13			use Sunrise\Http\Router\RouteCollection;
14			use Sunrise\Http\Router\Router;
15			use Sunrise\Http\ServerRequest\ServerRequestFactory;
16
17			/**
18			* Import functions
19			*/
20			use function array_merge;
21
22			/**
23			* RouterTest
24			*/
25			class RouterTest extends TestCase
26			{
27
28			/**
29			* @return void
30			*/
31			public function testConstructor() : void
32			{
33			$router = new Router();
34
35			$this->assertInstanceOf(RouteCollection::class, $router);
36			$this->assertInstanceOf(MiddlewareInterface::class, $router);
37			$this->assertInstanceOf(RequestHandlerInterface::class, $router);
38			}
39
40			/**
41			* @return void
42			*/
43			public function testGetRoute() : void
44			{
45			$routes = [
46			new Fixture\TestRoute(),
47			new Fixture\TestRoute(),
48			new Fixture\TestRoute(),
49			];
50
51			$router = new Router();
52			$router->addRoutes(...$routes);
53
54			$this->assertSame($routes[0], $router->getRoute($routes[0]->getName()));
55			$this->assertSame($routes[1], $router->getRoute($routes[1]->getName()));
56			$this->assertSame($routes[2], $router->getRoute($routes[2]->getName()));
57			}
58
59			/**
60			* @return void
61			*/
62			public function testGetUndefinedRoute() : void
63			{
64			$router = new Router();
65
66			$this->expectException(RouteNotFoundException::class);
67			$router->getRoute('foo');
68			}
69
70			/**
71			* @return void
72			*/
73			public function testMatch() : void
74			{
75			$routes = [
76			new Fixture\TestRoute(),
77			new Fixture\TestRoute(),
78			new Fixture\TestRoute(),
79			new Fixture\TestRoute(),
80			new Fixture\TestRoute(),
81			];
82
83			$router = new Router();
84			$router->addRoutes(...$routes);
85
86			$request = (new ServerRequestFactory)
87			->createServerRequest(
88			$routes[2]->getMethods()[1],
89			$routes[2]->getPath()
90			);
91
92			$foundRoute = $router->match($request);
93
94			$this->assertSame($routes[2]->getName(), $foundRoute->getName());
95			}
96
97			/**
98			* @return void
99			*/
100			public function testMatchForUnallowedMethod() : void
101			{
102			$routes = [
103			new Fixture\TestRoute(),
104			new Fixture\TestRoute(),
105			new Fixture\TestRoute(),
106			];
107
108			$router = new Router();
109			$router->addRoutes(...$routes);
110
111			$request = (new ServerRequestFactory)
112			->createServerRequest('GET', $routes[0]->getPath());
113
114			$this->expectException(MethodNotAllowedException::class);
115
116			try {
117			$router->match($request);
118			} catch (MethodNotAllowedException $e) {
119			$allowedMethods = array_merge(
120			$routes[0]->getMethods(),
121			$routes[1]->getMethods(),
122			$routes[2]->getMethods()
123			);
124
125			$this->assertSame($allowedMethods, $e->getAllowedMethods());
126
127			throw $e;
128			}
129			}
130
131			/**
132			* @return void
133			*/
134			public function testMatchForUndefinedRoute() : void
135			{
136			$routes = [
137			new Fixture\TestRoute(),
138			new Fixture\TestRoute(),
139			new Fixture\TestRoute(),
140			];
141
142			$router = new Router();
143			$router->addRoutes(...$routes);
144
145			$request = (new ServerRequestFactory)
146			->createServerRequest($routes[0]->getMethods()[0], '/');
147
148			$this->expectException(RouteNotFoundException::class);
149			$router->match($request);
150			}
151
152			/**
153			* @return void
154			*/
155			public function testHandle() : void
156			{
157			$routes = [
158			new Fixture\TestRoute(),
159			new Fixture\TestRoute(),
160			new Fixture\TestRoute(),
161			new Fixture\TestRoute(),
162			new Fixture\TestRoute(),
163			];
164
165			$router = new Router();
166			$router->addRoutes(...$routes);
167
168			$request = (new ServerRequestFactory)
169			->createServerRequest(
170			$routes[2]->getMethods()[1],
171			$routes[2]->getPath()
172			);
173
174			$router->handle($request);
175
176			$this->assertTrue($routes[2]->getRequestHandler()->isRunned());
177			}
178
179			/**
180			* @return void
181			*/
182			public function testHandleForUnallowedMethod() : void
183			{
184			$routes = [
185			new Fixture\TestRoute(),
186			new Fixture\TestRoute(),
187			new Fixture\TestRoute(),
188			];
189
190			$router = new Router();
191			$router->addRoutes(...$routes);
192
193			$request = (new ServerRequestFactory)
194			->createServerRequest('GET', '/');
195
196			$this->expectException(MethodNotAllowedException::class);
197
198			try {
199			$router->handle($request);
200			} catch (MethodNotAllowedException $e) {
201			$allowedMethods = array_merge(
202			$routes[0]->getMethods(),
203			$routes[1]->getMethods(),
204			$routes[2]->getMethods()
205			);
206
207			$this->assertSame($allowedMethods, $e->getAllowedMethods());
208
209			throw $e;
210			}
211			}
212
213			/**
214			* @return void
215			*/
216			public function testHandleForUndefinedRoute() : void
217			{
218			$routes = [
219			new Fixture\TestRoute(),
220			new Fixture\TestRoute(),
221			new Fixture\TestRoute(),
222			];
223
224			$router = new Router();
225			$router->addRoutes(...$routes);
226
227			$request = (new ServerRequestFactory)
228			->createServerRequest($routes[0]->getMethods()[0], '/');
229
230			$this->expectException(RouteNotFoundException::class);
231			$router->handle($request);
232			}
233
234			/**
235			* @return void
236			*/
237			public function testProcess() : void
238			{
239			$routes = [
240			new Fixture\TestRoute(),
241			new Fixture\TestRoute(),
242			new Fixture\TestRoute(),
243			new Fixture\TestRoute(),
244			new Fixture\TestRoute(),
245			];
246
247			$router = new Router();
248			$router->addRoutes(...$routes);
249
250			$request = (new ServerRequestFactory)
251			->createServerRequest(
252			$routes[2]->getMethods()[1],
253			$routes[2]->getPath()
254			);
255
256			$fallback = new Fixture\BlankRequestHandler();
257
258			$router->process($request, $fallback);
259
260			$this->assertTrue($routes[2]->getRequestHandler()->isRunned());
261			$this->assertFalse($fallback->isRunned());
262			}
263
264			/**
265			* @return void
266			*/
267			public function testProcessForUnallowedMethod() : void
268			{
269			$routes = [
270			new Fixture\TestRoute(),
271			new Fixture\TestRoute(),
272			new Fixture\TestRoute(),
273			];
274
275			$router = new Router();
276			$router->addRoutes(...$routes);
277
278			$request = (new ServerRequestFactory)
279			->createServerRequest('GET', '/');
280
281			$fallback = new Fixture\BlankRequestHandler();
282
283			$router->process($request, $fallback);
284
285			$this->assertInstanceOf(
286			MethodNotAllowedException::class,
287			$fallback->getAttribute(Router::ATTR_NAME_FOR_ROUTING_ERROR)
288			);
289
290			$this->assertTrue($fallback->isRunned());
291			}
292
293			/**
294			* @return void
295			*/
296			public function testProcessForUndefinedRoute() : void
297			{
298			$routes = [
299			new Fixture\TestRoute(),
300			new Fixture\TestRoute(),
301			new Fixture\TestRoute(),
302			];
303
304			$router = new Router();
305			$router->addRoutes(...$routes);
306
307			$request = (new ServerRequestFactory)
308			->createServerRequest($routes[0]->getMethods()[0], '/');
309
310			$fallback = new Fixture\BlankRequestHandler();
311
312			$router->process($request, $fallback);
313
314			$this->assertInstanceOf(
315			RouteNotFoundException::class,
316			$fallback->getAttribute(Router::ATTR_NAME_FOR_ROUTING_ERROR)
317			);
318
319			$this->assertTrue($fallback->isRunned());
320			}
321			}
322

sunrise-php / http-router

Pull Request — master (#32)

RouterTest::testMatchPatterns() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like