Refactor ExceptionHandlingMiddleware

Author: odan

CHANGELOG.md

@@ -22,9 +22,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - `ExceptionLoggingMiddleware` for custom error logging.
   - `ExceptionHandlingMiddleware` delegates exceptions to a custom error handler.
   - `ErrorHandlingMiddleware` converts errors into `ErrorException` instances that can then be handled by the `ExceptionHandlingMiddleware` and `ExceptionLoggingMiddleware`.
-  - New custom error handlers using a new `ExceptionHandlerInterface`. See new `ExceptionHandlingMiddleware`.
-  - New `JsonExceptionRenderer` generates a JSON problem details (rfc7807) response
-  - New `XmlExceptionRenderer` generates a XML problem details (rfc7807) response
+  - New custom error handlers using the new `ExceptionLoggingMiddleware` middleware.
+  - New `JsonExceptionRenderer` generates JSON error response.
+  - New `XmlExceptionRenderer` generates XML error response.
 - New `BasePathMiddleware` for dealing with Apache subdirectories.
 - New `HeadMethodMiddleware` ensures that the response body is empty for HEAD requests.
 - New `JsonRenderer` utility class for rendering JSON responses.
@@ -34,11 +34,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Support to build a custom middleware pipeline without the Slim App class. See new `ResponseFactoryMiddleware`
 - New media type detector
 - New Config class and ConfigInterface
-- New PhpDiContainerFactory class and ContainerFactoryInterface 
+- New ContainerFactoryInterface and PhpDiContainerFactory class  
 
 ### Changed
 
-* Require PHP 8.2 or 8.3. News versions will be supported after a review and test process.
+* Require PHP 8.2 or newer. News versions will be supported after a review and test process.
 * Migrated all tests to PHPUnit 11
 * Update GitHub action and build settings
 * Improve DI container integration. Make the DI container a first-class citizen. Require a PSR-11 package.

Slim/Container/DefaultDefinitions.php

@@ -19,21 +19,12 @@
 use Psr\Log\NullLogger;
 use Slim\Configuration\Config;
 use Slim\Emitter\ResponseEmitter;
-use Slim\Error\Handlers\ExceptionHandler;
-use Slim\Error\Renderers\HtmlExceptionRenderer;
-use Slim\Error\Renderers\JsonExceptionRenderer;
-use Slim\Error\Renderers\PlainTextExceptionRenderer;
-use Slim\Error\Renderers\XmlExceptionRenderer;
 use Slim\Interfaces\ConfigurationInterface;
 use Slim\Interfaces\ContainerResolverInterface;
 use Slim\Interfaces\EmitterInterface;
-use Slim\Interfaces\ExceptionHandlerInterface;
 use Slim\Interfaces\RequestHandlerInvocationStrategyInterface;
-use Slim\Media\MediaType;
 use Slim\Media\MediaTypeDetector;
 use Slim\Middleware\BodyParsingMiddleware;
-use Slim\Middleware\ExceptionHandlingMiddleware;
-use Slim\Middleware\ExceptionLoggingMiddleware;
 use Slim\RequestHandler\MiddlewareRequestHandler;
 use Slim\Routing\Router;
 use Slim\Routing\Strategies\RequestResponse;
@@ -77,46 +68,6 @@ public function __invoke(): array
                 return new ResponseEmitter();
             },
 
-            ExceptionHandlingMiddleware::class => function (ContainerInterface $container) {
-                $handler = $container->get(ExceptionHandlerInterface::class);
-
-                return (new ExceptionHandlingMiddleware())->withExceptionHandler($handler);
-            },
-
-            ExceptionHandlerInterface::class => function (ContainerInterface $container) {
-                // Default exception handler
-                $exceptionHandler = $container->get(ExceptionHandler::class);
-
-                // Settings
-                $displayErrorDetails = (bool)$container->get(ConfigurationInterface::class)
-                    ->get('display_error_details', false);
-
-                $exceptionHandler = $exceptionHandler
-                    ->withDisplayErrorDetails($displayErrorDetails)
-                    ->withDefaultMediaType(MediaType::TEXT_HTML);
-
-                return $exceptionHandler
-                    ->withoutHandlers()
-                    ->withHandler(MediaType::APPLICATION_JSON, JsonExceptionRenderer::class)
-                    ->withHandler(MediaType::TEXT_HTML, HtmlExceptionRenderer::class)
-                    ->withHandler(MediaType::APPLICATION_XHTML_XML, HtmlExceptionRenderer::class)
-                    ->withHandler(MediaType::APPLICATION_XML, XmlExceptionRenderer::class)
-                    ->withHandler(MediaType::TEXT_XML, XmlExceptionRenderer::class)
-                    ->withHandler(MediaType::TEXT_PLAIN, PlainTextExceptionRenderer::class);
-            },
-
-            ExceptionLoggingMiddleware::class => function (ContainerInterface $container) {
-                // Default logger
-                $logger = $container->get(LoggerInterface::class);
-                $middleware = new ExceptionLoggingMiddleware($logger);
-
-                // Read settings
-                $logErrorDetails = (bool)$container->get(ConfigurationInterface::class)
-                    ->get('log_error_details', false);
-
-                return $middleware->withLogErrorDetails($logErrorDetails);
-            },
-
             LoggerInterface::class => function () {
                 return new NullLogger();
             },

Slim/Error/Handlers/ExceptionHandler.php

@@ -112,7 +112,7 @@ public function withMaxAge(?int $maxAge): self
      * Set allowed origins. Null means allow all (*).
      * Pass an array of strings to specify allowed origins.
      */
-    public function withAllowedOrigins(?array $origins): self
+    public function withAllowedOrigins(?array $origins = null): self
     {
         $clone = clone $this;
         $clone->allowedOrigins = $origins;

Slim/Interfaces/ExceptionHandlerInterface.php

@@ -10,11 +10,18 @@
 
 namespace Slim\Middleware;
 
+use Psr\Container\ContainerInterface;
+use Psr\Http\Message\ResponseFactoryInterface;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Server\MiddlewareInterface;
 use Psr\Http\Server\RequestHandlerInterface;
-use Slim\Interfaces\ExceptionHandlerInterface;
+use RuntimeException;
+use Slim\Exception\HttpException;
+use Slim\Exception\HttpMethodNotAllowedException;
+use Slim\Interfaces\ContainerResolverInterface;
+use Slim\Interfaces\ExceptionRendererInterface;
+use Slim\Media\MediaTypeDetector;
 use Throwable;
 
 /**
@@ -27,26 +34,152 @@
  */
 final class ExceptionHandlingMiddleware implements MiddlewareInterface
 {
-    private ?ExceptionHandlerInterface $exceptionHandler = null;
+    private ResponseFactoryInterface $responseFactory;
+
+    private MediaTypeDetector $mediaTypeDetector;
+
+    private ContainerResolverInterface $resolver;
+
+    private bool $displayErrorDetails = false;
+
+    private string $defaultMediaType = 'text/html';
+
+    private array $handlers = [];
+
+    /**
+     * @var callable|ExceptionRendererInterface|string|null
+     */
+    private $defaultHandler = null;
+
+    public function __construct(
+        ContainerResolverInterface $resolver,
+        ResponseFactoryInterface $responseFactory,
+        MediaTypeDetector $mediaTypeDetector,
+    ) {
+        $this->resolver = $resolver;
+        $this->responseFactory = $responseFactory;
+        $this->mediaTypeDetector = $mediaTypeDetector;
+    }
+
+    public static function createFromContainer(ContainerInterface $container): self
+    {
+        return new self(
+            $container->get(ContainerResolverInterface::class),
+            $container->get(ResponseFactoryInterface::class),
+            $container->get(MediaTypeDetector::class)
+        );
+    }
 
     public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
     {
         try {
             return $handler->handle($request);
         } catch (Throwable $exception) {
-            if ($this->exceptionHandler) {
-                return ($this->exceptionHandler)($request, $exception);
-            }
+            $statusCode = $this->determineStatusCode($request, $exception);
+            $mediaType = $this->negotiateMediaType($request);
+            $response = $this->createResponse($statusCode, $mediaType, $exception);
+            $handler = $this->negotiateHandler($mediaType);
 
-            throw $exception;
+            // Invoke the formatter handler
+            return call_user_func(
+                $handler,
+                $request,
+                $response,
+                $exception,
+                $this->displayErrorDetails
+            );
         }
     }
 
-    public function withExceptionHandler(ExceptionHandlerInterface $exceptionHandler): self
+    public function withDefaultMediaType(string $defaultMediaType): self
+    {
+        $clone = clone $this;
+        $clone->defaultMediaType = $defaultMediaType;
+
+        return $clone;
+    }
+
+    public function withDisplayErrorDetails(bool $displayErrorDetails): self
+    {
+        $clone = clone $this;
+        $clone->displayErrorDetails = $displayErrorDetails;
+
+        return $clone;
+    }
+
+    public function withDefaultHandler(ExceptionRendererInterface|callable|string $handler): self
+    {
+        $clone = clone $this;
+        $clone->defaultHandler = $handler;
+
+        return $clone;
+    }
+
+    public function withHandler(string $mediaType, ExceptionRendererInterface|callable|string $handler): self
     {
         $clone = clone $this;
-        $clone->exceptionHandler = $exceptionHandler;
+        $clone->handlers[$mediaType] = $handler;
 
         return $clone;
     }
+
+    public function withoutHandlers(): self
+    {
+        $clone = clone $this;
+        $clone->handlers = [];
+        $clone->defaultHandler = null;
+
+        return $clone;
+    }
+
+    private function negotiateMediaType(ServerRequestInterface $request): string
+    {
+        $mediaTypes = $this->mediaTypeDetector->detect($request);
+
+        return $mediaTypes[0] ?? $this->defaultMediaType;
+    }
+
+    /**
+     * Determine which handler to use based on media type.
+     */
+    private function negotiateHandler(string $mediaType): callable
+    {
+        $handler = $this->handlers[$mediaType] ?? $this->defaultHandler ?? reset($this->handlers);
+
+        if (!$handler) {
+            throw new RuntimeException(sprintf('Exception handler for "%s" not found', $mediaType));
+        }
+
+        return $this->resolver->resolveCallable($handler);
+    }
+
+    private function determineStatusCode(ServerRequestInterface $request, Throwable $exception): int
+    {
+        if ($exception instanceof HttpException) {
+            return $exception->getCode();
+        }
+
+        if ($request->getMethod() === 'OPTIONS') {
+            return 200;
+        }
+
+        return 500;
+    }
+
+    private function createResponse(
+        int $statusCode,
+        string $contentType,
+        Throwable $exception,
+    ): ResponseInterface {
+        $response = $this->responseFactory
+            ->createResponse($statusCode)
+            ->withHeader('Content-Type', $contentType);
+
+        if ($exception instanceof HttpMethodNotAllowedException) {
+            $allowedMethods = implode(', ', $exception->getAllowedMethods());
+            $response = $response->withHeader('Allow', $allowedMethods);
+        }
+
+        return $response;
+    }
 }

Slim/Middleware/CorsMiddleware.php

@@ -21,6 +21,7 @@
 use RuntimeException;
 use Slim\App;
 use Slim\Builder\AppBuilder;
+use Slim\Error\Renderers\HtmlExceptionRenderer;
 use Slim\Exception\HttpMethodNotAllowedException;
 use Slim\Exception\HttpNotFoundException;
 use Slim\Interfaces\ContainerFactoryInterface;
@@ -57,11 +58,21 @@ final class AppTest extends TestCase
     public function testAppWithExceptionAndErrorDetails(): void
     {
         $builder = new AppBuilder();
-        $builder->addSettings(['display_error_details' => true]);
+        $builder->addDefinitions(
+            [
+                ExceptionHandlingMiddleware::class => function ($container) {
+                    $middleware = ExceptionHandlingMiddleware::createFromContainer($container);
+
+                    return $middleware
+                        ->withDisplayErrorDetails(true)
+                        ->withDefaultHandler(HtmlExceptionRenderer::class);
+                },
+            ]
+        );
         $app = $builder->build();
 
-        $app->add(RoutingMiddleware::class);
         $app->add(ExceptionHandlingMiddleware::class);
+        $app->add(RoutingMiddleware::class);
         $app->add(EndpointMiddleware::class);
 
         $app->get('/', fn () => throw new UnexpectedValueException('Test exception message'));

Slim/Middleware/ExceptionHandlingMiddleware.php

@@ -10,113 +10,75 @@
 
 namespace Slim\Tests\Middleware;
 
+use DOMDocument;
+use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
-use Psr\Http\Message\ResponseFactoryInterface;
-use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestFactoryInterface;
-use Psr\Http\Message\ServerRequestInterface;
 use RuntimeException;
 use Slim\Builder\AppBuilder;
-use Slim\Interfaces\ExceptionHandlerInterface;
+use Slim\Error\Renderers\HtmlExceptionRenderer;
+use Slim\Error\Renderers\JsonExceptionRenderer;
+use Slim\Error\Renderers\XmlExceptionRenderer;
+use Slim\Media\MediaType;
 use Slim\Middleware\EndpointMiddleware;
 use Slim\Middleware\ExceptionHandlingMiddleware;
 use Slim\Middleware\RoutingMiddleware;
 use Slim\Tests\Traits\AppTestTrait;
-use Throwable;
 
 final class ExceptionHandlingMiddlewareTest extends TestCase
 {
     use AppTestTrait;
 
-    public function testExceptionHandlingMiddlewareHandlesException()
+    public function testDefaultHandlerWithoutDetails(): void
     {
         $builder = new AppBuilder();
+        $builder->addDefinitions(
+            [
+                ExceptionHandlingMiddleware::class => function ($container) {
+                    $middleware = ExceptionHandlingMiddleware::createFromContainer($container);
+
+                    return $middleware
+                        ->withDisplayErrorDetails(false)
+                        ->withDefaultHandler(HtmlExceptionRenderer::class);
+                },
+            ]
+        );
         $app = $builder->build();
 
-        $responseFactory = $app->getContainer()->get(ResponseFactoryInterface::class);
-
-        // Custom ExceptionHandlerInterface implementation
-        $exceptionHandler = new class ($responseFactory) implements ExceptionHandlerInterface {
-            private ResponseFactoryInterface $responseFactory;
-
-            public function __construct($responseFactory)
-            {
-                $this->responseFactory = $responseFactory;
-            }
-
-            public function __invoke(ServerRequestInterface $request, Throwable $exception): ResponseInterface
-            {
-                $response = $this->responseFactory->createResponse(500, 'Internal Server Error');
-                $response->getBody()->write($exception->getMessage());
-
-                return $response;
-            }
-        };
-
-        $app->add((new ExceptionHandlingMiddleware())->withExceptionHandler($exceptionHandler));
+        $app->add(ExceptionHandlingMiddleware::class);
         $app->add(RoutingMiddleware::class);
         $app->add(EndpointMiddleware::class);
 
-        $app->get('/', function () {
-            throw new RuntimeException('Something went wrong');
-        });
-
         $request = $app->getContainer()
             ->get(ServerRequestFactoryInterface::class)
             ->createServerRequest('GET', '/');
 
-        $response = $app->handle($request);
-        $this->assertEquals(500, $response->getStatusCode());
-        $this->assertSame('Something went wrong', (string)$response->getBody());
-    }
-
-    public function testExceptionHandlingMiddlewarePassesThroughNonExceptionRequest()
-    {
-        $builder = new AppBuilder();
-        $app = $builder->build();
-
-        $responseFactory = $app->getContainer()->get(ResponseFactoryInterface::class);
-
-        // This handler should not be called in this test
-        $exceptionHandler = new class ($responseFactory) implements ExceptionHandlerInterface {
-            private ResponseFactoryInterface $responseFactory;
-
-            public function __construct($responseFactory)
-            {
-                $this->responseFactory = $responseFactory;
-            }
-
-            public function __invoke(ServerRequestInterface $request, Throwable $exception): ResponseInterface
-            {
-                $response = $this->responseFactory->createResponse(500);
-                $response->getBody()->write($exception->getMessage());
-
-                return $response;
-            }
-        };
-
-        $app->add(new ExceptionHandlingMiddleware($exceptionHandler));
-        $app->add(RoutingMiddleware::class);
-        $app->add(EndpointMiddleware::class);
-
-        $app->get('/', function (ServerRequestInterface $request, ResponseInterface $response) {
-            $response->getBody()->write('Hello World');
-
-            return $response;
+        $app->get('/', function () {
+            throw new RuntimeException('Test error');
         });
 
-        $request = $app->getContainer()
-            ->get(ServerRequestFactoryInterface::class)
-            ->createServerRequest('GET', '/');
-
         $response = $app->handle($request);
-        $this->assertEquals(200, $response->getStatusCode());
-        $this->assertSame('Hello World', (string)$response->getBody());
+
+        $this->assertSame(500, $response->getStatusCode());
+        $this->assertSame('text/html', $response->getHeaderLine('Content-Type'));
+        $this->assertStringNotContainsString('Test Error message', (string)$response->getBody());
+        $this->assertStringContainsString('<h1>Application Error</h1>', (string)$response->getBody());
     }
 
-    public function testDefaultMediaTypeWithoutDetails(): void
+    public function testDefaultHandlerWithDetails(): void
     {
         $builder = new AppBuilder();
+        $builder->addDefinitions(
+            [
+                ExceptionHandlingMiddleware::class => function ($container) {
+                    $middleware = ExceptionHandlingMiddleware::createFromContainer($container);
+
+                    return $middleware
+                        ->withDisplayErrorDetails(true)
+                        ->withDefaultHandler(HtmlExceptionRenderer::class);
+                },
+            ]
+        );
         $app = $builder->build();
 
         $app->add(ExceptionHandlingMiddleware::class);
@@ -128,21 +90,32 @@ public function testDefaultMediaTypeWithoutDetails(): void
             ->createServerRequest('GET', '/');
 
         $app->get('/', function () {
-            throw new RuntimeException('Test error');
+            throw new RuntimeException('Test error', 123);
         });
 
         $response = $app->handle($request);
 
         $this->assertSame(500, $response->getStatusCode());
-        $this->assertSame('text/html', $response->getHeaderLine('Content-Type'));
+        $this->assertSame('text/html', (string)$response->getHeaderLine('Content-Type'));
         $this->assertStringNotContainsString('Test Error message', (string)$response->getBody());
         $this->assertStringContainsString('<h1>Application Error</h1>', (string)$response->getBody());
     }
 
     public function testDefaultHtmlMediaTypeWithDetails(): void
     {
         $builder = new AppBuilder();
-        $builder->addSettings(['display_error_details' => true]);
+        $builder->addDefinitions(
+            [
+                ExceptionHandlingMiddleware::class => function ($container) {
+                    $middleware = ExceptionHandlingMiddleware::createFromContainer($container);
+
+                    return $middleware
+                        ->withDisplayErrorDetails(true)
+                        ->withDefaultMediaType(MediaType::TEXT_HTML)
+                        ->withHandler(MediaType::TEXT_HTML, HtmlExceptionRenderer::class);
+                },
+            ]
+        );
         $app = $builder->build();
 
         $app->add(ExceptionHandlingMiddleware::class);
@@ -151,7 +124,8 @@ public function testDefaultHtmlMediaTypeWithDetails(): void
 
         $request = $app->getContainer()
             ->get(ServerRequestFactoryInterface::class)
-            ->createServerRequest('GET', '/');
+            ->createServerRequest('GET', '/')
+            ->withHeader('Accept', 'application/json');
 
         $app->get('/', function () {
             throw new RuntimeException('Test error', 123);
@@ -165,10 +139,22 @@ public function testDefaultHtmlMediaTypeWithDetails(): void
         $this->assertStringContainsString('<h1>Application Error</h1>', (string)$response->getBody());
     }
 
-    public function testJsonMediaTypeWithDetails(): void
+    public function testJsonMediaTypeDisplayErrorDetails(): void
     {
         $builder = new AppBuilder();
-        $builder->addSettings(['display_error_details' => true]);
+
+        $builder->addDefinitions(
+            [
+                ExceptionHandlingMiddleware::class => function ($container) {
+                    $middleware = ExceptionHandlingMiddleware::createFromContainer($container);
+
+                    return $middleware
+                        ->withDisplayErrorDetails(true)
+                        ->withHandler(MediaType::APPLICATION_JSON, JsonExceptionRenderer::class);
+                },
+            ]
+        );
+
         $app = $builder->build();
 
         $app->add(ExceptionHandlingMiddleware::class);
@@ -197,12 +183,12 @@ public function testJsonMediaTypeWithDetails(): void
     public function testWithoutHandler(): void
     {
         $this->expectException(RuntimeException::class);
-        $this->expectExceptionMessage('Test error');
+        $this->expectExceptionMessage('Exception handler for "text/html" not found');
 
         $builder = new AppBuilder();
         $app = $builder->build();
 
-        $app->add(new ExceptionHandlingMiddleware());
+        $app->add(ExceptionHandlingMiddleware::class);
         $app->add(RoutingMiddleware::class);
         $app->add(EndpointMiddleware::class);
 
@@ -216,4 +202,155 @@ public function testWithoutHandler(): void
 
         $app->handle($request);
     }
+
+    #[DataProvider('textHmlHeaderProvider')]
+    public function testWithTextHtml(string $header, string $headerValue): void
+    {
+        $builder = new AppBuilder();
+        $builder->addDefinitions(
+            [
+                ExceptionHandlingMiddleware::class => function ($container) {
+                    $middleware = ExceptionHandlingMiddleware::createFromContainer($container);
+
+                    return $middleware
+                        ->withDisplayErrorDetails(true)
+                        ->withHandler(MediaType::TEXT_HTML, HtmlExceptionRenderer::class);
+                },
+            ]
+        );
+        $app = $builder->build();
+
+        $app->add(ExceptionHandlingMiddleware::class);
+        $app->add(RoutingMiddleware::class);
+        $app->add(EndpointMiddleware::class);
+
+        $app->get('/', function () {
+            throw new RuntimeException('Test Error message');
+        });
+
+        $request = $app->getContainer()
+            ->get(ServerRequestFactoryInterface::class)
+            ->createServerRequest('GET', '/')
+            ->withHeader($header, $headerValue);
+
+        $response = $app->handle($request);
+
+        $this->assertSame(500, $response->getStatusCode());
+        $this->assertSame('text/html', (string)$response->getHeaderLine('Content-Type'));
+        $this->assertStringContainsString('Test Error message', (string)$response->getBody());
+    }
+
+    public static function textHmlHeaderProvider(): array
+    {
+        return [
+            ['Accept', 'text/html'],
+            ['Accept', 'text/html, application/xhtml+xml, application/xml;q=0.9, image/webp, */*;q=0.8'],
+            ['Content-Type', 'text/html'],
+            ['Content-Type', 'text/html; charset=utf-8'],
+        ];
+    }
+
+    // todo: Add test for other media types
+
+    public function testWithAcceptJson(): void
+    {
+        $builder = new AppBuilder();
+        $builder->addDefinitions(
+            [
+                ExceptionHandlingMiddleware::class => function ($container) {
+                    $middleware = ExceptionHandlingMiddleware::createFromContainer($container);
+
+                    return $middleware
+                        ->withDisplayErrorDetails(false)
+                        ->withHandler(MediaType::APPLICATION_JSON, JsonExceptionRenderer::class);
+                },
+            ]
+        );
+        $app = $builder->build();
+
+        $app->add(ExceptionHandlingMiddleware::class);
+        $app->add(RoutingMiddleware::class);
+        $app->add(EndpointMiddleware::class);
+
+        $request = $app->getContainer()
+            ->get(ServerRequestFactoryInterface::class)
+            ->createServerRequest('GET', '/')
+            ->withHeader('Accept', 'application/json');
+
+        $app->get('/', function () {
+            throw new RuntimeException('Test exception');
+        });
+
+        $response = $app->handle($request);
+
+        $this->assertSame(500, $response->getStatusCode());
+        $expected = [
+            'message' => 'Application Error',
+        ];
+        $this->assertJsonResponse($expected, $response);
+    }
+
+    public static function xmlHeaderProvider(): array
+    {
+        return [
+            ['Accept', 'application/xml'],
+            ['Accept', 'application/xml, application/json'],
+            ['Content-Type', 'application/xml'],
+            ['Content-Type', 'application/xml; charset=utf-8'],
+        ];
+    }
+
+    #[DataProvider('xmlHeaderProvider')]
+    public function testWithAcceptXml(string $header, string $headerValue): void
+    {
+        $builder = new AppBuilder();
+        $builder->addDefinitions(
+            [
+                ExceptionHandlingMiddleware::class => function ($container) {
+                    $middleware = ExceptionHandlingMiddleware::createFromContainer($container);
+
+                    return $middleware->withDisplayErrorDetails(false)
+                        ->withoutHandlers()
+                        ->withHandler('application/json', JsonExceptionRenderer::class)
+                        ->withHandler('application/xml', XmlExceptionRenderer::class);
+                },
+            ]
+        );
+        $app = $builder->build();
+
+        $app->add(ExceptionHandlingMiddleware::class);
+        $app->add(RoutingMiddleware::class);
+        $app->add(EndpointMiddleware::class);
+
+        $request = $app->getContainer()
+            ->get(ServerRequestFactoryInterface::class)
+            ->createServerRequest('GET', '/')
+            ->withHeader($header, $headerValue);
+
+        $app->get('/', function () {
+            throw new RuntimeException('Test exception');
+        });
+
+        $response = $app->handle($request);
+
+        $this->assertSame(500, $response->getStatusCode());
+        $expected = '<?xml version="1.0" encoding="UTF-8"?>
+                    <error>
+                      <message>Application Error</message>
+                    </error>';
+
+        $dom = new DOMDocument();
+        $dom->preserveWhiteSpace = false;
+        $dom->formatOutput = true;
+        $dom->loadXML($expected);
+        $expected = $dom->saveXML();
+
+        $dom2 = new DOMDocument();
+        $dom2->preserveWhiteSpace = false;
+        $dom2->formatOutput = true;
+        $dom2->loadXML((string)$response->getBody());
+        $actual = $dom2->saveXML();
+
+        $this->assertSame($expected, $actual);
+    }
 }