RouterUnitTest::testPostRequestForExistingStaticRoute() - Code Metrics - Inspection of "feature/Unit-tests refactoring" - alexdodonov/mezon-router - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( c0420d...5d9bff )

by Alex

created 2020-04-24 14:50 UTC

testPostRequestForExistingStaticRoute() A

↳ Parent: RouterUnitTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	12
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	7
c	1
b	0
f	0
dl	0
loc	12
rs	10
cc	1
nc	1
nop	0

<?php

class RouterUnitTest extends \PHPUnit\Framework\TestCase
{

    /**
     * Default setup
     *
     * {@inheritdoc}
     * @see \PHPUnit\Framework\TestCase::setUp()
     */
    public function setUp(): void
    {
        $_SERVER['REQUEST_METHOD'] = 'GET';
    }

    /**
     * Function simply returns string.
     */
    public function helloWorldOutput(): string
    {
        return 'Hello world!';
    }

    /**
     * Testing action #1.
     */
    public function actionA1(): string
    {
        return 'action #1';
    }

    /**
     * Testing action #2.
     */
    public function actionA2(): string
    {
        return 'action #2';
    }

    public function actionDoubleWord(): string
    {
        return 'action double word';
    }

    /**
     * Testing one component router.
     */
    public function testOneComponentRouterClassMethod(): void
    {
        $router = new \Mezon\Router\Router();

        $router->addRoute('/index/', [
            $this,
            'helloWorldOutput'
        ]);

        $content = $router->callRoute('/index/');

        $this->assertEquals('Hello world!', $content);
    }

    /**
     * Testing one component router.
     */
    public function testOneComponentRouterLambda(): void
    {
        $router = new \Mezon\Router\Router();

        $router->addRoute('/index/', function () {
            return 'Hello world!';
        });

        $content = $router->callRoute('/index/');

        $this->assertEquals('Hello world!', $content);
    }

    /**
     * Testing unexisting route behaviour.
     */
    public function testUnexistingRoute(): void
    {
        $exception = '';
        $router = new \Mezon\Router\Router();
        $router->addRoute('/index/', [
            $this,
            'helloWorldOutput'
        ]);

        try {
            $router->callRoute('/unexisting-route/');
        } catch (Exception $e) {
            $exception = $e->getMessage();
        }

        $msg = "The processor was not found for the route";

        $this->assertNotFalse(strpos($exception, $msg), 'Valid error handling expected');
    }

    /**
     * Testing action fetching method.
     */
    public function testClassActions(): void
    {
        $router = new \Mezon\Router\Router();
        $router->fetchActions($this);

        $content = $router->callRoute('/a1/');
        $this->assertEquals('action #1', $content, 'Invalid a1 route');

        $content = $router->callRoute('/a2/');
        $this->assertEquals('action #2', $content, 'Invalid a2 route');

        $content = $router->callRoute('/double-word/');
        $this->assertEquals('action double word', $content, 'Invalid a2 route');
    }

    /**
     * Method tests POST actions
     */
    public function testPostClassAction(): void
    {
        $_SERVER['REQUEST_METHOD'] = 'POST';

        $router = new \Mezon\Router\Router();
        $router->fetchActions($this);
        $content = $router->callRoute('/a1/');
        $this->assertEquals('action #1', $content, 'Invalid a1 route');
    }

    /**
     * Testing invalid data types behaviour.
     */
    public function testInvalidType(): void
    {
        $router = new \Mezon\Router\Router();
        $router->addRoute('/catalog/[unexisting-type:i]/item/', [
            $this,
            'helloWorldOutput'
        ]);

        try {
            $router->callRoute('/catalog/1024/item/');
            $this->assertFalse(true, 'Exception expected');
        } catch (Exception $e) {
            $this->assertFalse(false, '');
        }
    }

    /**
     * Testing invalid data types behaviour.
     */
    public function testValidInvalidTypes(): void
    {
        $router = new \Mezon\Router\Router();
        $router->addRoute('/catalog/[i:cat_id]/item/[unexisting-type-trace:item_id]/', [
            $this,
            'helloWorldOutput'
        ]);

        try {
            $router->callRoute('/catalog/1024/item/2048/');
            $this->assertFalse(true, 'Exception expected');
        } catch (Exception $e) {
            $this->assertFalse(false, '');
        }
    }

    /**
     * Testing valid data types behaviour.
     */
    public function testValidTypes(): void
    {
        $exception = '';
        $router = new \Mezon\Router\Router();
        $router->addRoute('/catalog/[i:cat_id]/item/[i:item_id]/', [
            $this,
            'helloWorldOutput'
        ]);

        try {
            $router->callRoute('/catalog/1024/item/2048/');
        } catch (Exception $e) {
            $exception = $e->getMessage();
        }

        $msg = "Illegal parameter type";

        $this->assertFalse(strpos($exception, $msg), 'Valid type expected');
    }

    /**
     * Testing valid integer data types behaviour.
     */
    public function testValidIntegerParams(): void
    {
        $exception = '';
        $router = new \Mezon\Router\Router();
        $router->addRoute('/catalog/[i:cat_id]/', [
            $this,
            'helloWorldOutput'
        ]);

        try {
            $router->callRoute('/catalog/1024/');
        } catch (Exception $e) {
            $exception = $e->getMessage();
        }

        $msg = "Illegal parameter type";

        $this->assertFalse(strpos($exception, $msg), 'Valid type expected');
    }

    /**
     * Testing valid alnum data types behaviour.
     */
    public function testValidAlnumParams(): void
    {
        $exception = '';
        $router = new \Mezon\Router\Router();
        $router->addRoute('/catalog/[a:cat_id]/', [
            $this,
            'helloWorldOutput'
        ]);

        try {
            $router->callRoute('/catalog/foo/');
        } catch (Exception $e) {
            $exception = $e->getMessage();
        }

        $msg = "Illegal parameter type";

        $this->assertFalse(strpos($exception, $msg), 'Valid type expected');
    }

    /**
     * Testing invalid integer data types behaviour.
     */
    public function testInValidIntegerParams(): void
    {
        $exception = '';
        $router = new \Mezon\Router\Router();
        $router->addRoute('/catalog/[i:cat_id]/', [
            $this,
            'helloWorldOutput'
        ]);

        try {
            $router->callRoute('/catalog/a1024/');
        } catch (Exception $e) {
            $exception = $e->getMessage();
        }

        $msg = "The processor was not found for the route /catalog/a1024/";

        $this->assertNotFalse(strpos($exception, $msg), 'Invalid error response');
    }

    /**
     * Testing invalid alnum data types behaviour.
     */
    public function testInValidAlnumParams(): void
    {
        $exception = '';
        $router = new \Mezon\Router\Router();
        $router->addRoute('/catalog/[a:cat_id]/', [
            $this,
            'helloWorldOutput'
        ]);

        try {
            $router->callRoute('/catalog/~foo/');
        } catch (Exception $e) {
            $exception = $e->getMessage();
        }

        $msg = "The processor was not found for the route /catalog/~foo/";

        $this->assertNotFalse(strpos($exception, $msg), 'Invalid error response');
    }

    /**
     * Testing parameter extractor.
     */
    public function testValidExtractedParameter(): void
    {
        $router = new \Mezon\Router\Router();
        $router->addRoute('/catalog/[a:cat_id]/', function ($route, $parameters) {
            return $parameters['cat_id'];
        });

        $result = $router->callRoute('/catalog/foo/');

        $this->assertEquals($result, 'foo', 'Invalid extracted parameter');
    }

    /**
     * Testing parameter extractor.
     */
    public function testValidExtractedParameters(): void
    {
        $router = new \Mezon\Router\Router();
        $router->addRoute(
            '/catalog/[a:cat_id]/[i:item_id]',
            function ($route, $parameters) {
                return $parameters['cat_id'] . $parameters['item_id'];
            });

        $result = $router->callRoute('/catalog/foo/1024/');

        $this->assertEquals($result, 'foo1024', 'Invalid extracted parameter');
    }

    /**
     * Testing parameter extractor.
     */
    public function testValidRouteParameter(): void
    {
        $router = new \Mezon\Router\Router();
        $router->addRoute('/catalog/', function ($route) {
            return $route;
        });
        $router->addRoute('/catalog/[i:cat_id]', function ($route) {
            return $route;
        });

        $result = $router->callRoute('/catalog/');

        $this->assertEquals($result, '/catalog/', 'Invalid extracted route');

        $result = $router->callRoute('/catalog/1024/');

        $this->assertEquals($result, '/catalog/1024/', 'Invalid extracted route');
    }

    /**
     * Testing static routes for POST requests.
     */
    public function testPostRequestForExistingStaticRoute(): void
    {
        $_SERVER['REQUEST_METHOD'] = 'POST';

        $router = new \Mezon\Router\Router();
        $router->addRoute('/catalog/', function ($route) {
            return $route;
        }, 'POST');

        $result = $router->callRoute('/catalog/');

        $this->assertEquals($result, '/catalog/', 'Invalid extracted route');
    }

    /**
     * Testing dynamic routes for POST requests.
     */
    public function testPostRequestForExistingDynamicRoute(): void
    {
        $_SERVER['REQUEST_METHOD'] = 'POST';

        $router = new \Mezon\Router\Router();
        $router->addRoute('/catalog/[i:cat_id]', function ($route) {
            return $route;
        }, 'POST');

        $result = $router->callRoute('/catalog/1024/');

        $this->assertEquals($result, '/catalog/1024/', 'Invalid extracted route');
    }

    /**
     * Testing static routes for POST requests.
     */
    public function testPostRequestForUnExistingStaticRoute(): void
    {
        $_SERVER['REQUEST_METHOD'] = 'POST';

        $exception = '';
        $router = new \Mezon\Router\Router();
        $router->addRoute('/catalog/', [
            $this,
            'helloWorldOutput'
        ]);

        try {
            $router->callRoute('/catalog/');
        } catch (Exception $e) {
            $exception = $e->getMessage();
        }

        $msg = "The processor was not found for the route /catalog/";

        $this->assertNotFalse(strpos($exception, $msg), 'Invalid error response');
    }

    /**
     * Testing dynamic routes for POST requests.
     */
    public function testPostRequestForUnExistingDynamicRoute(): void
    {
        $_SERVER['REQUEST_METHOD'] = 'POST';

        $exception = '';
        $router = new \Mezon\Router\Router();
        $router->addRoute('/catalog/[i:cat_id]', [
            $this,
            'helloWorldOutput'
        ]);

        try {
            $router->callRoute('/catalog/1024/');
        } catch (Exception $e) {
            $exception = $e->getMessage();
        }

        $msg = "The processor was not found for the route /catalog/1024/";

        $this->assertNotFalse(strpos($exception, $msg), 'Invalid error response');
    }

    /**
     * Testing case when both GET and POST processors exists.
     */
    public function testGetPostPostDeleteRouteConcurrency(): void
    {
        $router = new \Mezon\Router\Router();
        $router->addRoute('/catalog/', function () {
            return 'POST';
        }, 'POST');
        $router->addRoute('/catalog/', function () {
            return 'GET';
        }, 'GET');
        $router->addRoute('/catalog/', function () {
            return 'PUT';
        }, 'PUT');
        $router->addRoute('/catalog/', function () {
            return 'DELETE';
        }, 'DELETE');

        $_SERVER['REQUEST_METHOD'] = 'POST';
        $result = $router->callRoute('/catalog/');
        $this->assertEquals($result, 'POST');

        $_SERVER['REQUEST_METHOD'] = 'GET';
        $result = $router->callRoute('/catalog/');
        $this->assertEquals($result, 'GET');

        $_SERVER['REQUEST_METHOD'] = 'PUT';
        $result = $router->callRoute('/catalog/');
        $this->assertEquals($result, 'PUT');

        $_SERVER['REQUEST_METHOD'] = 'DELETE';
        $result = $router->callRoute('/catalog/');
        $this->assertEquals($result, 'DELETE');
    }

    /**
     * Testing 'clear' method.
     */
    public function testClearMethod(): void
    {
        $router = new \Mezon\Router\Router();
        $router->addRoute('/catalog/', function () {
            return 'POST';
        }, 'POST');
        $router->addRoute('/catalog/', function () {
            return 'GET';
        }, 'GET');
        $router->addRoute('/catalog/', function () {
            return 'PUT';
        }, 'PUT');
        $router->addRoute('/catalog/', function () {
            return 'DELETE';
        }, 'DELETE');
        $router->clear();

        try {
            $_SERVER['REQUEST_METHOD'] = 'POST';
            $router->callRoute('/catalog/');
            $flag = 'not cleared';
        } catch (Exception $e) {
            $flag = 'cleared';
        }
        $this->assertEquals($flag, 'cleared', 'Data was not cleared');

        try {
            $_SERVER['REQUEST_METHOD'] = 'GET';
            $router->callRoute('/catalog/');
            $flag = 'not cleared';
        } catch (Exception $e) {
            $flag = 'cleared';
        }
        $this->assertEquals($flag, 'cleared', 'Data was not cleared');

        try {
            $_SERVER['REQUEST_METHOD'] = 'PUT';
            $router->callRoute('/catalog/');
            $flag = 'not cleared';
        } catch (Exception $e) {
            $flag = 'cleared';
        }
        $this->assertEquals($flag, 'cleared', 'Data was not cleared');

        try {
            $_SERVER['REQUEST_METHOD'] = 'DELETE';
            $router->callRoute('/catalog/');
            $flag = 'not cleared';
        } catch (Exception $e) {
            $flag = 'cleared';
        }
        $this->assertEquals($flag, 'cleared', 'Data was not cleared');
    }

    /**
     * Method increments assertion count
     */
    protected function errorHandler(): void
    {
        $this->addToAssertionCount(1);
    }

    /**
     * Test validate custom error handlers.
     */
    public function testSetErrorHandler(): void
    {
        $router = new \Mezon\Router\Router();
        $router->setNoProcessorFoundErrorHandler(function () {
            $this->errorHandler();
        });

        $_SERVER['REQUEST_METHOD'] = 'POST';
        $router->callRoute('/unexisting/');
    }
}


1			<?php
2
3			class RouterUnitTest extends \PHPUnit\Framework\TestCase
4			{
5
6			/**
7			* Default setup
8			*
9			* {@inheritdoc}
10			* @see \PHPUnit\Framework\TestCase::setUp()
11			*/
12			public function setUp(): void
13			{
14			$_SERVER['REQUEST_METHOD'] = 'GET';
15			}
16
17			/**
18			* Function simply returns string.
19			*/
20			public function helloWorldOutput(): string
21			{
22			return 'Hello world!';
23			}
24
25			/**
26			* Testing action #1.
27			*/
28			public function actionA1(): string
29			{
30			return 'action #1';
31			}
32
33			/**
34			* Testing action #2.
35			*/
36			public function actionA2(): string
37			{
38			return 'action #2';
39			}
40
41			public function actionDoubleWord(): string
42			{
43			return 'action double word';
44			}
45
46			/**
47			* Testing one component router.
48			*/
49			public function testOneComponentRouterClassMethod(): void
50			{
51			$router = new \Mezon\Router\Router();
52
53			$router->addRoute('/index/', [
54			$this,
55			'helloWorldOutput'
56			]);
57
58			$content = $router->callRoute('/index/');
59
60			$this->assertEquals('Hello world!', $content);
61			}
62
63			/**
64			* Testing one component router.
65			*/
66			public function testOneComponentRouterLambda(): void
67			{
68			$router = new \Mezon\Router\Router();
69
70			$router->addRoute('/index/', function () {
71			return 'Hello world!';
72			});
73
74			$content = $router->callRoute('/index/');
75
76			$this->assertEquals('Hello world!', $content);
77			}
78
79			/**
80			* Testing unexisting route behaviour.
81			*/
82			public function testUnexistingRoute(): void
83			{
84			$exception = '';
85			$router = new \Mezon\Router\Router();
86			$router->addRoute('/index/', [
87			$this,
88			'helloWorldOutput'
89			]);
90
91			try {
92			$router->callRoute('/unexisting-route/');
93			} catch (Exception $e) {
94			$exception = $e->getMessage();
95			}
96
97			$msg = "The processor was not found for the route";
98
99			$this->assertNotFalse(strpos($exception, $msg), 'Valid error handling expected');
100			}
101
102			/**
103			* Testing action fetching method.
104			*/
105			public function testClassActions(): void
106			{
107			$router = new \Mezon\Router\Router();
108			$router->fetchActions($this);
109
110			$content = $router->callRoute('/a1/');
111			$this->assertEquals('action #1', $content, 'Invalid a1 route');
112
113			$content = $router->callRoute('/a2/');
114			$this->assertEquals('action #2', $content, 'Invalid a2 route');
115
116			$content = $router->callRoute('/double-word/');
117			$this->assertEquals('action double word', $content, 'Invalid a2 route');
118			}
119
120			/**
121			* Method tests POST actions
122			*/
123			public function testPostClassAction(): void
124			{
125			$_SERVER['REQUEST_METHOD'] = 'POST';
126
127			$router = new \Mezon\Router\Router();
128			$router->fetchActions($this);
129			$content = $router->callRoute('/a1/');
130			$this->assertEquals('action #1', $content, 'Invalid a1 route');
131			}
132
133			/**
134			* Testing invalid data types behaviour.
135			*/
136			public function testInvalidType(): void
137			{
138			$router = new \Mezon\Router\Router();
139			$router->addRoute('/catalog/[unexisting-type:i]/item/', [
140			$this,
141			'helloWorldOutput'
142			]);
143
144			try {
145			$router->callRoute('/catalog/1024/item/');
146			$this->assertFalse(true, 'Exception expected');
147			} catch (Exception $e) {
148			$this->assertFalse(false, '');
149			}
150			}
151
152			/**
153			* Testing invalid data types behaviour.
154			*/
155			public function testValidInvalidTypes(): void
156			{
157			$router = new \Mezon\Router\Router();
158			$router->addRoute('/catalog/[i:cat_id]/item/[unexisting-type-trace:item_id]/', [
159			$this,
160			'helloWorldOutput'
161			]);
162
163			try {
164			$router->callRoute('/catalog/1024/item/2048/');
165			$this->assertFalse(true, 'Exception expected');
166			} catch (Exception $e) {
167			$this->assertFalse(false, '');
168			}
169			}
170
171			/**
172			* Testing valid data types behaviour.
173			*/
174			public function testValidTypes(): void
175			{
176			$exception = '';
177			$router = new \Mezon\Router\Router();
178			$router->addRoute('/catalog/[i:cat_id]/item/[i:item_id]/', [
179			$this,
180			'helloWorldOutput'
181			]);
182
183			try {
184			$router->callRoute('/catalog/1024/item/2048/');
185			} catch (Exception $e) {
186			$exception = $e->getMessage();
187			}
188
189			$msg = "Illegal parameter type";
190
191			$this->assertFalse(strpos($exception, $msg), 'Valid type expected');
192			}
193
194			/**
195			* Testing valid integer data types behaviour.
196			*/
197			public function testValidIntegerParams(): void
198			{
199			$exception = '';
200			$router = new \Mezon\Router\Router();
201			$router->addRoute('/catalog/[i:cat_id]/', [
202			$this,
203			'helloWorldOutput'
204			]);
205
206			try {
207			$router->callRoute('/catalog/1024/');
208			} catch (Exception $e) {
209			$exception = $e->getMessage();
210			}
211
212			$msg = "Illegal parameter type";
213
214			$this->assertFalse(strpos($exception, $msg), 'Valid type expected');
215			}
216
217			/**
218			* Testing valid alnum data types behaviour.
219			*/
220			public function testValidAlnumParams(): void
221			{
222			$exception = '';
223			$router = new \Mezon\Router\Router();
224			$router->addRoute('/catalog/[a:cat_id]/', [
225			$this,
226			'helloWorldOutput'
227			]);
228
229			try {
230			$router->callRoute('/catalog/foo/');
231			} catch (Exception $e) {
232			$exception = $e->getMessage();
233			}
234
235			$msg = "Illegal parameter type";
236
237			$this->assertFalse(strpos($exception, $msg), 'Valid type expected');
238			}
239
240			/**
241			* Testing invalid integer data types behaviour.
242			*/
243			public function testInValidIntegerParams(): void
244			{
245			$exception = '';
246			$router = new \Mezon\Router\Router();
247			$router->addRoute('/catalog/[i:cat_id]/', [
248			$this,
249			'helloWorldOutput'
250			]);
251
252			try {
253			$router->callRoute('/catalog/a1024/');
254			} catch (Exception $e) {
255			$exception = $e->getMessage();
256			}
257
258			$msg = "The processor was not found for the route /catalog/a1024/";
259
260			$this->assertNotFalse(strpos($exception, $msg), 'Invalid error response');
261			}
262
263			/**
264			* Testing invalid alnum data types behaviour.
265			*/
266			public function testInValidAlnumParams(): void
267			{
268			$exception = '';
269			$router = new \Mezon\Router\Router();
270			$router->addRoute('/catalog/[a:cat_id]/', [
271			$this,
272			'helloWorldOutput'
273			]);
274
275			try {
276			$router->callRoute('/catalog/~foo/');
277			} catch (Exception $e) {
278			$exception = $e->getMessage();
279			}
280
281			$msg = "The processor was not found for the route /catalog/~foo/";
282
283			$this->assertNotFalse(strpos($exception, $msg), 'Invalid error response');
284			}
285
286			/**
287			* Testing parameter extractor.
288			*/
289			public function testValidExtractedParameter(): void
290			{
291			$router = new \Mezon\Router\Router();
292			$router->addRoute('/catalog/[a:cat_id]/', function ($route, $parameters) {
293			return $parameters['cat_id'];
294			});
295
296			$result = $router->callRoute('/catalog/foo/');
297
298			$this->assertEquals($result, 'foo', 'Invalid extracted parameter');
299			}
300
301			/**
302			* Testing parameter extractor.
303			*/
304			public function testValidExtractedParameters(): void
305			{
306			$router = new \Mezon\Router\Router();
307			$router->addRoute(
308			'/catalog/[a:cat_id]/[i:item_id]',
309			function ($route, $parameters) {
310			return $parameters['cat_id'] . $parameters['item_id'];
311			});
312
313			$result = $router->callRoute('/catalog/foo/1024/');
314
315			$this->assertEquals($result, 'foo1024', 'Invalid extracted parameter');
316			}
317
318			/**
319			* Testing parameter extractor.
320			*/
321			public function testValidRouteParameter(): void
322			{
323			$router = new \Mezon\Router\Router();
324			$router->addRoute('/catalog/', function ($route) {
325			return $route;
326			});
327			$router->addRoute('/catalog/[i:cat_id]', function ($route) {
328			return $route;
329			});
330
331			$result = $router->callRoute('/catalog/');
332
333			$this->assertEquals($result, '/catalog/', 'Invalid extracted route');
334
335			$result = $router->callRoute('/catalog/1024/');
336
337			$this->assertEquals($result, '/catalog/1024/', 'Invalid extracted route');
338			}
339
340			/**
341			* Testing static routes for POST requests.
342			*/
343			public function testPostRequestForExistingStaticRoute(): void
344			{
345			$_SERVER['REQUEST_METHOD'] = 'POST';
346
347			$router = new \Mezon\Router\Router();
348			$router->addRoute('/catalog/', function ($route) {
349			return $route;
350			}, 'POST');
351
352			$result = $router->callRoute('/catalog/');
353
354			$this->assertEquals($result, '/catalog/', 'Invalid extracted route');
355			}
356
357			/**
358			* Testing dynamic routes for POST requests.
359			*/
360			public function testPostRequestForExistingDynamicRoute(): void
361			{
362			$_SERVER['REQUEST_METHOD'] = 'POST';
363
364			$router = new \Mezon\Router\Router();
365			$router->addRoute('/catalog/[i:cat_id]', function ($route) {
366			return $route;
367			}, 'POST');
368
369			$result = $router->callRoute('/catalog/1024/');
370
371			$this->assertEquals($result, '/catalog/1024/', 'Invalid extracted route');
372			}
373
374			/**
375			* Testing static routes for POST requests.
376			*/
377			public function testPostRequestForUnExistingStaticRoute(): void
378			{
379			$_SERVER['REQUEST_METHOD'] = 'POST';
380
381			$exception = '';
382			$router = new \Mezon\Router\Router();
383			$router->addRoute('/catalog/', [
384			$this,
385			'helloWorldOutput'
386			]);
387
388			try {
389			$router->callRoute('/catalog/');
390			} catch (Exception $e) {
391			$exception = $e->getMessage();
392			}
393
394			$msg = "The processor was not found for the route /catalog/";
395
396			$this->assertNotFalse(strpos($exception, $msg), 'Invalid error response');
397			}
398
399			/**
400			* Testing dynamic routes for POST requests.
401			*/
402			public function testPostRequestForUnExistingDynamicRoute(): void
403			{
404			$_SERVER['REQUEST_METHOD'] = 'POST';
405
406			$exception = '';
407			$router = new \Mezon\Router\Router();
408			$router->addRoute('/catalog/[i:cat_id]', [
409			$this,
410			'helloWorldOutput'
411			]);
412
413			try {
414			$router->callRoute('/catalog/1024/');
415			} catch (Exception $e) {
416			$exception = $e->getMessage();
417			}
418
419			$msg = "The processor was not found for the route /catalog/1024/";
420
421			$this->assertNotFalse(strpos($exception, $msg), 'Invalid error response');
422			}
423
424			/**
425			* Testing case when both GET and POST processors exists.
426			*/
427			public function testGetPostPostDeleteRouteConcurrency(): void
428			{
429			$router = new \Mezon\Router\Router();
430			$router->addRoute('/catalog/', function () {
431			return 'POST';
432			}, 'POST');
433			$router->addRoute('/catalog/', function () {
434			return 'GET';
435			}, 'GET');
436			$router->addRoute('/catalog/', function () {
437			return 'PUT';
438			}, 'PUT');
439			$router->addRoute('/catalog/', function () {
440			return 'DELETE';
441			}, 'DELETE');
442
443			$_SERVER['REQUEST_METHOD'] = 'POST';
444			$result = $router->callRoute('/catalog/');
445			$this->assertEquals($result, 'POST');
446
447			$_SERVER['REQUEST_METHOD'] = 'GET';
448			$result = $router->callRoute('/catalog/');
449			$this->assertEquals($result, 'GET');
450
451			$_SERVER['REQUEST_METHOD'] = 'PUT';
452			$result = $router->callRoute('/catalog/');
453			$this->assertEquals($result, 'PUT');
454
455			$_SERVER['REQUEST_METHOD'] = 'DELETE';
456			$result = $router->callRoute('/catalog/');
457			$this->assertEquals($result, 'DELETE');
458			}
459
460			/**
461			* Testing 'clear' method.
462			*/
463			public function testClearMethod(): void
464			{
465			$router = new \Mezon\Router\Router();
466			$router->addRoute('/catalog/', function () {
467			return 'POST';
468			}, 'POST');
469			$router->addRoute('/catalog/', function () {
470			return 'GET';
471			}, 'GET');
472			$router->addRoute('/catalog/', function () {
473			return 'PUT';
474			}, 'PUT');
475			$router->addRoute('/catalog/', function () {
476			return 'DELETE';
477			}, 'DELETE');
478			$router->clear();
479
480			try {
481			$_SERVER['REQUEST_METHOD'] = 'POST';
482			$router->callRoute('/catalog/');
483			$flag = 'not cleared';
484			} catch (Exception $e) {
485			$flag = 'cleared';
486			}
487			$this->assertEquals($flag, 'cleared', 'Data was not cleared');
488
489			try {
490			$_SERVER['REQUEST_METHOD'] = 'GET';
491			$router->callRoute('/catalog/');
492			$flag = 'not cleared';
493			} catch (Exception $e) {
494			$flag = 'cleared';
495			}
496			$this->assertEquals($flag, 'cleared', 'Data was not cleared');
497
498			try {
499			$_SERVER['REQUEST_METHOD'] = 'PUT';
500			$router->callRoute('/catalog/');
501			$flag = 'not cleared';
502			} catch (Exception $e) {
503			$flag = 'cleared';
504			}
505			$this->assertEquals($flag, 'cleared', 'Data was not cleared');
506
507			try {
508			$_SERVER['REQUEST_METHOD'] = 'DELETE';
509			$router->callRoute('/catalog/');
510			$flag = 'not cleared';
511			} catch (Exception $e) {
512			$flag = 'cleared';
513			}
514			$this->assertEquals($flag, 'cleared', 'Data was not cleared');
515			}
516
517			/**
518			* Method increments assertion count
519			*/
520			protected function errorHandler(): void
521			{
522			$this->addToAssertionCount(1);
523			}
524
525			/**
526			* Test validate custom error handlers.
527			*/
528			public function testSetErrorHandler(): void
529			{
530			$router = new \Mezon\Router\Router();
531			$router->setNoProcessorFoundErrorHandler(function () {
532			$this->errorHandler();
533			});
534
535			$_SERVER['REQUEST_METHOD'] = 'POST';
536			$router->callRoute('/unexisting/');
537			}
538			}
539

alexdodonov / mezon-router

Push — master ( c0420d...5d9bff )

testPostRequestForExistingStaticRoute() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like