Merge branch 'release/4.0' of https://github.com/dbsystel/DBNetworkStack into release/4.0

lightsprint09 · lightsprint09 · commit 7a0784c85160 · 2024-11-25T13:27:47.000+01:00
diff --git a/Source/NetworkError.swift b/Source/NetworkError.swift
@@ -36,7 +36,7 @@ public enum NetworkError: Error, Sendable {
     /// Error on the server (HTTP Error 500...511)
     case serverError(response: HTTPURLResponse?, data: Data?)
     /// Parsing the body into expected type failed.
-    case serializationError(error: Error, data: Data?)
+    case serializationError(error: Error, response: HTTPURLResponse, data: Data?)
     /// Complete request failed.
     case requestError(error: Error)
     
@@ -75,21 +75,21 @@ extension NetworkError: CustomDebugStringConvertible {
         case .cancelled:
             return "Request cancelled"
         case .unauthorized(let response, let data):
-            return "Authorization error: \(response), response: ".appendingContentsOf(data: data)
+            return "Authorization error, response headers: \(response), response body: ".appendingContentsOf(data: data)
         case .clientError(let response, let data):
             if let response = response {
-                return "Client error: \((response)), response: ".appendingContentsOf(data: data)
+                return "Client error, response headers: \((response)), response body: ".appendingContentsOf(data: data)
             }
-            return "Client error, response: ".appendingContentsOf(data: data)
-        case .serializationError(let description, let data):
-            return "Serialization error: \(description), response: ".appendingContentsOf(data: data)
+            return "Client error, response headers: nil, response body: ".appendingContentsOf(data: data)
+        case .serializationError(let error, let response, let data):
+            return "Serialization error: \(error), response headers: \(response), response body: ".appendingContentsOf(data: data)
         case .requestError(let error):
             return "Request error: \(error)"
         case .serverError(let response, let data):
-            if let response = response {
-                return "Server error: \(String(describing: response)), response: ".appendingContentsOf(data: data)
+            if let response {
+                return "Server error, response headers: \(String(describing: response)), response body: ".appendingContentsOf(data: data)
             } else {
-                return "Server error: nil, response: ".appendingContentsOf(data: data)
+                return "Server error: nil, response body: ".appendingContentsOf(data: data)
             }
         }
     }
diff --git a/Source/NetworkServices/BasicNetworkService.swift b/Source/NetworkServices/BasicNetworkService.swift
@@ -86,7 +86,7 @@ public final class BasicNetworkService: NetworkService {
             do {
                 return .success((try resource.parse(data), response))
             } catch let error {
-                return .failure(.serializationError(error: error, data: data))
+                return .failure(.serializationError(error: error, response: response, data: data))
             }
         } catch let error {
             if case URLError.cancelled = error {
diff --git a/Source/Resource+Decodable.swift b/Source/Resource+Decodable.swift
@@ -33,7 +33,11 @@ extension Resource where Model: Decodable {
     ///   - decoder: a decoder which can decode the payload into the model type
     ///   - mapError: a closure which maps to Error
     public init(request: URLRequest, decoder: JSONDecoder, mapError: @escaping @Sendable  (_ networkError: NetworkError) -> E) {
-        self.init(request: request, parse: { try decoder.decode(Model.self, from: $0) }, mapError: mapError)
+        self.init(request: request, parse: {
+                try decoder.decode(Model.self, from: $0)
+            },
+            mapError: mapError
+        )
     }
 }
 
@@ -47,6 +51,12 @@ extension Resource where Model: Decodable, E: NetworkErrorConvertible {
     ///   - decoder: a decoder which can decode the payload into the model type
     ///   - mapError: a closure which maps to Error
     public init(request: URLRequest, decoder: JSONDecoder) {
-        self.init(request: request, parse: { try decoder.decode(Model.self, from: $0) }, mapError: { E(networkError: $0) })
+        self.init(request: request, parse: {
+                try decoder.decode(Model.self, from: $0)
+            },
+            mapError: {
+                E(networkError: $0)
+            }
+        )
     }
 }
diff --git a/Source/Resource+Inspect.swift b/Source/Resource+Inspect.swift
@@ -36,7 +36,7 @@ extension Resource {
      - parameter inspector: closure which gets passed the data
      - returns: a new resource which gets instepcted before parsing
      */
-    public func inspectData(_ inspector: @escaping @Sendable  (Data) -> Void) -> Resource<Model, E> {
+    public func inspectData(_ inspector: @escaping @Sendable (Data) -> Void) -> Resource<Model, E> {
         let parse: @Sendable (Data) throws -> Model = { data in
             inspector(data)
             return try self.parse(data)
diff --git a/Source/Resource+Map.swift b/Source/Resource+Map.swift
@@ -30,7 +30,9 @@ extension Resource {
     public func map<T>(transform: @escaping @Sendable  (Model) throws -> T) -> Resource<T, E> {
         return Resource<T, E>(
             request: request,
-            parse: {  return try transform(try self.parse($0)) },
+            parse: { data in
+                return try transform(try self.parse(data))
+            },
             mapError: mapError
         )
     }
diff --git a/Tests/DecodableResoureTest.swift b/Tests/DecodableResoureTest.swift
@@ -34,7 +34,7 @@ class DecodableResoureTest: XCTestCase {
     func testResource_withValidData() {
         //When
         let fetchedTrain = try? resource.parse(Train.validJSONData)
-        
+
         //Then
         XCTAssertEqual(fetchedTrain?.name, "ICE")
     }
@@ -43,7 +43,7 @@ class DecodableResoureTest: XCTestCase {
         //When
         let nameResource = resource.map { $0.name }
         let fetchedTrainName = try? nameResource.parse(Train.validJSONData)
-        
+
         //Then
         XCTAssertEqual(fetchedTrainName, "ICE")
     }
diff --git a/Tests/ModifyRequestNetworkService.swift b/Tests/ModifyRequestNetworkService.swift
@@ -36,12 +36,12 @@ class ModifyRequestNetworkServiceTest: XCTestCase {
         let networkService = ModifyRequestNetworkService(networkService: networkServiceMock, requestModifications: modification)
         let request = URLRequest(path: "/trains", baseURL: .defaultMock)
         let resource = Resource<Int, NetworkError>(request: request, parse: { _ in return 1 })
-        
+
         //When
         await networkService.requestResult(for: resource)
 
         //Then
-        let lastRequest = await networkServiceMock.lastRequest
+        let lastRequest = networkServiceMock.lastRequest
         let lastRequestURL = try XCTUnwrap(lastRequest?.url)
         XCTAssert(lastRequestURL.absoluteString.contains("key=1"))
     }
diff --git a/Tests/NetworkErrorTest.swift b/Tests/NetworkErrorTest.swift
@@ -135,8 +135,8 @@ class NetworkErrorTest: XCTestCase {
         let debugDescription = error.debugDescription
         
         //Then
-        XCTAssert(debugDescription.hasPrefix("Authorization error: <NSHTTPURLResponse: "))
-        XCTAssert(debugDescription.hasSuffix("response: dataString"))
+        XCTAssert(debugDescription.hasPrefix("Authorization error, response headers: <NSHTTPURLResponse: "), debugDescription)
+        XCTAssert(debugDescription.hasSuffix("response body: dataString"), debugDescription)
     }
     
     func testUnknownError_clientError_description() {
@@ -149,21 +149,22 @@ class NetworkErrorTest: XCTestCase {
         let debugDescription = error.debugDescription
         
         //Then
-        XCTAssert(debugDescription.hasPrefix("Client error: <NSHTTPURLResponse: "))
-        XCTAssert(debugDescription.hasSuffix("response: dataString"))
+        XCTAssert(debugDescription.hasPrefix("Client error, response headers: <NSHTTPURLResponse: "), debugDescription)
+        XCTAssert(debugDescription.hasSuffix("response body: dataString"), debugDescription)
     }
     
     func testUnknownError_serializationError_description() {
         //Given
         let nserror = NSError(domain: "TestError", code: 0, userInfo: nil)
         let data = "dataString".data(using: .utf8)
-        let error: NetworkError = .serializationError(error: nserror, data: data)
-        
+        let error: NetworkError = .serializationError(error: nserror, response: HTTPURLResponse.defaultMock, data: data)
+
         //When
         let debugDescription = error.debugDescription
         
         //Then
-        XCTAssertEqual(debugDescription, "Serialization error: Error Domain=TestError Code=0 \"(null)\", response: dataString")
+        XCTAssert(debugDescription.hasPrefix("Serialization error: Error Domain=TestError Code=0 \"(null)\", response headers: <NSHTTPURLResponse:"), debugDescription)
+        XCTAssert(debugDescription.hasSuffix("response body: dataString"), debugDescription)
     }
     
     func testUnknownError_requestError_description() {
diff --git a/Tests/NetworkServiceMockTest.swift b/Tests/NetworkServiceMockTest.swift
@@ -41,7 +41,7 @@ class NetworkServiceMockTest: XCTestCase {
         try await networkServiceMock.request(resource)
 
         //Then
-        let requestCount = await  networkServiceMock.requestCount
+        let requestCount = networkServiceMock.requestCount
         XCTAssertEqual(requestCount, 2)
     }
     
@@ -57,7 +57,7 @@ class NetworkServiceMockTest: XCTestCase {
         try await networkServiceMock.request(resource)
 
         //Then
-        let lastRequests = await networkServiceMock.lastRequests
+        let lastRequests = networkServiceMock.lastRequests
         XCTAssertEqual(lastRequests, [resource.request, resource.request])
     }
     
diff --git a/Tests/NetworkServiceTest.swift b/Tests/NetworkServiceTest.swift
@@ -59,7 +59,7 @@ class NetworkServiceTest: XCTestCase {
         let result = await networkService.requestResult(for: resource)
 
         //Then
-        if case .failure(.serializationError(_, let data)) = result {
+        if case .failure(.serializationError(_, _, let data)) = result {
             XCTAssertEqual(data, Train.JSONDataWithInvalidKey)
         } else {
             XCTFail("Expects serializationError")
diff --git a/Tests/ResourceInspectTest.swift b/Tests/ResourceInspectTest.swift
@@ -27,23 +27,42 @@ final class ResourceInspectTest: XCTestCase {
     func testInspect() {
         //Given
         let data = Data()
-        var capuredParsingData: Data?
-        var capturedInspectedData: Data?
+        let capturedParsingData = Container<Data?>(nil)
+        let capturedInspectedData = Container<Data?>(nil)
+
         let resource = Resource<Int, NetworkError>(request: URLRequest.defaultMock, parse: { data in
-            capuredParsingData = data
+            capturedParsingData.setValue(data)
             return 1
         })
         
         //When
         let inspectedResource = resource.inspectData({ data in
-            capturedInspectedData = data
+            capturedInspectedData.setValue(data)
         })
         let result = try? inspectedResource.parse(data)
-        
+
         //Then
         XCTAssertNotNil(result)
-        XCTAssertEqual(capuredParsingData, capturedInspectedData)
-        XCTAssertEqual(data, capturedInspectedData)
-        XCTAssertEqual(capuredParsingData, data)
+        XCTAssertEqual(capturedParsingData.getValue(), capturedInspectedData.getValue())
+        XCTAssertEqual(data, capturedInspectedData.getValue())
+        XCTAssertEqual(capturedParsingData.getValue(), data)
+    }
+}
+
+private class Container<T> {
+    private var value: T
+
+    init(_ value: T) {
+        self.value = value
+    }
+
+    /// caller should manage concurrent access to its own state
+    func setValue(_ newValue: T) {
+        value = newValue
+    }
+
+    /// caller should manage concurrent access to its own state
+    func getValue() -> T {
+        value
     }
 }
diff --git a/Tests/ResourceTest.swift b/Tests/ResourceTest.swift
@@ -35,7 +35,7 @@ class ResourceTest: XCTestCase {
 
         //When
         let name = try resource.parse(validData)
-        
+
         //Then
         XCTAssertEqual(name, "ICE")
     }
diff --git a/Tests/ResourceWithErrorTest.swift b/Tests/ResourceWithErrorTest.swift
@@ -39,7 +39,7 @@ class ResourceWithErrorTest: XCTestCase {
         
         //When
         let name = try resource.parse(validData)
-        
+
         //Then
         XCTAssertEqual(name, "ICE")
     }
diff --git a/Tests/RetryNetworkserviceTest.swift b/Tests/RetryNetworkserviceTest.swift
@@ -32,7 +32,6 @@ class RetryNetworkserviceTest: XCTestCase {
     
     func testRetryRequest_shouldRetry() async throws {
         //Given
-        let errorCount = 2
         let numberOfRetries = 2
         let networkServiceMock = NetworkServiceMock(
             Result<Int, NetworkError>.failure(.unknownError),

Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,7 @@ public final class BasicNetworkService: NetworkService {`
`86`	`86`	`do {`
`87`	`87`	`return .success((try resource.parse(data), response))`
`88`	`88`	`} catch let error {`
`89`		`- return .failure(.serializationError(error: error, data: data))`
	`89`	`+ return .failure(.serializationError(error: error, response: response, data: data))`
`90`	`90`	`}`
`91`	`91`	`} catch let error {`
`92`	`92`	`if case URLError.cancelled = error {`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,9 @@ extension Resource {`
`30`	`30`	`public func map<T>(transform: @escaping @Sendable (Model) throws -> T) -> Resource<T, E> {`
`31`	`31`	`return Resource<T, E>(`
`32`	`32`	`request: request,`
`33`		`- parse: { return try transform(try self.parse($0)) },`
	`33`	`+ parse: { data in`
	`34`	`+ return try transform(try self.parse(data))`
	`35`	`+ },`
`34`	`36`	`mapError: mapError`
`35`	`37`	`)`
`36`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ class NetworkServiceMockTest: XCTestCase {`
`41`	`41`	`try await networkServiceMock.request(resource)`
`42`	`42`
`43`	`43`	`//Then`
`44`		`- let requestCount = await networkServiceMock.requestCount`
	`44`	`+ let requestCount = networkServiceMock.requestCount`
`45`	`45`	`XCTAssertEqual(requestCount, 2)`
`46`	`46`	`}`
`47`	`47`
`@@ -57,7 +57,7 @@ class NetworkServiceMockTest: XCTestCase {`
`57`	`57`	`try await networkServiceMock.request(resource)`
`58`	`58`
`59`	`59`	`//Then`
`60`		`- let lastRequests = await networkServiceMock.lastRequests`
	`60`	`+ let lastRequests = networkServiceMock.lastRequests`
`61`	`61`	`XCTAssertEqual(lastRequests, [resource.request, resource.request])`
`62`	`62`	`}`
`63`	`63`