index/tests/RouterTest.php

<?php
// RouterTest.php
// Created: 2022-01-20
// Updated: 2025-03-02

declare(strict_types=1);

use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use Index\Http\{HttpHeaders,HttpRequest,HttpUri,NullStream};
use Index\Http\Routing\{Filter,Route,Router,RouteHandler,RouteHandlerCommon};

/**
 * This test isn't super representative of the current functionality
 *  it mostly just does the same tests that were done against the previous implementation
 */
#[CoversClass(Filter::class)]
#[CoversClass(Route::class)]
#[CoversClass(Router::class)]
#[CoversClass(RouteHandler::class)]
#[CoversClass(RouteHandlerCommon::class)]
final class RouterTest extends TestCase {
    public function testRouter(): void {
        $router1 = new Router;

        $router1->route('GET', '/', fn() => 'get');
        $router1->route('POST', '/', fn() => 'post');
        $router1->route('DELETE', '/', fn() => 'delete');
        $router1->route('PATCH', '/', fn() => 'patch');
        $router1->route('PUT', '/', fn() => 'put');
        $router1->route('CUSTOM', '/', fn() => 'wacky');

        $this->assertEquals('get', $router1->resolve('GET', '/')->dispatch([]));
        $this->assertEquals('wacky', $router1->resolve('CUSTOM', '/')->dispatch([]));

        $router1->filter('/', function() { /* this one intentionally does nothing */ });

        // registration order should matter
        $router1->filter('/deep', fn() => 'deep');

        $postRoot = $router1->resolve('POST', '/');
        $this->assertNull($postRoot->runFilters([]));
        $this->assertEquals('post', $postRoot->dispatch([]));

        $this->assertEquals('deep', $router1->resolve('GET', '/deep/nothing')->runFilters([]));

        $router1->filter('/user/([A-Za-z0-9]+)/below', fn(string $user) => 'warioware below ' . $user);

        $router1->route('GET', '/user/static', fn() => 'the static one');
        $router1->route('GET', '/user/static/below', fn() => 'below the static one');
        $router1->route('GET', '/user/([A-Za-z0-9]+)', fn(string $user) => $user);
        $router1->route('GET', '/user/([A-Za-z0-9]+)/below', fn(string $user) => 'below ' . $user);

        $this->assertEquals('below the static one', $router1->resolve('GET', '/user/static/below')->dispatch([]));

        $getWariowareBelowFlashwave = $router1->resolve('GET', '/user/flashwave/below');
        $this->assertEquals('warioware below flashwave', $getWariowareBelowFlashwave->runFilters([]));
        $this->assertEquals('below flashwave', $getWariowareBelowFlashwave->dispatch([]));

        $router2 = new Router;
        $router2->filter('/', fn() => 'meow');
        $router2->route('GET', '/rules', fn() => 'rules page');
        $router2->route('GET', '/contact', fn() => 'contact page');
        $router2->route('GET', '/25252', fn() => 'numeric test');

        $getRules = $router2->resolve('GET', '/rules');
        $this->assertEquals('meow', $getRules->runFilters([]));
        $this->assertEquals('rules page', $getRules->dispatch([]));

        $get25252 = $router2->resolve('GET', '/25252');
        $this->assertEquals('meow', $get25252->runFilters([]));
        $this->assertEquals('numeric test', $get25252->dispatch([]));
    }

    public function testAttribute(): void {
        $router = new Router;
        $handler = new class implements RouteHandler {
            use RouteHandlerCommon;

            #[Route('GET', '/')]
            public function getIndex(): string {
                return 'index';
            }

            #[Route('POST', '/avatar')]
            public function postAvatar(): string {
                return 'avatar';
            }

            #[Route('PUT', '/static')]
            public static function putStatic(): string {
                return 'static';
            }

            #[Route('GET', '/meow')]
            #[Route('POST', '/meow')]
            public function multiple(): string {
                return 'meow';
            }

            #[Filter('/filter')]
            public function useFilter(): string {
                return 'this intercepts';
            }

            #[Route('GET', '/filter')]
            public function getFilter(): string {
                return 'this is intercepted';
            }

            public function hasNoAttr(): string {
                return 'not a route';
            }
        };

        $router->register($handler);
        $this->assertFalse($router->resolve('GET', '/soap')->hasHandler());

        $patchAvatar = $router->resolve('PATCH', '/avatar');
        $this->assertFalse($patchAvatar->hasHandler());
        $this->assertTrue(!empty($patchAvatar->supportedMethods));
        $this->assertEquals(['POST'], $patchAvatar->supportedMethods);

        $this->assertEquals('index', $router->resolve('GET', '/')->dispatch([]));
        $this->assertEquals('avatar', $router->resolve('POST', '/avatar')->dispatch([]));
        $this->assertEquals('static', $router->resolve('PUT', '/static')->dispatch([]));
        $this->assertEquals('meow', $router->resolve('GET', '/meow')->dispatch([]));
        $this->assertEquals('meow', $router->resolve('POST', '/meow')->dispatch([]));

        // stopping on filter is the dispatcher's job
        $getFilter = $router->resolve('GET', '/filter');
        $this->assertEquals('this intercepts', $getFilter->runFilters([]));
        $this->assertEquals('this is intercepted', $getFilter->dispatch([]));
    }

    public function testEEPROMSituation(): void {
        $router = new Router;

        $router->route('OPTIONS', '/uploads/([A-Za-z0-9\-_]+)(?:\.(t|json))?', function() {});
        $router->route('GET', '/uploads/([A-Za-z0-9\-_]+)(?:\.(t|json))?', function() {});
        $router->route('DELETE', '/uploads/([A-Za-z0-9\-_]+)', function() {});

        $resolved = $router->resolve('DELETE', '/uploads/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA');

        $this->assertEquals(['OPTIONS', 'GET', 'DELETE'], $resolved->supportedMethods);
    }

    public function testFilterInterceptionOnRoot(): void {
        $router = new Router;
        $router->filter('/', fn() => 'expected');
        $router->route('GET', '/', fn() => 'unexpected');
        $router->route('GET', '/test', fn() => 'also unexpected');

        ob_start();
        $router->dispatch(new HttpRequest('1.1', [], NullStream::instance(), [], 'GET', HttpUri::createUri('/'), [], []));
        $this->assertEquals('expected', ob_get_clean());

        ob_start();
        $router->dispatch(new HttpRequest('1.1', [], NullStream::instance(), [], 'GET', HttpUri::createUri('/test'), [], []));
        $this->assertEquals('expected', ob_get_clean());

        ob_start();
        $router->dispatch(new HttpRequest('1.1', [], NullStream::instance(), [], 'GET', HttpUri::createUri('/error'), [], []));
        $this->assertEquals('expected', ob_get_clean());
    }
}