feat(http): RFC 7807 problem+json renderer + default handler covers new types

Author: thced

src/main/java/com/retailsvc/http/ExceptionHandler.java

@@ -9,7 +9,12 @@
  *
  * @author thced
  */
+@FunctionalInterface
 public interface ExceptionHandler {
 
-  void handleException(HttpExchange exchange, Exception e) throws IOException;
+  void handle(HttpExchange exchange, Throwable t) throws IOException;
+
+  default void handleException(HttpExchange exchange, Exception e) throws IOException {
+    handle(exchange, e);
+  }
 }

src/main/java/com/retailsvc/http/Handlers.java

@@ -1,42 +1,56 @@
 package com.retailsvc.http;
 
+import static java.net.HttpURLConnection.HTTP_BAD_METHOD;
+import static java.net.HttpURLConnection.HTTP_BAD_REQUEST;
 import static java.net.HttpURLConnection.HTTP_INTERNAL_ERROR;
 import static java.net.HttpURLConnection.HTTP_NOT_FOUND;
+import static java.nio.charset.StandardCharsets.UTF_8;
 
-import com.sun.net.httpserver.HttpExchange;
+import com.retailsvc.http.internal.ProblemDetailRenderer;
 import com.sun.net.httpserver.HttpHandler;
 import java.io.IOException;
+import java.util.stream.Collectors;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-public class Handlers {
+public final class Handlers {
 
   private static final Logger LOG = LoggerFactory.getLogger(Handlers.class);
 
   private Handlers() {}
 
-  public static HttpHandler notFoundHandler() {
-    return exchange -> {
+  public static ExceptionHandler defaultExceptionHandler() {
+    return (exchange, t) -> {
       try (exchange) {
-        endRequest(exchange, HTTP_NOT_FOUND);
+        switch (t) {
+          case ValidationException ve -> {
+            byte[] body = ProblemDetailRenderer.render(ve.error()).getBytes(UTF_8);
+            exchange.getResponseHeaders().add("Content-Type", "application/problem+json");
+            exchange.sendResponseHeaders(HTTP_BAD_REQUEST, body.length);
+            exchange.getResponseBody().write(body);
+          }
+          case NotFoundException nf -> exchange.sendResponseHeaders(HTTP_NOT_FOUND, 0);
+          case MethodNotAllowedException mna -> {
+            String allow = mna.allowed().stream().map(Enum::name).collect(Collectors.joining(", "));
+            exchange.getResponseHeaders().add("Allow", allow);
+            exchange.sendResponseHeaders(HTTP_BAD_METHOD, 0);
+          }
+          default -> {
+            LOG.error("Unhandled exception in handler", t);
+            exchange.sendResponseHeaders(HTTP_INTERNAL_ERROR, 0);
+          }
+        }
+      } catch (IOException io) {
+        LOG.error("Failed writing error response", io);
       }
     };
   }
 
-  public static ExceptionHandler internalServerErrorHandler() {
-    return (exchange, throwable) -> {
+  public static HttpHandler notFoundHandler() {
+    return exchange -> {
       try (exchange) {
-        LOG.error("Error in handling request", throwable);
-        endRequest(exchange, HTTP_INTERNAL_ERROR);
+        exchange.sendResponseHeaders(HTTP_NOT_FOUND, 0);
       }
     };
   }
-
-  public static ExceptionHandler defaultExceptionHandler() {
-    return (exchange, e) -> internalServerErrorHandler().handleException(exchange, e);
-  }
-
-  private static void endRequest(HttpExchange exchange, int status) throws IOException {
-    exchange.sendResponseHeaders(status, 0);
-  }
 }

src/main/java/com/retailsvc/http/internal/ProblemDetailRenderer.java

@@ -0,0 +1,43 @@
+package com.retailsvc.http.internal;
+
+import com.retailsvc.http.validate.ValidationError;
+
+public final class ProblemDetailRenderer {
+  private ProblemDetailRenderer() {}
+
+  public static String render(ValidationError error) {
+    return "{"
+        + "\"type\":\"about:blank\","
+        + "\"title\":\"Bad Request\","
+        + "\"status\":400,"
+        + "\"detail\":\""
+        + escape(error.message())
+        + "\","
+        + "\"pointer\":\""
+        + escape(error.pointer())
+        + "\","
+        + "\"keyword\":\""
+        + escape(error.keyword())
+        + "\""
+        + "}";
+  }
+
+  private static String escape(String s) {
+    StringBuilder b = new StringBuilder(s.length() + 8);
+    for (int i = 0; i < s.length(); i++) {
+      char c = s.charAt(i);
+      switch (c) {
+        case '\\' -> b.append("\\\\");
+        case '"' -> b.append("\\\"");
+        case '\n' -> b.append("\\n");
+        case '\r' -> b.append("\\r");
+        case '\t' -> b.append("\\t");
+        default -> {
+          if (c < 0x20) b.append(String.format("\\u%04x", (int) c));
+          else b.append(c);
+        }
+      }
+    }
+    return b.toString();
+  }
+}

src/test/java/com/retailsvc/http/HandlersDefaultExceptionTest.java

@@ -0,0 +1,53 @@
+package com.retailsvc.http;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.retailsvc.http.spec.HttpMethod;
+import com.retailsvc.http.validate.ValidationError;
+import com.sun.net.httpserver.Headers;
+import com.sun.net.httpserver.HttpExchange;
+import java.io.ByteArrayOutputStream;
+import java.util.Set;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+class HandlersDefaultExceptionTest {
+  private HttpExchange newExchange(ByteArrayOutputStream sink) {
+    HttpExchange ex = Mockito.mock(HttpExchange.class);
+    Mockito.when(ex.getResponseHeaders()).thenReturn(new Headers());
+    Mockito.when(ex.getResponseBody()).thenReturn(sink);
+    return ex;
+  }
+
+  @Test
+  void validationExceptionRendersProblem() throws Exception {
+    ByteArrayOutputStream sink = new ByteArrayOutputStream();
+    HttpExchange ex = newExchange(sink);
+
+    Handlers.defaultExceptionHandler()
+        .handle(
+            ex,
+            new ValidationException(new ValidationError("/x", "type", "expected string", null)));
+
+    Mockito.verify(ex).sendResponseHeaders(Mockito.eq(400), Mockito.anyLong());
+    assertThat(ex.getResponseHeaders().getFirst("Content-Type"))
+        .isEqualTo("application/problem+json");
+    assertThat(sink.toString()).contains("\"keyword\":\"type\"");
+  }
+
+  @Test
+  void notFoundReturns404() throws Exception {
+    HttpExchange ex = newExchange(new ByteArrayOutputStream());
+    Handlers.defaultExceptionHandler().handle(ex, new NotFoundException("GET /x"));
+    Mockito.verify(ex).sendResponseHeaders(404, 0);
+  }
+
+  @Test
+  void methodNotAllowedReturns405WithAllowHeader() throws Exception {
+    HttpExchange ex = newExchange(new ByteArrayOutputStream());
+    Handlers.defaultExceptionHandler()
+        .handle(ex, new MethodNotAllowedException(Set.of(HttpMethod.GET, HttpMethod.POST)));
+    Mockito.verify(ex).sendResponseHeaders(405, 0);
+    assertThat(ex.getResponseHeaders().getFirst("Allow")).contains("GET").contains("POST");
+  }
+}

src/test/java/com/retailsvc/http/internal/ProblemDetailRendererTest.java

@@ -0,0 +1,29 @@
+package com.retailsvc.http.internal;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.retailsvc.http.validate.ValidationError;
+import org.junit.jupiter.api.Test;
+
+class ProblemDetailRendererTest {
+  @Test
+  void rendersExpectedFields() {
+    String body =
+        ProblemDetailRenderer.render(
+            new ValidationError("/email", "format", "string does not match format 'email'", null));
+    assertThat(body)
+        .contains("\"type\":\"about:blank\"")
+        .contains("\"title\":\"Bad Request\"")
+        .contains("\"status\":400")
+        .contains("\"pointer\":\"/email\"")
+        .contains("\"keyword\":\"format\"")
+        .contains("\"detail\":\"string does not match format 'email'\"");
+  }
+
+  @Test
+  void escapesQuotesInDetail() {
+    String body =
+        ProblemDetailRenderer.render(new ValidationError("/x", "k", "has \"quotes\"", null));
+    assertThat(body).contains("\"detail\":\"has \\\"quotes\\\"\"");
+  }
+}