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

Passed

Push — master ( f3dde3...f14a68 )

by Alex

created 2020-09-01 10:13 UTC

RouterUnitTest::testDifferentHandlers() A

↳ Parent: RouterUnitTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	11
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	4
nc	1
nop	3
dl	0
loc	11
rs	10
c	0
b	0
f	0

<?php
namespace Mezon\Router\Tests;

use Mezon\Router\Router;

class RouterUnitTest extends \PHPUnit\Framework\TestCase
{

    const DELETE_REQUEST_METHOD = 'DELETE';

    /**
     * Function sets $_SERVER['REQUEST_METHOD']
     *
     * @param string $requestMethod
     *            request method
     */
    public static function setRequestMethod(string $requestMethod): void
    {
        $_SERVER['REQUEST_METHOD'] = $requestMethod;
    }

    /**
     * Default setup
     *
     * {@inheritdoc}
     * @see \PHPUnit\Framework\TestCase::setUp()
     */
    public function setUp(): void
    {
        RouterUnitTest::setRequestMethod('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';
    }

    /**
     * Data provider for the test
     *
     * @return array
     */
    public function differentHandlersDataProvider(): array
    {
        return [
            # 0, class method
            [
                '/one-component-class-method/',
                [
                    $this,
                    'helloWorldOutput'
                ],
                'Hello world!'
            ],
            # 1, lambda
            [
                '/one-component-lambda/',
                function () {
                    return 'Hello lambda!';
                },
                'Hello lambda!'
            ],
        ];
    }

    /**
     * Testing router with different handlers
     *
     * @dataProvider differentHandlersDataProvider
     */
    public function testDifferentHandlers(string $url, $handler, string $expectedResult): void
    {
        // setup
        $router = new Router();
        $router->addRoute($url, $handler);

        // test body
        $content = $router->callRoute($url);

        // assertions
        $this->assertEquals($expectedResult, $content);
    }

    /**
     * Data provider for the test testClassAction
     *
     * @return array test data
     */
    public function classActionDataProvider(): array
    {
        $testData = [];

        foreach ([
            'GET',
            'POST'
        ] as $requestMethod) {
            $testData[] = [
                $requestMethod,
                '/a1/',
                'action #1'
            ];

            $testData[] = [
                $requestMethod,
                '/a2/',
                'action #2'
            ];

            $testData[] = [
                $requestMethod,
                '/double-word/',
                'action double word'
            ];
        }

        return $testData;
    }

    /**
     * Method tests class actions
     *
     * @param string $requestMethod
     *            request method
     * @param string $route
     *            requesting route
     * @param string $expectedResult
     *            expected result of route processing
     * @dataProvider classActionDataProvider
     */
    public function testClassAction(string $requestMethod, string $route, string $expectedResult): void
    {
        RouterUnitTest::setRequestMethod($requestMethod);

        $router = new \Mezon\Router\Router();
        $router->fetchActions($this);
        $result = $router->callRoute($route);
        $this->assertEquals($expectedResult, $result);
    }

    /**
     * Testing case when all processors exist
     */
    public function testRequestMethodsConcurrency(): void
    {
        $route = '/catalog/';
        $router = new \Mezon\Router\Router();
        $router->addRoute($route, function () {
            return 'POST';
        }, 'POST');
        $router->addRoute($route, function () {
            return 'GET';
        }, 'GET');
        $router->addRoute($route, function () {
            return 'PUT';
        }, 'PUT');
        $router->addRoute($route, function () {
            return RouterUnitTest::DELETE_REQUEST_METHOD;
        }, RouterUnitTest::DELETE_REQUEST_METHOD);

        RouterUnitTest::setRequestMethod('POST');
        $result = $router->callRoute($route);
        $this->assertEquals($result, 'POST');

        RouterUnitTest::setRequestMethod('GET');
        $result = $router->callRoute($route);
        $this->assertEquals($result, 'GET');

        RouterUnitTest::setRequestMethod('PUT');
        $result = $router->callRoute($route);
        $this->assertEquals($result, 'PUT');

        RouterUnitTest::setRequestMethod(RouterUnitTest::DELETE_REQUEST_METHOD);
        $result = $router->callRoute($route);
        $this->assertEquals($result, RouterUnitTest::DELETE_REQUEST_METHOD);
    }

    /**
     * Data provider
     *
     * @return array
     */
    public function clearMethodTestDataProvider(): array
    {
        $result = [];

        foreach (\Mezon\Router\Router::getListOfSupportedRequestMethods() as $method) {
            $result[] = [
                $method
            ];
        }

        return $result;
    }

    /**
     * Testing 'clear' method
     *
     * @param string $method
     *            request method
     * @dataProvider clearMethodTestDataProvider
     */
    public function testClearMethod(string $method): void
    {
        $router = new \Mezon\Router\Router();
        $router->addRoute('/route-to-clear/', function () use ($method) {
            return $method;
        }, $method);
        $router->clear();

        try {
            RouterUnitTest::setRequestMethod($method);
            $router->callRoute('/route-to-clear/');
            $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
    {
        // setup
        $router = new \Mezon\Router\Router();
        $router->setNoProcessorFoundErrorHandler(function () {
            $this->errorHandler();
        });

        // test body and assertions
        RouterUnitTest::setRequestMethod('POST');
        $router->callRoute('/unexisting/');
    }
}


1			<?php
2			namespace Mezon\Router\Tests;
3
4			use Mezon\Router\Router;
5
6			class RouterUnitTest extends \PHPUnit\Framework\TestCase
7			{
8
9			const DELETE_REQUEST_METHOD = 'DELETE';
10
11			/**
12			* Function sets $_SERVER['REQUEST_METHOD']
13			*
14			* @param string $requestMethod
15			* request method
16			*/
17			public static function setRequestMethod(string $requestMethod): void
18			{
19			$_SERVER['REQUEST_METHOD'] = $requestMethod;
20			}
21
22			/**
23			* Default setup
24			*
25			* {@inheritdoc}
26			* @see \PHPUnit\Framework\TestCase::setUp()
27			*/
28			public function setUp(): void
29			{
30			RouterUnitTest::setRequestMethod('GET');
31			}
32
33			/**
34			* Function simply returns string.
35			*/
36			public function helloWorldOutput(): string
37			{
38			return 'Hello world!';
39			}
40
41			/**
42			* Testing action #1.
43			*/
44			public function actionA1(): string
45			{
46			return 'action #1';
47			}
48
49			/**
50			* Testing action #2.
51			*/
52			public function actionA2(): string
53			{
54			return 'action #2';
55			}
56
57			public function actionDoubleWord(): string
58			{
59			return 'action double word';
60			}
61
62			/**
63			* Data provider for the test
64			*
65			* @return array
66			*/
67			public function differentHandlersDataProvider(): array
68			{
69			return [
70			# 0, class method
71			[
72			'/one-component-class-method/',
73			[
74			$this,
75			'helloWorldOutput'
76			],
77			'Hello world!'
78			],
79			# 1, lambda
80			[
81			'/one-component-lambda/',
82			function () {
83			return 'Hello lambda!';
84			},
85			'Hello lambda!'
86			],
87			];
88			}
89
90			/**
91			* Testing router with different handlers
92			*
93			* @dataProvider differentHandlersDataProvider
94			*/
95			public function testDifferentHandlers(string $url, $handler, string $expectedResult): void
96			{
97			// setup
98			$router = new Router();
99			$router->addRoute($url, $handler);
100
101			// test body
102			$content = $router->callRoute($url);
103
104			// assertions
105			$this->assertEquals($expectedResult, $content);
106			}
107
108			/**
109			* Data provider for the test testClassAction
110			*
111			* @return array test data
112			*/
113			public function classActionDataProvider(): array
114			{
115			$testData = [];
116
117			foreach ([
118			'GET',
119			'POST'
120			] as $requestMethod) {
121			$testData[] = [
122			$requestMethod,
123			'/a1/',
124			'action #1'
125			];
126
127			$testData[] = [
128			$requestMethod,
129			'/a2/',
130			'action #2'
131			];
132
133			$testData[] = [
134			$requestMethod,
135			'/double-word/',
136			'action double word'
137			];
138			}
139
140			return $testData;
141			}
142
143			/**
144			* Method tests class actions
145			*
146			* @param string $requestMethod
147			* request method
148			* @param string $route
149			* requesting route
150			* @param string $expectedResult
151			* expected result of route processing
152			* @dataProvider classActionDataProvider
153			*/
154			public function testClassAction(string $requestMethod, string $route, string $expectedResult): void
155			{
156			RouterUnitTest::setRequestMethod($requestMethod);
157
158			$router = new \Mezon\Router\Router();
159			$router->fetchActions($this);
160			$result = $router->callRoute($route);
161			$this->assertEquals($expectedResult, $result);
162			}
163
164			/**
165			* Testing case when all processors exist
166			*/
167			public function testRequestMethodsConcurrency(): void
168			{
169			$route = '/catalog/';
170			$router = new \Mezon\Router\Router();
171			$router->addRoute($route, function () {
172			return 'POST';
173			}, 'POST');
174			$router->addRoute($route, function () {
175			return 'GET';
176			}, 'GET');
177			$router->addRoute($route, function () {
178			return 'PUT';
179			}, 'PUT');
180			$router->addRoute($route, function () {
181			return RouterUnitTest::DELETE_REQUEST_METHOD;
182			}, RouterUnitTest::DELETE_REQUEST_METHOD);
183
184			RouterUnitTest::setRequestMethod('POST');
185			$result = $router->callRoute($route);
186			$this->assertEquals($result, 'POST');
187
188			RouterUnitTest::setRequestMethod('GET');
189			$result = $router->callRoute($route);
190			$this->assertEquals($result, 'GET');
191
192			RouterUnitTest::setRequestMethod('PUT');
193			$result = $router->callRoute($route);
194			$this->assertEquals($result, 'PUT');
195
196			RouterUnitTest::setRequestMethod(RouterUnitTest::DELETE_REQUEST_METHOD);
197			$result = $router->callRoute($route);
198			$this->assertEquals($result, RouterUnitTest::DELETE_REQUEST_METHOD);
199			}
200
201			/**
202			* Data provider
203			*
204			* @return array
205			*/
206			public function clearMethodTestDataProvider(): array
207			{
208			$result = [];
209
210			foreach (\Mezon\Router\Router::getListOfSupportedRequestMethods() as $method) {
211			$result[] = [
212			$method
213			];
214			}
215
216			return $result;
217			}
218
219			/**
220			* Testing 'clear' method
221			*
222			* @param string $method
223			* request method
224			* @dataProvider clearMethodTestDataProvider
225			*/
226			public function testClearMethod(string $method): void
227			{
228			$router = new \Mezon\Router\Router();
229			$router->addRoute('/route-to-clear/', function () use ($method) {
230			return $method;
231			}, $method);
232			$router->clear();
233
234			try {
235			RouterUnitTest::setRequestMethod($method);
236			$router->callRoute('/route-to-clear/');
237			$flag = 'not cleared';
238			} catch (\Exception $e) {
239			$flag = 'cleared';
240			}
241			$this->assertEquals($flag, 'cleared', 'Data was not cleared');
242			}
243
244			/**
245			* Method increments assertion count
246			*/
247			protected function errorHandler(): void
248			{
249			$this->addToAssertionCount(1);
250			}
251
252			/**
253			* Test validate custom error handlers.
254			*/
255			public function testSetErrorHandler(): void
256			{
257			// setup
258			$router = new \Mezon\Router\Router();
259			$router->setNoProcessorFoundErrorHandler(function () {
260			$this->errorHandler();
261			});
262
263			// test body and assertions
264			RouterUnitTest::setRequestMethod('POST');
265			$router->callRoute('/unexisting/');
266			}
267			}
268

alexdodonov / mezon-router

Push — master ( f3dde3...f14a68 )

RouterUnitTest::testDifferentHandlers() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like