Migrated BodyParserMiddleware to psr-15 middleware

module/Core/test/Action/PreviewActionTest.php

@@ -1,16 +1,15 @@
 <?php
 namespace ShlinkioTest\Shlink\Core\Action;
 
+use Interop\Http\ServerMiddleware\DelegateInterface;
 use PHPUnit\Framework\TestCase;
 use Prophecy\Argument;
 use Prophecy\Prophecy\ObjectProphecy;
-use Shlinkio\Shlink\Common\Exception\PreviewGenerationException;
 use Shlinkio\Shlink\Common\Service\PreviewGenerator;
 use Shlinkio\Shlink\Core\Action\PreviewAction;
 use Shlinkio\Shlink\Core\Exception\InvalidShortCodeException;
 use Shlinkio\Shlink\Core\Service\UrlShortener;
 use ShlinkioTest\Shlink\Common\Util\TestUtils;
-use Zend\Diactoros\Response;
 use Zend\Diactoros\ServerRequestFactory;
 
 class PreviewActionTest extends TestCase
@@ -42,14 +41,13 @@ class PreviewActionTest extends TestCase
     {
         $shortCode = 'abc123';
         $this->urlShortener->shortCodeToUrl($shortCode)->willReturn(null)->shouldBeCalledTimes(1);
-        $delegate = TestUtils::createDelegateMock();
+        $delegate = $this->prophesize(DelegateInterface::class);
+        $delegate->process(Argument::cetera())->shouldBeCalledTimes(1);
 
         $this->action->process(
             ServerRequestFactory::fromGlobals()->withAttribute('shortCode', $shortCode),
             $delegate->reveal()
         );
-
-        $delegate->process(Argument::cetera())->shouldHaveBeenCalledTimes(1);
     }
 
     /**
@@ -75,12 +73,12 @@ class PreviewActionTest extends TestCase
     /**
      * @test
      */
-    public function invalidShortcodeExceptionFallsBackToNextMiddleware()
+    public function invalidShortCodeExceptionFallsBackToNextMiddleware()
     {
         $shortCode = 'abc123';
         $this->urlShortener->shortCodeToUrl($shortCode)->willThrow(InvalidShortCodeException::class)
                                                        ->shouldBeCalledTimes(1);
-        $delegate = TestUtils::createDelegateMock();
+        $delegate = $this->prophesize(DelegateInterface::class);
 
         $this->action->process(
             ServerRequestFactory::fromGlobals()->withAttribute('shortCode', $shortCode),

module/Core/test/Action/QrCodeActionTest.php

@@ -1,6 +1,7 @@
 <?php
 namespace ShlinkioTest\Shlink\Core\Action;
 
+use Interop\Http\ServerMiddleware\DelegateInterface;
 use PHPUnit\Framework\TestCase;
 use Prophecy\Argument;
 use Prophecy\Prophecy\ObjectProphecy;
@@ -9,7 +10,6 @@ use Shlinkio\Shlink\Core\Action\QrCodeAction;
 use Shlinkio\Shlink\Core\Entity\ShortUrl;
 use Shlinkio\Shlink\Core\Exception\InvalidShortCodeException;
 use Shlinkio\Shlink\Core\Service\UrlShortener;
-use ShlinkioTest\Shlink\Common\Util\TestUtils;
 use Zend\Diactoros\ServerRequestFactory;
 use Zend\Expressive\Router\RouterInterface;
 
@@ -41,7 +41,7 @@ class QrCodeActionTest extends TestCase
     {
         $shortCode = 'abc123';
         $this->urlShortener->shortCodeToUrl($shortCode)->willReturn(null)->shouldBeCalledTimes(1);
-        $delegate = TestUtils::createDelegateMock();
+        $delegate = $this->prophesize(DelegateInterface::class);
 
         $this->action->process(
             ServerRequestFactory::fromGlobals()->withAttribute('shortCode', $shortCode),
@@ -59,7 +59,7 @@ class QrCodeActionTest extends TestCase
         $shortCode = 'abc123';
         $this->urlShortener->shortCodeToUrl($shortCode)->willThrow(InvalidShortCodeException::class)
                                                        ->shouldBeCalledTimes(1);
-        $delegate = TestUtils::createDelegateMock();
+        $delegate = $this->prophesize(DelegateInterface::class);
 
         $this->action->process(
             ServerRequestFactory::fromGlobals()->withAttribute('shortCode', $shortCode),
@@ -76,7 +76,7 @@ class QrCodeActionTest extends TestCase
     {
         $shortCode = 'abc123';
         $this->urlShortener->shortCodeToUrl($shortCode)->willReturn(new ShortUrl())->shouldBeCalledTimes(1);
-        $delegate = TestUtils::createDelegateMock();
+        $delegate = $this->prophesize(DelegateInterface::class);
 
         $resp = $this->action->process(
             ServerRequestFactory::fromGlobals()->withAttribute('shortCode', $shortCode),

module/Core/test/Action/RedirectActionTest.php

@@ -1,6 +1,7 @@
 <?php
 namespace ShlinkioTest\Shlink\Core\Action;
 
+use Interop\Http\ServerMiddleware\DelegateInterface;
 use PHPUnit\Framework\TestCase;
 use Prophecy\Argument;
 use Prophecy\Prophecy\ObjectProphecy;
@@ -57,7 +58,7 @@ class RedirectActionTest extends TestCase
         $shortCode = 'abc123';
         $this->urlShortener->shortCodeToUrl($shortCode)->willReturn(null)
                            ->shouldBeCalledTimes(1);
-        $delegate = TestUtils::createDelegateMock();
+        $delegate = $this->prophesize(DelegateInterface::class);
 
         $request = ServerRequestFactory::fromGlobals()->withAttribute('shortCode', $shortCode);
         $this->action->process($request, $delegate->reveal());
@@ -73,7 +74,7 @@ class RedirectActionTest extends TestCase
         $shortCode = 'abc123';
         $this->urlShortener->shortCodeToUrl($shortCode)->willThrow(\Exception::class)
                                                        ->shouldBeCalledTimes(1);
-        $delegate = TestUtils::createDelegateMock();
+        $delegate = $this->prophesize(DelegateInterface::class);
 
         $request = ServerRequestFactory::fromGlobals()->withAttribute('shortCode', $shortCode);
         $this->action->process($request, $delegate->reveal());

module/Core/test/Middleware/QrCodeCacheMiddlewareTest.php

@@ -3,10 +3,10 @@ namespace ShlinkioTest\Shlink\Core\Middleware;
 
 use Doctrine\Common\Cache\ArrayCache;
 use Doctrine\Common\Cache\Cache;
+use Interop\Http\ServerMiddleware\DelegateInterface;
 use PHPUnit\Framework\TestCase;
 use Prophecy\Argument;
 use Shlinkio\Shlink\Core\Middleware\QrCodeCacheMiddleware;
-use ShlinkioTest\Shlink\Common\Util\TestUtils;
 use Zend\Diactoros\Response;
 use Zend\Diactoros\ServerRequestFactory;
 use Zend\Diactoros\Uri;
@@ -33,13 +33,14 @@ class QrCodeCacheMiddlewareTest extends TestCase
      */
     public function noCachedPathFallsBackToNextMiddleware()
     {
-        $delegate = TestUtils::createDelegateMock();
+        $delegate = $this->prophesize(DelegateInterface::class);
+        $delegate->process(Argument::any())->willReturn(new Response())->shouldBeCalledTimes(1);
+
         $this->middleware->process(ServerRequestFactory::fromGlobals()->withUri(
             new Uri('/foo/bar')
         ), $delegate->reveal());
 
         $this->assertTrue($this->cache->contains('/foo/bar'));
-        $delegate->process(Argument::any())->shouldHaveBeenCalledTimes(1);
     }
 
     /**
@@ -50,7 +51,7 @@ class QrCodeCacheMiddlewareTest extends TestCase
         $isCalled = false;
         $uri = (new Uri())->withPath('/foo');
         $this->cache->save('/foo', ['body' => 'the body', 'content-type' => 'image/png']);
-        $delegate = TestUtils::createDelegateMock();
+        $delegate = $this->prophesize(DelegateInterface::class);
 
         $resp = $this->middleware->process(
             ServerRequestFactory::fromGlobals()->withUri($uri),

module/Rest/src/Middleware/BodyParserMiddleware.php

@@ -1,55 +1,45 @@
 <?php
 namespace Shlinkio\Shlink\Rest\Middleware;
 
+use Fig\Http\Message\RequestMethodInterface;
+use Interop\Http\ServerMiddleware\DelegateInterface;
+use Interop\Http\ServerMiddleware\MiddlewareInterface;
 use Psr\Http\Message\ResponseInterface as Response;
 use Psr\Http\Message\ServerRequestInterface as Request;
 use Shlinkio\Shlink\Common\Exception\RuntimeException;
-use Zend\Stratigility\MiddlewareInterface;
 
-class BodyParserMiddleware implements MiddlewareInterface
+class BodyParserMiddleware implements MiddlewareInterface, RequestMethodInterface
 {
     /**
-     * Process an incoming request and/or response.
+     * Process an incoming server request and return a response, optionally delegating
-     *
+     * to the next middleware component to create the response.
-     * Accepts a server-side request and a response instance, and does
-     * something with them.
-     *
-     * If the response is not complete and/or further processing would not
-     * interfere with the work done in the middleware, or if the middleware
-     * wants to delegate to another process, it can use the `$out` callable
-     * if present.
-     *
-     * If the middleware does not return a value, execution of the current
-     * request is considered complete, and the response instance provided will
-     * be considered the response to return.
-     *
-     * Alternately, the middleware may return a response instance.
-     *
-     * Often, middleware will `return $out();`, with the assumption that a
-     * later middleware will return a response.
      *
      * @param Request $request
-     * @param Response $response
+     * @param DelegateInterface $delegate
-     * @param null|callable $out
+     *
-     * @return null|Response
+     * @return Response
      */
-    public function __invoke(Request $request, Response $response, callable $out = null)
+    public function process(Request $request, DelegateInterface $delegate)
     {
         $method = $request->getMethod();
         $currentParams = $request->getParsedBody();
 
         // In requests that do not allow body or if the body has already been parsed, continue to next middleware
-        if (in_array($method, ['GET', 'HEAD', 'OPTIONS']) || ! empty($currentParams)) {
+        if (! empty($currentParams) || in_array($method, [
-            return $out($request, $response);
+            self::METHOD_GET,
+            self::METHOD_HEAD,
+            self::METHOD_OPTIONS
+        ], true)) {
+            return $delegate->process($request);
         }
 
         // If the accepted content is JSON, try to parse the body from JSON
         $contentType = $this->getRequestContentType($request);
-        if (in_array($contentType, ['application/json', 'text/json', 'application/x-json'])) {
+        if (in_array($contentType, ['application/json', 'text/json', 'application/x-json'], true)) {
-            return $out($this->parseFromJson($request), $response);
+            return $delegate->process($this->parseFromJson($request));
         }
 
-        return $out($this->parseFromUrlEncoded($request), $response);
+        return $delegate->process($this->parseFromUrlEncoded($request));
     }
 
     /**

module/Rest/test/Middleware/BodyParserMiddlewareTest.php

@@ -1,8 +1,11 @@
 <?php
 namespace ShlinkioTest\Shlink\Rest\Middleware;
 
+use Interop\Http\ServerMiddleware\DelegateInterface;
 use PHPUnit\Framework\TestCase;
-use Psr\Http\Message\ServerRequestInterface as Request;
+use Prophecy\Argument;
+use Prophecy\Prophecy\MethodProphecy;
+use Psr\Http\Message\ServerRequestInterface;
 use Shlinkio\Shlink\Rest\Middleware\BodyParserMiddleware;
 use Zend\Diactoros\Response;
 use Zend\Diactoros\ServerRequestFactory;
@@ -26,16 +29,13 @@ class BodyParserMiddlewareTest extends TestCase
     public function requestsFromOtherMethodsJustFallbackToNextMiddleware()
     {
         $request = ServerRequestFactory::fromGlobals()->withMethod('GET');
-        $test = $this;
+        $delegate = $this->prophesize(DelegateInterface::class);
-        $this->middleware->__invoke($request, new Response(), function ($req, $resp) use ($test, $request) {
+        /** @var MethodProphecy $process */
-            $test->assertSame($request, $req);
+        $process = $delegate->process($request)->willReturn(new Response());
-        });
 
-        $request = $request->withMethod('POST');
+        $this->middleware->process($request, $delegate->reveal());
-        $test = $this;
+
-        $this->middleware->__invoke($request, new Response(), function ($req, $resp) use ($test, $request) {
+        $process->shouldHaveBeenCalledTimes(1);
-            $test->assertSame($request, $req);
-        });
     }
 
     /**
@@ -43,19 +43,31 @@ class BodyParserMiddlewareTest extends TestCase
      */
     public function jsonRequestsAreJsonDecoded()
     {
+        $test = $this;
         $body = new Stream('php://temp', 'wr');
         $body->write('{"foo": "bar", "bar": ["one", 5]}');
         $request = ServerRequestFactory::fromGlobals()->withMethod('PUT')
                                                       ->withBody($body)
                                                       ->withHeader('content-type', 'application/json');
-        $test = $this;
+        $delegate = $this->prophesize(DelegateInterface::class);
-        $this->middleware->__invoke($request, new Response(), function (Request $req, $resp) use ($test, $request) {
+        /** @var MethodProphecy $process */
-            $test->assertNotSame($request, $req);
+        $process = $delegate->process(Argument::type(ServerRequestInterface::class))->will(
-            $test->assertEquals([
+            function (array $args) use ($test) {
-                'foo' => 'bar',
+                /** @var ServerRequestInterface $req */
-                'bar' => ['one', 5],
+                $req = array_shift($args);
-            ], $req->getParsedBody());
+
-        });
+                $test->assertEquals([
+                    'foo' => 'bar',
+                    'bar' => ['one', 5],
+                ], $req->getParsedBody());
+
+                return new Response();
+            }
+        );
+
+        $this->middleware->process($request, $delegate->reveal());
+
+        $process->shouldHaveBeenCalledTimes(1);
     }
 
     /**
@@ -63,17 +75,29 @@ class BodyParserMiddlewareTest extends TestCase
      */
     public function regularRequestsAreUrlDecoded()
     {
+        $test = $this;
         $body = new Stream('php://temp', 'wr');
         $body->write('foo=bar&bar[]=one&bar[]=5');
         $request = ServerRequestFactory::fromGlobals()->withMethod('PUT')
                                                       ->withBody($body);
-        $test = $this;
+        $delegate = $this->prophesize(DelegateInterface::class);
-        $this->middleware->__invoke($request, new Response(), function (Request $req, $resp) use ($test, $request) {
+        /** @var MethodProphecy $process */
-            $test->assertNotSame($request, $req);
+        $process = $delegate->process(Argument::type(ServerRequestInterface::class))->will(
-            $test->assertEquals([
+            function (array $args) use ($test) {
-                'foo' => 'bar',
+                /** @var ServerRequestInterface $req */
-                'bar' => ['one', 5],
+                $req = array_shift($args);
-            ], $req->getParsedBody());
+
-        });
+                $test->assertEquals([
+                    'foo' => 'bar',
+                    'bar' => ['one', 5],
+                ], $req->getParsedBody());
+
+                return new Response();
+            }
+        );
+
+        $this->middleware->process($request, $delegate->reveal());
+
+        $process->shouldHaveBeenCalledTimes(1);
     }
 }