feat: add support for provider fatal error (#44)

Author: nicklasl

Sources/OpenFeature/exceptions/ErrorCode.swift

@@ -8,4 +8,5 @@ public enum ErrorCode: Int {
     case targetingKeyMissing
     case invalidContext
     case general
+    case providerFatal
 }

Sources/OpenFeature/exceptions/OpenFeatureError.swift

@@ -9,6 +9,7 @@ public enum OpenFeatureError: Error, Equatable {
     case typeMismatchError
     case valueNotConvertableError
     case providerNotReadyError
+    case providerFatarError(message: String)
 
     public func errorCode() -> ErrorCode {
         switch self {
@@ -28,6 +29,8 @@ public enum OpenFeatureError: Error, Equatable {
             return .general
         case .providerNotReadyError:
             return .providerNotReady
+        case .providerFatarError:
+            return .providerFatal
         }
     }
 }
@@ -51,6 +54,8 @@ extension OpenFeatureError: CustomStringConvertible {
             return "Could not convert value"
         case .providerNotReadyError:
             return "The value was resolved before the provider was ready"
+        case .providerFatarError(let message):
+            return "A fatal error occurred in the provider: \(message)"
         }
     }
 }

Tests/OpenFeatureTests/FlagEvaluationTests.swift

@@ -236,6 +236,35 @@ final class FlagEvaluationTests: XCTestCase {
         XCTAssertNotNil(eventState)
     }
 
+    func testBrokenProviderThrowsFatal() {
+        let provider = AlwaysBrokenProvider()
+        provider.throwFatal = true
+        let fatalExpectation = XCTestExpectation(description: "NotReady")
+
+        let eventState = provider.observe().sink { event in
+            switch event {
+            case .notReady:
+                // The provider starts in this state.
+                return
+            case .error:
+                fatalExpectation.fulfill()
+            default:
+                XCTFail("Unexpected event")
+            }
+        }
+        OpenFeatureAPI.shared.setProvider(provider: provider)
+        wait(for: [fatalExpectation], timeout: 5)
+
+        let client = OpenFeatureAPI.shared.getClient()
+
+        XCTAssertFalse(client.getValue(key: "testkey", defaultValue: false))
+        let details = client.getDetails(key: "testkey", defaultValue: false)
+
+        XCTAssertEqual(details.errorCode, .providerFatal)
+        XCTAssertEqual(details.reason, Reason.error.rawValue)
+        XCTAssertEqual(details.errorMessage, "A fatal error occurred in the provider: Always broken")
+    }
+
     func testClientMetadata() {
         let client1 = OpenFeatureAPI.shared.getClient()
         XCTAssertNil(client1.metadata.name)

Tests/OpenFeatureTests/Helpers/AlwaysBrokenProvider.swift

@@ -1,11 +1,12 @@
-import Foundation
 import Combine
+import Foundation
 
 @testable import OpenFeature
 
 class AlwaysBrokenProvider: FeatureProvider {
     var metadata: ProviderMetadata = AlwaysBrokenMetadata()
     var hooks: [any Hook] = []
+    var throwFatal = false
     private let eventHandler = EventHandler()
 
     func onContextSet(oldContext: OpenFeature.EvaluationContext?, newContext: OpenFeature.EvaluationContext) {
@@ -19,30 +20,45 @@ class AlwaysBrokenProvider: FeatureProvider {
     func getBooleanEvaluation(key: String, defaultValue: Bool, context: EvaluationContext?) throws
         -> OpenFeature.ProviderEvaluation<Bool>
     {
+        if self.throwFatal {
+            throw OpenFeatureError.providerFatarError(message: "Always broken")
+        }
         throw OpenFeatureError.flagNotFoundError(key: key)
     }
 
     func getStringEvaluation(key: String, defaultValue: String, context: EvaluationContext?) throws
         -> OpenFeature.ProviderEvaluation<String>
     {
+        if self.throwFatal {
+            throw OpenFeatureError.providerFatarError(message: "Always broken")
+        }
         throw OpenFeatureError.flagNotFoundError(key: key)
     }
 
     func getIntegerEvaluation(key: String, defaultValue: Int64, context: EvaluationContext?) throws
         -> OpenFeature.ProviderEvaluation<Int64>
     {
+        if self.throwFatal {
+            throw OpenFeatureError.providerFatarError(message: "Always broken")
+        }
         throw OpenFeatureError.flagNotFoundError(key: key)
     }
 
     func getDoubleEvaluation(key: String, defaultValue: Double, context: EvaluationContext?) throws
         -> OpenFeature.ProviderEvaluation<Double>
     {
+        if self.throwFatal {
+            throw OpenFeatureError.providerFatarError(message: "Always broken")
+        }
         throw OpenFeatureError.flagNotFoundError(key: key)
     }
 
     func getObjectEvaluation(key: String, defaultValue: OpenFeature.Value, context: EvaluationContext?) throws
         -> OpenFeature.ProviderEvaluation<OpenFeature.Value>
     {
+        if self.throwFatal {
+            throw OpenFeatureError.providerFatarError(message: "Always broken")
+        }
         throw OpenFeatureError.flagNotFoundError(key: key)
     }