feat: add timeout to fetchAndActivate

Sources/Confidence/Confidence.swift

@@ -289,7 +289,7 @@ extension Confidence {
         internal var region: ConfidenceRegion = .global
         internal var metadata: ConfidenceMetadata?
         internal var initialContext: ConfidenceStruct = [:]
-        internal var timeout: Double = 0
+        internal var timeout: Double = 10
 
         // Injectable for testing
         internal var flagApplier: FlagApplier?
@@ -339,6 +339,10 @@ extension Confidence {
             return self
         }
 
+        /**
+         Sets the timeout for the network requests to the Confidence backend.
+         The default is 10 seconds.
+         */
         public func withTimeout(timeout: Double) -> Builder {
             self.timeout = timeout
             return self

Sources/Confidence/Http/NetworkClient.swift

@@ -19,7 +19,6 @@ final class NetworkClient: HttpClient {
         ?? {
             let configuration = URLSessionConfiguration.default
             configuration.httpAdditionalHeaders = defaultHeaders
-            configuration.timeoutIntervalForRequest = timeoutIntervalForRequests
 
             return URLSession(configuration: configuration)
         }()

Tests/ConfidenceTests/ConfidenceTest.swift

@@ -581,6 +581,45 @@ class ConfidenceTest: XCTestCase {
             XCTAssertEqual(error as? ConfidenceError, ConfidenceError.invalidContextInMessage)
         }
     }
+
+    func testRequestTimedOut() async throws {
+        class FakeClient: ConfidenceResolveClient {
+            var resolvedValues: [ResolvedValue] = []
+            func resolve(ctx: ConfidenceStruct) async throws -> ResolvesResult {
+                try await Task.sleep(nanoseconds: 5000000000)
+                return .init(resolvedValues: resolvedValues, resolveToken: "token")
+            }
+        }
+
+        let client = FakeClient()
+        client.resolvedValues = [
+            ResolvedValue(
+                variant: "default",
+                value: .init(structure: ["size": .init(integer: 3)]),
+                flag: "flag",
+                resolveReason: .match)
+        ]
+
+        let confidence = Confidence.Builder(clientSecret: "test")
+            .withContext(initialContext: ["targeting_key": .init(string: "user2")])
+            .withFlagResolverClient(flagResolver: client)
+            .withFlagApplier(flagApplier: flagApplier)
+            .withTimeout(timeout: 1)
+            .build()
+
+        try await confidence.fetchAndActivate()
+        let evaluation = try confidence.getEvaluation(
+            key: "flag.size",
+            defaultValue: 0)
+
+        XCTAssertEqual(evaluation.value, 3)
+        XCTAssertNil(evaluation.errorCode)
+        XCTAssertNil(evaluation.errorMessage)
+        XCTAssertEqual(evaluation.reason, .match)
+        XCTAssertEqual(evaluation.variant, "default")
+        await fulfillment(of: [flagApplier.applyExpectation], timeout: 1)
+        XCTAssertEqual(flagApplier.applyCallCount, 1)
+    }
 }
 
 final class DispatchQueueFake: DispatchQueueType {