Improve Tests for NetworkTask, DataTask & DownloadTask

Author: SwiftyJoeyy

Tests/NetworkingClientTests/Tasks/DataTaskTests.swift

@@ -20,15 +20,14 @@ struct DataTaskTests {
     }
 
 // MARK: - Tests
-    @Test func executingDataTaskReturnsDataAndResponseOnSuccess() async throws {
+    @Test func executingDataTaskReturnsDataOnSuccess() async throws {
         let requestID = "data-task-success"
         let request = TestRequest()
             .testID(requestID)
 
         let string = "Hello, this is a data test."
-        let expectedStatus = ResponseStatus.ok
         await MockURLProtocol.setResult(
-            .success((string.data(using: .utf8)!, expectedStatus)),
+            .success((string.data(using: .utf8)!, .ok)),
             for: requestID
         )
 
@@ -39,7 +38,21 @@ struct DataTaskTests {
 
         let decoded = String(data: response.data, encoding: .utf8)
         #expect(decoded == string)
-        #expect(response.response.status == expectedStatus)
+    }
+    
+    @Test(arguments: [ResponseStatus.accepted, ResponseStatus.badRequest])
+    func executingDataTaskReturnsResponseOnSuccess(expectedStatus: ResponseStatus) async throws {
+        let requestID = "expect-status\(expectedStatus.rawValue)"
+        let request = TestRequest()
+            .testID(requestID)
+        
+        let response = (Data(), expectedStatus)
+        await MockURLProtocol.setResult(.success(response), for: requestID)
+        
+        let status = try await session.dataTask(request)
+            .response()
+            .1.status
+        #expect(status == expectedStatus)
     }
 
     @Test func dataTaskResponseDecoding() async throws {
@@ -85,6 +98,29 @@ struct DataTaskTests {
         #expect(object == expectedObject)
     }
 
+    @Test func dataTaskResponseDecodingThrowsErrorOnDecodeFailure() async throws {
+        let requestID = "data-task-decoding-error"
+        let request = TestRequest()
+            .testID(requestID)
+        
+        let data = try JSONEncoder().encode(TestCodable())
+        await MockURLProtocol.setResult(
+            .success((data, .ok)),
+            for: requestID
+        )
+        
+        let networkingError = try await #require(throws: NetworkingError.self) {
+            _ = try await session
+                .dataTask(request)
+                .decode(as: String.self)
+        }
+        var foundCorrectError = false
+        if case NetworkingError.decoding = networkingError {
+            foundCorrectError = true
+        }
+        #expect(foundCorrectError, "Found error \(String(describing: networkingError))")
+    }
+    
     @Test func executingDataTaskThrowsErrorOnFailure() async throws {
         let requestID = "data-task-failure"
         let request = TestRequest()
@@ -109,10 +145,54 @@ struct DataTaskTests {
         }
         #expect(foundCorrectError, "Found error \(String(describing: networkingError))")
     }
+    
+    @Test func urlSessionTaskGetsCancelledWhenCancellingTask() async throws {
+        let requestID = "expect-cancellation-error"
+        let request = TestRequest()
+            .testID(requestID)
+        
+        await MockURLProtocol.setResult(
+            (4_000_000_000, .failure(MockURLError.errorMock)),
+            for: requestID
+        )
+        let task = ErrorExtractingDataTask(request: AnyRequest(request), session: session)
+        task._accept(session.configurations)
+        
+        Task {
+            try await Task.sleep(nanoseconds: 1_000_000_000)
+            await task.cancel()
+        }
+        
+        _ = try? await task.response()
+        let networkingError = try #require(task.error)
+        
+        var foundCorrectError = false
+        if case NetworkingError.custom(let error) = networkingError,
+           let clientError = error as? ClientError,
+           case ClientError.urlError(let urlError) = clientError {
+            foundCorrectError = urlError.code == .cancelled
+        }
+        #expect(foundCorrectError, "Found error \(String(describing: networkingError))")
+    }
 }
 
 extension DataTaskTests {
     struct TestCodable: Codable, Equatable {
         var someId = UUID()
     }
+    class ErrorExtractingDataTask: DataTask, @unchecked Sendable {
+        var error: NetworkingError?
+        
+        open override func _execute(
+            _ urlRequest: borrowing URLRequest,
+            session: Session
+        ) async throws(NetworkingError) -> DataResponse {
+            do {
+                return try await super._execute(urlRequest, session: session)
+            }catch {
+                self.error = error
+                throw error
+            }
+        }
+    }
 }

Tests/NetworkingClientTests/Tasks/DonwloadTaskTests.swift

@@ -74,14 +74,14 @@ struct DownloadTaskTests {
         let task = session.downloadTask(TestRequest())
 
         Task {
-            try await Task.sleep(nanoseconds: 1_000_000_000)
+            try await Task.sleep(nanoseconds: 1_000_000_00)
             for update in expectedUpdates {
                 await task._session(
                     didWriteData: 2,
                     totalBytesWritten: Int64(update * 10),
                     totalBytesExpectedToWrite: 10
                 )
-                try await Task.sleep(nanoseconds: 100_000_000)
+                try await Task.sleep(nanoseconds: 1_000_000_00)
             }
             await task._finished(with: nil)
         }
@@ -122,7 +122,7 @@ struct DownloadTaskTests {
             let task = session.downloadTask(TestRequest())
 
             Task {
-                try await Task.sleep(nanoseconds: 1_000_000_000)
+                try await Task.sleep(nanoseconds: 1_000_000_00)
                 await task._session(
                     didWriteData: 0,
                     totalBytesWritten: 0,
@@ -141,7 +141,7 @@ struct DownloadTaskTests {
             let task = session.downloadTask(TestRequest())
 
             Task {
-                try await Task.sleep(nanoseconds: 1_000_000_000)
+                try await Task.sleep(nanoseconds: 1_000_000_00)
                 await task._session(
                     didResumeAtOffset: 0,
                     expectedTotalBytes: 0
@@ -155,4 +155,54 @@ struct DownloadTaskTests {
             }
         }
     }
+    
+    @Test func urlSessionTaskGetsCancelledWhenCancellingTask() async throws {
+        let requestID = "expect-cancellation-error"
+        let request = TestRequest()
+            .testID(requestID)
+        
+        await MockURLProtocol.setResult(
+            (4_000_000_000, .failure(MockURLError.errorMock)),
+            for: requestID
+        )
+        let task = ErrorExtractingDownloadTask(
+            request: AnyRequest(request),
+            session: session
+        )
+        task._accept(session.configurations)
+        
+        Task {
+            try await Task.sleep(nanoseconds: 1_000_000_00)
+            await task.cancel()
+        }
+        
+        _ = try? await task.response()
+        let networkingError = try #require(task.error)
+        
+        var foundCorrectError = false
+        if case NetworkingError.custom(let error) = networkingError,
+           let clientError = error as? ClientError,
+           case ClientError.urlError(let urlError) = clientError {
+            foundCorrectError = urlError.code == .cancelled
+        }
+        #expect(foundCorrectError, "Found error \(String(describing: networkingError))")
+    }
+}
+
+extension DownloadTaskTests {
+    class ErrorExtractingDownloadTask: DownloadTask, @unchecked Sendable {
+        var error: NetworkingError?
+        
+        open override func _execute(
+            _ urlRequest: borrowing URLRequest,
+            session: Session
+        ) async throws(NetworkingError) -> DownloadResponse {
+            do {
+                return try await super._execute(urlRequest, session: session)
+            }catch {
+                self.error = error
+                throw error
+            }
+        }
+    }
 }