Middleware Runner

Author: WyriHaximus

src/MiddlewareRunner.php

@@ -5,6 +5,8 @@
 use Psr\Http\Message\RequestInterface;
 use Psr\Http\Message\ResponseInterface;
 use React\Promise\CancellablePromiseInterface;
+use Throwable;
+use function React\Promise\reject;
 use function React\Promise\resolve;
 
 final class MiddlewareRunner
@@ -84,4 +86,26 @@ public function post(
 
         return $promise;
     }
+
+    /**
+     * @param Throwable $throwable
+     * @return CancellablePromiseInterface
+     */
+    public function error(
+        Throwable $throwable
+    ): CancellablePromiseInterface {
+
+        $promise = reject($throwable);
+
+        $this->middlewares = array_reverse($this->middlewares);
+
+        foreach ($this->middlewares as $middleware) {
+            $errorMiddleware = $middleware;
+            $promise = $promise->then(null, function (Throwable $throwable) use ($errorMiddleware) {
+                return reject($errorMiddleware->error($throwable, $this->options));
+            });
+        }
+
+        return $promise;
+    }
 }

tests/MiddlewareRunnerTest.php

@@ -2,13 +2,15 @@
 
 namespace ApiClients\Tests\Foundation\Middleware;
 
-use ApiClients\Foundation\Middleware\MiddlewareRunner;
 use ApiClients\Foundation\Middleware\MiddlewareInterface;
+use ApiClients\Foundation\Middleware\MiddlewareRunner;
 use ApiClients\Tools\TestUtilities\TestCase;
-use function Clue\React\Block\await;
+use Exception;
 use GuzzleHttp\Psr7\Request;
 use GuzzleHttp\Psr7\Response;
 use Phake;
+use function Clue\React\Block\await;
+use function React\Promise\reject;
 use function React\Promise\resolve;
 
 class MiddlewareRunnerTest extends TestCase
@@ -17,22 +19,26 @@ public function testAll()
     {
         $request = new Request('GET', 'https://example.com/');
         $response = new Response(200);
+        $exception = new Exception();
         $options = [];
 
         $middlewareOne = Phake::mock(MiddlewareInterface::class);
         Phake::when($middlewareOne)->priority()->thenReturn(1000);
         Phake::when($middlewareOne)->pre($request, $options)->thenReturn(resolve($request));
         Phake::when($middlewareOne)->post($response, $options)->thenReturn(resolve($response));
+        Phake::when($middlewareOne)->error($exception, $options)->thenReturn(reject($exception));
 
         $middlewareTwo = Phake::mock(MiddlewareInterface::class);
         Phake::when($middlewareTwo)->priority()->thenReturn(500);
         Phake::when($middlewareTwo)->pre($request, $options)->thenReturn(resolve($request));
         Phake::when($middlewareTwo)->post($response, $options)->thenReturn(resolve($response));
+        Phake::when($middlewareTwo)->error($exception, $options)->thenReturn(reject($exception));
 
         $middlewareThree = Phake::mock(MiddlewareInterface::class);
         Phake::when($middlewareThree)->priority()->thenReturn(0);
         Phake::when($middlewareThree)->pre($request, $options)->thenReturn(resolve($request));
         Phake::when($middlewareThree)->post($response, $options)->thenReturn(resolve($response));
+        Phake::when($middlewareThree)->error($exception, $options)->thenReturn(reject($exception));
 
         $args = [
             $options,
@@ -44,14 +50,18 @@ public function testAll()
         $executioner = new MiddlewareRunner(...$args);
         $executioner->pre($request);
         $executioner->post($response);
+        $executioner->error($exception);
 
         Phake::inOrder(
             Phake::verify($middlewareOne)->pre($request, $options),
             Phake::verify($middlewareTwo)->pre($request, $options),
             Phake::verify($middlewareThree)->pre($request, $options),
             Phake::verify($middlewareThree)->post($response, $options),
             Phake::verify($middlewareTwo)->post($response, $options),
-            Phake::verify($middlewareOne)->post($response, $options)
+            Phake::verify($middlewareOne)->post($response, $options),
+            Phake::verify($middlewareOne)->error($exception, $options),
+            Phake::verify($middlewareTwo)->error($exception, $options),
+            Phake::verify($middlewareThree)->error($exception, $options)
         );
     }
 }