Create function composition DSL for okhttp, retrofit, that mirrors Failsafe class

Author: jhalterman

modules/okhttp/src/main/java/dev/failsafe/okhttp/FailsafeCall.java

@@ -38,30 +38,47 @@ public final class FailsafeCall {
   private AtomicBoolean cancelled = new AtomicBoolean();
   private AtomicBoolean executed = new AtomicBoolean();
 
-  private FailsafeCall(okhttp3.Call call, FailsafeExecutor<Response> failsafe) {
-    this.initialCall = call;
+  private FailsafeCall(FailsafeExecutor<Response> failsafe, okhttp3.Call call) {
     this.failsafe = failsafe;
+    this.initialCall = call;
+  }
+
+  public static final class FailsafeCallBuilder {
+    private FailsafeExecutor<Response> failsafe;
+
+    private FailsafeCallBuilder(FailsafeExecutor<Response> failsafe) {
+      this.failsafe = failsafe;
+    }
+
+    public <P extends Policy<Response>> FailsafeCallBuilder compose(P innerPolicy) {
+      failsafe = failsafe.compose(innerPolicy);
+      return this;
+    }
+
+    public FailsafeCall compose(okhttp3.Call call) {
+      return new FailsafeCall(failsafe, call);
+    }
   }
 
   /**
-   * Returns a FailsafeCall for the {@code call}, {@code outerPolicy} and {@code policies}. See {@link
-   * Failsafe#with(Policy, Policy[])} for docs on how policy composition works.
+   * Returns a FailsafeCallBuilder for the {@code outerPolicy} and {@code policies}. See {@link Failsafe#with(Policy,
+   * Policy[])} for docs on how policy composition works.
    *
    * @param <P> policy type
    * @throws NullPointerException if {@code call} or {@code outerPolicy} are null
    */
   @SafeVarargs
-  public static <P extends Policy<Response>> FailsafeCall of(okhttp3.Call call, P outerPolicy, P... policies) {
-    return of(call, Failsafe.with(outerPolicy, policies));
+  public static <P extends Policy<Response>> FailsafeCallBuilder with(P outerPolicy, P... policies) {
+    return new FailsafeCallBuilder(Failsafe.with(outerPolicy, policies));
   }
 
   /**
-   * Returns a FailsafeCall for the {@code call} and {@code failsafeExecutor}.
+   * Returns a FailsafeCallBuilder for the {@code failsafeExecutor}.
    *
-   * @throws NullPointerException if {@code call} or {@code failsafeExecutor} are null
+   * @throws NullPointerException if {@code failsafeExecutor} is null
    */
-  public static FailsafeCall of(okhttp3.Call call, FailsafeExecutor<Response> failsafeExecutor) {
-    return new FailsafeCall(Assert.notNull(call, "call"), Assert.notNull(failsafeExecutor, "failsafeExecutor"));
+  public static FailsafeCallBuilder with(FailsafeExecutor<Response> failsafeExecutor) {
+    return new FailsafeCallBuilder(Assert.notNull(failsafeExecutor, "failsafeExecutor"));
   }
 
   /**
@@ -80,7 +97,7 @@ public void cancel() {
    * Returns a clone of the FailsafeCall.
    */
   public FailsafeCall clone() {
-    return FailsafeCall.of(initialCall.clone(), failsafe);
+    return new FailsafeCall(failsafe, initialCall.clone());
   }
 
   /**

modules/okhttp/src/test/java/dev/failsafe/okhttp/FailsafeCallTest.java

@@ -168,7 +168,7 @@ public void testCancel() {
     Call call = callFor("/test");
 
     // When / Then Sync
-    FailsafeCall failsafeCall = FailsafeCall.of(call, failsafe);
+    FailsafeCall failsafeCall = FailsafeCall.with(failsafe).compose(call);
     runInThread(() -> {
       sleep(150);
       failsafeCall.cancel();
@@ -179,7 +179,7 @@ public void testCancel() {
 
     // When / Then Async
     Call call2 = call.clone();
-    FailsafeCall failsafeCall2 = FailsafeCall.of(call2, failsafe);
+    FailsafeCall failsafeCall2 = FailsafeCall.with(failsafe).compose(call2);
     runInThread(() -> {
       sleep(150);
       failsafeCall2.cancel();
@@ -197,7 +197,7 @@ public void testCancelViaFuture() {
     Call call = callFor("/test");
 
     // When / Then Async
-    FailsafeCall failsafeCall = FailsafeCall.of(call, failsafe);
+    FailsafeCall failsafeCall = FailsafeCall.with(failsafe).compose(call);
     Future<Response> future = failsafeCall.executeAsync();
     sleep(150);
     future.cancel(false);

modules/okhttp/src/test/java/dev/failsafe/okhttp/testing/OkHttpTesting.java

@@ -72,7 +72,7 @@ private <T> void test(FailsafeExecutor<Response> failsafe, Call when, Then<Respo
 
     // Run sync test and assert result
     System.out.println("\nRunning sync test");
-    FailsafeCall failsafeCall = FailsafeCall.of(when, failsafe);
+    FailsafeCall failsafeCall = FailsafeCall.with(failsafe).compose(when);
     if (expectedExceptions == null) {
       assertResult.accept(unwrapExceptions(failsafeCall::execute));
     } else {

modules/retrofit/src/main/java/dev/failsafe/retrofit/FailsafeCall.java

@@ -27,45 +27,61 @@
 /**
  * A Failsafe wrapped Retrofit {@link Call}. Supports synchronous and asynchronous executions, and cancellation.
  *
- * @param <T> response type
+ * @param <R> response type
  * @author Jonathan Halterman
  */
-public final class FailsafeCall<T> {
-  private final FailsafeExecutor<Response<T>> failsafe;
-  private final retrofit2.Call<T> initialCall;
+public final class FailsafeCall<R> {
+  private final FailsafeExecutor<Response<R>> failsafe;
+  private final retrofit2.Call<R> initialCall;
 
-  private volatile Call<Response<T>> failsafeCall;
-  private volatile CompletableFuture<Response<T>> failsafeFuture;
+  private volatile Call<Response<R>> failsafeCall;
+  private volatile CompletableFuture<Response<R>> failsafeFuture;
   private AtomicBoolean cancelled = new AtomicBoolean();
   private AtomicBoolean executed = new AtomicBoolean();
 
-  private FailsafeCall(retrofit2.Call<T> call, FailsafeExecutor<Response<T>> failsafe) {
-    this.initialCall = call;
+  private FailsafeCall(FailsafeExecutor<Response<R>> failsafe, retrofit2.Call<R> call) {
     this.failsafe = failsafe;
+    this.initialCall = call;
+  }
+
+  public static final class FailsafeCallBuilder<R> {
+    private FailsafeExecutor<Response<R>> failsafe;
+
+    private FailsafeCallBuilder(FailsafeExecutor<Response<R>> failsafe) {
+      this.failsafe = failsafe;
+    }
+
+    public <P extends Policy<Response<R>>> FailsafeCallBuilder<R> compose(P innerPolicy) {
+      failsafe = failsafe.compose(innerPolicy);
+      return this;
+    }
+
+    public FailsafeCall<R> compose(retrofit2.Call<R> call) {
+      return new FailsafeCall<>(failsafe, call);
+    }
   }
 
   /**
-   * Returns a FailsafeCall for the {@code call}, {@code outerPolicy} and {@code policies}. See {@link
-   * Failsafe#with(Policy, Policy[])} for docs on how policy composition works.
+   * Returns a FailsafeCallBuilder for the {@code outerPolicy} and {@code policies}. See {@link Failsafe#with(Policy,
+   * Policy[])} for docs on how policy composition works.
    *
-   * @param <T> response type
+   * @param <R> result type
    * @param <P> policy type
    * @throws NullPointerException if {@code call} or {@code outerPolicy} are null
    */
   @SafeVarargs
-  public static <T, P extends Policy<Response<T>>> FailsafeCall<T> of(retrofit2.Call<T> call, P outerPolicy,
-    P... policies) {
-    return of(call, Failsafe.with(outerPolicy, policies));
+  public static <R, P extends Policy<Response<R>>> FailsafeCallBuilder<R> with(P outerPolicy, P... policies) {
+    return new FailsafeCallBuilder<>(Failsafe.with(outerPolicy, policies));
   }
 
   /**
-   * Returns a FailsafeCall for the {@code call} and {@code failsafeExecutor}.
+   * Returns a FailsafeCallBuilder for the {@code failsafeExecutor}.
    *
-   * @param <T> response type
-   * @throws NullPointerException if {@code call} or {@code failsafeExecutor} are null
+   * @param <R> result type
+   * @throws NullPointerException if {@code failsafeExecutor} is null
    */
-  public static <T> FailsafeCall<T> of(retrofit2.Call<T> call, FailsafeExecutor<Response<T>> failsafeExecutor) {
-    return new FailsafeCall<>(Assert.notNull(call, "call"), Assert.notNull(failsafeExecutor, "failsafeExecutor"));
+  public static <R> FailsafeCallBuilder<R> with(FailsafeExecutor<Response<R>> failsafeExecutor) {
+    return new FailsafeCallBuilder<>(Assert.notNull(failsafeExecutor, "failsafeExecutor"));
   }
 
   /**
@@ -83,8 +99,8 @@ public void cancel() {
   /**
    * Returns a clone of the FailsafeCall.
    */
-  public FailsafeCall<T> clone() {
-    return FailsafeCall.of(initialCall.clone(), failsafe);
+  public FailsafeCall<R> clone() {
+    return new FailsafeCall<>(failsafe, initialCall.clone());
   }
 
   /**
@@ -95,7 +111,7 @@ public FailsafeCall<T> clone() {
    * @throws FailsafeException if the execution fails with a checked Exception. {@link FailsafeException#getCause()} can
    * be used to learn the underlying checked exception.
    */
-  public Response<T> execute() throws IOException {
+  public Response<R> execute() throws IOException {
     Assert.isTrue(executed.compareAndSet(false, true), "already executed");
 
     failsafeCall = failsafe.newCall(ctx -> {
@@ -114,22 +130,22 @@ public Response<T> execute() throws IOException {
   /**
    * Executes the call asynchronously until a successful result is returned or the configured policies are exceeded.
    */
-  public CompletableFuture<Response<T>> executeAsync() {
+  public CompletableFuture<Response<R>> executeAsync() {
     if (!executed.compareAndSet(false, true)) {
-      CompletableFuture<Response<T>> result = new CompletableFuture<>();
+      CompletableFuture<Response<R>> result = new CompletableFuture<>();
       result.completeExceptionally(new IllegalStateException("already executed"));
       return result;
     }
 
     failsafeFuture = failsafe.getAsyncExecution(exec -> {
-      prepareCall(exec).enqueue(new Callback<T>() {
+      prepareCall(exec).enqueue(new Callback<R>() {
         @Override
-        public void onResponse(retrofit2.Call<T> call, Response<T> response) {
+        public void onResponse(retrofit2.Call<R> call, Response<R> response) {
           exec.recordResult(response);
         }
 
         @Override
-        public void onFailure(retrofit2.Call<T> call, Throwable throwable) {
+        public void onFailure(retrofit2.Call<R> call, Throwable throwable) {
           exec.recordException(throwable);
         }
       });
@@ -152,8 +168,8 @@ public boolean isExecuted() {
     return executed.get();
   }
 
-  private retrofit2.Call<T> prepareCall(ExecutionContext<Response<T>> ctx) {
-    retrofit2.Call<T> call = ctx.isFirstAttempt() ? initialCall : initialCall.clone();
+  private retrofit2.Call<R> prepareCall(ExecutionContext<Response<R>> ctx) {
+    retrofit2.Call<R> call = ctx.isFirstAttempt() ? initialCall : initialCall.clone();
 
     // Propagate cancellation to the call
     ctx.onCancel(() -> {

modules/retrofit/src/test/java/dev/retrofit/FailsafeCallTest.java

@@ -183,7 +183,7 @@ public void testCancel() {
     Call<User> call = service.testUser();
 
     // When / Then Sync
-    FailsafeCall<User> failsafeCall = FailsafeCall.of(call, failsafe);
+    FailsafeCall<User> failsafeCall = FailsafeCall.with(failsafe).compose(call);
     runInThread(() -> {
       sleep(150);
       failsafeCall.cancel();
@@ -194,7 +194,7 @@ public void testCancel() {
 
     // When / Then Async
     Call<User> call2 = call.clone();
-    FailsafeCall<User> failsafeCall2 = FailsafeCall.of(call2, failsafe);
+    FailsafeCall<User> failsafeCall2 = FailsafeCall.with(failsafe).compose(call2);
     runInThread(() -> {
       sleep(150);
       failsafeCall2.cancel();
@@ -210,7 +210,7 @@ public void testCancelViaFuture() {
     mockDelayedResponse(200, "foo", 1000);
     FailsafeExecutor<Response<User>> failsafe = Failsafe.none();
     Call<User> call = service.testUser();
-    FailsafeCall<User> failsafeCall = FailsafeCall.of(call, failsafe);
+    FailsafeCall<User> failsafeCall = FailsafeCall.with(failsafe).compose(call);
 
     // When / Then Async
     Future<Response<User>> future = failsafeCall.executeAsync();

modules/retrofit/src/test/java/dev/retrofit/testing/RetrofitTesting.java

@@ -68,7 +68,7 @@ private <T> void test(FailsafeExecutor<Response<T>> failsafe, Call<T> when, Then
 
     // Run sync test and assert result
     System.out.println("\nRunning sync test");
-    FailsafeCall<T> failsafeCall = FailsafeCall.of(when, failsafe);
+    FailsafeCall<T> failsafeCall = FailsafeCall.with(failsafe).compose(when);
     if (expectedExceptions == null) {
       assertResult.accept(unwrapExceptions(failsafeCall::execute));
     } else {