Added MiddlewareInterface to the request handler so it can be used either as RequestHandler or as middleware. Introduce BC break

Author: noglitchyo

README.md

@@ -10,10 +10,12 @@ Lightweight & dead simple PSR-15 Server Request Handler implementation to proces
 
 ### Description
 
-PSR-7 Request Handler implementing the [RequestHandlerInterface](https://github.com/php-fig/http-server-handler/blob/master/src/RequestHandlerInterface.php) 
-and able to manage a collection of Middlewares implementing the [MiddlewareInterface](https://github.com/php-fig/http-server-middleware/blob/master/src/MiddlewareInterface.php).
+PSR-15 request handler implementing both [RequestHandlerInterface](https://github.com/php-fig/http-server-handler/blob/master/src/RequestHandlerInterface.php) and [MiddlewareInterface](https://github.com/php-fig/http-server-middleware/blob/master/src/MiddlewareInterface.php)
+able to manage a collection of middlewares implementing the [MiddlewareInterface](https://github.com/php-fig/http-server-middleware/blob/master/src/MiddlewareInterface.php).
 
-It comes with a set of middleware collections using different strategy on how to provide the middlewares to the RequestHandler, and also provide a dead simple collection interface to implement in a glimpse your own strategy.
+It can be used either as a RequestHandler or as a Middleware to fit into any implementation.
+
+Comes with a set of middleware collections using different strategy (LIFO, FIFO...) on how the middlewares from the collection are provided to the RequestHandler, and also provides a simple MiddlewareCollectionInterface to implement in a glimpse your own strategy.
 
 ### Goals
 

src/RequestHandler.php

@@ -26,11 +26,13 @@
 
 namespace NoGlitchYo\MiddlewareCollectionRequestHandler;
 
+use LogicException;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\MiddlewareInterface;
 use Psr\Http\Server\RequestHandlerInterface;
 
-class RequestHandler implements RequestHandlerInterface
+class RequestHandler implements RequestHandlerInterface, MiddlewareInterface
 {
     use RequestHandlerTrait;
 
@@ -40,15 +42,15 @@ class RequestHandler implements RequestHandlerInterface
     private $middlewareCollection;
 
     /**
-     * @var RequestHandlerInterface
+     * @var RequestHandlerInterface|null
      */
     private $defaultRequestHandler;
 
     public function __construct(
-        RequestHandlerInterface $defaultRequestHandler,
-        MiddlewareCollectionInterface $middlewareCollection
+        MiddlewareCollectionInterface $middlewareCollection,
+        RequestHandlerInterface $defaultRequestHandler = null
     ) {
-        $this->middlewareCollection = $middlewareCollection;
+        $this->middlewareCollection  = $middlewareCollection;
         $this->defaultRequestHandler = $defaultRequestHandler;
     }
 
@@ -57,7 +59,7 @@ public static function fromCallable(
         MiddlewareCollectionInterface $middlewareCollection
     ): self {
         $defaultRequestHandler = static::createRequestHandlerFromCallable($callable);
-        return new static($defaultRequestHandler, $middlewareCollection);
+        return new static($middlewareCollection, $defaultRequestHandler);
     }
 
     public function __invoke(ServerRequestInterface $serverRequest): ResponseInterface
@@ -67,6 +69,12 @@ public function __invoke(ServerRequestInterface $serverRequest): ResponseInterfa
 
     public function handle(ServerRequestInterface $request): ResponseInterface
     {
+        if ($this->defaultRequestHandler === null) {
+            throw new LogicException(
+                'A default request handler must be defined if RequestHandler is used as a RequestHandler.'
+            );
+        }
+
         if ($this->middlewareCollection->isEmpty()) {
             return $this->defaultRequestHandler->handle($request);
         }
@@ -75,4 +83,15 @@ public function handle(ServerRequestInterface $request): ResponseInterface
 
         return $nextMiddleware->process($request, $this);
     }
+
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        if ($this->middlewareCollection->isEmpty()) {
+            return $handler->handle($request);
+        }
+
+        $nextMiddleware = $this->middlewareCollection->next();
+
+        return $nextMiddleware->process($request, $this);
+    }
 }

tests/RequestHandlerTest.php

@@ -25,6 +25,7 @@
 
 namespace NoGlitchYo\MiddlewareCollectionRequestHandler\Tests;
 
+use LogicException;
 use NoGlitchYo\MiddlewareCollectionRequestHandler\MiddlewareCollectionInterface;
 use NoGlitchYo\MiddlewareCollectionRequestHandler\RequestHandler;
 use Nyholm\Psr7\Response;
@@ -59,15 +60,15 @@ class RequestHandlerTest extends TestCase
 
     protected function setUp(): void
     {
-        $this->requestHandlerMock = $this->createMock(RequestHandlerInterface::class);
+        $this->requestHandlerMock       = $this->createMock(RequestHandlerInterface::class);
         $this->middlewareCollectionMock = $this->createMock(MiddlewareCollectionInterface::class);
 
-        $this->sut = new RequestHandler($this->requestHandlerMock, $this->middlewareCollectionMock);
+        $this->sut = new RequestHandler($this->middlewareCollectionMock, $this->requestHandlerMock);
     }
 
     public function testHandleDelegateToDefaultHandlerIfNoMiddleware()
     {
-        $request = new ServerRequest('GET', '/test');
+        $request  = new ServerRequest('GET', '/test');
         $response = new Response(404);
 
         $this->middlewareCollectionMock->method('isEmpty')
@@ -87,7 +88,7 @@ function (ServerRequestInterface $request) use ($response) {
 
     public function testIsCallable()
     {
-        $request = new ServerRequest('GET', '/test');
+        $request  = new ServerRequest('GET', '/test');
         $response = new Response(404);
 
         $this->middlewareCollectionMock->method('isEmpty')
@@ -136,15 +137,29 @@ public function testHandleCallNextMiddlewareWithInstanceOfThisAsHandler()
             ->method('next')
             ->willReturnOnConsecutiveCalls(
                 self::getMiddleware(false),
-                self::getMiddleware(true),
-                );
+                self::getMiddleware(true)
+            );
 
         $this->assertInstanceOf(ResponseInterface::class, $this->sut->handle($request));
     }
 
-    public function testFromCallableCreateDefaultRequestHandlerFromCallable()
+    public function testHandleThrowExceptionIfDefaultRequestHandlerIsNull()
     {
         $request = new ServerRequest('GET', '/test');
+
+        $this->middlewareCollectionMock = $this->createMock(MiddlewareCollectionInterface::class);
+
+        $sut = new RequestHandler($this->middlewareCollectionMock);
+
+        $this->expectException(LogicException::class);
+        $this->expectExceptionMessage('A default request handler must be defined if RequestHandler is used as a RequestHandler.');
+
+        $sut->handle($request);
+    }
+
+    public function testFromCallableCreateDefaultRequestHandlerFromCallable()
+    {
+        $request  = new ServerRequest('GET', '/test');
         $response = new Response(405);
         $callable = function () use ($response) {
             return $response;
@@ -158,5 +173,58 @@ public function testFromCallableCreateDefaultRequestHandlerFromCallable()
         $this->assertSame($response, $sut->handle($request));
     }
 
+    public function testProcessCallNextMiddleware()
+    {
+        $request = new ServerRequest('GET', '/test');
+
+        $this->middlewareCollectionMock
+            ->expects($this->once())
+            ->method('isEmpty')
+            ->willReturn(false);
 
+        $this->middlewareCollectionMock
+            ->expects($this->once())
+            ->method('next')
+            ->willReturn(self::getMiddleware(true));
+
+        $handler = new class implements RequestHandlerInterface
+        {
+            public function handle(ServerRequestInterface $request): ResponseInterface
+            {
+                return new Response();
+            }
+        };
+
+        $this->assertInstanceOf(ResponseInterface::class, $this->sut->process($request, $handler));
+    }
+
+
+    public function testProcessReturnAndDelegateToHandlerIfNoMiddleware()
+    {
+        $request  = new ServerRequest('GET', '/test');
+        $response = new Response(404);
+
+        $this->middlewareCollectionMock->method('isEmpty')
+            ->willReturn(true);
+
+        $handler = new class($response) implements RequestHandlerInterface
+        {
+            /**
+             * @var ResponseInterface
+             */
+            private $response;
+
+            public function __construct(ResponseInterface $response)
+            {
+                $this->response = $response;
+            }
+
+            public function handle(ServerRequestInterface $request): ResponseInterface
+            {
+                return $this->response;
+            }
+        };
+
+        $this->assertSame($response, $this->sut->process($request, $handler));
+    }
 }