Treat cancellation more like pause, similar to cancelling all.

Author: donnywals

Sources/TUSKit/TUSClient.swift

@@ -733,6 +733,23 @@ extension TUSClient: SchedulerDelegate {
                 return nil
             }
         }
+        
+        func isCancellation(_ error: Error) -> Bool {
+            if let tusError = error as? TUSClientError, case .taskCancelled = tusError {
+                return true
+            }
+            
+            if let apiError = error as? TUSAPIError, case let .underlyingError(underlying) = apiError {
+                return isCancellation(underlying)
+            }
+            
+            if let urlError = error as? URLError, urlError.code == .cancelled {
+                return true
+            }
+            
+            let nsError = error as NSError
+            return nsError.domain == NSURLErrorDomain && nsError.code == NSURLErrorCancelled
+        }
 
         var shouldReturnEarly = false
         queue.sync {
@@ -747,6 +764,10 @@ extension TUSClient: SchedulerDelegate {
             return
         }
 
+        if isCancellation(error) {
+            return
+        }
+        
         metaData.errorCount += 1
         do {
             try files.encodeAndStore(metaData: metaData)

Tests/TUSKitTests/TUSClient/TUSClientInternalTests.swift

@@ -123,4 +123,21 @@ final class TUSClientInternalTests: XCTestCase {
             XCTFail("Expected a couldNotStoreFileMetadata error")
         }
     }
+    
+    func testCancellationDoesNotIncrementErrorCountOrRetry() throws {
+        let metaData = try storeFiles()
+        let creationTask = try CreationTask(metaData: metaData,
+                                            api: TUSAPI(session: URLSession(configuration: .ephemeral)),
+                                            files: files)
+        let scheduler = Scheduler()
+        
+        XCTAssertEqual(metaData.errorCount, 0)
+        
+        client.onError(error: TUSClientError.taskCancelled, task: creationTask, scheduler: scheduler)
+        
+        scheduler.queue.sync { }
+        
+        XCTAssertEqual(metaData.errorCount, 0)
+        XCTAssertTrue(scheduler.allTasks.isEmpty)
+    }
 }