Add Task Cancellation

Sources/MicroClient/NetworkClient.swift

@@ -42,6 +42,8 @@
         var lastError: Error?
 
         for attempt in 0...retryStrategy.count {
+            try Task.checkCancellation()
+
             do {
                 return try await performRequest(networkRequest, attempt: attempt)
             } catch {
@@ -56,7 +58,7 @@
 
     // swiftlint:disable function_body_length
 
     private func performRequest<ResponseModel>(
         _ networkRequest: NetworkRequest<some Any, ResponseModel>,
         attempt: Int
     ) async throws -> NetworkResponse<ResponseModel> {
@@ -100,13 +102,18 @@
                 for: urlRequest,
                 delegate: nil
             )
+        } catch let error as CancellationError {
+            throw error
         } catch {
             log(.error, "Transport error: \(error.localizedDescription)")
             throw NetworkClientError.transportError(error)
         }
 
         if let httpResponse = response as? HTTPURLResponse {
-            log(.info, "Response: \(httpResponse.statusCode) \(urlRequest.httpMethod ?? "") \(urlRequest.url?.absoluteString ?? "")")
+            log(
+                .info,
+                "Response: \(httpResponse.statusCode) \(urlRequest.httpMethod ?? "") \(urlRequest.url?.absoluteString ?? "")"
+            )
             log(.debug, "Response headers: \(httpResponse.allHeaderFields)")
 
             guard (200...299).contains(httpResponse.statusCode) else {
@@ -150,6 +157,8 @@
             throw NetworkClientError.responseInterceptorError(error)
         }
 
+        try Task.checkCancellation()
+
         return networkResponse
     }
 

Tests/MicroClientTests/Doubles/URLSessionMock.swift

@@ -12,6 +12,7 @@ final class URLSessionMock: URLSessionProtocol, @unchecked Sendable {
     private var stubbedResponseToReturn = URLResponse()
     private var stubbedErrorToThrow: Error?
     var succeedAfter = 0
+    var delay: TimeInterval = 0
 
     // MARK: - Public
 
@@ -22,6 +23,10 @@ final class URLSessionMock: URLSessionProtocol, @unchecked Sendable {
         lastRequest = request
         requestCount += 1
 
+        if delay > 0 {
+            try await Task.sleep(nanoseconds: UInt64(delay * 1_000_000_000))
+        }
+
         if succeedAfter > 0, requestCount > succeedAfter {
             // Do not throw error, return stubbed data
         } else if let error = stubbedErrorToThrow {

Tests/MicroClientTests/NetworkClientCancellationTests.swift

@@ -0,0 +1,156 @@
+import Foundation
+import Testing
+
+@testable import MicroClient
+
+@Suite("NetworkClient Cancellation Tests")
+struct NetworkClientCancellationTests {
+
+    @Test("It should throw CancellationError when task is cancelled before request")
+    func throwCancellationErrorWhenTaskIsCancelledBeforeRequest() async throws {
+        // Given
+        let mockSession = NetworkClientMother.makeMockSession()
+        let client = NetworkClientMother.makeNetworkClient(
+            session: mockSession
+        )
+
+        let expectedURL = try #require(URL(string: "https://api.example.com/test"))
+        mockSession.stubDataToReturn(
+            data: Data(),
+            response: NetworkClientMother.makeSuccessResponse(
+                for: expectedURL
+            )
+        )
+
+        let request = NetworkRequest<VoidRequest, VoidResponse>(
+            path: "/test",
+            method: .get
+        )
+
+        // When
+        let task = Task {
+            try await client.run(request)
+        }
+
+        task.cancel()
+
+        // Then
+        await #expect(throws: CancellationError.self) {
+            try await task.value
+        }
+    }
+
+    @Test("It should cancel ongoing request when task is cancelled mid-flight")
+    func cancelOngoingRequestWhenTaskIsCancelledMidFlight() async throws {
+        // Given
+        let mockSession = NetworkClientMother.makeMockSession()
+        mockSession.delay = 0.1
+
+        let client = NetworkClientMother.makeNetworkClient(
+            session: mockSession
+        )
+
+        let expectedURL = try #require(URL(string: "https://api.example.com/test"))
+        mockSession.stubDataToReturn(
+            data: Data(),
+            response: NetworkClientMother.makeSuccessResponse(
+                for: expectedURL
+            )
+        )
+
+        let request = NetworkRequest<VoidRequest, VoidResponse>(
+            path: "/test",
+            method: .get
+        )
+
+        // When
+        let task = Task {
+            try await client.run(request)
+        }
+
+        try await Task.sleep(nanoseconds: 10_000_000)
+        task.cancel()
+
+        // Then
+        await #expect(throws: CancellationError.self) {
+            try await task.value
+        }
+    }
+
+    @Test("It should cancel request during retry attempts")
+    func cancelRequestDuringRetryAttempts() async throws {
+        // Given
+        let mockSession = NetworkClientMother.makeMockSession()
+        mockSession.delay = 0.05
+        mockSession.stubDataToThrow(
+            error: URLError(.networkConnectionLost)
+        )
+
+        let retryStrategy = RetryStrategy.retry(count: 5)
+        let client = NetworkClientMother.makeNetworkClient(
+            session: mockSession,
+            retryStrategy: retryStrategy
+        )
+
+        let request = NetworkRequest<VoidRequest, VoidResponse>(
+            path: "/test",
+            method: .get
+        )
+
+        // When
+        let task = Task {
+            try await client.run(request)
+        }
+
+        try await Task.sleep(nanoseconds: 60_000_000)
+        task.cancel()
+
+        // Then
+        await #expect(throws: CancellationError.self) {
+            try await task.value
+        }
+
+        #expect(
+            mockSession.requestCount < retryStrategy.count + 1,
+            "It should not complete all retry attempts"
+        )
+    }
+
+    @Test("It should complete successfully if not cancelled")
+    func completeSuccessfullyIfNotCancelled() async throws {
+        // Given
+        let mockSession = NetworkClientMother.makeMockSession()
+        mockSession.delay = 0.01
+
+        let client = NetworkClientMother.makeNetworkClient(
+            session: mockSession
+        )
+
+        let expectedURL = try #require(URL(string: "https://api.example.com/test"))
+        mockSession.stubDataToReturn(
+            data: Data(),
+            response: NetworkClientMother.makeSuccessResponse(
+                for: expectedURL
+            )
+        )
+
+        let request = NetworkRequest<VoidRequest, VoidResponse>(
+            path: "/test",
+            method: .get
+        )
+
+        // When
+        let response = try await client.run(request)
+
+        // Then
+        #expect(
+            type(of: response.value) == VoidResponse.self,
+            "It should return VoidResponse"
+        )
+
+        #expect(
+            mockSession.requestCount == 1,
+            "It should make exactly one request"
+        )
+    }
+}