diff --git a/split_openfeature/__init__.py b/split_openfeature/__init__.py index 0af51b8..e63e61e 100644 --- a/split_openfeature/__init__.py +++ b/split_openfeature/__init__.py @@ -1,3 +1,3 @@ -from split_openfeature.split_provider import SplitProvider +from split_openfeature.split_provider import SplitProvider, SplitProviderAsync from split_openfeature.split_client_wrapper import SplitClientWrapper diff --git a/split_openfeature/split_client_wrapper.py b/split_openfeature/split_client_wrapper.py index 09a8419..7496d75 100644 --- a/split_openfeature/split_client_wrapper.py +++ b/split_openfeature/split_client_wrapper.py @@ -1,5 +1,4 @@ -from splitio import get_factory -from splitio.client.client import Client +from splitio import get_factory, get_factory_async from splitio.exceptions import TimeoutException import logging @@ -14,29 +13,50 @@ def __init__(self, initial_context): if not self._validate_context(initial_context): raise AttributeError() + self._api_key = initial_context.get("SdkKey") + self._config = {} + if initial_context.get("ConfigOptions") != None: + self._config = initial_context.get("ConfigOptions") + + self._ready_block_time = 10 + if initial_context.get("ReadyBlockTime") != None: + self._ready_block_time = initial_context.get("ReadyBlockTime") + + if initial_context.get("ThreadingMode") != None: + self._threading_mode = initial_context.get("ThreadingMode") + if self._threading_mode == "asyncio": + self._initial_context = initial_context + return + if initial_context.get("SplitClient") != None: self.split_client = initial_context.get("SplitClient") self._factory = self.split_client._factory return - - api_key = initial_context.get("SdkKey") - config = {} - if initial_context.get("ConfigOptions") != None: - config = initial_context.get("ConfigOptions") - self._factory = get_factory(api_key, config=config) - ready_block_time = 10 - if initial_context.get("ReadyBlockTime") != None: - ready_block_time = initial_context.get("ReadyBlockTime") + try: + self._factory = get_factory(self._api_key, config=self._config) + self._factory.block_until_ready(self._ready_block_time) + self.sdk_ready = True + except TimeoutException: + _LOGGER.debug("Split SDK timed out") + + self.split_client = self._factory.client() + + async def create(self): + if self._initial_context.get("SplitClient") != None: + self.split_client = self._initial_context.get("SplitClient") + self._factory = self.split_client._factory + return try: - self._factory.block_until_ready(ready_block_time) + self._factory = await get_factory_async(self._api_key, config=self._config) + await self._factory.block_until_ready(self._ready_block_time) self.sdk_ready = True except TimeoutException: _LOGGER.debug("Split SDK timed out") self.split_client = self._factory.client() - + def is_sdk_ready(self): if self.sdk_ready: return True @@ -48,6 +68,18 @@ def is_sdk_ready(self): _LOGGER.debug("Split SDK timed out") return self.sdk_ready + + async def is_sdk_ready_async(self): + if self.sdk_ready: + return True + + try: + await self._factory.block_until_ready(0.1) + self.sdk_ready = True + except TimeoutException: + _LOGGER.debug("Split SDK timed out") + + return self.sdk_ready def _validate_context(self, initial_context): if initial_context != None and not isinstance(initial_context, dict): diff --git a/split_openfeature/split_provider.py b/split_openfeature/split_provider.py index d7a1366..e2adc1e 100644 --- a/split_openfeature/split_provider.py +++ b/split_openfeature/split_provider.py @@ -11,10 +11,7 @@ _LOGGER = logging.getLogger(__name__) -class SplitProvider(AbstractProvider): - - def __init__(self, initial_context): - self._split_client_wrapper = SplitClientWrapper(initial_context) +class SplitProviderBase(AbstractProvider): def get_metadata(self) -> Metadata: return Metadata("Split") @@ -22,26 +19,6 @@ def get_metadata(self) -> Metadata: def get_provider_hooks(self) -> typing.List[Hook]: return [] - def resolve_boolean_details(self, flag_key: str, default_value: bool, - evaluation_context: EvaluationContext = EvaluationContext()): - return self._evaluate_treatment(flag_key, evaluation_context, default_value) - - def resolve_string_details(self, flag_key: str, default_value: str, - evaluation_context: EvaluationContext = EvaluationContext()): - return self._evaluate_treatment(flag_key, evaluation_context, default_value) - - def resolve_integer_details(self, flag_key: str, default_value: int, - evaluation_context: EvaluationContext = EvaluationContext()): - return self._evaluate_treatment(flag_key, evaluation_context, default_value) - - def resolve_float_details(self, flag_key: str, default_value: float, - evaluation_context: EvaluationContext = EvaluationContext()): - return self._evaluate_treatment(flag_key, evaluation_context, default_value) - - def resolve_object_details(self, flag_key: str, default_value: dict, - evaluation_context: EvaluationContext = EvaluationContext()): - return self._evaluate_treatment(flag_key, evaluation_context, default_value) - def _evaluate_treatment(self, key: str, evaluation_context: EvaluationContext, default_value): if evaluation_context is None: raise GeneralError("Evaluation Context must be provided for the Split Provider") @@ -54,9 +31,12 @@ def _evaluate_treatment(self, key: str, evaluation_context: EvaluationContext, d if not targeting_key: raise TargetingKeyMissingError("Missing targeting key") + attributes = SplitProvider.transform_context(evaluation_context) + evaluated = self._split_client_wrapper.split_client.get_treatment_with_config(targeting_key, key, attributes) + return self._process_treatment(evaluated, default_value) + + def _process_treatment(self, evaluated, default_value): try: - attributes = SplitProvider.transform_context(evaluation_context) - evaluated = self._split_client_wrapper.split_client.get_treatment_with_config(targeting_key, key, attributes) treatment = None config = None if evaluated != None: @@ -116,3 +96,111 @@ def construct_flag_resolution(value, variant, config, reason: Reason = Reason.TA error_code: ErrorCode = None): return FlagResolutionDetails(value=value, error_code=error_code, reason=reason, variant=variant, flag_metadata={"config": config}) + + def resolve_boolean_details(self, flag_key: str, default_value: bool, + evaluation_context: EvaluationContext = EvaluationContext()): + pass + + def resolve_string_details(self, flag_key: str, default_value: str, + evaluation_context: EvaluationContext = EvaluationContext()): + pass + + def resolve_integer_details(self, flag_key: str, default_value: int, + evaluation_context: EvaluationContext = EvaluationContext()): + pass + + def resolve_float_details(self, flag_key: str, default_value: float, + evaluation_context: EvaluationContext = EvaluationContext()): + pass + + def resolve_object_details(self, flag_key: str, default_value: dict, + evaluation_context: EvaluationContext = EvaluationContext()): + pass + + async def resolve_boolean_details_async(self, flag_key: str, default_value: bool, + evaluation_context: EvaluationContext = EvaluationContext()): + pass + + async def resolve_string_details_async(self, flag_key: str, default_value: str, + evaluation_context: EvaluationContext = EvaluationContext()): + pass + async def resolve_integer_details_async(self, flag_key: str, default_value: int, + evaluation_context: EvaluationContext = EvaluationContext()): + pass + + async def resolve_float_details_async(self, flag_key: str, default_value: float, + evaluation_context: EvaluationContext = EvaluationContext()): + pass + + async def resolve_object_details_async(self, flag_key: str, default_value: dict, + evaluation_context: EvaluationContext = EvaluationContext()): + pass + +class SplitProvider(SplitProviderBase): + def __init__(self, initial_context): + self._split_client_wrapper = SplitClientWrapper(initial_context) + + def resolve_boolean_details(self, flag_key: str, default_value: bool, + evaluation_context: EvaluationContext = EvaluationContext()): + return self._evaluate_treatment(flag_key, evaluation_context, default_value) + + def resolve_string_details(self, flag_key: str, default_value: str, + evaluation_context: EvaluationContext = EvaluationContext()): + return self._evaluate_treatment(flag_key, evaluation_context, default_value) + + def resolve_integer_details(self, flag_key: str, default_value: int, + evaluation_context: EvaluationContext = EvaluationContext()): + return self._evaluate_treatment(flag_key, evaluation_context, default_value) + + def resolve_float_details(self, flag_key: str, default_value: float, + evaluation_context: EvaluationContext = EvaluationContext()): + return self._evaluate_treatment(flag_key, evaluation_context, default_value) + + def resolve_object_details(self, flag_key: str, default_value: dict, + evaluation_context: EvaluationContext = EvaluationContext()): + return self._evaluate_treatment(flag_key, evaluation_context, default_value) + +class SplitProviderAsync(SplitProviderBase): + def __init__(self, initial_context): + if isinstance(initial_context, dict): + initial_context["ThreadingMode"] = "asyncio" + self._split_client_wrapper = SplitClientWrapper(initial_context) + + async def create(self): + await self._split_client_wrapper.create() + + async def resolve_boolean_details_async(self, flag_key: str, default_value: bool, + evaluation_context: EvaluationContext = EvaluationContext()): + return await self._evaluate_treatment_async(flag_key, evaluation_context, default_value) + + async def resolve_string_details_async(self, flag_key: str, default_value: str, + evaluation_context: EvaluationContext = EvaluationContext()): + return await self._evaluate_treatment_async(flag_key, evaluation_context, default_value) + + async def resolve_integer_details_async(self, flag_key: str, default_value: int, + evaluation_context: EvaluationContext = EvaluationContext()): + return await self._evaluate_treatment_async(flag_key, evaluation_context, default_value) + + async def resolve_float_details_async(self, flag_key: str, default_value: float, + evaluation_context: EvaluationContext = EvaluationContext()): + return await self._evaluate_treatment_async(flag_key, evaluation_context, default_value) + + async def resolve_object_details_async(self, flag_key: str, default_value: dict, + evaluation_context: EvaluationContext = EvaluationContext()): + return await self._evaluate_treatment_async(flag_key, evaluation_context, default_value) + + async def _evaluate_treatment_async(self, key: str, evaluation_context: EvaluationContext, default_value): + if evaluation_context is None: + raise GeneralError("Evaluation Context must be provided for the Split Provider") + + if not await self._split_client_wrapper.is_sdk_ready_async(): + return SplitProvider.construct_flag_resolution(default_value, None, None, Reason.ERROR, + ErrorCode.PROVIDER_NOT_READY) + + targeting_key = evaluation_context.targeting_key + if not targeting_key: + raise TargetingKeyMissingError("Missing targeting key") + + attributes = SplitProvider.transform_context(evaluation_context) + evaluated = await self._split_client_wrapper.split_client.get_treatment_with_config(targeting_key, key, attributes) + return self._process_treatment(evaluated, default_value) diff --git a/tests/test_split_client_wrapper.py b/tests/test_split_client_wrapper.py index 4ae27aa..561e685 100644 --- a/tests/test_split_client_wrapper.py +++ b/tests/test_split_client_wrapper.py @@ -1,10 +1,10 @@ import pytest -from splitio import get_factory -from split_openfeature import SplitClientWrapper import unittest -class TestSplitClientWrapper(unittest.TestCase): +from splitio import get_factory, get_factory_async +from split_openfeature import SplitClientWrapper +class TestSplitClientWrapper(unittest.TestCase): def test_using_external_splitclient(self): split_factory = get_factory("localhost", config={"splitFile": "split.yaml"}) split_factory.block_until_ready(5) @@ -19,7 +19,6 @@ def test_using_internal_splitclient(self): assert wrapper.is_sdk_ready() assert wrapper.sdk_ready == 1 - def test_sdk_not_ready(self): wrapper = SplitClientWrapper({"ReadyBlockTime": 0.1, "SdkKey": "api", "ConfigOptions": {}}) assert not wrapper.is_sdk_ready() @@ -39,3 +38,28 @@ def test_no_params(self): def test_reqwuired_params(self): with self.assertRaises(AttributeError) as context: wrapper = SplitClientWrapper({"ConfigOptions": {}}) + +class TestSplitClientWrapperAsync(object): + @pytest.mark.asyncio + async def test_using_external_splitclient_async(self): + split_factory = await get_factory_async("localhost", config={"splitFile": "split.yaml"}) + await split_factory.block_until_ready(5) + split_client = split_factory.client() + wrapper = SplitClientWrapper({"SplitClient": split_client, "ThreadingMode": "asyncio"}) + await wrapper.create() + assert wrapper.split_client != None + assert await wrapper.is_sdk_ready_async() + + @pytest.mark.asyncio + async def test_using_internal_splitclient_async(self): + wrapper = SplitClientWrapper({"ReadyBlockTime": 1, "SdkKey": "localhost", "ConfigOptions": {"splitFile": "split.yaml"}, "ThreadingMode": "asyncio"}) + await wrapper.create() + assert wrapper.split_client != None + assert await wrapper.is_sdk_ready_async() + assert wrapper.sdk_ready == True + + @pytest.mark.asyncio + async def test_sdk_not_ready_async(self): + wrapper = SplitClientWrapper({"ReadyBlockTime": 0.1, "SdkKey": "api", "ConfigOptions": {}, "ThreadingMode": "asyncio"}) + await wrapper.create() + assert not await wrapper.is_sdk_ready_async() diff --git a/tests/test_split_provider.py b/tests/test_split_provider.py index dda79f8..08a7115 100644 --- a/tests/test_split_provider.py +++ b/tests/test_split_provider.py @@ -3,8 +3,7 @@ from mock import MagicMock from openfeature.exception import ErrorCode, OpenFeatureError from openfeature.evaluation_context import EvaluationContext -from split_openfeature import SplitProvider - +from split_openfeature import SplitProvider, SplitProviderAsync class TestProvider(object): eval_context = EvaluationContext("someKey") @@ -274,3 +273,306 @@ def test_sdk_not_ready(self): details = provider.resolve_boolean_details(self.flag_name, False, self.eval_context) assert details.error_code == ErrorCode.PROVIDER_NOT_READY assert details.value == False + +class TestProviderAsync(object): + eval_context = EvaluationContext("someKey") + flag_name = "flagName" + + async def reset_client(self): + self.client = MagicMock() + self._factory = self.client._factory + + async def block_until_ready(x): + pass + self._factory.block_until_ready = block_until_ready + + self.provider = SplitProviderAsync({"SplitClient": self.client}) + await self.provider.create() + + def mock_client_return(self, val): + async def get_treatment_with_config(*_): + return (val, "{'prop':'val'}") + self.client.get_treatment_with_config = get_treatment_with_config + + # *** Boolean eval tests *** + @pytest.mark.asyncio + async def test_boolean_none_empty(self): + # if a treatment is None or empty it should return the default treatment + await self.reset_client() + + self.mock_client_return(None) + result = await self.provider.resolve_boolean_details_async(self.flag_name, True, self.eval_context) + assert result.value + result = await self.provider.resolve_boolean_details_async(self.flag_name, False, self.eval_context) + assert not result.value + + @pytest.mark.asyncio + async def test_boolean_control(self): + # if a treatment is "control" it should return the default treatment + await self.reset_client() + self.mock_client_return("control") + result = await self.provider.resolve_boolean_details_async(self.flag_name, False, self.eval_context) + assert not result.value + result = await self.provider.resolve_boolean_details_async(self.flag_name, True, self.eval_context) + assert result.value + + @pytest.mark.asyncio + async def test_boolean_true(self): + # treatment of "true" should eval to True boolean + await self.reset_client() + self.mock_client_return("true") + details = await self.provider.resolve_boolean_details_async(self.flag_name, False, self.eval_context) + assert details.value + assert details.flag_metadata["config"] == "{'prop':'val'}" + assert details.variant == "true" + + @pytest.mark.asyncio + async def test_boolean_on(self): + # treatment of "on" should eval to True boolean + await self.reset_client() + self.mock_client_return("on") + details = await self.provider.resolve_boolean_details_async(self.flag_name, False, self.eval_context) + assert details.value + assert details.flag_metadata["config"] == "{'prop':'val'}" + assert details.variant == "on" + + @pytest.mark.asyncio + async def test_boolean_false(self): + # treatment of "true" should eval to True boolean + await self.reset_client() + self.mock_client_return("false") + details = await self.provider.resolve_boolean_details_async(self.flag_name, False, self.eval_context) + assert not details.value + assert details.flag_metadata["config"] == "{'prop':'val'}" + assert details.variant == "false" + + @pytest.mark.asyncio + async def test_boolean_off(self): + # treatment of "on" should eval to True boolean + await self.reset_client() + self.mock_client_return("off") + details = await self.provider.resolve_boolean_details_async(self.flag_name, False, self.eval_context) + assert not details.value + assert details.flag_metadata["config"] == "{'prop':'val'}" + assert details.variant == "off" + + @pytest.mark.asyncio + async def test_boolean_error(self): + # any other random string other than on,off,true,false,control should throw an error + await self.reset_client() + self.mock_client_return("a random string") + try: + await self.provider.resolve_boolean_details_async(self.flag_name, False, self.eval_context) + fail("Should have thrown an error casting string to boolean") + except OpenFeatureError as e: + assert e.error_code == ErrorCode.PARSE_ERROR + except Exception: + fail("Unexpected exception occurred") + + # *** String eval tests *** + @pytest.mark.asyncio + async def test_string_none_empty(self): + # if a treatment is None or empty it should return the default treatment + await self.reset_client() + default_treatment = "defaultTreatment" + + self.mock_client_return(None) + result = await self.provider.resolve_string_details_async(self.flag_name, default_treatment, self.eval_context) + assert result.value == default_treatment + + self.mock_client_return("") + result = await self.provider.resolve_string_details_async(self.flag_name, default_treatment, self.eval_context) + assert result.value == default_treatment + + @pytest.mark.asyncio + async def test_string_control(self): + # "control" treatment should eval to default treatment + await self.reset_client() + self.mock_client_return("control") + default_treatment = "defaultTreatment" + result = await self.provider.resolve_string_details_async(self.flag_name, default_treatment, self.eval_context) + assert result.value == default_treatment + + @pytest.mark.asyncio + async def test_string_regular(self): + # a string treatment should eval to itself + await self.reset_client() + treatment = "treatment" + self.mock_client_return(treatment) + result = await self.provider.resolve_string_details_async(self.flag_name, "someDefaultTreatment", self.eval_context) + assert result.value == treatment + assert result.flag_metadata["config"] == "{'prop':'val'}" + assert result.variant == "treatment" + + # *** Integer eval tests *** + @pytest.mark.asyncio + async def test_int_none_empty(self): + # if a treatment is null empty it should return the default treatment + await self.reset_client() + default_treatment = 10 + + self.mock_client_return(None) + result = await self.provider.resolve_integer_details_async(self.flag_name, default_treatment, self.eval_context) + assert result.value == default_treatment + + self.mock_client_return("") + result = await self.provider.resolve_integer_details_async(self.flag_name, default_treatment, self.eval_context) + assert result.value == default_treatment + + @pytest.mark.asyncio + async def test_int_control(self): + # "control" treatment should eval to default treatment + await self.reset_client() + self.mock_client_return("control") + default_treatment = 10 + result = await self.provider.resolve_integer_details_async(self.flag_name, default_treatment, self.eval_context) + assert result.value == default_treatment + + @pytest.mark.asyncio + async def test_int_regular(self): + # a parsable int string treatment should eval to that integer + await self.reset_client() + + self.mock_client_return("50") + result = await self.provider.resolve_integer_details_async(self.flag_name, 1, self.eval_context) + assert result.value == 50 + assert isinstance(result.value, int) + assert result.flag_metadata["config"] == "{'prop':'val'}" + assert result.variant == "50" + + @pytest.mark.asyncio + async def test_int_error(self): + # an un-parsable int treatment should throw an error + await self.reset_client() + self.mock_client_return("notAnInt") + try: + await self.provider.resolve_integer_details_async(self.flag_name, 100, self.eval_context) + fail("Should have thrown an exception casting string to num") + except OpenFeatureError as e: + assert e.error_code == ErrorCode.PARSE_ERROR + except Exception: + fail("Unexpected exception occurred") + + self.mock_client_return("50.5") + try: + await self.provider.resolve_integer_details_async(self.flag_name, 100, self.eval_context) + fail("Should have thrown an exception casting string to int") + except OpenFeatureError as e: + assert e.error_code == ErrorCode.PARSE_ERROR + except Exception: + fail("Unexpected exception occurred") + + # *** Float eval tests *** + @pytest.mark.asyncio + async def test_float_none_empty(self): + # if a treatment is null empty it should return the default treatment + await self.reset_client() + default_treatment = 10.5 + + self.mock_client_return(None) + result = await self.provider.resolve_float_details_async(self.flag_name, default_treatment, self.eval_context) + assert result.value == default_treatment + + self.mock_client_return("") + result = await self.provider.resolve_float_details_async(self.flag_name, default_treatment, self.eval_context) + assert result.value == default_treatment + + @pytest.mark.asyncio + async def test_float_control(self): + # "control" treatment should eval to default treatment + await self.reset_client() + self.mock_client_return("control") + default_treatment = 10.5 + result = await self.provider.resolve_float_details_async(self.flag_name, default_treatment, self.eval_context) + assert result.value == default_treatment + + @pytest.mark.asyncio + async def test_float_regular(self): + # a parsable float string treatment should eval to that float + await self.reset_client() + self.mock_client_return("50.5") + result = await self.provider.resolve_float_details_async(self.flag_name, 1.5, self.eval_context) + assert result.value == 50.5 + assert result.flag_metadata["config"] == "{'prop':'val'}" + assert result.variant == "50.5" + + # it should also be able to handle regular ints + self.mock_client_return("50") + result = await self.provider.resolve_float_details_async(self.flag_name, 1.5, self.eval_context) + assert result.value == 50.0 + assert isinstance(result.value, float) + + @pytest.mark.asyncio + async def test_float_error(self): + # an un-parsable float treatment should throw an error + await self.reset_client() + self.mock_client_return("notAFloat") + try: + await self.provider.resolve_float_details_async(self.flag_name, 100.5, self.eval_context) + fail("Should have thrown an exception casting string to float") + except OpenFeatureError as e: + assert e.error_code == ErrorCode.PARSE_ERROR + except Exception: + fail("Unexpected exception occurred") + + # *** Object eval tests *** + @pytest.mark.asyncio + async def test_obj_none_empty(self): + # if a treatment is null empty it should return the default treatment + await self.reset_client() + default_treatment = {"foo": "bar"} + + self.mock_client_return(None) + result = await self.provider.resolve_object_details_async(self.flag_name, default_treatment, self.eval_context) + assert result.value == default_treatment + + self.mock_client_return("") + result = await self.provider.resolve_object_details_async(self.flag_name, default_treatment, self.eval_context) + assert result.value == default_treatment + + @pytest.mark.asyncio + async def test_obj_control(self): + # "control" treatment should eval to default treatment + await self.reset_client() + self.mock_client_return("control") + default_treatment = {"foo": "bar"} + result = await self.provider.resolve_object_details_async(self.flag_name, default_treatment, self.eval_context) + assert result.value == default_treatment + + @pytest.mark.asyncio + async def test_obj_regular(self): + # an object treatment should eval to that object + await self.reset_client() + self.mock_client_return('{"foo": "bar"}') + result = await self.provider.resolve_object_details_async(self.flag_name, {"blah": "blaah"}, self.eval_context) + assert result.value == {"foo": "bar"} + assert result.flag_metadata["config"] == "{'prop':'val'}" + assert result.variant == '{"foo": "bar"}' + + @pytest.mark.asyncio + async def test_obj_complex(self): + await self.reset_client() + self.mock_client_return('{"string": "blah", "int": 10, "bool": true, "struct": {"foo": "bar"}, "list": [1, 2]}') + result = await self.provider.resolve_object_details_async(self.flag_name, {"blah": "blaah"}, self.eval_context) + assert result.value == {"string": "blah", "int": 10, "bool": True, "struct": {"foo": "bar"}, "list": [1, 2]} + + @pytest.mark.asyncio + async def test_obj_error(self): + # a treatment that can not be converted to an object should throw an error + await self.reset_client() + self.mock_client_return("not an object") + try: + await self.provider.resolve_object_details_async(self.flag_name, {"foo": "bar"}, self.eval_context) + fail("Should have thrown an exception casting string to an object") + except OpenFeatureError as e: + assert e.error_code == ErrorCode.PARSE_ERROR + except Exception: + fail("Unexpected exception occurred") + + @pytest.mark.asyncio + async def test_sdk_not_ready(self): + provider = SplitProviderAsync({"ReadyBlockTime": 0.1,"SdkKey": "api"}) + await provider.create() + details = await provider.resolve_boolean_details_async(self.flag_name, False, self.eval_context) + assert details.error_code == ErrorCode.PROVIDER_NOT_READY + assert details.value == False \ No newline at end of file