New test case for retry.When

retry/src/main/scala/Policy.scala

@@ -197,8 +197,8 @@ object Backoff {
     }
 }
 
-/** A retry policy in which the a failure determines the way a future should be retried. The partial function provided
-  * may define the domain of both the success OR exceptional failure of a future fails explicitly.
+/** A retry policy in which the type of failure determines the way a future should be retried. The partial function
+  * provided may define the domain of both the success OR exceptional failure of a future fails explicitly.
   *
   * {{{
   *  val policy = retry.When {

retry/src/test/scala/PolicySpec.scala

@@ -607,5 +607,33 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
         assert(retried.get() == 1)
       }
     }
+
+    it("should stop repeating when the failure changes") {
+      implicit val success = Success[Boolean](identity)
+      object RecoverableException extends RuntimeException("recoverable exception")
+      object FatalException extends RuntimeException("fatal exception")
+      val retried = new AtomicInteger()
+      val retriedUntilFailure = 5
+      def run() = {
+        println(retried.get())
+        if (retried.getAndIncrement() < retriedUntilFailure) {
+          Future.failed(RecoverableException)
+        } else {
+          if(retried.get() > 2 * retriedUntilFailure) {
+            // this state should never be reached
+            Future(true)
+          } else Future.failed(FatalException)
+        }
+      }
+
+      val policy = When {
+        case FatalException => throw FatalException
+        case _ => Directly.forever
+      }
+      policy(run()).failed.map { t =>
+        assert(t.getMessage === "fatal exception")
+        assert(retried.get() == 5)
+      }
+    }
   }
 }