Merge branch 'feature/12-interop-middleware'

Close #12

Author: weierophinney

CHANGELOG.md

@@ -37,6 +37,12 @@ Versions 0.3.0 and prior were released as "weierophinney/problem-details".
   `Zend\Expressive\ProblemDetails\Exception\ExceptionInterface`, a marker
   interface for exceptions provided by the package.
 
+- [#12](https://github.com/zendframework/zend-problem-details/pull/12) adds
+  support for http-interop/http-middleware 0.5.0 via a polyfill provided by the
+  package webimpress/http-middleware-compatibility. Essentially, this means you
+  can drop this package into an application targeting either the 0.4.1 or 0.5.0
+  versions of http-middleware, and it will "just work".
+
 ### Changed
 
 - [#8](https://github.com/zendframework/zend-problem-details/pull/8) renames the

composer.json

@@ -24,10 +24,10 @@
         "php": "^7.1",
         "ext-json": "*",
         "fig/http-message-util": "^1.1.2",
-        "http-interop/http-middleware": "^0.4.1",
         "psr/container": "^1.0",
         "psr/http-message": "^1.0",
         "spatie/array-to-xml": "^2.3",
+        "webimpress/http-middleware-compatibility": "^0.1.1",
         "willdurand/negotiation": "^2.3"
     },
     "require-dev": {

composer.lock

@@ -35,10 +35,10 @@ As an example, the following catches domain excpetions and uses them to create
 problem details responses:
 
 ```php
-use Interop\Http\ServerMiddleware\DelegateInterface;
-use Interop\Http\ServerMiddleware\MiddlewareInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Throwable;
+use Webimpress\HttpMiddlewareCompatibility\HandlerInterface as DelegateInterface;
+use Webimpress\HttpMiddlewareCompatibility\MiddlewareInterface;
 use Zend\Diactoros\Response\JsonResponse;
 use Zend\ProblemDetails\ProblemDetailsResponseFactory;
 
@@ -91,10 +91,10 @@ an example, validation failure is an expected condition, but should likely
 result in problem details to the end user.
 
 ```php
-use Interop\Http\ServerMiddleware\DelegateInterface;
-use Interop\Http\ServerMiddleware\MiddlewareInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Throwable;
+use Webimpress\HttpMiddlewareCompatibility\HandlerInterface as DelegateInterface;
+use Webimpress\HttpMiddlewareCompatibility\MiddlewareInterface;
 use Zend\Diactoros\Response\JsonResponse;
 use Zend\InputFilter\InputFilterInterface;
 use Zend\ProblemDetails\ProblemDetailsResponseFactory;

docs/book/quick-start.md

@@ -153,9 +153,9 @@ Let's say you have middleware that you know will only be used in a production
 context, and need to return problem details:
 
 ```php
-use Interop\Http\ServerMiddleware\DelegateInterface;
-use Interop\Http\ServerMiddleware\MiddlewareInterface;
 use Psr\Http\Message\ServerRequestInterface;
+use Webimpress\HttpMiddlewareCompatibility\HandlerInterface as DelegateInterface;
+use Webimpress\HttpMiddlewareCompatibility\MiddlewareInterface;
 use Zend\ProblemDetails\ProblemDetailsResponseFactory;
 
 class ApiMiddleware implements MiddlewareInterface
@@ -186,15 +186,15 @@ composes, and that service could raise an exception or other `Throwable`. For
 this, you can use the `createResponseFromThrowable()` method instead.
 
 ```php
-use Interop\Http\ServerMiddleware\DelegateInterface;
-use Interop\Http\ServerMiddleware\MiddlewareInterface;
+use Interop\Http\Server\MiddlewareInterface;
+use Interop\Http\Server\RequestHandlerInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Throwable;
 use Zend\ProblemDetails\ProblemDetailsResponseFactory;
 
 class ApiMiddleware implements MiddlewareInterface
 {
-    public function process(ServerRequestInterface $request, DelegateInterface $delegate)
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler)
     {
         try {
             // some code that may raise an exception or throwable
@@ -221,8 +221,8 @@ pass a configured `ProblemDetailsResponseFactory` instance to your middleware's
 constructor. As a more complete example:
 
 ```php
-use Interop\Http\ServerMiddleware\DelegateInterface;
-use Interop\Http\ServerMiddleware\MiddlewareInterface;
+use Interop\Http\Server\MiddlewareInterface;
+use Interop\Http\Server\RequestHandlerInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Throwable;
 use Zend\ProblemDetails\ProblemDetailsResponseFactory;
@@ -239,7 +239,7 @@ class ApiMiddleware implements MiddlewareInterface
         $this->problemDetailsFactory = $problemDetailsFactory;
     }
 
-    public function process(ServerRequestInterface $request, DelegateInterface $delegate)
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler)
     {
         try {
             // some code that may raise an exception or throwable

docs/book/response.md

@@ -8,12 +8,14 @@
 namespace Zend\ProblemDetails;
 
 use ErrorException;
-use Interop\Http\ServerMiddleware\DelegateInterface;
-use Interop\Http\ServerMiddleware\MiddlewareInterface;
 use Negotiation\Negotiator;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Throwable;
+use Webimpress\HttpMiddlewareCompatibility\HandlerInterface as DelegateInterface;
+use Webimpress\HttpMiddlewareCompatibility\MiddlewareInterface;
+
+use const Webimpress\HttpMiddlewareCompatibility\HANDLER_METHOD;
 
 /**
  * Middleware that ensures a Problem Details response is returned
@@ -38,12 +40,12 @@ public function process(ServerRequestInterface $request, DelegateInterface $dele
     {
         // If we cannot provide a representation, act as a no-op.
         if (! $this->canActAsErrorHandler($request)) {
-            return $delegate->process($request);
+            return $delegate->{HANDLER_METHOD}($request);
         }
 
         try {
             set_error_handler($this->createErrorHandler());
-            $response = $delegate->process($request);
+            $response = $delegate->{HANDLER_METHOD}($request);
 
             if (! $response instanceof ResponseInterface) {
                 throw new Exception\MissingResponseException('Application did not return a response');

src/ProblemDetailsMiddleware.php

@@ -7,13 +7,15 @@
 
 namespace Zend\ProblemDetails;
 
-use Interop\Http\ServerMiddleware\DelegateInterface;
-use Interop\Http\ServerMiddleware\MiddlewareInterface as ServerMiddlewareInterface;
 use Negotiation\Negotiator;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
+use Webimpress\HttpMiddlewareCompatibility\HandlerInterface as DelegateInterface;
+use Webimpress\HttpMiddlewareCompatibility\MiddlewareInterface as ServerMiddlewareInterface;
 use Zend\Stratigility\Delegate\CallableDelegateDecorator;
 
+use const Webimpress\HttpMiddlewareCompatibility\HANDLER_METHOD;
+
 class ProblemDetailsNotFoundHandler implements ServerMiddlewareInterface
 {
     /**
@@ -37,7 +39,7 @@ public function process(ServerRequestInterface $request, DelegateInterface $dele
     {
         // If we cannot provide a representation, act as a no-op.
         if (! $this->canActAsErrorHandler($request)) {
-            return $delegate->process($request);
+            return $delegate->{HANDLER_METHOD}($request);
         }
 
         return $this->responseFactory->createResponse(

src/ProblemDetailsNotFoundHandler.php

@@ -8,16 +8,18 @@
 namespace ZendTest\ProblemDetails;
 
 use ErrorException;
-use Interop\Http\ServerMiddleware\DelegateInterface;
 use PHPUnit\Framework\TestCase;
 use Prophecy\Argument;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
+use Webimpress\HttpMiddlewareCompatibility\HandlerInterface as DelegateInterface;
 use Zend\ProblemDetails\Exception\MissingResponseException;
 use Zend\ProblemDetails\ProblemDetailsMiddleware;
 use Zend\ProblemDetails\ProblemDetailsResponseFactory;
 use ZendTest\ProblemDetails\TestAsset;
 
+use const Webimpress\HttpMiddlewareCompatibility\HANDLER_METHOD;
+
 class ProblemDetailsMiddlewareTest extends TestCase
 {
     use ProblemDetailsAssertionsTrait;
@@ -45,7 +47,7 @@ public function testSuccessfulDelegationReturnsDelegateResponse() : void
         $response = $this->prophesize(ResponseInterface::class);
         $delegate = $this->prophesize(DelegateInterface::class);
         $delegate
-            ->process(Argument::that([$this->request, 'reveal']))
+            ->{HANDLER_METHOD}(Argument::that([$this->request, 'reveal']))
             ->will([$response, 'reveal']);
 
 
@@ -64,7 +66,7 @@ public function testDelegateNotReturningResponseResultsInProblemDetails(string $
 
         $delegate = $this->prophesize(DelegateInterface::class);
         $delegate
-            ->process(Argument::that([$this->request, 'reveal']))
+            ->{HANDLER_METHOD}(Argument::that([$this->request, 'reveal']))
             ->willReturn('Unexpected');
 
         $expected = $this->prophesize(ResponseInterface::class)->reveal();
@@ -88,7 +90,7 @@ public function testThrowableRaisedByDelegateResultsInProblemDetails(string $acc
 
         $delegate  = $this->prophesize(DelegateInterface::class);
         $delegate
-            ->process(Argument::that([$this->request, 'reveal']))
+            ->{HANDLER_METHOD}(Argument::that([$this->request, 'reveal']))
             ->willThrow($exception);
 
         $expected = $this->prophesize(ResponseInterface::class)->reveal();
@@ -110,7 +112,7 @@ public function testMiddlewareRegistersErrorHandlerToConvertErrorsToProblemDetai
 
         $delegate = $this->prophesize(DelegateInterface::class);
         $delegate
-            ->process(Argument::that([$this->request, 'reveal']))
+            ->{HANDLER_METHOD}(Argument::that([$this->request, 'reveal']))
             ->will(function () {
                 trigger_error('Triggered error!', \E_USER_ERROR);
             });
@@ -136,7 +138,7 @@ public function testRethrowsCaughtExceptionIfUnableToNegotiateAcceptHeader() : v
         $exception = new TestAsset\RuntimeException('Thrown!', 507);
         $delegate  = $this->prophesize(DelegateInterface::class);
         $delegate
-            ->process(Argument::that([$this->request, 'reveal']))
+            ->{HANDLER_METHOD}(Argument::that([$this->request, 'reveal']))
             ->willThrow($exception);
 
         $middleware = new ProblemDetailsMiddleware();

test/ProblemDetailsMiddlewareTest.php

@@ -7,16 +7,16 @@
 
 namespace ZendTest\ProblemDetails;
 
-use ErrorException;
-use Interop\Http\ServerMiddleware\DelegateInterface;
 use PHPUnit\Framework\TestCase;
 use Prophecy\Argument;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
-use Psr\Http\Message\StreamInterface;
+use Webimpress\HttpMiddlewareCompatibility\HandlerInterface as DelegateInterface;
 use Zend\ProblemDetails\ProblemDetailsNotFoundHandler;
 use Zend\ProblemDetails\ProblemDetailsResponseFactory;
 
+use const Webimpress\HttpMiddlewareCompatibility\HANDLER_METHOD;
+
 class ProblemDetailsNotFoundHandlerTest extends TestCase
 {
     use ProblemDetailsAssertionsTrait;
@@ -97,7 +97,7 @@ public function testDelegateIsCalledIfAcceptHeaderIsUnacceptable() : void
         $response = $this->prophesize(ResponseInterface::class);
 
         $delegate = $this->prophesize(DelegateInterface::class);
-        $delegate->process($request->reveal())->will([$response, 'reveal']);
+        $delegate->{HANDLER_METHOD}($request->reveal())->will([$response, 'reveal']);
 
         $responseFactory = $this->prophesize(ProblemDetailsResponseFactory::class);