fixed NPE bug with no wait backoff and added new capability to specify custom exception checking logic

Author: elennick

README.md

@@ -127,7 +127,6 @@ Retry4j does not require any external dependencies. It does require that you are
 
 If you do not specify how exceptions should be handled or explicitly say **failOnAnyException()**, the CallExecutor will fail and throw an **UnexpectedException** when encountering exceptions while running. Use this configuration if you want the executor to cease its work when it runs into any exception at all.
 
-
 ```java
 RetryConfig config = new RetryConfigBuilder()
         .failOnAnyException()
@@ -144,7 +143,6 @@ RetryConfig config = new RetryConfigBuilder()
 
 If you want the executor to continue to retry on all encountered exceptions, specify this using the **retryOnAnyException()** config option.
 
-
 ```java
 RetryConfig config = new RetryConfigBuilder()
         .retryOnAnyException()
@@ -159,6 +157,18 @@ RetryConfig config = new RetryConfigBuilder()
         .build();
 ```
 
+If you do not want to use these built-in mechanisms for retrying on exceptions, you can override them and create custom logic:
+
+```java
+RetryConfig config = new RetryConfigBuilder()
+        .retryOnCustomExceptionLogic(ex -> {
+            //return true to retry, otherwise return false
+        })
+        .build();
+```
+
+If you create custom exception logic, no other built-in configuration can be used at the same time.
+
 ### Value Handling Config
 
 If you want the executor to retry based on the returned value from the Callable:

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

@@ -15,7 +15,7 @@
 import java.util.concurrent.TimeUnit;
 
 /**
- * Default implementation that does a single, synchrnous retry in the same thread that it is called from.
+ * Default implementation that does a single, synchronous retry in the same thread that it is called from.
  *
  * @param <T> The type that is returned by the Callable (eg: Boolean, Void, Object, etc)
  */
@@ -62,7 +62,8 @@ public Status<T> execute(Callable<T> callable, String callName) {
         status.setStartTime(start);
 
         int maxTries = config.getMaxNumberOfTries();
-        long millisBetweenTries = config.getDelayBetweenRetries().toMillis();
+        long millisBetweenTries = config.getDelayBetweenRetries() != null
+                ? config.getDelayBetweenRetries().toMillis() : 0L;
         this.status.setCallName(callName);
 
         AttemptStatus<T> attemptStatus = new AttemptStatus<>();
@@ -181,26 +182,31 @@ private void sleep(long millis, int tries) {
     }
 
     private boolean shouldThrowException(Exception e) {
-        //config says to always retry
-        if (this.config.isRetryOnAnyException()) {
-            return false;
-        }
-
-        //config says to retry only on specific exceptions
-        for (Class<? extends Exception> exceptionInSet : this.config.getRetryOnSpecificExceptions()) {
-            if (exceptionInSet.isAssignableFrom(e.getClass())) {
+        if (this.config.getCustomRetryOnLogic() != null) {
+            //custom retry logic
+            return !this.config.getCustomRetryOnLogic().apply(e);
+        } else {
+            //config says to always retry
+            if (this.config.isRetryOnAnyException()) {
                 return false;
             }
-        }
 
-        //config says to retry on all except specific exceptions
-        for (Class<? extends Exception> exceptionInSet : this.config.getRetryOnAnyExceptionExcluding()) {
-            if (!exceptionInSet.isAssignableFrom(e.getClass())) {
-                return false;
+            //config says to retry only on specific exceptions
+            for (Class<? extends Exception> exceptionInSet : this.config.getRetryOnSpecificExceptions()) {
+                if (exceptionInSet.isAssignableFrom(e.getClass())) {
+                    return false;
+                }
             }
-        }
 
-        return true;
+            //config says to retry on all except specific exceptions
+            for (Class<? extends Exception> exceptionInSet : this.config.getRetryOnAnyExceptionExcluding()) {
+                if (!exceptionInSet.isAssignableFrom(e.getClass())) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
     }
 
     @Override

src/main/java/com/evanlennick/retry4j/config/RetryConfig.java

@@ -5,6 +5,7 @@
 import java.time.Duration;
 import java.util.HashSet;
 import java.util.Set;
+import java.util.function.Function;
 
 public class RetryConfig {
 
@@ -16,6 +17,7 @@ public class RetryConfig {
     private BackoffStrategy backoffStrategy;
     private Object valueToRetryOn;
     private Boolean retryOnValue = false;
+    private Function<Exception, Boolean> customRetryOnLogic;
 
     public Object getValueToRetryOn() {
         return valueToRetryOn;
@@ -89,14 +91,26 @@ public void setBackoffStrategy(BackoffStrategy backoffStrategy) {
         this.backoffStrategy = backoffStrategy;
     }
 
+    public Function<Exception, Boolean> getCustomRetryOnLogic() {
+        return customRetryOnLogic;
+    }
+
+    public void setCustomRetryOnLogic(Function<Exception, Boolean> customRetryOnLogic) {
+        this.customRetryOnLogic = customRetryOnLogic;
+    }
+
     @Override
     public String toString() {
         final StringBuilder sb = new StringBuilder("RetryConfig{");
         sb.append("retryOnAnyException=").append(retryOnAnyException);
         sb.append(", retryOnSpecificExceptions=").append(retryOnSpecificExceptions);
+        sb.append(", retryOnAnyExceptionExcluding=").append(retryOnAnyExceptionExcluding);
         sb.append(", maxNumberOfTries=").append(maxNumberOfTries);
         sb.append(", delayBetweenRetries=").append(delayBetweenRetries);
         sb.append(", backoffStrategy=").append(backoffStrategy);
+        sb.append(", valueToRetryOn=").append(valueToRetryOn);
+        sb.append(", retryOnValue=").append(retryOnValue);
+        sb.append(", customRetryOnLogic=").append(customRetryOnLogic);
         sb.append('}');
         return sb.toString();
     }

src/main/java/com/evanlennick/retry4j/config/RetryConfigBuilder.java

@@ -14,12 +14,13 @@
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;
+import java.util.function.Function;
 
 import static java.time.temporal.ChronoUnit.SECONDS;
 
 public class RetryConfigBuilder {
 
-    private boolean exceptionStrategySpecified;
+    private boolean builtInExceptionStrategySpecified;
     private RetryConfig config;
     private boolean validationEnabled;
 
@@ -33,10 +34,12 @@ public class RetryConfigBuilder {
             = "Retry config cannot specify more than one exception strategy!";
     public final static String ALREADY_SPECIFIED_NUMBER_OF_TRIES__ERROR_MSG
             = "Number of tries can only be specified once!";
+    public final static String CAN_ONLY_SPECIFY_CUSTOM_EXCEPTION_STRAT__ERROR_MSG
+            = "You cannot use built in exception logic and custom exception logic in the same config!";
 
     public RetryConfigBuilder() {
         this.config = new RetryConfig();
-        this.exceptionStrategySpecified = false;
+        this.builtInExceptionStrategySpecified = false;
         this.validationEnabled = true;
     }
 
@@ -58,7 +61,7 @@ public RetryConfigBuilder retryOnAnyException() {
 
         config.setRetryOnAnyException(true);
 
-        exceptionStrategySpecified = true;
+        builtInExceptionStrategySpecified = true;
         return this;
     }
 
@@ -68,7 +71,7 @@ public RetryConfigBuilder failOnAnyException() {
         config.setRetryOnAnyException(false);
         config.setRetryOnSpecificExceptions(new HashSet<>());
 
-        exceptionStrategySpecified = true;
+        builtInExceptionStrategySpecified = true;
         return this;
     }
 
@@ -79,7 +82,7 @@ public final RetryConfigBuilder retryOnSpecificExceptions(Class<? extends Except
         Set<Class<? extends Exception>> setOfExceptions = new HashSet<>(Arrays.asList(exceptions));
         config.setRetryOnSpecificExceptions(setOfExceptions);
 
-        exceptionStrategySpecified = true;
+        builtInExceptionStrategySpecified = true;
         return this;
     }
 
@@ -90,7 +93,7 @@ public final RetryConfigBuilder retryOnAnyExceptionExcluding(Class<? extends Exc
         Set<Class<? extends Exception>> setOfExceptions = new HashSet<>(Arrays.asList(exceptions));
         config.setRetryOnAnyExceptionExcluding(setOfExceptions);
 
-        exceptionStrategySpecified = true;
+        builtInExceptionStrategySpecified = true;
         return this;
     }
 
@@ -101,6 +104,11 @@ public final RetryConfigBuilder retryOnReturnValue(Object value) {
         return this;
     }
 
+    public RetryConfigBuilder retryOnCustomExceptionLogic(Function<Exception, Boolean> customRetryFunction) {
+        this.config.setCustomRetryOnLogic(customRetryFunction);
+        return this;
+    }
+
     public RetryConfigBuilder withMaxNumberOfTries(int max) {
         if (config.getMaxNumberOfTries() != null) {
             throw new InvalidRetryConfigException(ALREADY_SPECIFIED_NUMBER_OF_TRIES__ERROR_MSG);
@@ -190,6 +198,10 @@ private void validateConfig() {
             throw new InvalidRetryConfigException(MUST_SPECIFY_MAX_TRIES__ERROR_MSG);
         }
 
+        if (null != config.getCustomRetryOnLogic() && builtInExceptionStrategySpecified) {
+            throw new InvalidRetryConfigException(CAN_ONLY_SPECIFY_CUSTOM_EXCEPTION_STRAT__ERROR_MSG);
+        }
+
         config.getBackoffStrategy().validateConfig(config);
     }
 
@@ -208,7 +220,7 @@ private void validateExceptionStrategyAddition() {
             return;
         }
 
-        if (exceptionStrategySpecified) {
+        if (builtInExceptionStrategySpecified) {
             throw new InvalidRetryConfigException(CAN_ONLY_SPECIFY_ONE_EXCEPTION_STRAT__ERROR_MSG);
         }
     }

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

@@ -5,7 +5,6 @@
 import com.evanlennick.retry4j.config.RetryConfigBuilder;
 import com.evanlennick.retry4j.exception.RetriesExhaustedException;
 import com.evanlennick.retry4j.exception.UnexpectedException;
-
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.testng.annotations.BeforeMethod;
@@ -258,4 +257,18 @@ public void verifyRetryPolicyTimeoutIsUsed() {
         assertThat(System.currentTimeMillis() - before).isGreaterThan(5000);
         verify(mockBackOffStrategy).getDurationToWait(1, delayBetweenTriesDuration);
     }
+
+    @Test
+    public void verifyNoDurationSpecifiedSucceeds() {
+        Callable<String> callable = () -> "test";
+
+        RetryConfig noWaitConfig = new RetryConfigBuilder()
+                .withMaxNumberOfTries(1)
+                .withNoWaitBackoff()
+                .build();
+
+        Status status = new CallExecutor(noWaitConfig).execute(callable);
+
+        assertThat(status.getResult()).isEqualTo("test");
+    }
 }

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

@@ -0,0 +1,49 @@
+package com.evanlennick.retry4j;
+
+import com.evanlennick.retry4j.config.RetryConfig;
+import com.evanlennick.retry4j.config.RetryConfigBuilder;
+import com.evanlennick.retry4j.exception.RetriesExhaustedException;
+import com.evanlennick.retry4j.exception.UnexpectedException;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.time.Duration;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.testng.Assert.fail;
+
+public class CallExecutorTest_RetryOnCustomLogicTest {
+
+    private static RetryConfig config;
+
+    @BeforeClass
+    public static void setup() {
+        config = new RetryConfigBuilder()
+                .retryOnCustomExceptionLogic(ex -> ex.getMessage().contains("should retry!"))
+                .withFixedBackoff()
+                .withDelayBetweenTries(Duration.ofMillis(1))
+                .withMaxNumberOfTries(3)
+                .build();
+    }
+
+    @Test
+    public void verifyShouldRetry() {
+        try {
+            new CallExecutor<>(config)
+                    .execute(() -> {
+                        throw new RuntimeException("should retry!");
+                    });
+            fail();
+        } catch (RetriesExhaustedException e) {
+            assertThat(e.getStatus().getTotalTries()).isEqualTo(3);
+        }
+    }
+
+    @Test(expected = UnexpectedException.class)
+    public void verifyShouldNotRetry() {
+        new CallExecutor<>(config)
+                .execute(() -> {
+                    throw new RuntimeException("should NOT retry!");
+                });
+    }
+}

src/test/java/com/evanlennick/retry4j/config/RetryConfigBuilderTest_WithValidationTest.java

@@ -1,10 +1,12 @@
 package com.evanlennick.retry4j.config;
 
 import com.evanlennick.retry4j.exception.InvalidRetryConfigException;
+import org.testng.TestException;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
 
 import java.net.ConnectException;
+import java.time.Duration;
 import java.time.temporal.ChronoUnit;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -193,4 +195,55 @@ public void verifyMaxRetriesSpecifiedTwiceThrowsException_twoNumbers() {
                     .isEqualTo(RetryConfigBuilder.ALREADY_SPECIFIED_NUMBER_OF_TRIES__ERROR_MSG);
         }
     }
+
+    @Test
+    public void verifySpecifyingMultipleBuildInAndCustomExceptionStrategiesThrowsException_anyException() {
+        try {
+            retryConfigBuilder
+                    .retryOnAnyException()
+                    .retryOnCustomExceptionLogic(ex -> ex.getMessage().contains("should retry!"))
+                    .withFixedBackoff()
+                    .withDelayBetweenTries(Duration.ofMillis(1))
+                    .withMaxNumberOfTries(3)
+                    .build();
+            fail("Expected InvalidRetryConfigException but one wasn't thrown!");
+        } catch (InvalidRetryConfigException e) {
+            assertThat(e.getMessage())
+                    .isEqualTo(RetryConfigBuilder.CAN_ONLY_SPECIFY_CUSTOM_EXCEPTION_STRAT__ERROR_MSG);
+        }
+    }
+
+    @Test
+    public void verifySpecifyingMultipleBuildInAndCustomExceptionStrategiesThrowsException_specificExceptions() {
+        try {
+            retryConfigBuilder
+                    .retryOnSpecificExceptions(TestException.class)
+                    .retryOnCustomExceptionLogic(ex -> ex.getMessage().contains("should retry!"))
+                    .withFixedBackoff()
+                    .withDelayBetweenTries(Duration.ofMillis(1))
+                    .withMaxNumberOfTries(3)
+                    .build();
+            fail("Expected InvalidRetryConfigException but one wasn't thrown!");
+        } catch (InvalidRetryConfigException e) {
+            assertThat(e.getMessage())
+                    .isEqualTo(RetryConfigBuilder.CAN_ONLY_SPECIFY_CUSTOM_EXCEPTION_STRAT__ERROR_MSG);
+        }
+    }
+
+    @Test
+    public void verifySpecifyingMultipleBuildInAndCustomExceptionStrategiesThrowsException_excludingExceptions() {
+        try {
+            retryConfigBuilder
+                    .retryOnAnyExceptionExcluding(TestException.class)
+                    .retryOnCustomExceptionLogic(ex -> ex.getMessage().contains("should retry!"))
+                    .withFixedBackoff()
+                    .withDelayBetweenTries(Duration.ofMillis(1))
+                    .withMaxNumberOfTries(3)
+                    .build();
+            fail("Expected InvalidRetryConfigException but one wasn't thrown!");
+        } catch (InvalidRetryConfigException e) {
+            assertThat(e.getMessage())
+                    .isEqualTo(RetryConfigBuilder.CAN_ONLY_SPECIFY_CUSTOM_EXCEPTION_STRAT__ERROR_MSG);
+        }
+    }
 }