Merge pull request #13 from FranklinEkemezie/dev

Improved Routing and Request handling functionalities

Author: FranklinEkemezie

app/Core/App.php

@@ -4,6 +4,9 @@
 
 use PHPAether\Core\HTTP\Request;
 use PHPAether\Core\HTTP\Router;
+use PHPAether\Exceptions\Exception;
+use PHPAether\Exceptions\RouterExceptions\MethodNotAllowedException;
+use PHPAether\Exceptions\RouterExceptions\RouteNotFoundException;
 use PHPAether\Exceptions\RouterExceptions\RouterException;
 use PHPAether\Utils\Config;
 
@@ -18,16 +21,41 @@ public function __construct(
     }
 
     /**
-     * @throws RouterException
+     * @throws Exception
      */
     public function run(Request $request): string
     {
-        // Route requests
-        [
-            'middlewares'   => $middlewares,
-            'action'        => $action,
-            'params'        => $params
-        ] = $this->router->route($request);
+
+        try {
+
+            // Route requests
+            [
+                'middlewares'   => $middlewares,
+                'action'        => $action,
+                'params'        => $params
+            ] = $this->router->route($request);
+        } catch (MethodNotAllowedException $exception) {
+            // TODO: Handle method not allowed exception
+
+            return "Method Not Allowed\n";
+        } catch (RouteNotFoundException $exception) {
+            // TODO: Handle route not found exception
+
+            return "Route Not Found Exception";
+        } catch (RouterException $exception) {
+            // TODO: Handle general router exception
+
+            return "An error occurred while routing";
+        } catch (Exception $exception) {
+            // TODO: Handle any exception
+
+            return "An error occurred";
+        }
+
+        // Ensure the action is callable
+        if (! is_callable($action)) {
+            throw new Exception("Invalid request handler. Route action is not callable");
+        }
 
         // Resolve middlewares
         foreach ($middlewares as $middleware) {
@@ -36,6 +64,6 @@ public function run(Request $request): string
             $middleware->resolve();
         }
 
-        return $action($request, ...$params);
+        return $action($request);
     }
 }

app/Core/HTTP/Request.php

@@ -12,9 +12,23 @@
 class Request
 {
 
+    /**
+     * @var string The request path
+     */
     public readonly string $path;
+    /**
+     * @var HTTPRequestMethod The request method
+     */
     public readonly HTTPRequestMethod $method;
+    /**
+     * @var RequestType The request type
+     */
     public readonly RequestType $type;
+    /**
+     * @var array The request data.
+     * Stores the URL placeholder values, query parameter and `$_GET` values
+     */
+    public readonly array $data;
 
     /**
      * @throws Exception
@@ -35,13 +49,47 @@ public function __construct(?array $serverVariables=null, RequestType $requestTy
 
         $routeInfo = parse_url($requestUri);
         if ($routeInfo === false) {
-            throw new Exception('Could not parse request url. URL may be malformed');
+            throw new \InvalidArgumentException('Could not parse request url. URL may be malformed');
         }
 
+        // Parse the query parameters
+        $queryParams = [];
+        parse_str($routeInfo['query'] ?? '', $queryParams);
+
         $this->path     = (string) $routeInfo['path'];
         $this->method   = HTTPRequestMethod::tryFrom(strtoupper($requestMethod));
         $this->type     = $requestType;
+        $this->data     = array_merge($queryParams, $_GET);
+    }
+
+    /**
+     * Get a request data
+     * @param string|null $key
+     * @return array
+     */
+    public function getData(?string $key=null): array
+    {
+        if (is_null($key)) return $this->data;
+        if (! isset($this->data[$key])) {
+            throw new \InvalidArgumentException("No data found with key: $key");
+        }
+
+        return $this->data[$key];
     }
 
+    /**
+     * Set request data
+     * @param array $data
+     * @return $this
+     */
+    public function setData(array $data): self
+    {
+        if (empty($data) || array_is_list($data)) {
+            throw new \InvalidArgumentException('Invalid data provided');
+        }
+
+        $this->data = array_merge($this->data, $data);
+        return $this;
+    }
 
 }

app/Core/HTTP/Router.php

@@ -348,12 +348,16 @@ private function matchRequestPathToRoute(string $path, string $route): array|fal
      * @throws MethodNotAllowedException
      * @throws RouteNotFoundException
      */
-    public function route(Request $request): array
+    public function route(Request &$request): array
     {
         $routes = $this->getRegisteredRoutes($request->type, $request->method);
         foreach ($routes as $route => $routeInfo) {
             $params = $this->matchRequestPathToRoute($request->path, $route);
             if ($params !== false) {
+
+                // Set the params as part of request data
+                $request->setData($params);
+
                 return [
                     'route'         => $route,
                     'action'        => $routeInfo['action'],

tests/MockHTTPRequestTestCase.php

@@ -14,22 +14,37 @@ public static function mockHTTPRequestTestCases(): \Generator
         foreach ($testUrls as $requestMethod => $testUrlTestCases) {
 
             foreach ($testUrlTestCases as $testUrlTestCase) {
-                $testUrlTestCase['method'] = $requestMethod;
 
-                $url = $testUrlTestCase['url'];
-                yield "[$requestMethod] $url" => $testUrlTestCase;
+                $url            = $testUrlTestCase['url'];
+                $data           = $testUrlTestCase['info']['data'] ?? [];
+                $requestBuilder = fn(self $testCase): Request => (
+                    $testCase->createMockRequest($url, $requestMethod, $data)
+                );
+
+                yield "[$requestMethod] $url" => [
+                    'requestBuilder'    => $requestBuilder,
+                    'expected'          => $testUrlTestCase['expected']
+                ];
             }
         }
     }
 
-    public function createMockRequest(string $url, string $method): Request&MockObject
+    public function createMockRequest(string $url, string $method, array $data=[]): Request&MockObject
     {
         // Prepare server variables
         $_SERVER['REQUEST_URI'] = $url;
         $_SERVER['REQUEST_METHOD'] = $method;
 
+        if ($method === 'GET') $_GET = $data;
+        else $_POST = $data;
+
         return $this->getMockBuilder(Request::class)
             ->setConstructorArgs([$_SERVER])
             ->getMock();
     }
+
+    public static function getExpectedValue(array $expected, string $category, string $key, mixed $default=null): mixed
+    {
+        return $expected[$category][$key] ?? $default;
+    }
 }

tests/Unit/Core/HTTP/RequestTest.php

@@ -1,7 +1,8 @@
 <?php
 
-namespace Core\HTTP;
+namespace PHPAether\Tests\Unit\Core\HTTP;
 
+use Exception;
 use PHPAether\Core\HTTP\Request;
 use PHPAether\Tests\MockHTTPRequestTestCase;
 use PHPUnit\Framework\Attributes\DataProvider;
@@ -10,33 +11,41 @@
 class RequestTest extends MockHTTPRequestTestCase
 {
 
-    public static function requestTestCases(): array
+    /**
+     * @throws Exception
+     */
+    public static function getRequest(string $url, string $method): Request
+    {
+        $_SERVER['REQUEST_URI']     = $url;
+        $_SERVER['REQUEST_METHOD']  = $method;
+
+        return new Request($_SERVER);
+    }
+
+    /**
+     * @throws Exception
+     */
+    #[Test]
+    #[DataProvider('mockHTTPRequestTestCases')]
+    public function it_gets_route_path(callable $requestBuilder, array $expected): void
     {
-        return [
-            ['/', 'GET', '/'],
-            ['/login?r_url=/user/dashboard', 'POST', '/login'],
-            ['/auth/otp/verify', 'GET', '/auth/otp/verify'],
-            ['/user/profile', 'PUT', '/user/profile']
-        ];
+        $expectedPath = static::getExpectedValue($expected, 'request', 'path');
+        $this->assertSame($expectedPath, $requestBuilder($this)->path);
     }
 
     /**
-     * @throws \Exception
+     * @throws Exception
      */
     #[Test]
-    #[DataProvider('requestTestCases')]
-    public function it_gets_route_path(
-        string $requestUri,
-        string $requestMethod,
-        string $expectedRoutePath
-    )
+    #[DataProvider('mockHTTPRequestTestCases')]
+    public function it_gets_route_params(callable $requestBuilder, array $expected): void
     {
-        $_SERVER['REQUEST_METHOD'] = $requestMethod;
-        $_SERVER['REQUEST_URI'] = $requestUri;
+        $expectedParams = static::getExpectedValue($expected, 'request', 'params', []);
 
-        $request = new Request($_SERVER);
+        $request = $requestBuilder($this);
+        static::$APP->router->route($request);
 
-        $this->assertSame($expectedRoutePath, $request->path);
+        $this->assertSame($expectedParams, $request->getData);
     }
 
 }

tests/Unit/Core/HTTP/RouterTest.php

@@ -11,7 +11,6 @@
 use PHPAether\Tests\MockHTTPRequestTestCase;
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\Attributes\Test;
-use PHPUnit\Framework\MockObject\Exception;
 
 class RouterTest extends MockHTTPRequestTestCase
 {
@@ -126,17 +125,19 @@ public function it_registers_cli_routes_from_file(): void
     }
 
     /**
-     * @throws Exception
-     * @throws RouterException
+     * @param callable $requestBuilder
+     * @param array|null $expected
+     * @throws MethodNotAllowedException
+     * @throws RouteNotFoundException
      */
     #[Test]
     #[DataProvider('mockHTTPRequestTestCases')]
-    public function it_routes_request_to_route(string $url, string $method, ?array $expected=[])
+    public function it_routes_request_to_route(callable $requestBuilder, ?array $expected=[])
     {
         $expectedRoute = $expected['router']['route'] ?? null;
 
         // Mock a request object; register routes
-        $request = $this->createMockRequest($url, $method);
+        $request = $requestBuilder($this);
         $this->router->registerRoutesFromFiles(TESTS_DIR . '/config/routes');
 
         $actualRoute = $this->router->route($request)['route'];
@@ -166,7 +167,8 @@ public function it_throws_method_not_allowed_for_invalid_routes(): void
     public function it_throws_route_not_found_for_invalid_routes(): void
     {
         $this->expectException(RouteNotFoundException::class);
-        $this->router->route($this->createMockRequest('/tests/some/products/2', 'GET'));
+        $request = $this->createMockRequest('/tests/some/products/2', 'GET');
+        $this->router->route($request);
     }
 
     /**
@@ -177,10 +179,8 @@ public function it_matches_wildcard_route(): void
     {
         // Register a wildcard route
         $this->router->get('/tests/books/:id', fn() => '');
-        $this->assertEquals(
-            ['id' => 5],
-            $this->router->route($this->createMockRequest('/tests/books/5', 'GET'))['params']
-        );
+        $request = $this->createMockRequest('/tests/books/5', 'GET');
 
+        $this->assertEquals(['id' => 5], $this->router->route($request)['params']);
     }
 }

tests/urls/DELETE.json

@@ -0,0 +1,3 @@
+[
+
+]