made changes to support the async call executor without an executorservice

Author: elennick

src/main/java/com/evanlennick/retry4j/AsyncCallExecutor.java

@@ -6,11 +6,10 @@
 import java.util.concurrent.Callable;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 
 /**
  * Implementation that kicks off each retry request in its own separate thread that does not block the thread the
- * execution is called from.
+ * execution is called from. If you provide an ExecutorService, it will be used when creating threads.
  *
  * @param <T> The type that is returned by the Callable (eg: Boolean, Void, Object, etc)
  */
@@ -30,10 +29,8 @@ public class AsyncCallExecutor<T> implements RetryExecutor<T, CompletableFuture<
 
     private RetryListener onCompletionListener;
 
-    private static final int DEFAULT_NUMBER_OF_THREADS_IN_POOL = 5;
-
     public AsyncCallExecutor(RetryConfig config) {
-        this(config, Executors.newFixedThreadPool(DEFAULT_NUMBER_OF_THREADS_IN_POOL));
+        this(config, null);
     }
 
     public AsyncCallExecutor(RetryConfig config, ExecutorService executorService) {
@@ -58,18 +55,26 @@ public CompletableFuture<Status<T>> execute(Callable<T> callable, String callNam
 
         CompletableFuture<Status<T>> completableFuture = new CompletableFuture<>();
 
-        executorService.submit(() -> {
-            try {
-                Status<T> status = synchronousCallExecutor.execute(callable, callName);
-                completableFuture.complete(status);
-            } catch (Throwable t) {
-                completableFuture.completeExceptionally(t);
-            }
-        });
+        if (executorService != null) {
+            executorService.submit(()
+                    -> executeFuture(callable, callName, synchronousCallExecutor, completableFuture));
+        } else {
+            (new Thread(()
+                    -> executeFuture(callable, callName, synchronousCallExecutor, completableFuture))).start();
+        }
 
         return completableFuture;
     }
 
+    private void executeFuture(Callable<T> callable, String callName, CallExecutor<T> synchronousCallExecutor, CompletableFuture<Status<T>> completableFuture) {
+        try {
+            Status<T> status = synchronousCallExecutor.execute(callable, callName);
+            completableFuture.complete(status);
+        } catch (Throwable t) {
+            completableFuture.completeExceptionally(t);
+        }
+    }
+
     public AsyncCallExecutor<T> afterFailedTry(RetryListener listener) {
         this.afterFailedTryListener = listener;
         return this;
@@ -100,6 +105,15 @@ public void setConfig(RetryConfig config) {
         this.config = config;
     }
 
+    public void setExecutorService(ExecutorService executorService) {
+        this.executorService = executorService;
+    }
+
+    public ExecutorService getExecutorService() {
+        return executorService;
+    }
+
+    @Deprecated
     public ExecutorService getThreadExecutorService() {
         return executorService;
     }

src/test/java/com/evanlennick/retry4j/AsyncCallExecutorTest.java

@@ -4,13 +4,16 @@
 import com.evanlennick.retry4j.config.RetryConfigBuilder;
 import com.evanlennick.retry4j.exception.RetriesExhaustedException;
 import com.evanlennick.retry4j.exception.UnexpectedException;
+import org.testng.annotations.AfterClass;
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
 
 import java.time.Duration;
 import java.util.concurrent.Callable;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
@@ -21,6 +24,8 @@ public class AsyncCallExecutorTest {
 
     private RetryConfig failOnAnyExceptionConfig;
 
+    private ExecutorService executorService;
+
     @BeforeClass
     public void setup() {
         retryOnAnyExceptionConfig = new RetryConfigBuilder()
@@ -36,10 +41,17 @@ public void setup() {
                 .withMaxNumberOfTries(1)
                 .withDelayBetweenTries(Duration.ofMillis(0))
                 .build();
+
+        executorService = Executors.newFixedThreadPool(5);
+    }
+
+    @AfterClass
+    public void teardown() {
+        executorService.shutdown();
     }
 
     @Test
-    public void verifyMultipleCalls() throws Exception {
+    public void verifyMultipleCalls_noExecutorService() throws Exception {
         Callable<Boolean> callable = () -> true;
 
         AsyncCallExecutor<Boolean> executor = new AsyncCallExecutor<>(retryOnAnyExceptionConfig);
@@ -58,7 +70,7 @@ public void verifyMultipleCalls() throws Exception {
     }
 
     @Test
-    public void verifyOneCall_success() throws Exception {
+    public void verifyOneCall_success_noExecutorService() throws Exception {
         Callable<Boolean> callable = () -> true;
 
         AsyncCallExecutor<Boolean> executor = new AsyncCallExecutor<>(retryOnAnyExceptionConfig);
@@ -71,7 +83,7 @@ public void verifyOneCall_success() throws Exception {
     }
 
     @Test
-    public void verifyOneCall_failDueToTooManyRetries() throws Exception {
+    public void verifyOneCall_failDueToTooManyRetries_noExecutorService() throws Exception {
         Callable<Boolean> callable = () -> { throw new RuntimeException(); };
 
         AsyncCallExecutor<Boolean> executor = new AsyncCallExecutor<>(retryOnAnyExceptionConfig);
@@ -84,7 +96,7 @@ public void verifyOneCall_failDueToTooManyRetries() throws Exception {
     }
 
     @Test
-    public void verifyOneCall_failDueToUnexpectedException() throws Exception {
+    public void verifyOneCall_failDueToUnexpectedException_noExecutorService() throws Exception {
         Callable<Boolean> callable = () -> { throw new RuntimeException(); };
 
         AsyncCallExecutor<Boolean> executor = new AsyncCallExecutor<>(failOnAnyExceptionConfig);
@@ -95,4 +107,70 @@ public void verifyOneCall_failDueToUnexpectedException() throws Exception {
                 .isExactlyInstanceOf(ExecutionException.class)
                 .hasCauseExactlyInstanceOf(UnexpectedException.class);
     }
+
+    @Test
+    public void verifyMultipleCalls_withExecutorService() throws Exception {
+        Callable<Boolean> callable = () -> true;
+
+        AsyncCallExecutor<Boolean> executor = new AsyncCallExecutor<>(
+                retryOnAnyExceptionConfig,
+                executorService);
+
+        CompletableFuture<Status<Boolean>> future1 = executor.execute(callable);
+        CompletableFuture<Status<Boolean>> future2 = executor.execute(callable);
+        CompletableFuture<Status<Boolean>> future3 = executor.execute(callable);
+
+        CompletableFuture combinedFuture
+                = CompletableFuture.allOf(future1, future2, future3);
+        combinedFuture.get();
+
+        assertThat(future1).isDone();
+        assertThat(future2).isDone();
+        assertThat(future3).isDone();
+    }
+
+    @Test
+    public void verifyOneCall_success_withExecutorService() throws Exception {
+        Callable<Boolean> callable = () -> true;
+
+        AsyncCallExecutor<Boolean> executor = new AsyncCallExecutor<>(
+                retryOnAnyExceptionConfig,
+                executorService);
+
+        CompletableFuture<Status<Boolean>> future = executor.execute(callable);
+
+        Status<Boolean> status = future.get();
+        assertThat(future).isDone();
+        assertThat(status.wasSuccessful()).isTrue();
+    }
+
+    @Test
+    public void verifyOneCall_failDueToTooManyRetries_withExecutorService() throws Exception {
+        Callable<Boolean> callable = () -> { throw new RuntimeException(); };
+
+        AsyncCallExecutor<Boolean> executor = new AsyncCallExecutor<>(
+                retryOnAnyExceptionConfig,
+                executorService);
+
+        CompletableFuture<Status<Boolean>> future = executor.execute(callable);
+
+        assertThatThrownBy(future::get)
+                .isExactlyInstanceOf(ExecutionException.class)
+                .hasCauseExactlyInstanceOf(RetriesExhaustedException.class);
+    }
+
+    @Test
+    public void verifyOneCall_failDueToUnexpectedException_withExecutorService() throws Exception {
+        Callable<Boolean> callable = () -> { throw new RuntimeException(); };
+
+        AsyncCallExecutor<Boolean> executor = new AsyncCallExecutor<>(
+                failOnAnyExceptionConfig,
+                executorService);
+
+        CompletableFuture<Status<Boolean>> future = executor.execute(callable);
+
+        assertThatThrownBy(future::get)
+                .isExactlyInstanceOf(ExecutionException.class)
+                .hasCauseExactlyInstanceOf(UnexpectedException.class);
+    }
 }