index/tests/RouterTest.php

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

declare(strict_types=1);

use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use Index\Http\{HttpHeaders,HttpResponseBuilder,HttpRequest,HttpUri,NullStream};
use Index\Http\Routing\{
    ExactRoute,
    FilterInfo,
    PatternRoute,PrefixFilter,
    RouteInfo,RouteHandler,RouteHandlerCommon,Router
};

/**
 * 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(Router::class)]
#[CoversClass(RouteInfo::class)]
#[CoversClass(PrefixFilter::class)]
#[CoversClass(ExactRoute::class)]
#[CoversClass(RouteHandler::class)]
#[CoversClass(RouteHandlerCommon::class)]
#[CoversClass(PatternRoute::class)]
#[CoversClass(FilterInfo::class)]
final class RouterTest extends TestCase {
    public function testRouter(): void {
        $router1 = new Router;

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

        $this->assertEquals('get', (string)$router1->handle(new HttpRequest('1.1', [], NullStream::instance(), [], 'GET', HttpUri::createUri('/'), [], []))->getBody());
        $this->assertEquals('wacky', (string)$router1->handle(new HttpRequest('1.1', [], NullStream::instance(), [], 'CUSTOM', HttpUri::createUri('/'), [], []))->getBody());

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

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

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

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

        $this->assertEquals('warioware below static', (string)$router1->handle(new HttpRequest('1.1', [], NullStream::instance(), [], 'GET', HttpUri::createUri('/user/static/below'), [], []))->getBody());

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

        $this->assertEquals('meow', (string)$router2->handle(new HttpRequest('1.1', [], NullStream::instance(), [], 'GET', HttpUri::createUri('/rules'), [], []))->getBody());
    }

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

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

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

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

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

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

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

            #[PatternRoute('GET', '/profile/([A-Za-z0-9]+)')]
            public function getPattern(string $beans): string {
                return sprintf('profile of %s', $beans);
            }

            #[PatternRoute('GET', '#^/profile-but-raw/([A-Za-z0-9]+)$#uD', raw: true)]
            public function getPatternRaw(string $beans): string {
                return sprintf('still the profile of %s', $beans);
            }

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

        $router->register($handler);

        $this->assertEquals('index', (string)$router->handle(new HttpRequest('1.1', [], NullStream::instance(), [], 'GET', HttpUri::createUri('/'), [], []))->getBody());
        $this->assertEquals('avatar', (string)$router->handle(new HttpRequest('1.1', [], NullStream::instance(), [], 'POST', HttpUri::createUri('/avatar'), [], []))->getBody());
        $this->assertEquals('static', (string)$router->handle(new HttpRequest('1.1', [], NullStream::instance(), [], 'PUT', HttpUri::createUri('/static'), [], []))->getBody());
        $this->assertEquals('meow', (string)$router->handle(new HttpRequest('1.1', [], NullStream::instance(), [], 'GET', HttpUri::createUri('/meow'), [], []))->getBody());
        $this->assertEquals('meow', (string)$router->handle(new HttpRequest('1.1', [], NullStream::instance(), [], 'POST', HttpUri::createUri('/meow'), [], []))->getBody());
        $this->assertEquals('profile of Cool134', (string)$router->handle(new HttpRequest('1.1', [], NullStream::instance(), [], 'GET', HttpUri::createUri('/profile/Cool134'), [], []))->getBody());
        $this->assertEquals('still the profile of Cool134', (string)$router->handle(new HttpRequest('1.1', [], NullStream::instance(), [], 'GET', HttpUri::createUri('/profile-but-raw/Cool134'), [], []))->getBody());
    }

    public function testEEPROMSituation(): void {
        $router = new Router;
        $router->route(RouteInfo::pattern('GET', '#^/uploads/([A-Za-z0-9\-_]+)(?:\.(t|json))?$#uD', fn(string $id) => "Get {$id}"));
        $router->route(RouteInfo::pattern('DELETE', '#^/uploads/([A-Za-z0-9\-_]+)$#uD', fn(string $id) => "Delete {$id}"));

        // make sure both GET and DELETE are able to execute with a different pattern
        $this->assertEquals('Get AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', (string)$router->handle(new HttpRequest('1.1', [], NullStream::instance(), [], 'GET', HttpUri::createUri('/uploads/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'), [], []))->getBody());
        $this->assertEquals('Delete BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB', (string)$router->handle(new HttpRequest('1.1', [], NullStream::instance(), [], 'DELETE', HttpUri::createUri('/uploads/BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB'), [], []))->getBody());
    }

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

        $this->assertEquals('expected', (string)$router->handle(new HttpRequest('1.1', [], NullStream::instance(), [], 'GET', HttpUri::createUri('/'), [], []))->getBody());
        $this->assertEquals('expected', (string)$router->handle(new HttpRequest('1.1', [], NullStream::instance(), [], 'GET', HttpUri::createUri('/test'), [], []))->getBody());
        $this->assertEquals('expected', (string)$router->handle(new HttpRequest('1.1', [], NullStream::instance(), [], 'GET', HttpUri::createUri('/error'), [], []))->getBody());
    }

    public function testDefaultOptionsImplementation(): void {
        $router = new Router;
        $router->route(RouteInfo::exact('GET', '/test', fn() => 'get'));
        $router->route(RouteInfo::exact('POST', '/test', fn() => 'post'));
        $router->route(RouteInfo::exact('PATCH', '/test', fn() => 'patch'));

        $response = $router->handle(new HttpRequest('1.1', [], NullStream::instance(), [], 'OPTIONS', HttpUri::createUri('/test'), [], []));
        $this->assertEquals(204, $response->getStatusCode());
        $this->assertEquals('No Content', $response->getReasonPhrase());
        $this->assertEquals('GET, HEAD, OPTIONS, PATCH, POST', $response->getHeaderLine('Allow'));
    }
}