RouteCollectionTest - Code Metrics - Inspection of "CS fix" - sunrise-php/http-router - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — release/v2.0.0 (caca50)

by Anatoly

created 2019-11-14 21:25 UTC

RouteCollectionTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	327
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
wmc	16
eloc	148
c	2
b	0
f	0
dl	0
loc	327
rs	10

<?php declare(strict_types=1);

namespace Sunrise\Http\Router\Tests;

/**
 * Import classes
 */
use PHPUnit\Framework\TestCase;
use Sunrise\Http\Router\RouteInterface;
use Sunrise\Http\Router\RouteCollection;
use Sunrise\Http\Router\RouteCollectionInterface;

/**
 * Import functions
 */
use function end;

/**
 * RouteCollectionTest
 */
class RouteCollectionTest extends TestCase
{

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

        $this->assertInstanceOf(RouteCollectionInterface::class, $collection);
    }

    /**
     * @return void
     */
    public function testGetDefaultPrefix() : void
    {
        $collection = new RouteCollection();

        $this->assertNull($collection->getPrefix());
    }

    /**
     * @return void
     */
    public function testGetDefaultMiddlewares() : void
    {
        $collection = new RouteCollection();

        $this->assertSame([], $collection->getMiddlewares());
    }

    /**
     * @return void
     */
    public function testGetDefaultRoutes() : void
    {
        $collection = new RouteCollection();

        $this->assertSame([], $collection->getRoutes());
    }

    /**
     * @return void
     */
    public function testSetPrefix() : void
    {
        $collection = new RouteCollection();

        $this->assertSame($collection, $collection->setPrefix('/foo'));
        $this->assertSame('/foo', $collection->getPrefix());

        // override prefix...
        $collection->setPrefix('/bar');
        $this->assertSame('/bar', $collection->getPrefix());

        // https://github.com/sunrise-php/http-router/issues/26
        $collection->setPrefix('/baz/');
        $this->assertSame('/baz', $collection->getPrefix());
    }

    /**
     * @return void
     */
    public function testAddMiddlewares() : void
    {
        $middlewares = [
            new Fixture\BlankMiddleware(),
            new Fixture\BlankMiddleware(),
        ];

        $collection = new RouteCollection();

        $this->assertSame($collection, $collection->addMiddlewares(...$middlewares));
        $this->assertSame($middlewares, $collection->getMiddlewares());

        // extending...
        $middlewares[] = new Fixture\BlankMiddleware();
        $collection->addMiddlewares(end($middlewares));
        $this->assertSame($middlewares, $collection->getMiddlewares());
    }

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

        $collection = new RouteCollection();

        $this->assertSame($collection, $collection->addRoutes(...$routes));
        $this->assertSame($routes, $collection->getRoutes());

        // extending...
        $routes[] = new Fixture\TestRoute();
        $collection->addRoutes(end($routes));
        $this->assertSame($routes, $collection->getRoutes());
    }

    /**
     * @return void
     */
    public function testMakeRoute() : void
    {
        $routeName = Fixture\TestRoute::getTestRouteName();
        $routePath = Fixture\TestRoute::getTestRoutePath();
        $routeMethods = Fixture\TestRoute::getTestRouteMethods();
        $routeRequestHandler = Fixture\TestRoute::getTestRouteRequestHandler();

        $collection = new RouteCollection();

        $route = $collection->route(
            $routeName,
            $routePath,
            $routeMethods,
            $routeRequestHandler
        );

        $this->assertInstanceOf(RouteInterface::class, $route);
        $this->assertSame($routeName, $route->getName());
        $this->assertSame($routePath, $route->getPath());
        $this->assertSame($routeMethods, $route->getMethods());
        $this->assertSame($routeRequestHandler, $route->getRequestHandler());
        $this->assertSame([], $route->getMiddlewares());
        $this->assertSame([], $route->getAttributes());
        $this->assertSame([$route], $collection->getRoutes());
    }

    /**
     * @return void
     */
    public function testMakeRouteWithOptionalParams() : void
    {
        $routeName = Fixture\TestRoute::getTestRouteName();
        $routePath = Fixture\TestRoute::getTestRoutePath();
        $routeMethods = Fixture\TestRoute::getTestRouteMethods();
        $routeRequestHandler = Fixture\TestRoute::getTestRouteRequestHandler();
        $routeMiddlewares = Fixture\TestRoute::getTestRouteMiddlewares();
        $routeAttributes = Fixture\TestRoute::getTestRouteAttributes();

        $collection = new RouteCollection();

        $route = $collection->route(
            $routeName,
            $routePath,
            $routeMethods,
            $routeRequestHandler,
            $routeMiddlewares,
            $routeAttributes
        );

        $this->assertInstanceOf(RouteInterface::class, $route);
        $this->assertSame($routeName, $route->getName());
        $this->assertSame($routePath, $route->getPath());
        $this->assertSame($routeMethods, $route->getMethods());
        $this->assertSame($routeRequestHandler, $route->getRequestHandler());
        $this->assertSame($routeMiddlewares, $route->getMiddlewares());
        $this->assertSame($routeAttributes, $route->getAttributes());
        $this->assertSame([$route], $collection->getRoutes());
    }

    /**
     * @return void
     */
    public function testMakeRouteWithTransferringPrefix() : void
    {
        $collection = new RouteCollection();
        $collection->setPrefix('/api');

        $route = $collection->route('foo', '/foo', ['GET'], new Fixture\BlankRequestHandler());
        $this->assertSame('/api/foo', $route->getPath());
    }

    /**
     * @return void
     */
    public function testMakeRouteWithTransferringMiddlewares() : void
    {
        $middlewares = [new Fixture\BlankMiddleware()];

        $collection = new RouteCollection();
        $collection->addMiddlewares(...$middlewares);

        $route = $collection->route('foo', '/foo', ['GET'], new Fixture\BlankRequestHandler());
        $this->assertSame($middlewares, $route->getMiddlewares());

        // merging...
        $middlewares[] = new Fixture\BlankMiddleware();
        $route = $collection->route('foo', '/foo', ['GET'], new Fixture\BlankRequestHandler(), [end($middlewares)]);
        $this->assertSame($middlewares, $route->getMiddlewares());
    }

    /**
     * @return void
     *
     * @dataProvider makeVerbableRoutesDataProvider
     */
    public function testMakeVerbableRoutes(string $calledMethod, string $expectedHttpMethod) : void
    {
        $routeName = Fixture\TestRoute::getTestRouteName();
        $routePath = Fixture\TestRoute::getTestRoutePath();
        $routeRequestHandler = Fixture\TestRoute::getTestRouteRequestHandler();

        $collection = new RouteCollection();

        $route = $collection->{$calledMethod}(
            $routeName,
            $routePath,
            $routeRequestHandler
        );

        $this->assertInstanceOf(RouteInterface::class, $route);
        $this->assertSame($routeName, $route->getName());
        $this->assertSame($routePath, $route->getPath());
        $this->assertSame([$expectedHttpMethod], $route->getMethods());
        $this->assertSame($routeRequestHandler, $route->getRequestHandler());
        $this->assertSame([], $route->getMiddlewares());
        $this->assertSame([], $route->getAttributes());
        $this->assertSame([$route], $collection->getRoutes());
    }

    /**
     * @return void
     *
     * @dataProvider makeVerbableRoutesDataProvider
     */
    public function testMakeVerbableRoutesWithOptionalParams(string $calledMethod, string $expectedHttpMethod) : void
    {
        $routeName = Fixture\TestRoute::getTestRouteName();
        $routePath = Fixture\TestRoute::getTestRoutePath();
        $routeRequestHandler = Fixture\TestRoute::getTestRouteRequestHandler();
        $routeMiddlewares = Fixture\TestRoute::getTestRouteMiddlewares();
        $routeAttributes = Fixture\TestRoute::getTestRouteAttributes();

        $collection = new RouteCollection();

        $route = $collection->{$calledMethod}(
            $routeName,
            $routePath,
            $routeRequestHandler,
            $routeMiddlewares,
            $routeAttributes
        );

        $this->assertInstanceOf(RouteInterface::class, $route);
        $this->assertSame($routeName, $route->getName());
        $this->assertSame($routePath, $route->getPath());
        $this->assertSame([$expectedHttpMethod], $route->getMethods());
        $this->assertSame($routeRequestHandler, $route->getRequestHandler());
        $this->assertSame($routeMiddlewares, $route->getMiddlewares());
        $this->assertSame($routeAttributes, $route->getAttributes());
        $this->assertSame([$route], $collection->getRoutes());
    }

    /**
     * @return void
     *
     * @dataProvider makeVerbableRoutesDataProvider
     */
    public function testMakeVerbableRoutesWithTransferringPrefix(string $calledMethod) : void
    {
        $collection = new RouteCollection();
        $collection->setPrefix('/api');

        $route = $collection->{$calledMethod}('foo', '/foo', new Fixture\BlankRequestHandler());
        $this->assertSame('/api/foo', $route->getPath());
    }

    /**
     * @return void
     *
     * @dataProvider makeVerbableRoutesDataProvider
     */
    public function testMakeVerbableRoutesWithTransferringMiddlewares(string $calledMethod) : void
    {
        $middlewares = [new Fixture\BlankMiddleware()];

        $collection = new RouteCollection();
        $collection->addMiddlewares(...$middlewares);

        $route = $collection->{$calledMethod}('foo', '/foo', new Fixture\BlankRequestHandler());
        $this->assertSame($middlewares, $route->getMiddlewares());

        // merging...
        $middlewares[] = new Fixture\BlankMiddleware();
        $route = $collection->{$calledMethod}('foo', '/foo', new Fixture\BlankRequestHandler(), [end($middlewares)]);
        $this->assertSame($middlewares, $route->getMiddlewares());
    }

    /**
     * @return array
     */
    public function makeVerbableRoutesDataProvider() : array
    {
        return [
            [
                'head',
                'HEAD',
            ],
            [
                'get',
                'GET',
            ],
            [
                'post',
                'POST',
            ],
            [
                'put',
                'PUT',
            ],
            [
                'patch',
                'PATCH',
            ],
            [
                'delete',
                'DELETE',
            ],
            [
                'purge',
                'PURGE',
            ],
        ];
    }
}


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 Sunrise\Http\Router\RouteInterface;
10			use Sunrise\Http\Router\RouteCollection;
11			use Sunrise\Http\Router\RouteCollectionInterface;
12
13			/**
14			* Import functions
15			*/
16			use function end;
17
18			/**
19			* RouteCollectionTest
20			*/
21			class RouteCollectionTest extends TestCase
22			{
23
24			/**
25			* @return void
26			*/
27			public function testConstructor() : void
28			{
29			$collection = new RouteCollection();
30
31			$this->assertInstanceOf(RouteCollectionInterface::class, $collection);
32			}
33
34			/**
35			* @return void
36			*/
37			public function testGetDefaultPrefix() : void
38			{
39			$collection = new RouteCollection();
40
41			$this->assertNull($collection->getPrefix());
42			}
43
44			/**
45			* @return void
46			*/
47			public function testGetDefaultMiddlewares() : void
48			{
49			$collection = new RouteCollection();
50
51			$this->assertSame([], $collection->getMiddlewares());
52			}
53
54			/**
55			* @return void
56			*/
57			public function testGetDefaultRoutes() : void
58			{
59			$collection = new RouteCollection();
60
61			$this->assertSame([], $collection->getRoutes());
62			}
63
64			/**
65			* @return void
66			*/
67			public function testSetPrefix() : void
68			{
69			$collection = new RouteCollection();
70
71			$this->assertSame($collection, $collection->setPrefix('/foo'));
72			$this->assertSame('/foo', $collection->getPrefix());
73
74			// override prefix...
75			$collection->setPrefix('/bar');
76			$this->assertSame('/bar', $collection->getPrefix());
77
78			// https://github.com/sunrise-php/http-router/issues/26
79			$collection->setPrefix('/baz/');
80			$this->assertSame('/baz', $collection->getPrefix());
81			}
82
83			/**
84			* @return void
85			*/
86			public function testAddMiddlewares() : void
87			{
88			$middlewares = [
89			new Fixture\BlankMiddleware(),
90			new Fixture\BlankMiddleware(),
91			];
92
93			$collection = new RouteCollection();
94
95			$this->assertSame($collection, $collection->addMiddlewares(...$middlewares));
96			$this->assertSame($middlewares, $collection->getMiddlewares());
97
98			// extending...
99			$middlewares[] = new Fixture\BlankMiddleware();
100			$collection->addMiddlewares(end($middlewares));
101			$this->assertSame($middlewares, $collection->getMiddlewares());
102			}
103
104			/**
105			* @return void
106			*/
107			public function testAddRoutes() : void
108			{
109			$routes = [
110			new Fixture\TestRoute(),
111			new Fixture\TestRoute(),
112			];
113
114			$collection = new RouteCollection();
115
116			$this->assertSame($collection, $collection->addRoutes(...$routes));
117			$this->assertSame($routes, $collection->getRoutes());
118
119			// extending...
120			$routes[] = new Fixture\TestRoute();
121			$collection->addRoutes(end($routes));
122			$this->assertSame($routes, $collection->getRoutes());
123			}
124
125			/**
126			* @return void
127			*/
128			public function testMakeRoute() : void
129			{
130			$routeName = Fixture\TestRoute::getTestRouteName();
131			$routePath = Fixture\TestRoute::getTestRoutePath();
132			$routeMethods = Fixture\TestRoute::getTestRouteMethods();
133			$routeRequestHandler = Fixture\TestRoute::getTestRouteRequestHandler();
134
135			$collection = new RouteCollection();
136
137			$route = $collection->route(
138			$routeName,
139			$routePath,
140			$routeMethods,
141			$routeRequestHandler
142			);
143
144			$this->assertInstanceOf(RouteInterface::class, $route);
145			$this->assertSame($routeName, $route->getName());
146			$this->assertSame($routePath, $route->getPath());
147			$this->assertSame($routeMethods, $route->getMethods());
148			$this->assertSame($routeRequestHandler, $route->getRequestHandler());
149			$this->assertSame([], $route->getMiddlewares());
150			$this->assertSame([], $route->getAttributes());
151			$this->assertSame([$route], $collection->getRoutes());
152			}
153
154			/**
155			* @return void
156			*/
157			public function testMakeRouteWithOptionalParams() : void
158			{
159			$routeName = Fixture\TestRoute::getTestRouteName();
160			$routePath = Fixture\TestRoute::getTestRoutePath();
161			$routeMethods = Fixture\TestRoute::getTestRouteMethods();
162			$routeRequestHandler = Fixture\TestRoute::getTestRouteRequestHandler();
163			$routeMiddlewares = Fixture\TestRoute::getTestRouteMiddlewares();
164			$routeAttributes = Fixture\TestRoute::getTestRouteAttributes();
165
166			$collection = new RouteCollection();
167
168			$route = $collection->route(
169			$routeName,
170			$routePath,
171			$routeMethods,
172			$routeRequestHandler,
173			$routeMiddlewares,
174			$routeAttributes
175			);
176
177			$this->assertInstanceOf(RouteInterface::class, $route);
178			$this->assertSame($routeName, $route->getName());
179			$this->assertSame($routePath, $route->getPath());
180			$this->assertSame($routeMethods, $route->getMethods());
181			$this->assertSame($routeRequestHandler, $route->getRequestHandler());
182			$this->assertSame($routeMiddlewares, $route->getMiddlewares());
183			$this->assertSame($routeAttributes, $route->getAttributes());
184			$this->assertSame([$route], $collection->getRoutes());
185			}
186
187			/**
188			* @return void
189			*/
190			public function testMakeRouteWithTransferringPrefix() : void
191			{
192			$collection = new RouteCollection();
193			$collection->setPrefix('/api');
194
195			$route = $collection->route('foo', '/foo', ['GET'], new Fixture\BlankRequestHandler());
196			$this->assertSame('/api/foo', $route->getPath());
197			}
198
199			/**
200			* @return void
201			*/
202			public function testMakeRouteWithTransferringMiddlewares() : void
203			{
204			$middlewares = [new Fixture\BlankMiddleware()];
205
206			$collection = new RouteCollection();
207			$collection->addMiddlewares(...$middlewares);
208
209			$route = $collection->route('foo', '/foo', ['GET'], new Fixture\BlankRequestHandler());
210			$this->assertSame($middlewares, $route->getMiddlewares());
211
212			// merging...
213			$middlewares[] = new Fixture\BlankMiddleware();
214			$route = $collection->route('foo', '/foo', ['GET'], new Fixture\BlankRequestHandler(), [end($middlewares)]);
215			$this->assertSame($middlewares, $route->getMiddlewares());
216			}
217
218			/**
219			* @return void
220			*
221			* @dataProvider makeVerbableRoutesDataProvider
222			*/
223			public function testMakeVerbableRoutes(string $calledMethod, string $expectedHttpMethod) : void
224			{
225			$routeName = Fixture\TestRoute::getTestRouteName();
226			$routePath = Fixture\TestRoute::getTestRoutePath();
227			$routeRequestHandler = Fixture\TestRoute::getTestRouteRequestHandler();
228
229			$collection = new RouteCollection();
230
231			$route = $collection->{$calledMethod}(
232			$routeName,
233			$routePath,
234			$routeRequestHandler
235			);
236
237			$this->assertInstanceOf(RouteInterface::class, $route);
238			$this->assertSame($routeName, $route->getName());
239			$this->assertSame($routePath, $route->getPath());
240			$this->assertSame([$expectedHttpMethod], $route->getMethods());
241			$this->assertSame($routeRequestHandler, $route->getRequestHandler());
242			$this->assertSame([], $route->getMiddlewares());
243			$this->assertSame([], $route->getAttributes());
244			$this->assertSame([$route], $collection->getRoutes());
245			}
246
247			/**
248			* @return void
249			*
250			* @dataProvider makeVerbableRoutesDataProvider
251			*/
252			public function testMakeVerbableRoutesWithOptionalParams(string $calledMethod, string $expectedHttpMethod) : void
253			{
254			$routeName = Fixture\TestRoute::getTestRouteName();
255			$routePath = Fixture\TestRoute::getTestRoutePath();
256			$routeRequestHandler = Fixture\TestRoute::getTestRouteRequestHandler();
257			$routeMiddlewares = Fixture\TestRoute::getTestRouteMiddlewares();
258			$routeAttributes = Fixture\TestRoute::getTestRouteAttributes();
259
260			$collection = new RouteCollection();
261
262			$route = $collection->{$calledMethod}(
263			$routeName,
264			$routePath,
265			$routeRequestHandler,
266			$routeMiddlewares,
267			$routeAttributes
268			);
269
270			$this->assertInstanceOf(RouteInterface::class, $route);
271			$this->assertSame($routeName, $route->getName());
272			$this->assertSame($routePath, $route->getPath());
273			$this->assertSame([$expectedHttpMethod], $route->getMethods());
274			$this->assertSame($routeRequestHandler, $route->getRequestHandler());
275			$this->assertSame($routeMiddlewares, $route->getMiddlewares());
276			$this->assertSame($routeAttributes, $route->getAttributes());
277			$this->assertSame([$route], $collection->getRoutes());
278			}
279
280			/**
281			* @return void
282			*
283			* @dataProvider makeVerbableRoutesDataProvider
284			*/
285			public function testMakeVerbableRoutesWithTransferringPrefix(string $calledMethod) : void
286			{
287			$collection = new RouteCollection();
288			$collection->setPrefix('/api');
289
290			$route = $collection->{$calledMethod}('foo', '/foo', new Fixture\BlankRequestHandler());
291			$this->assertSame('/api/foo', $route->getPath());
292			}
293
294			/**
295			* @return void
296			*
297			* @dataProvider makeVerbableRoutesDataProvider
298			*/
299			public function testMakeVerbableRoutesWithTransferringMiddlewares(string $calledMethod) : void
300			{
301			$middlewares = [new Fixture\BlankMiddleware()];
302
303			$collection = new RouteCollection();
304			$collection->addMiddlewares(...$middlewares);
305
306			$route = $collection->{$calledMethod}('foo', '/foo', new Fixture\BlankRequestHandler());
307			$this->assertSame($middlewares, $route->getMiddlewares());
308
309			// merging...
310			$middlewares[] = new Fixture\BlankMiddleware();
311			$route = $collection->{$calledMethod}('foo', '/foo', new Fixture\BlankRequestHandler(), [end($middlewares)]);
312			$this->assertSame($middlewares, $route->getMiddlewares());
313			}
314
315			/**
316			* @return array
317			*/
318			public function makeVerbableRoutesDataProvider() : array
319			{
320			return [
321			[
322			'head',
323			'HEAD',
324			],
325			[
326			'get',
327			'GET',
328			],
329			[
330			'post',
331			'POST',
332			],
333			[
334			'put',
335			'PUT',
336			],
337			[
338			'patch',
339			'PATCH',
340			],
341			[
342			'delete',
343			'DELETE',
344			],
345			[
346			'purge',
347			'PURGE',
348			],
349			];
350			}
351			}
352

sunrise-php / http-router

Branch — release/v2.0.0 (caca50)

RouteCollectionTest A

Complexity

Size/Duplication

Importance

Duplication Side-by-Side

Filter issues like