Add support for no policies via Failsafe.none

Closes #252

Author: jhalterman

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

@@ -84,6 +84,20 @@ public static <R, P extends Policy<R>> FailsafeExecutor<R> with(P outerPolicy, P
    */
   @SuppressWarnings("unchecked")
   public static <R> FailsafeExecutor<R> with(List<? extends Policy<R>> policies) {
-    return new FailsafeExecutor<>((List<Policy<R>>) Assert.notNull(policies, "policies"));
+    Assert.notNull(policies, "policies");
+    Assert.isTrue(!policies.isEmpty(), "At least one policy must be supplied");
+    return new FailsafeExecutor<>((List<Policy<R>>) policies);
+  }
+
+  /**
+   * Creates and returns a noop {@link FailsafeExecutor} instance that treats any exception as a failure for the
+   * purposes of calling event listeners, and provides no additional failure handling.
+   *
+   * @param <R> result type
+   * @throws NullPointerException if {@code policies} is null
+   * @throws IllegalArgumentException if {@code policies} is empty
+   */
+  public static <R> FailsafeExecutor<R> none() {
+    return new FailsafeExecutor<>(Collections.emptyList());
   }
 }

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

@@ -51,7 +51,6 @@ public class FailsafeExecutor<R> extends PolicyListeners<FailsafeExecutor<R>, R>
    * @throws IllegalArgumentException if {@code policies} is empty
    */
   FailsafeExecutor(List<Policy<R>> policies) {
-    Assert.isTrue(!policies.isEmpty(), "At least one policy must be supplied");
     this.policies = policies;
   }
 

src/test/java/net/jodah/failsafe/functional/NoPolicyTest.java

@@ -0,0 +1,48 @@
+package net.jodah.failsafe.functional;
+
+import net.jodah.failsafe.Failsafe;
+import net.jodah.failsafe.FailsafeExecutor;
+import org.testng.annotations.Test;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static net.jodah.failsafe.Testing.testSyncAndAsyncFailure;
+import static net.jodah.failsafe.Testing.testSyncAndAsyncSuccess;
+import static org.testng.Assert.assertEquals;
+
+@Test
+public class NoPolicyTest {
+  public void testWithNoPolicy() {
+    AtomicInteger successCounter = new AtomicInteger();
+    AtomicInteger failureCounter = new AtomicInteger();
+    FailsafeExecutor<Object> executor = Failsafe.none().onFailure(e -> {
+      failureCounter.incrementAndGet();
+    }).onSuccess(e -> {
+      successCounter.incrementAndGet();
+    });
+
+    // Test success
+    testSyncAndAsyncSuccess(executor, () -> {
+      successCounter.set(0);
+      failureCounter.set(0);
+    }, () -> "success", e -> {
+      assertEquals(e.getAttemptCount(), 1);
+      assertEquals(e.getExecutionCount(), 1);
+      assertEquals(successCounter.get(), 1);
+      assertEquals(failureCounter.get(), 0);
+    }, "success");
+
+    // Test failure
+    testSyncAndAsyncFailure(executor, () -> {
+      successCounter.set(0);
+      failureCounter.set(0);
+    }, () -> {
+      throw new IllegalStateException();
+    }, e -> {
+      assertEquals(e.getAttemptCount(), 1);
+      assertEquals(e.getExecutionCount(), 1);
+      assertEquals(successCounter.get(), 0);
+      assertEquals(failureCounter.get(), 1);
+    }, IllegalStateException.class);
+  }
+}