Merge pull request #5 from reactphp-parallel/support-an-array-of-middleware

Support an array of middleware

Author: WyriHaximus

src/Next.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace ReactParallel\Psr15Adapter;
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\MiddlewareInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+final class Next implements RequestHandlerInterface
+{
+    private MiddlewareInterface $middleware;
+    private RequestHandlerInterface $next;
+
+    public function __construct(MiddlewareInterface $middleware, RequestHandlerInterface $next)
+    {
+        $this->middleware = $middleware;
+        $this->next       = $next;
+    }
+
+    public function handle(ServerRequestInterface $request): ResponseInterface
+    {
+        return $this->middleware->process($request, $this->next);
+    }
+}

src/ReactMiddleware.php

@@ -26,19 +26,19 @@ final class ReactMiddleware
     private WorkerPool $workerPool;
 
     public function __construct(
+        LoopInterface $loop,
+        EventLoopBridge $eventLoopBridge,
         Factory $streamFactory,
         LowLevelPoolInterface $pool,
-        MiddlewareInterface $middleware,
-        LoopInterface $loop,
-        EventLoopBridge $eventLoopBridge
+        MiddlewareInterface ...$middleware
     ) {
         $this->streamFactory = $streamFactory;
         $this->workerPool    = new WorkerPool(
             $loop,
             $eventLoopBridge,
             $pool,
             new WorkerFactory(
-                $middleware
+                ...$middleware
             ),
             (int) '13'
         );

src/Worker.php

@@ -8,13 +8,15 @@
 use ReactParallel\Pool\Worker\Work;
 use ReactParallel\Pool\Worker\Work\Worker as WorkerContract;
 
+use function array_reverse;
 use function assert;
 
 final class Worker implements WorkerContract
 {
-    private MiddlewareInterface $middleware;
+    /** @var MiddlewareInterface[] */
+    private array $middleware;
 
-    public function __construct(MiddlewareInterface $middleware)
+    public function __construct(MiddlewareInterface ...$middleware)
     {
         $this->middleware = $middleware;
     }
@@ -27,6 +29,11 @@ public function perform(Work $workWrapper): Response
         $input   = $work->input();
         $output  = $work->output();
 
-        return new Response($this->middleware->process($request, new Psr15RequestHandlerAdapter($input, $output)));
+        $requestHandler = new Psr15RequestHandlerAdapter($input, $output);
+        foreach (array_reverse($this->middleware) as $middleware) {
+            $requestHandler = new Next($middleware, $requestHandler);
+        }
+
+        return new Response($requestHandler->handle($request));
     }
 }

src/WorkerFactory.php

@@ -15,13 +15,13 @@ final class WorkerFactory implements WorkerFactoryContract
 {
     private string $middleware;
 
-    public function __construct(MiddlewareInterface $middleware)
+    public function __construct(MiddlewareInterface ...$middleware)
     {
         $this->middleware = serialize($middleware);
     }
 
     public function construct(): WorkerContract
     {
-        return new Worker(unserialize($this->middleware));
+        return new Worker(...unserialize($this->middleware));
     }
 }

tests/AnotherPsr15MiddlewareStub.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace ReactParallel\Tests\Psr15Adapter;
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\MiddlewareInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+use function Safe\sleep;
+
+/**
+ * @internal
+ */
+final class AnotherPsr15MiddlewareStub implements MiddlewareInterface
+{
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        sleep(1);
+
+        return $handler->handle($request)->withAddedHeader('__CLASS__', self::class);
+    }
+}

tests/ReactMiddlewareTest.php

@@ -20,6 +20,7 @@
 
 use function assert;
 use function bin2hex;
+use function implode;
 use function iterator_to_array;
 use function random_bytes;
 use function React\Promise\resolve;
@@ -39,7 +40,8 @@ public function handle(): void
         $eventLoopBridge = new EventLoopBridge($loop);
         $pool            = new Infinite($loop, $eventLoopBridge, 10);
         $stub            = new Psr15MiddlewareStub();
-        $middleware      = new ReactMiddleware(new StreamFactory($eventLoopBridge), $pool, $stub, $loop, $eventLoopBridge);
+        $anotherStub     = new AnotherPsr15MiddlewareStub();
+        $middleware      = new ReactMiddleware($loop, $eventLoopBridge, new StreamFactory($eventLoopBridge), $pool, $stub, $stub, $anotherStub);
         $request         = new ServerRequest('GET', 'https://example.com/');
         $request         = $request->withAttribute('body', $rnd);
 
@@ -66,7 +68,7 @@ static function (ServerRequestInterface $request): PromiseInterface {
             Info::SIZE  => 1,
         ], iterator_to_array($pool->info()));
 
-        $response = $this->await($promise, $loop, 3.3);
+        $response = $this->await($promise, $loop, 9.9);
         assert($response instanceof ResponseInterface);
 
         self::assertSame([
@@ -79,7 +81,10 @@ static function (ServerRequestInterface $request): PromiseInterface {
 
         self::assertSame(666, $response->getStatusCode());
         self::assertSame($rnd, $response->getBody()->getContents());
-        self::assertSame(Psr15MiddlewareStub::class, $response->getHeaderLine('__CLASS__'));
+        self::assertSame(
+            implode(', ', [AnotherPsr15MiddlewareStub::class, Psr15MiddlewareStub::class, Psr15MiddlewareStub::class]),
+            $response->getHeaderLine('__CLASS__')
+        );
 
         $middleware->__destruct();
 

tests/ResponseMiddlewareStub.php

@@ -17,6 +17,6 @@ final class ResponseMiddlewareStub implements MiddlewareInterface
 {
     public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
     {
-        return new Response();
+        return (new Response())->withAddedHeader('__CLASS__', self::class);
     }
 }

tests/WorkerTest.php

@@ -13,6 +13,7 @@
 use WyriHaximus\AsyncTestUtilities\AsyncTestCase;
 
 use function assert;
+use function implode;
 
 /**
  * @internal
@@ -24,11 +25,16 @@ final class WorkerTest extends AsyncTestCase
      */
     public function handle(): void
     {
-        $channel  = new Channel(Channel::Infinite);
-        $request  = $this->prophesize(ServerRequestInterface::class)->reveal();
-        $stub     = new ResponseMiddlewareStub();
-        $response = (new WorkerFactory($stub))->construct()->perform(new Work(new Request($request, $channel, $channel)));
+        $channel                = new Channel(Channel::Infinite);
+        $request                = $this->prophesize(ServerRequestInterface::class)->reveal();
+        $responseMiddlewareStub = new ResponseMiddlewareStub();
+        $stub                   = new Psr15MiddlewareStub();
+        $response               = (new WorkerFactory($stub, $stub, $responseMiddlewareStub))->construct()->perform(new Work(new Request($request, $channel, $channel)));
         assert($response instanceof Response);
         self::assertSame(200, $response->result()->getStatusCode());
+        self::assertSame(
+            implode(', ', [ResponseMiddlewareStub::class, Psr15MiddlewareStub::class, Psr15MiddlewareStub::class]),
+            $response->result()->getHeaderLine('__CLASS__')
+        );
     }
 }