fix: TypeMismatch error is handled

spotify · Nov 5, 2024 · 8ad1db4 · 8ad1db4
1 parent 58c3a71
commit 8ad1db4
Show file tree

Hide file tree

Showing 4 changed files with 59 additions and 11 deletions.
diff --git a/Sources/Confidence/FlagEvaluation.swift b/Sources/Confidence/FlagEvaluation.swift
@@ -13,6 +13,7 @@ public enum ErrorCode {
     case invalidContext
     case flagNotFound
     case evaluationError
+    case typeMismatch
 }
 
 struct FlagResolution: Encodable, Decodable, Equatable {
@@ -68,28 +69,35 @@ extension FlagResolution {
             }
 
             let parsedValue = try getValue(path: parsedKey.path, value: value)
-            let pathValue: T = getTyped(value: parsedValue) ?? defaultValue
+            let typedValue: T? = getTyped(value: parsedValue)
+            let resolveReason = (resolvedFlag.resolveReason == .match && self.context != context)
+            ? .stale
+            : resolvedFlag.resolveReason
 
-            if resolvedFlag.resolveReason == .match {
-                var resolveReason: ResolveReason = .match
-                if self.context != context {
-                    resolveReason = .stale
-                }
+            if let typedValue = typedValue {
                 return Evaluation(
-                    value: pathValue,
+                    value: typedValue,
                     variant: resolvedFlag.variant,
                     reason: resolveReason,
                     errorCode: nil,
                     errorMessage: nil
                 )
-            } else {
+            } else if parsedValue == .init(null: ()) {
                 return Evaluation(
                     value: defaultValue,
                     variant: resolvedFlag.variant,
-                    reason: resolvedFlag.resolveReason,
+                    reason: resolveReason,
                     errorCode: nil,
                     errorMessage: nil
                 )
+            } else {
+                return Evaluation(
+                    value: defaultValue,
+                    variant: nil,
+                    reason: .error,
+                    errorCode: .typeMismatch,
+                    errorMessage: nil
+                )
             }
         } catch {
             return Evaluation(

diff --git a/Sources/ConfidenceProvider/ConfidenceFeatureProvider.swift b/Sources/ConfidenceProvider/ConfidenceFeatureProvider.swift
@@ -145,6 +145,8 @@ extension Evaluation {
                 throw OpenFeatureError.flagNotFoundError(key: self.errorMessage ?? "unknown key")
             case .evaluationError:
                 throw OpenFeatureError.generalError(message: self.errorMessage ?? "unknown error")
+            case .typeMismatch:
+                throw OpenFeatureError.typeMismatchError
             }
         }
         return ProviderEvaluation(

diff --git a/Tests/ConfidenceTests/ConfidenceIntegrationTest.swift b/Tests/ConfidenceTests/ConfidenceIntegrationTest.swift
@@ -30,7 +30,7 @@ class ConfidenceIntegrationTests: XCTestCase {
             .withContext(initialContext: ctx)
             .build()
         try await confidence.fetchAndActivate()
-        let intResult = confidence.getEvaluation(key: "\(resolveFlag).my-integer", defaultValue: "1")
+        let intResult = confidence.getEvaluation(key: "\(resolveFlag).my-integer", defaultValue: 1)
         let boolResult = confidence.getEvaluation(key: "\(resolveFlag).my-boolean", defaultValue: false)
 
 

diff --git a/Tests/ConfidenceTests/ConfidenceTest.swift b/Tests/ConfidenceTests/ConfidenceTest.swift
@@ -258,7 +258,7 @@ class ConfidenceTest: XCTestCase {
         let client = FakeClient()
         client.resolvedValues = [
             ResolvedValue(
-                value: .init(structure: ["size": .init(integer: 3)]),
+                value: nil,
                 flag: "flag",
                 resolveReason: .noSegmentMatch)
         ]
@@ -618,6 +618,44 @@ class ConfidenceTest: XCTestCase {
         }
     }
 
+    func testTypeMismatch() 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(boolean: true)]),
+                flag: "flag",
+                resolveReason: .match)
+        ]
+
+        let confidence = Confidence.Builder(clientSecret: "test")
+            .withContext(initialContext: ["targeting_key": .init(string: "user1")])
+            .withFlagResolverClient(flagResolver: client)
+            .withFlagApplier(flagApplier: flagApplier)
+            .build()
+
+        try await confidence.fetchAndActivate()
+        let evaluation = confidence.getEvaluation(
+            key: "flag.size",
+            defaultValue: 1)
+
+        XCTAssertEqual(client.resolveStats, 1)
+        XCTAssertEqual(evaluation.value, 1)
+        XCTAssertEqual(evaluation.errorCode, .typeMismatch)
+        XCTAssertNil(evaluation.errorMessage, "")
+        XCTAssertEqual(evaluation.reason, .error)
+        XCTAssertEqual(evaluation.variant, nil)
+    }
+
     func testConcurrentActivate() async {
         for _ in 1...100 {
             Task {