feat: implement type checking for resolved values

Signed-off-by: Federico Bond <[email protected]>

Author: federicobond

providers/openfeature-provider-ofrep/src/openfeature/contrib/provider/ofrep/__init__.py

@@ -1,7 +1,7 @@
 import re
 from datetime import datetime, timedelta, timezone
 from email.utils import parsedate_to_datetime
-from typing import Any, Dict, List, NoReturn, Optional, Union
+from typing import Any, Dict, List, NoReturn, Optional, Tuple, Type, Union
 from urllib.parse import urljoin
 
 import requests
@@ -16,14 +16,27 @@
     OpenFeatureError,
     ParseError,
     TargetingKeyMissingError,
+    TypeMismatchError,
 )
-from openfeature.flag_evaluation import FlagResolutionDetails, Reason
+from openfeature.flag_evaluation import FlagResolutionDetails, FlagType, Reason
 from openfeature.hook import Hook
 from openfeature.provider import AbstractProvider, Metadata
 
 __all__ = ["OFREPProvider"]
 
 
+TypeMap = Dict[
+    FlagType,
+    Union[
+        Type[bool],
+        Type[int],
+        Type[float],
+        Type[str],
+        Tuple[Type[dict], Type[list]],
+    ],
+]
+
+
 class OFREPProvider(AbstractProvider):
     def __init__(
         self,
@@ -53,42 +66,53 @@ def resolve_boolean_details(
         default_value: bool,
         evaluation_context: Optional[EvaluationContext] = None,
     ) -> FlagResolutionDetails[bool]:
-        return self._resolve(flag_key, default_value, evaluation_context)
+        return self._resolve(
+            FlagType.BOOLEAN, flag_key, default_value, evaluation_context
+        )
 
     def resolve_string_details(
         self,
         flag_key: str,
         default_value: str,
         evaluation_context: Optional[EvaluationContext] = None,
     ) -> FlagResolutionDetails[str]:
-        return self._resolve(flag_key, default_value, evaluation_context)
+        return self._resolve(
+            FlagType.STRING, flag_key, default_value, evaluation_context
+        )
 
     def resolve_integer_details(
         self,
         flag_key: str,
         default_value: int,
         evaluation_context: Optional[EvaluationContext] = None,
     ) -> FlagResolutionDetails[int]:
-        return self._resolve(flag_key, default_value, evaluation_context)
+        return self._resolve(
+            FlagType.INTEGER, flag_key, default_value, evaluation_context
+        )
 
     def resolve_float_details(
         self,
         flag_key: str,
         default_value: float,
         evaluation_context: Optional[EvaluationContext] = None,
     ) -> FlagResolutionDetails[float]:
-        return self._resolve(flag_key, default_value, evaluation_context)
+        return self._resolve(
+            FlagType.FLOAT, flag_key, default_value, evaluation_context
+        )
 
     def resolve_object_details(
         self,
         flag_key: str,
         default_value: Union[dict, list],
         evaluation_context: Optional[EvaluationContext] = None,
     ) -> FlagResolutionDetails[Union[dict, list]]:
-        return self._resolve(flag_key, default_value, evaluation_context)
+        return self._resolve(
+            FlagType.OBJECT, flag_key, default_value, evaluation_context
+        )
 
     def _resolve(
         self,
+        flag_type: FlagType,
         flag_key: str,
         default_value: Union[bool, str, int, float, dict, list],
         evaluation_context: Optional[EvaluationContext] = None,
@@ -117,6 +141,8 @@ def _resolve(
         except JSONDecodeError as e:
             raise ParseError(str(e)) from e
 
+        _typecheck_flag_value(data["value"], flag_type)
+
         return FlagResolutionDetails(
             value=data["value"],
             reason=Reason[data["reason"]],
@@ -178,3 +204,18 @@ def _parse_retry_after(retry_after: Optional[str]) -> Optional[datetime]:
         seconds = int(retry_after)
         return datetime.now(timezone.utc) + timedelta(seconds=seconds)
     return parsedate_to_datetime(retry_after)
+
+
+def _typecheck_flag_value(value: Any, flag_type: FlagType) -> None:
+    type_map: TypeMap = {
+        FlagType.BOOLEAN: bool,
+        FlagType.STRING: str,
+        FlagType.OBJECT: (dict, list),
+        FlagType.FLOAT: float,
+        FlagType.INTEGER: int,
+    }
+    _type = type_map.get(flag_type)
+    if not _type:
+        raise GeneralError(error_message="Unknown flag type")
+    if not isinstance(value, _type):
+        raise TypeMismatchError(f"Expected type {_type} but got {type(value)}")

providers/openfeature-provider-ofrep/tests/test_provider.py

@@ -7,6 +7,7 @@
     GeneralError,
     InvalidContextError,
     ParseError,
+    TypeMismatchError,
 )
 from openfeature.flag_evaluation import FlagResolutionDetails, Reason
 
@@ -15,24 +16,51 @@ def test_provider_init():
     OFREPProvider("http://localhost:8080", headers={"Authorization": "Bearer token"})
 
 
-def test_provider_successful_resolution(ofrep_provider, requests_mock):
+@pytest.mark.parametrize(
+    "flag_type, resolved_value, default_value, get_method",
+    (
+        (bool, True, False, "resolve_boolean_details"),
+        (str, "String", "default", "resolve_string_details"),
+        (int, 100, 0, "resolve_integer_details"),
+        (float, 10.23, 0.0, "resolve_float_details"),
+        (
+            dict,
+            {
+                "String": "string",
+                "Number": 2,
+                "Boolean": True,
+            },
+            {},
+            "resolve_object_details",
+        ),
+        (
+            list,
+            ["string1", "string2"],
+            [],
+            "resolve_object_details",
+        ),
+    ),
+)
+def test_provider_successful_resolution(
+    flag_type, resolved_value, default_value, get_method, ofrep_provider, requests_mock
+):
     requests_mock.post(
         "http://localhost:8080/ofrep/v1/evaluate/flags/flag_key",
         json={
             "key": "flag_key",
             "reason": "TARGETING_MATCH",
-            "variant": "true",
+            "variant": str(resolved_value),
             "metadata": {"foo": "bar"},
-            "value": True,
+            "value": resolved_value,
         },
     )
 
-    resolution = ofrep_provider.resolve_boolean_details("flag_key", False)
+    resolution = getattr(ofrep_provider, get_method)("flag_key", default_value)
 
     assert resolution == FlagResolutionDetails(
-        value=True,
+        value=resolved_value,
         reason=Reason.TARGETING_MATCH,
-        variant="true",
+        variant=str(resolved_value),
         flag_metadata={"foo": "bar"},
     )
 
@@ -117,3 +145,19 @@ def test_provider_retry_after_shortcircuit_resolution(ofrep_provider, requests_m
         GeneralError, match="OFREP evaluation paused due to TooManyRequests"
     ):
         ofrep_provider.resolve_boolean_details("flag_key", False)
+
+
+def test_provider_typecheck_flag_value(ofrep_provider, requests_mock):
+    requests_mock.post(
+        "http://localhost:8080/ofrep/v1/evaluate/flags/flag_key",
+        json={
+            "key": "flag_key",
+            "reason": "TARGETING_MATCH",
+            "variant": "true",
+            "metadata": {},
+            "value": "true",
+        },
+    )
+
+    with pytest.raises(TypeMismatchError):
+        ofrep_provider.resolve_boolean_details("flag_key", False)