Do not retry if the thrown error is CancellationError.

Author: fumoboy007

Sources/Retry/Retry.swift

@@ -285,7 +285,7 @@ public func retry<ClockType, ReturnType>(
    var attempt = 0
    while true {
       var latestError: any Error
-      let isErrorRetryable: Bool
+      var isErrorRetryable: Bool
 
       do {
          return try await operation()
@@ -305,6 +305,10 @@ public func retry<ClockType, ReturnType>(
          }
 
          latestError = latestError.originalError
+
+         if latestError is CancellationError {
+            isErrorRetryable = false
+         }
       }
 
       logger?[metadataKey: "retry.attempt"] = "\(attempt)"

Tests/RetryTests/Fakes/ClockFake.swift

@@ -29,53 +29,88 @@ class ClockFake: Clock, @unchecked Sendable {
 
    private let lock = NSLock()
 
-   private var _now: Instant
-
-   private var _allSleepDurations = [Duration]()
-
    init() {
       self._now = realClock.now
    }
 
-   var now: Instant {
-      lock.lock()
-      defer {
-         lock.unlock()
+   private var _now: Instant
+   private(set) var now: Instant {
+      get {
+         lock.lock()
+         defer {
+            lock.unlock()
+         }
+
+         return _now
       }
 
-      return _now
+      set {
+         lock.lock()
+         defer {
+            lock.unlock()
+         }
+
+         _now = max(newValue, _now)
+      }
    }
 
    var minimumResolution: Duration {
       return realClock.minimumResolution
    }
 
+   private var _isSleepEnabled = false
+   var isSleepEnabled: Bool {
+      get {
+         lock.lock()
+         defer {
+            lock.unlock()
+         }
+
+         return _isSleepEnabled
+      }
+
+      set {
+         lock.lock()
+         defer {
+            lock.unlock()
+         }
+
+         _isSleepEnabled = newValue
+      }
+   }
+
    func sleep(until deadline: Instant,
               tolerance: Duration?) async throws {
       // Refactored into a non-async method so that `NSLock.lock` and `NSLock.unlock` can be used.
       // Cannot use the async-safe `NSLock.withLocking` method until the following change is released:
       // https://github.com/apple/swift-corelibs-foundation/pull/4736
-      sleep(until: deadline)
+      recordSleepDuration(deadline: deadline)
+
+      if isSleepEnabled {
+         try await realClock.sleep(until: deadline,
+                                   tolerance: tolerance)
+      }
+
+      now = deadline
    }
 
-   private func sleep(until deadline: Instant) {
+   private var _allSleepDurations = [Duration]()
+   var allSleepDurations: [Duration] {
       lock.lock()
       defer {
          lock.unlock()
       }
 
-      let duration = deadline - _now
-      _allSleepDurations.append(duration)
-
-      _now = max(deadline, _now)
+      return _allSleepDurations
    }
 
-   var allSleepDurations: [Duration] {
+   private func recordSleepDuration(deadline: Instant) {
       lock.lock()
       defer {
          lock.unlock()
       }
 
-      return _allSleepDurations
+      let duration = deadline - _now
+      _allSleepDurations.append(duration)
    }
 }

Tests/RetryTests/RetryTests.swift

@@ -78,7 +78,7 @@ final class RetryTests: XCTestCase {
    }
 
    func testAllAttemptsFail_failureAfterRetries() async throws {
-      try await assertThrowsErrorFake {
+      try await assertThrows(ErrorFake.self) {
          try await retry(with: testingConfiguration) {
             throw ErrorFake()
          }
@@ -90,7 +90,7 @@ final class RetryTests: XCTestCase {
    func testFailure_shouldRetryReturnsFalse_failureWithoutRetry() async throws {
       precondition(Self.maxAttempts > 1)
 
-      try await assertThrowsErrorFake {
+      try await assertThrows(ErrorFake.self) {
          try await retry(with: testingConfiguration.withShouldRetry({ _ in false })) {
             throw ErrorFake()
          }
@@ -102,7 +102,7 @@ final class RetryTests: XCTestCase {
    func testFailure_isNotRetryableError_failureWithoutRetry() async throws {
       precondition(Self.maxAttempts > 1)
 
-      try await assertThrowsErrorFake {
+      try await assertThrows(ErrorFake.self) {
          try await retry(with: testingConfiguration) {
             throw NotRetryable(ErrorFake())
          }
@@ -130,7 +130,7 @@ final class RetryTests: XCTestCase {
    }
 
    func testAllAttemptsFail_latestErrorIsRetryableError_throwsOriginalError() async throws {
-      try await assertThrowsErrorFake {
+      try await assertThrows(ErrorFake.self) {
          try await retry(with: testingConfiguration) {
             throw Retryable(NotRetryable(ErrorFake()))
          }
@@ -139,8 +139,8 @@ final class RetryTests: XCTestCase {
       assertRetried(times: Self.maxAttempts - 1)
    }
 
-   func testFailure_errorIsNotRetryableError_throwsOriginalError() async throws {
-      try await assertThrowsErrorFake {
+   func testFailure_isNotRetryableError_throwsOriginalError() async throws {
+      try await assertThrows(ErrorFake.self) {
          try await retry(with: testingConfiguration) {
             throw NotRetryable(Retryable(ErrorFake()))
          }
@@ -149,12 +149,82 @@ final class RetryTests: XCTestCase {
       assertRetried(times: 0)
    }
 
+   func testFailure_isCancellationError_failureWithoutRetry() async throws {
+      precondition(Self.maxAttempts > 1)
+
+      try await assertThrows(CancellationError.self) {
+         try await retry(with: testingConfiguration) {
+            throw CancellationError()
+         }
+      }
+
+      assertRetried(times: 0)
+   }
+
+   func testFailure_isCancellationErrorWrappedInRetryableError_failureWithoutRetry() async throws {
+      precondition(Self.maxAttempts > 1)
+
+      try await assertThrows(CancellationError.self) {
+         try await retry(with: testingConfiguration) {
+            throw Retryable(CancellationError())
+         }
+      }
+
+      assertRetried(times: 0)
+   }
+
+   func testFailure_isCancellationErrorWrappedInNotRetryableError_failureWithoutRetry() async throws {
+      precondition(Self.maxAttempts > 1)
+
+      try await assertThrows(CancellationError.self) {
+         try await retry(with: testingConfiguration) {
+            throw NotRetryable(CancellationError())
+         }
+      }
+
+      assertRetried(times: 0)
+   }
+
+   func testCancelledDuringSleep_immediateFailure() async throws {
+      precondition(Self.maxAttempts > 1)
+
+      clockFake.isSleepEnabled = true
+      let configuration = testingConfiguration.withBackoff(.constant(.seconds(60)))
+
+      let retryTask = Task {
+         try await retry(with: configuration) {
+            throw ErrorFake()
+         }
+      }
+
+      // Wait until the retry task is sleeping after the first attempt.
+      while clockFake.allSleepDurations.isEmpty {
+         try await Task.sleep(for: .milliseconds(1))
+      }
+
+      retryTask.cancel()
+
+      let realClock = ContinuousClock()
+      let start = realClock.now
+
+      try await assertThrows(CancellationError.self) {
+         try await retryTask.value
+      }
+
+      let end = realClock.now
+      let duration = end - start
+      XCTAssertLessThan(duration, .seconds(1))
+   }
+
    // MARK: - Assertions
 
-   private func assertThrowsErrorFake(operation: () async throws -> Void) async throws {
+   private func assertThrows<T: Error>(
+      _ errorType: T.Type,
+      operation: () async throws -> Void
+   ) async throws {
       do {
          try await operation()
-      } catch is ErrorFake {
+      } catch is T {
          // Expected.
       }
    }