chore(retry): add optional max duration (#75)

Author: ns-vasilev

Sources/Typhoon/Classes/Model/RetryPolicyError.swift

@@ -9,4 +9,6 @@ import Foundation
 public enum RetryPolicyError: Error {
     /// The retry limit for attempts to perform a request has been exceeded.
     case retryLimitExceeded
+    /// Thrown when the total allowed duration for retries has been exceeded.
+    case totalDurationExceeded
 }

Sources/Typhoon/Classes/RetryPolicyService/RetryPolicyService.swift

@@ -56,13 +56,21 @@ public final class RetryPolicyService {
     /// The strategy defining the behavior of the retry policy.
     private let strategy: RetryPolicyStrategy
 
+    /// Optional maximum total duration allowed for all retry attempts.
+    private let maxTotalDuration: DispatchTimeInterval?
+
     // MARK: Initialization
 
-    /// Creates a new `RetryPolicyService` instance.
+    /// Initializes a new instance of `RetryPolicyService`.
     ///
-    /// - Parameter strategy: The strategy defining the behavior of the retry policy.
-    public init(strategy: RetryPolicyStrategy) {
+    /// - Parameters:
+    ///   - strategy: The strategy that determines how retries are performed.
+    ///   - maxTotalDuration: Optional maximum duration for all retries combined. If `nil`,
+    ///                       retries can continue indefinitely based on the
+    /// strategy.
+    public init(strategy: RetryPolicyStrategy, maxTotalDuration: DispatchTimeInterval? = nil) {
         self.strategy = strategy
+        self.maxTotalDuration = maxTotalDuration
     }
 }
 
@@ -86,7 +94,13 @@ extension RetryPolicyService: IRetryPolicyService {
 
         var iterator = RetrySequence(strategy: effectiveStrategy).makeIterator()
 
+        let deadline = maxTotalDuration?.double.map { Date().addingTimeInterval($0) }
+
         while true {
+            if let deadline, Date() > deadline {
+                throw RetryPolicyError.totalDurationExceeded
+            }
+
             do {
                 return try await closure()
             } catch {

Tests/TyphoonTests/UnitTests/RetryPolicyServiceTests.swift

@@ -257,6 +257,109 @@ final class RetryPolicyServiceTests: XCTestCase {
         let lastError = await errorContainer.getError()
         XCTAssertNotNil(lastError)
     }
+
+    // MARK: Tests - Max Total Duration
+
+    func test_thatRetryThrowsTotalDurationExceededError_whenDeadlineIsExceeded() async throws {
+        // given
+        let slowService = RetryPolicyService(
+            strategy: .constant(retry: 10, duration: .milliseconds(200)),
+            maxTotalDuration: .milliseconds(300)
+        )
+
+        // when
+        var receivedError: Error?
+        do {
+            _ = try await slowService.retry {
+                throw URLError(.unknown)
+            }
+        } catch {
+            receivedError = error
+        }
+
+        // then
+        XCTAssertEqual(receivedError as? RetryPolicyError, .totalDurationExceeded)
+    }
+
+    func test_thatRetrySucceeds_whenOperationCompletesBeforeDeadline() async throws {
+        // given
+        let expectedValue = 42
+        let service = RetryPolicyService(
+            strategy: .constant(retry: 5, duration: .nanoseconds(1)),
+            maxTotalDuration: .seconds(5)
+        )
+
+        // when
+        let result = try await service.retry {
+            expectedValue
+        }
+
+        // then
+        XCTAssertEqual(result, expectedValue)
+    }
+
+    func test_thatRetrySucceedsAfterRetries_whenDeadlineIsNotExceeded() async throws {
+        // given
+        let counter = Counter()
+        let expectedValue = 99
+        let service = RetryPolicyService(
+            strategy: .constant(retry: 5, duration: .nanoseconds(1)),
+            maxTotalDuration: .seconds(5)
+        )
+
+        // when
+        let result = try await service.retry {
+            let count = await counter.increment()
+            if count >= 3 { return expectedValue }
+            throw URLError(.unknown)
+        }
+
+        // then
+        XCTAssertEqual(result, expectedValue)
+    }
+
+    func test_thatRetryThrowsTotalDurationExceeded_notRetryLimitExceeded_whenDeadlineHitsFirst() async throws {
+        // given
+        let service = RetryPolicyService(
+            strategy: .constant(retry: 100, duration: .milliseconds(100)),
+            maxTotalDuration: .milliseconds(250)
+        )
+
+        // when
+        var receivedError: Error?
+        do {
+            _ = try await service.retry {
+                throw URLError(.unknown)
+            }
+        } catch {
+            receivedError = error
+        }
+
+        // then
+        XCTAssertEqual(receivedError as? RetryPolicyError, .totalDurationExceeded)
+        XCTAssertNotEqual(receivedError as? RetryPolicyError, .retryLimitExceeded)
+    }
+
+    func test_thatRetryIgnoresDeadline_whenMaxTotalDurationIsNil() async throws {
+        // given
+        let counter = Counter()
+        let service = RetryPolicyService(
+            strategy: .constant(retry: .defaultRetryCount, duration: .nanoseconds(1)),
+            maxTotalDuration: nil
+        )
+
+        // when
+        do {
+            _ = try await service.retry {
+                _ = await counter.increment()
+                throw URLError(.unknown)
+            }
+        } catch {}
+
+        // then
+        let attempts = await counter.getValue()
+        XCTAssertEqual(attempts, .defaultRetryCount + 1)
+    }
 }
 
 // MARK: - Counter