Max backoff for exponential backoffs

src/main/scala/Defaults.scala

@@ -5,5 +5,6 @@ import java.util.concurrent.TimeUnit
 
 object Defaults {
   val delay: FiniteDuration = Duration(500, TimeUnit.MILLISECONDS)
+  val maxDelay: Duration = Duration.Inf
 }
 

src/main/scala/Policy.scala

@@ -77,9 +77,14 @@ object Pause {
 }
 
 object Backoff {
+  private def nextDelay(calculatedDelay: FiniteDuration, maxDelay: Duration): FiniteDuration =
+    maxDelay match {
+      case _: Duration.Infinite => calculatedDelay
+      case delay: FiniteDuration => List(calculatedDelay, delay).min
+    }
 
   /** Retry with exponential backoff forever */
-  def forever(delay: FiniteDuration = Defaults.delay, base: Int = 2)
+  def forever(delay: FiniteDuration = Defaults.delay, base: Int = 2, maxDelay: Duration = Defaults.maxDelay)
    (implicit timer: Timer): Policy =
     new Policy {
       def apply[T]
@@ -88,7 +93,7 @@ object Backoff {
          executor: ExecutionContext): Future[T] = {
           def run(delay: FiniteDuration): Future[T] = retry(promise, { () =>
             Delay(delay) {
-              run(Duration(delay.length * base, delay.unit))
+              run(nextDelay(delay * base, maxDelay))
             }.future.flatMap(identity)
           })
           run(delay)
@@ -99,7 +104,8 @@ object Backoff {
   def apply(
     max: Int = 8,
     delay: FiniteDuration = Defaults.delay,
-    base: Int = 2)
+    base: Int = 2,
+    maxDelay: Duration = Defaults.maxDelay)
    (implicit timer: Timer): Policy =
     new CountingPolicy {
       def apply[T]
@@ -109,7 +115,7 @@ object Backoff {
           def run(max: Int, delay: FiniteDuration): Future[T] = countdown(
             max, promise,
             count => Delay(delay) {
-              run(count, Duration(delay.length * base, delay.unit))
+              run(count, nextDelay(delay * base, maxDelay))
             }.future.flatMap(identity))
           run(max, delay)
         }

src/test/scala/PolicySpec.scala

@@ -116,6 +116,21 @@ class PolicySpec extends FunSpec with BeforeAndAfterAll {
       assert(took <= 110.millis === true,
              s"took more time than expected: $took")
     }
+
+    it ("should wait up to a max time each time") {
+      implicit val success = Success[Int](_ == 2)
+      val tries = forwardCountingFutureStream().iterator
+      val policy = retry.Backoff(2, 30.millis, maxDelay = 50.millis)
+      val took = time {
+        val result = Await.result(policy(tries.next),
+          80.millis + 20.millis)
+        assert(success.predicate(result) === true, "predicate failed")
+      }
+      assert(took >= 80.millis === true,
+        s"took less time than expected: $took")
+      assert(took <= 100.millis === true,
+        s"took more time than expected: $took")
+    }
   }
 
   describe("retry.When") {