Add async().asVoid() option

Author: rbygrave

client/src/main/java/io/avaje/http/client/DHttpAsync.java

@@ -25,6 +25,13 @@ public CompletableFuture<HttpResponse<Void>> asDiscarding() {
     return withHandler(HttpResponse.BodyHandlers.discarding());
   }
 
+  @Override
+  public CompletableFuture<HttpResponse<Void>> asVoid() {
+    return request
+      .performSendAsync(true, HttpResponse.BodyHandlers.ofByteArray())
+      .thenApply(request::asyncVoid);
+  }
+
   @Override
   public CompletableFuture<HttpResponse<String>> asString() {
     return request

client/src/main/java/io/avaje/http/client/DHttpClientRequest.java

@@ -404,6 +404,11 @@ protected <T> CompletableFuture<HttpResponse<T>> performSendAsync(boolean loggab
     return context.sendAsync(httpRequest, responseHandler);
   }
 
+  protected HttpResponse<Void> asyncVoid(HttpResponse<byte[]> response) {
+    afterAsyncEncoded(response);
+    return new HttpVoidResponse(response);
+  }
+
   protected <E> E asyncBean(Class<E> type, HttpResponse<byte[]> response) {
     afterAsyncEncoded(response);
     return context.readBean(type, encodedResponseBody);

client/src/main/java/io/avaje/http/client/HttpAsyncResponse.java

@@ -10,8 +10,57 @@
  */
 public interface HttpAsyncResponse {
 
+  /**
+   * Process the response with check for 200 range status code
+   * returning as {@literal HttpResponse<Void>}.
+   * <p>
+   * Unlike {@link #asDiscarding()} this request will read any response
+   * content as bytes with the view that the response content can be
+   * an error message that could be read via for example
+   * {@link HttpException#bean(Class)}.
+   * <p>
+   * Will throw an HttpException if the status code is in the
+   * error range allowing the caller to access the error message
+   * body via for example {@link HttpException#bean(Class)}
+   * <p>
+   * This is intended to be used for POST, PUT, DELETE requests
+   * where the caller is only interested in the response body
+   * when an error occurs (status code not in 200 range).
+   *
+   * <pre>{@code
+   *
+   *   clientContext.request()
+   *       .path("hello/world")
+   *       .GET()
+   *       .async().asVoid()
+   *       .whenComplete((hres, throwable) -> {
+   *
+   *         if (throwable != null) {
+   *
+   *           // if throwable.getCause() is a HttpException for status code >= 300
+   *           HttpException httpException = (HttpException) throwable.getCause();
+   *           int status = httpException.getStatusCode();
+   *
+   *           // convert json error response body to a bean
+   *           ErrorResponse errorResponse = httpException.bean(ErrorResponse.class);
+   *           ...
+   *         } else {
+   *           int statusCode = hres.statusCode();
+   *           ...
+   *         }
+   *       });
+   *
+   * }</pre>
+   */
+  CompletableFuture<HttpResponse<Void>> asVoid();
+
   /**
    * Process discarding response body as {@literal HttpResponse<Void>}.
+   * <p>
+   * Unlike {@link #asVoid()} this will discard any response body including
+   * any error response body. We should instead use {@link #asVoid()} if we
+   * might get an error response body that we want to read via
+   * for example {@link HttpException#bean(Class)}.
    *
    * <pre>{@code
    *

client/src/test/java/io/avaje/http/client/HelloControllerTest.java

@@ -579,6 +579,40 @@ void postForm_asVoid_invokesValidation_expect_badRequest_extractError() {
     }
   }
 
+  @Test
+  void asyncAsVoid_extractError() throws InterruptedException {
+    AtomicReference<HttpException> ref = new AtomicReference<>();
+
+    final CompletableFuture<HttpResponse<Void>> future =
+      clientContext.request()
+        .path("hello/saveform")
+        .formParam("email", "user@foo.com")
+        .formParam("url", "notAValidUrl")
+        .POST()
+        .async()
+        .asVoid()
+        .whenComplete((hres, throwable) -> {
+
+          final HttpException cause = (HttpException) throwable.getCause();
+          ref.set(cause);
+
+          final HttpResponse<?> httpResponse = cause.getHttpResponse();
+          assertNotNull(httpResponse);
+          assertEquals(422, httpResponse.statusCode());
+
+          final ErrorResponse errorResponse = cause.bean(ErrorResponse.class);
+          final Map<String, String> errorMap = errorResponse.getErrors();
+          assertThat(errorMap.get("url")).isEqualTo("must be a valid URL");
+          assertThat(errorMap.get("name")).isEqualTo("must not be null");
+        });
+
+    try {
+      future.get();
+    } catch (ExecutionException e) {
+      assertThat(ref.get()).isNotNull();
+    }
+  }
+
   @Test
   void postForm_asBytes_validation_expect_badRequest_extractError() {
     try {