fix: run error hooks if provider returns FlagResolutionDetails with non-empty error_code

Author: federicobond

openfeature/client.py

@@ -425,6 +425,7 @@ def _create_provider_evaluation(
             raise GeneralError(error_message="Unknown flag type")
 
         resolution = get_details_callable(*args)
+        resolution.raise_for_error()
 
         # we need to check the get_args to be compatible with union types.
         _typecheck_flag_value(resolution.value, flag_type)

openfeature/exception.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import typing
 from enum import Enum
 
@@ -12,6 +14,24 @@ class ErrorCode(Enum):
     INVALID_CONTEXT = "INVALID_CONTEXT"
     GENERAL = "GENERAL"
 
+    @classmethod
+    def to_exception(
+        cls, error_code: ErrorCode, error_message: str
+    ) -> OpenFeatureError:
+        return typing.cast(
+            OpenFeatureError,
+            {
+                ErrorCode.PROVIDER_NOT_READY: ProviderNotReadyError,
+                ErrorCode.PROVIDER_FATAL: ProviderFatalError,
+                ErrorCode.FLAG_NOT_FOUND: FlagNotFoundError,
+                ErrorCode.PARSE_ERROR: ParseError,
+                ErrorCode.TYPE_MISMATCH: TypeMismatchError,
+                ErrorCode.TARGETING_KEY_MISSING: TargetingKeyMissingError,
+                ErrorCode.INVALID_CONTEXT: InvalidContextError,
+                ErrorCode.GENERAL: GeneralError,
+            }.get(error_code, GeneralError)(error_message),
+        )
+
 
 class OpenFeatureError(Exception):
     """

openfeature/flag_evaluation.py

@@ -63,3 +63,8 @@ class FlagResolutionDetails(typing.Generic[U_co]):
     reason: typing.Optional[typing.Union[str, Reason]] = None
     variant: typing.Optional[str] = None
     flag_metadata: FlagMetadata = field(default_factory=dict)
+
+    def raise_for_error(self) -> None:
+        if self.error_code:
+            raise ErrorCode.to_exception(self.error_code, self.error_message or "")
+        return None

tests/test_client.py

@@ -2,12 +2,12 @@
 
 import pytest
 
-from openfeature.api import add_hooks, clear_hooks, set_provider
+from openfeature.api import add_hooks, clear_hooks, get_client, set_provider
 from openfeature.client import OpenFeatureClient
 from openfeature.exception import ErrorCode, OpenFeatureError
-from openfeature.flag_evaluation import Reason
+from openfeature.flag_evaluation import FlagResolutionDetails, Reason
 from openfeature.hook import Hook
-from openfeature.provider import ProviderStatus
+from openfeature.provider import FeatureProvider, ProviderStatus
 from openfeature.provider.in_memory_provider import InMemoryFlag, InMemoryProvider
 from openfeature.provider.no_op_provider import NoOpProvider
 
@@ -236,3 +236,27 @@ def test_should_shortcircuit_if_provider_is_in_irrecoverable_error_state(
     assert flag_details.reason == Reason.ERROR
     assert flag_details.error_code == ErrorCode.PROVIDER_FATAL
     spy_hook.error.assert_called_once()
+
+
+def test_should_run_error_hooks_if_provider_returns_resolution_with_error_code():
+    # Given
+    spy_hook = MagicMock(spec=Hook)
+    provider = MagicMock(spec=FeatureProvider)
+    provider.get_provider_hooks.return_value = []
+    provider.resolve_boolean_details.return_value = FlagResolutionDetails(
+        value=True,
+        reason=Reason.ERROR,
+        error_code=ErrorCode.PROVIDER_FATAL,
+        error_message="This is an error message",
+    )
+    set_provider(provider)
+    client = get_client()
+    client.add_hooks([spy_hook])
+    # When
+    flag_details = client.get_boolean_details(flag_key="Key", default_value=True)
+    # Then
+    assert flag_details is not None
+    assert flag_details.value
+    assert flag_details.reason == Reason.ERROR
+    assert flag_details.error_code == ErrorCode.PROVIDER_FATAL
+    spy_hook.error.assert_called_once()