🚧 🧪 Prepares for basic retrier. Polishes tests.

- Adds previousAttempts in preparation for basic retrier.
- Adds tests that validate previousAttempts is correctly incremented.
- Adds updates plugin handlers to all through, matching their protocol.
- Adds tests that validate throwing errors rethrows up correctly.
- Replaces unused closure parameters with underscore to reduce noise.

Author: connor-ricks

Sources/HTTPNetworking/HTTPRequest.swift

@@ -19,7 +19,7 @@ import Foundation
 /// You can retry the ``HTTPRequest`` if it fails by calling ``retry(_:)`` or ``retry(with:)``.
 /// By providing a ``RetryHandler`` or ``HTTPRequestRetrier``, you can determine if a request should be retried if it fails.
 /// Typical use cases include retrying requests a given number of times in the event of poor network connectivity.
-public class HTTPRequest<T: Decodable> {
+public class HTTPRequest<Value: Decodable> {
 
     // MARK: Properties
 
@@ -61,10 +61,14 @@ public class HTTPRequest<T: Decodable> {
 
     // MARK: Execution
 
-    /// Triggers the request to actually be sent.
-    public func run() async throws -> T {
+    /// Dispatches the request, returning the request's expected `Value`.
+    public func run() async throws -> Value {
+        try await execute(previousAttempts: 0)
+    }
+    
+    /// Executes the request to the dispatcher.
+    private func execute(previousAttempts: Int) async throws -> Value {
         var request = self.request
-        
         do {
 
             try Task.checkCancellation()
@@ -87,17 +91,24 @@ public class HTTPRequest<T: Decodable> {
             try Task.checkCancellation()
 
             // Convert data to the expected type
-            return try decoder.decode(T.self, from: data)
+            return try decoder.decode(Value.self, from: data)
         } catch {
-            let strategy = try await ZipRetrier(retriers).retry(request, for: dispatcher.session, dueTo: error)
+            let previousAttempts = previousAttempts + 1
+            let strategy = try await ZipRetrier(retriers).retry(
+                request,
+                for: dispatcher.session,
+                dueTo: error,
+                previousAttempts: previousAttempts
+            )
+            
             switch strategy {
             case .concede:
                 throw error
             case .retryAfterDelay(let delay):
                 try await Task.sleep(for: delay)
                 fallthrough
             case .retry:
-                return try await run()
+                return try await execute(previousAttempts: previousAttempts)
             }
         }
     }

Sources/HTTPNetworking/Plugins/HTTPRequestRetrier.swift

@@ -7,7 +7,7 @@ import Foundation
 /// By conforming to ``HTTPRequestRetrier`` you can implement both simple and complex logic for retrying an ``HTTPRequest`` when
 /// it fails. Common uses cases include retrying a given amount of times due to a specific error such as poor network connectivity.
 public protocol HTTPRequestRetrier {
-    func retry(_ request: URLRequest, for session: URLSession, dueTo error: Error) async throws -> RetryStrategy
+    func retry(_ request: URLRequest, for session: URLSession, dueTo error: Error, previousAttempts: Int) async throws -> RetryStrategy
 }
 
 // MARK: - RetryStrategy

Sources/HTTPNetworking/Plugins/Retriers/Retrier.swift

@@ -1,6 +1,6 @@
 import Foundation
 
-public typealias RetryHandler = (URLRequest, URLSession, Error) async -> RetryStrategy
+public typealias RetryHandler = (URLRequest, URLSession, Error, Int) async throws -> RetryStrategy
 
 /// An ``HTTPRequestRetrier`` that can be used to retry an ``HTTPRequest`` upon failure.
 public struct Retrier: HTTPRequestRetrier {
@@ -21,8 +21,13 @@ public struct Retrier: HTTPRequestRetrier {
 
     // MARK: ResponseValidator
 
-    public func retry(_ request: URLRequest, for session: URLSession, dueTo error: Error) async -> RetryStrategy {
-        await handler(request, session, error)
+    public func retry(
+        _ request: URLRequest,
+        for session: URLSession,
+        dueTo error: Error,
+        previousAttempts: Int
+    ) async throws -> RetryStrategy {
+        try await handler(request, session, error, previousAttempts)
     }
 }
 

Sources/HTTPNetworking/Plugins/Retriers/ZipRetrier.swift

@@ -26,11 +26,22 @@ public struct ZipRetrier: HTTPRequestRetrier {
 
     // MARK: ResponseValidator
 
-    public func retry(_ request: URLRequest, for session: URLSession, dueTo error: Error) async throws -> RetryStrategy {
+    public func retry(
+        _ request: URLRequest,
+        for session: URLSession,
+        dueTo error: Error,
+        previousAttempts: Int
+    ) async throws -> RetryStrategy {
         for retrier in retriers {
             try Task.checkCancellation()
 
-            let strategy = try await retrier.retry(request, for: session, dueTo: error)
+            let strategy = try await retrier.retry(
+                request,
+                for: session,
+                dueTo: error,
+                previousAttempts: previousAttempts
+            )
+            
             switch strategy {
             case .concede:
                 continue

Sources/HTTPNetworking/Plugins/Validators/Validator.swift

@@ -1,6 +1,6 @@
 import Foundation
 
-public typealias ValidationHandler = (HTTPURLResponse, URLRequest, Data) async -> ValidationResult
+public typealias ValidationHandler = (HTTPURLResponse, URLRequest, Data) async throws -> ValidationResult
 
 /// An ``HTTPResponseValidator`` that can be used to validate a response from an ``HTTPRequest``.
 public struct Validator: HTTPResponseValidator {
@@ -20,8 +20,8 @@ public struct Validator: HTTPResponseValidator {
 
     // MARK: HTTPResponseValidator
 
-    public func validate(_ response: HTTPURLResponse, for request: URLRequest, with data: Data) async -> ValidationResult {
-        await handler(response, request, data)
+    public func validate(_ response: HTTPURLResponse, for request: URLRequest, with data: Data) async throws -> ValidationResult {
+        try await handler(response, request, data)
     }
 }