Add Async bean() support

Author: rbygrave

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

@@ -25,4 +25,10 @@ public CompletableFuture<HttpResponse<String>> asString() {
       .thenApply(request::afterAsync);
   }
 
+  @Override
+  public <E> CompletableFuture<E> bean(Class<E> type) {
+    return request
+      .performSendAsync(true, HttpResponse.BodyHandlers.ofByteArray())
+      .thenApply(httpResponse -> request.asyncBean(type, httpResponse));
+  }
 }

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

@@ -100,7 +100,7 @@ public void checkResponse(HttpResponse<?> response) {
     }
   }
 
-  void check(HttpResponse<byte[]> response) {
+  void checkMaybeThrow(HttpResponse<byte[]> response) {
     if (response.statusCode() >= 300) {
       throw new HttpException(this, response);
     }

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

@@ -327,7 +327,7 @@ public HttpClientResponse TRACE() {
   private void readResponseContent() {
     final HttpResponse<byte[]> response = asByteArray();
     this.httpResponse = response;
-    context.check(response);
+    context.checkMaybeThrow(response);
     encodedResponseBody = context.readContent(response);
   }
 
@@ -393,6 +393,15 @@ protected <T> CompletableFuture<HttpResponse<T>> performSendAsync(boolean loggab
     return context.sendAsync(httpRequest, responseHandler);
   }
 
+  protected <E> E asyncBean(Class<E> type, HttpResponse<byte[]> response) {
+    requestTimeNanos = System.nanoTime() - startAsyncNanos;
+    httpResponse = response;
+    encodedResponseBody = context.readContent(response);
+    context.afterResponse(this);
+    context.checkMaybeThrow(response);
+    return context.readBean(type, encodedResponseBody);
+  }
+
   public <E> HttpResponse<E> afterAsync(HttpResponse<E> response) {
     requestTimeNanos = System.nanoTime() - startAsyncNanos;
     httpResponse = response;

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

@@ -18,4 +18,37 @@ public interface HttpAsyncResponse {
    */
   CompletableFuture<HttpResponse<String>> asString();
 
+  /**
+   * Process expecting a (json) bean response body.
+   * <p>
+   * If the HTTP statusCode is 300 or above a HttpException is throw which
+   * contains the HttpResponse.
+   *
+   * <pre>{@code
+   *
+   *    clientContext.request()
+   *       ...
+   *       .POST().async()
+   *       .bean(HelloDto.class)
+   *       .whenComplete((helloDto, throwable) -> {
+   *
+   *         if (throwable != null) {
+   *           HttpException httpException = (HttpException) throwable.getCause();
+   *           int statusCode = httpException.getStatusCode();
+   *
+   *           // maybe convert json error response body to a bean (using Jackson/Gson)
+   *           MyErrorBean errorResponse = httpException.bean(MyErrorBean.class);
+   *           ..
+   *
+   *         } else {
+   *           // use helloDto
+   *           ...
+   *         }
+   *
+   *       });
+   *
+   *
+   * }</pre>
+   */
+  <E> CompletableFuture<E> bean(Class<E> type);
 }

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

@@ -8,7 +8,10 @@
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -106,6 +109,108 @@ void get_withPathParamAndQueryParam_returningBean() {
     assertThat(dto.otherParam).isEqualTo("other");
   }
 
+  @Test
+  void async_whenComplete_returningBean() throws ExecutionException, InterruptedException {
+
+    final AtomicInteger counter = new AtomicInteger();
+    final AtomicReference<HelloDto> ref = new AtomicReference<>();
+
+    final CompletableFuture<HelloDto> future = clientContext.request()
+      .path("hello/43/2020-03-05").queryParam("otherParam", "other").queryParam("foo", null)
+      .GET()
+      .async().bean(HelloDto.class);
+
+    future.whenComplete((dto, throwable) -> {
+      counter.incrementAndGet();
+      ref.set(dto);
+
+      assertThat(throwable).isNull();
+      assertThat(dto.id).isEqualTo(43L);
+      assertThat(dto.name).isEqualTo("2020-03-05");
+      assertThat(dto.otherParam).isEqualTo("other");
+    });
+
+    // wait ...
+    final HelloDto dto = future.get();
+    assertThat(counter.incrementAndGet()).isEqualTo(2);
+    assertThat(dto).isSameAs(ref.get());
+
+    assertThat(dto.id).isEqualTo(43L);
+    assertThat(dto.name).isEqualTo("2020-03-05");
+    assertThat(dto.otherParam).isEqualTo("other");
+  }
+
+  @Test
+  void async_whenComplete_throwingHttpException() {
+
+    AtomicReference<HttpException> causeRef = new AtomicReference<>();
+
+    final CompletableFuture<HelloDto> future = clientContext.request()
+      .path("hello/saveform3")
+      .formParam("name", "Bax")
+      .formParam("email", "notValidEmail")
+      .formParam("url", "notValidUrl")
+      .formParam("startDate", "2030-12-03")
+      .POST()
+      .async()
+      .bean(HelloDto.class)
+      .whenComplete((helloDto, throwable) -> {
+        // we get a throwable
+        assertThat(throwable.getCause()).isInstanceOf(HttpException.class);
+        assertThat(helloDto).isNull();
+
+        final HttpException httpException = (HttpException) throwable.getCause();
+        causeRef.set(httpException);
+        assertThat(httpException.getStatusCode()).isEqualTo(422);
+
+        // convert json error response body to a bean
+        final ErrorResponse errorResponse = httpException.bean(ErrorResponse.class);
+
+        final Map<String, String> errorMap = errorResponse.getErrors();
+        assertThat(errorMap.get("url")).isEqualTo("must be a valid URL");
+        assertThat(errorMap.get("email")).isEqualTo("must be a well-formed email address");
+      });
+
+    try {
+      future.join();
+    } catch (CompletionException e) {
+      assertThat(e.getCause()).isSameAs(causeRef.get());
+    }
+  }
+
+  @Test
+  void async_exceptionally_style() {
+
+    AtomicReference<HttpException> causeRef = new AtomicReference<>();
+
+    final CompletableFuture<HelloDto> future = clientContext.request()
+      .path("hello/saveform3")
+      .formParam("name", "Bax")
+      .formParam("email", "notValidEmail")
+      .formParam("url", "notValidUrl")
+      .formParam("startDate", "2030-12-03")
+      .POST()
+      .async()
+      .bean(HelloDto.class);
+
+    future.exceptionally(throwable -> {
+        final HttpException httpException = (HttpException) throwable.getCause();
+        causeRef.set(httpException);
+        assertThat(httpException.getStatusCode()).isEqualTo(422);
+
+        return new HelloDto(0, "ErrorResponse", "");
+
+    }).thenAccept(helloDto -> {
+      assertThat(helloDto.name).isEqualTo("ErrorResponse");
+    });
+
+    try {
+      future.join();
+    } catch (CompletionException e) {
+      assertThat(e.getCause()).isSameAs(causeRef.get());
+    }
+  }
+
   @Test
   void post_bean_returningBean_usingExplicitConverters() {