fix: handle Int32 and Int64 in defaultValue evaluations

Sources/Confidence/FlagEvaluation.swift

@@ -86,6 +86,7 @@ extension FlagResolution {
         }
     }
 
+    // swiftlint:disable:next cyclomatic_complexity
     private func getTyped<T>(value: ConfidenceValue) -> T? {
         if let value = self as? T {
             return value
@@ -97,7 +98,16 @@ extension FlagResolution {
         case .string:
             return value.asString() as? T
         case .integer:
-            return value.asInteger() as? T
+            if let intValue = value.asInteger() as? T {
+                return intValue
+            }
+            if T.self == Int32.self, let intValue = value.asInteger() {
+                return Int32(intValue) as? T
+            }
+            if T.self == Int64.self, let intValue = value.asInteger() {
+                return Int64(intValue) as? T
+            }
+            return nil
         case .double:
             return value.asDouble() as? T
         case .date:

Tests/ConfidenceTests/ConfidenceTest.swift

@@ -210,6 +210,44 @@ class ConfidenceTest: XCTestCase {
     }
 
 
+    func testResolveIntegerFlagWithInt64() async throws {
+        class FakeClient: ConfidenceResolveClient {
+            var resolveStats: Int = 0
+            var resolvedValues: [ResolvedValue] = []
+            func resolve(ctx: ConfidenceStruct) async throws -> ResolvesResult {
+                self.resolveStats += 1
+                return .init(resolvedValues: resolvedValues, resolveToken: "token")
+            }
+        }
+
+        let client = FakeClient()
+        client.resolvedValues = [
+            ResolvedValue(
+                variant: "control",
+                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)
+            .build()
+
+        try await confidence.fetchAndActivate()
+        let value = try confidence.getValue(
+            key: "flag.size",
+            defaultValue: 0 as Int64)
+
+        XCTAssertEqual(client.resolveStats, 1)
+        XCTAssertEqual(value, 3)
+        XCTAssertEqual(client.resolveStats, 1)
+        await fulfillment(of: [flagApplier.applyExpectation], timeout: 1)
+        XCTAssertEqual(flagApplier.applyCallCount, 1)
+    }
+
+
     func testResolveAndApplyIntegerFlagNoSegmentMatch() async throws {
         class FakeClient: ConfidenceResolveClient {
             var resolveStats: Int = 0