RouterUnitTest::testValidAlnumParams()

Complexity

Conditions	2
Paths	2

Size

Total Lines	18
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

1 Method

Rating	Name	Duplication	Size	Complexity
A	RouterUnitTest::errorHandler()	0	3	1

<?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 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/');
    }
}