Altered Failsafe's exception policy to only throw FailsafeExceptions if an execution fails due to a checked Exception. Closes failsafe-lib#66.

Author: jhalterman

CHANGES.md

@@ -1,3 +1,9 @@
+# 1.0.0
+
+### API Changes
+
+* Failsafe will now only throw `FailsafeException` when an execution fails with a checked `Exception`. See [issue #66](https://github.com/jhalterman/failsafe/issues/66) for details.
+
 # 0.9.5
 
 ### Bug Fixes

src/main/java/net/jodah/failsafe/SyncFailsafe.java

@@ -48,8 +48,8 @@ public class SyncFailsafe<R> extends FailsafeConfig<R, SyncFailsafe<R>> {
    * exceeded.
    * 
    * @throws NullPointerException if the {@code callable} is null
-   * @throws FailsafeException if the {@code callable} fails with a Throwable and the retry policy is exceeded, or if
-   *           interrupted while waiting to perform a retry.
+   * @throws FailsafeException if the {@code callable} fails with a checked Exception or if interrupted while waiting to
+   *           perform a retry.
    * @throws CircuitBreakerOpenException if a configured circuit is open.
    */
   public <T> T get(Callable<T> callable) {
@@ -61,8 +61,8 @@ public <T> T get(Callable<T> callable) {
    * exceeded.
    * 
    * @throws NullPointerException if the {@code callable} is null
-   * @throws FailsafeException if the {@code callable} fails with a Throwable and the retry policy is exceeded, or if
-   *           interrupted while waiting to perform a retry.
+   * @throws FailsafeException if the {@code callable} fails with a checked Exception or if interrupted while waiting to
+   *           perform a retry.
    * @throws CircuitBreakerOpenException if a configured circuit is open.
    */
   public <T> T get(ContextualCallable<T> callable) {
@@ -73,8 +73,8 @@ public <T> T get(ContextualCallable<T> callable) {
    * Executes the {@code runnable} until successful or until the configured {@link RetryPolicy} is exceeded.
    * 
    * @throws NullPointerException if the {@code runnable} is null
-   * @throws FailsafeException if the {@code callable} fails with a Throwable and the retry policy is exceeded, or if
-   *           interrupted while waiting to perform a retry.
+   * @throws FailsafeException if the {@code callable} fails with a checked Exception or if interrupted while waiting to
+   *           perform a retry.
    * @throws CircuitBreakerOpenException if a configured circuit is open.
    */
   public void run(CheckedRunnable runnable) {
@@ -85,8 +85,8 @@ public void run(CheckedRunnable runnable) {
    * Executes the {@code runnable} until successful or until the configured {@link RetryPolicy} is exceeded.
    * 
    * @throws NullPointerException if the {@code runnable} is null
-   * @throws FailsafeException if the {@code callable} fails with a Throwable and the retry policy is exceeded, or if
-   *           interrupted while waiting to perform a retry.
+   * @throws FailsafeException if the {@code runnable} fails with a checked Exception or if interrupted while waiting to
+   *           perform a retry.
    * @throws CircuitBreakerOpenException if a configured circuit is open.
    */
   public void run(ContextualRunnable runnable) {
@@ -116,8 +116,8 @@ public AsyncFailsafe<R> with(Scheduler scheduler) {
   /**
    * Calls the {@code callable} synchronously, performing retries according to the {@code retryPolicy}.
    * 
-   * @throws FailsafeException if the {@code callable} fails with a Throwable and the retry policy is exceeded or if
-   *           interrupted while waiting to perform a retry
+   * @throws FailsafeException if the {@code callable} fails with a checked Exception or if interrupted while waiting to
+   *           perform a retry.
    * @throws CircuitBreakerOpenException if a configured circuit breaker is open
    */
   @SuppressWarnings("unchecked")
@@ -156,7 +156,7 @@ private <T> T call(Callable<T> callable) {
           return result;
         if (fallback != null)
           return fallbackFor((R) result, failure);
-        throw failure instanceof FailsafeException ? (FailsafeException) failure : new FailsafeException(failure);
+        throw failure instanceof RuntimeException ? (RuntimeException) failure : new FailsafeException(failure);
       } else {
         try {
           Thread.sleep(execution.getWaitTime().toMillis());
@@ -175,7 +175,7 @@ private <T> T fallbackFor(R result, Throwable failure) {
     try {
       return (T) fallback.apply(result, failure);
     } catch (Exception e) {
-      throw e instanceof FailsafeException ? (FailsafeException) e : new FailsafeException(e);
+      throw e instanceof RuntimeException ? (RuntimeException) e : new FailsafeException(e);
     }
   }
 }

src/test/java/net/jodah/failsafe/FailsafeConfigTest.java

@@ -205,7 +205,7 @@ public void testListenersForUnhandledFailure() throws Throwable {
     RetryPolicy retryPolicy = new RetryPolicy().retryOn(IllegalStateException.class).withMaxRetries(10);
 
     // When
-    Asserts.assertThrows(() -> registerListeners(Failsafe.with(retryPolicy)).get(callable), FailsafeException.class,
+    Asserts.assertThrows(() -> registerListeners(Failsafe.with(retryPolicy)).get(callable),
         IllegalArgumentException.class);
 
     // Then
@@ -230,7 +230,7 @@ public void testListenersForRetriesExceeded() throws Throwable {
     RetryPolicy retryPolicy = new RetryPolicy().abortOn(IllegalArgumentException.class).withMaxRetries(3);
 
     // When
-    Asserts.assertThrows(() -> registerListeners(Failsafe.with(retryPolicy)).get(callable), FailsafeException.class,
+    Asserts.assertThrows(() -> registerListeners(Failsafe.with(retryPolicy)).get(callable),
         IllegalStateException.class);
 
     // Then
@@ -256,7 +256,7 @@ public void testListenersForAbort() throws Throwable {
     RetryPolicy retryPolicy = new RetryPolicy().abortOn(IllegalArgumentException.class).withMaxRetries(3);
 
     // When
-    Asserts.assertThrows(() -> registerListeners(Failsafe.with(retryPolicy)).get(callable), FailsafeException.class,
+    Asserts.assertThrows(() -> registerListeners(Failsafe.with(retryPolicy)).get(callable),
         IllegalArgumentException.class);
 
     // Then

src/test/java/net/jodah/failsafe/SyncFailsafeTest.java

@@ -31,6 +31,7 @@
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.testng.annotations.BeforeMethod;
@@ -44,10 +45,10 @@
 public class SyncFailsafeTest extends AbstractFailsafeTest {
   // Results from a synchronous Failsafe call
   private @SuppressWarnings("unchecked") Class<? extends Throwable>[] syncThrowables = new Class[] {
-      FailsafeException.class, ConnectException.class };
+      ConnectException.class };
   // Results from a get against a future that wraps a synchronous Failsafe call
   private @SuppressWarnings("unchecked") Class<? extends Throwable>[] futureSyncThrowables = new Class[] {
-      ExecutionException.class, FailsafeException.class, ConnectException.class };
+      ExecutionException.class, ConnectException.class };
 
   @BeforeMethod
   protected void beforeMethod() {
@@ -78,7 +79,7 @@ private void assertRun(Object runnable) throws Throwable {
     // When / Then
     assertThrows(() -> {
       run(Failsafe.with(retryTwice), runnable);
-    } , syncThrowables);
+    }, syncThrowables);
     verify(service, times(3)).connect();
   }
 
@@ -158,8 +159,7 @@ public void shouldThrowOnNonRetriableFailure() throws Throwable {
     RetryPolicy retryPolicy = new RetryPolicy().retryOn(ConnectException.class);
 
     // When / Then
-    assertThrows(() -> Failsafe.with(retryPolicy).get(() -> service.connect()), FailsafeException.class,
-        IllegalStateException.class);
+    assertThrows(() -> Failsafe.with(retryPolicy).get(() -> service.connect()), IllegalStateException.class);
     verify(service, times(3)).connect();
   }
 
@@ -251,6 +251,12 @@ public void shouldCompleteWhenMaxDurationExceeded() throws Throwable {
     verify(service).connect();
   }
 
+  public void shouldWrapCheckedExceptions() throws Throwable {
+    assertThrows(() -> Failsafe.with(new RetryPolicy().withMaxRetries(1)).run(() -> {
+      throw new TimeoutException();
+    }), FailsafeException.class, TimeoutException.class);
+  }
+
   private void run(SyncFailsafe<?> failsafe, Object runnable) {
     if (runnable instanceof CheckedRunnable)
       failsafe.run((CheckedRunnable) runnable);