devcycle-python-server-sdk 3.3.6__py3-none-any.whl → 3.6.0__py3-none-any.whl

test/openfeature_test/test_provider.py

@@ -0,0 +1,219 @@
+import logging
+import unittest
+from unittest.mock import MagicMock
+
+from openfeature.provider import EvaluationContext
+from openfeature.flag_evaluation import Reason
+from openfeature.exception import (
+    ErrorCode,
+    TargetingKeyMissingError,
+    InvalidContextError,
+    TypeMismatchError,
+)
+
+from devcycle_python_sdk.models.variable import Variable, TypeEnum
+
+from devcycle_python_sdk.open_feature_provider.provider import (
+    DevCycleProvider,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+class DevCycleProviderTest(unittest.TestCase):
+    def setUp(self):
+        self.client = MagicMock()
+        self.client.is_initialized.return_value = True
+        self.provider = DevCycleProvider(self.client)
+
+    def test_resolve_details_client_not_ready(self):
+        self.client.is_initialized.return_value = False
+
+        details = self.provider._resolve(
+            "test-flag", False, EvaluationContext("test-user")
+        )
+
+        self.assertIsNotNone(details)
+        self.assertEqual(details.value, False)
+        self.assertEqual(details.reason, Reason.ERROR)
+        self.assertEqual(details.error_code, ErrorCode.PROVIDER_NOT_READY)
+
+    def test_resolve_details_client_no_user_in_context(self):
+        context = EvaluationContext(targeting_key=None, attributes={})
+
+        with self.assertRaises(TargetingKeyMissingError):
+            self.provider._resolve("test-flag", False, context)
+
+    def test_resolve_details_no_key(self):
+        self.client.variable.side_effect = ValueError("test error")
+        context = EvaluationContext(targeting_key="user-1234")
+        with self.assertRaises(InvalidContextError):
+            self.provider._resolve(None, False, context)
+
+    def test_resolve_details_no_default_value(self):
+        self.client.variable.side_effect = ValueError("test error")
+        context = EvaluationContext(targeting_key="user-1234")
+        with self.assertRaises(InvalidContextError):
+            self.provider._resolve("test-flag", None, context)
+
+    def test_resolve_details_client_returns_none(self):
+        self.client.variable.return_value = None
+        context = EvaluationContext(targeting_key="user-1234")
+
+        details = self.provider._resolve("test-flag", False, context)
+
+        self.assertIsNotNone(details)
+        self.assertEqual(details.value, False)
+        self.assertEqual(details.reason, Reason.DEFAULT)
+
+    def test_resolve_details_client_returns_default_variable(self):
+        self.client.variable.return_value = Variable.create_default_variable(
+            key="test-flag", default_value=False
+        )
+        context = EvaluationContext(targeting_key="user-1234")
+        details = self.provider._resolve("test-flag", False, context)
+
+        self.assertIsNotNone(details)
+        self.assertEqual(details.value, False)
+        self.assertEqual(details.reason, Reason.DEFAULT)
+
+    def test_resolve_boolean_details(self):
+        key = "test-flag"
+        variable_value = True
+        default_value = False
+
+        self.client.variable.return_value = Variable(
+            _id=None,
+            value=variable_value,
+            key=key,
+            type=TypeEnum.BOOLEAN,
+            isDefaulted=False,
+            defaultValue=False,
+        )
+
+        context = EvaluationContext(targeting_key="user-1234")
+        details = self.provider.resolve_boolean_details(key, default_value, context)
+
+        self.assertIsNotNone(details)
+        self.assertEqual(details.value, variable_value)
+        self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+
+    def test_resolve_string_details(self):
+        key = "test-flag"
+        variable_value = "some string"
+        default_value = "default string"
+
+        self.client.variable.return_value = Variable(
+            _id=None,
+            value=variable_value,
+            key=key,
+            type=TypeEnum.STRING,
+            isDefaulted=False,
+            defaultValue=False,
+        )
+
+        context = EvaluationContext(targeting_key="user-1234")
+        details = self.provider.resolve_string_details(key, default_value, context)
+
+        self.assertIsNotNone(details)
+        self.assertEqual(details.value, variable_value)
+        self.assertIsInstance(details.value, str)
+        self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+
+    def test_resolve_integer_details(self):
+        key = "test-flag"
+        variable_value = 12345
+        default_value = 0
+
+        self.client.variable.return_value = Variable(
+            _id=None,
+            value=variable_value,
+            key=key,
+            type=TypeEnum.STRING,
+            isDefaulted=False,
+            defaultValue=False,
+        )
+
+        context = EvaluationContext(targeting_key="user-1234")
+        details = self.provider.resolve_integer_details(key, default_value, context)
+
+        self.assertIsNotNone(details)
+        self.assertIsInstance(details.value, int)
+        self.assertEqual(details.value, variable_value)
+        self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+
+    def test_resolve_float_details(self):
+        key = "test-flag"
+        variable_value = 3.145
+        default_value = 0.0
+
+        self.client.variable.return_value = Variable(
+            _id=None,
+            value=variable_value,
+            key=key,
+            type=TypeEnum.STRING,
+            isDefaulted=False,
+            defaultValue=False,
+        )
+
+        context = EvaluationContext(targeting_key="user-1234")
+        details = self.provider.resolve_float_details(key, default_value, context)
+
+        self.assertIsNotNone(details)
+        self.assertIsInstance(details.value, float)
+        self.assertEqual(details.value, variable_value)
+        self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+
+    def test_resolve_object_details_verify_default_value(self):
+        key = "test-flag"
+        context = EvaluationContext(targeting_key="user-1234")
+
+        # Only flat dictionaries are supported as objects
+        # lists, primitives and nested objects are not supported
+        with self.assertRaises(TypeMismatchError):
+            self.provider.resolve_object_details(key, [], context)
+
+        with self.assertRaises(TypeMismatchError):
+            self.provider.resolve_object_details(key, 1234, context)
+
+        with self.assertRaises(TypeMismatchError):
+            self.provider.resolve_object_details(key, 3.14, context)
+
+        with self.assertRaises(TypeMismatchError):
+            self.provider.resolve_object_details(key, False, context)
+
+        with self.assertRaises(TypeMismatchError):
+            self.provider.resolve_object_details(key, "some string", context)
+
+        # test dictionaries with nested objects
+        with self.assertRaises(TypeMismatchError):
+            self.provider.resolve_object_details(
+                key, {"nestedMap": {"someProp": "some value"}}, context
+            )
+
+    def test_resolve_object_details(self):
+        key = "test-flag"
+        variable_value = {"some": "value"}
+        default_value = {}
+
+        self.client.variable.return_value = Variable(
+            _id=None,
+            value=variable_value,
+            key=key,
+            type=TypeEnum.STRING,
+            isDefaulted=False,
+            defaultValue=False,
+        )
+
+        context = EvaluationContext(targeting_key="user-1234")
+        details = self.provider.resolve_object_details(key, default_value, context)
+
+        self.assertIsNotNone(details)
+        self.assertIsInstance(details.value, dict)
+        self.assertDictEqual(details.value, variable_value)
+        self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+
+
+if __name__ == "__main__":
+    unittest.main()

test/openfeature_test/test_provider_local_sdk.py

@@ -0,0 +1,136 @@
+import logging
+import time
+import unittest
+
+import responses
+
+from devcycle_python_sdk import DevCycleLocalClient, DevCycleLocalOptions
+from test.fixture.data import small_config_json
+
+from openfeature.provider import EvaluationContext
+from openfeature.flag_evaluation import Reason
+
+logger = logging.getLogger(__name__)
+
+
+class DevCycleProviderWithLocalSDKTest(unittest.TestCase):
+    """
+    Tests the DevCycleProvider with actual data from the Local SDK client to confirm data translations work
+    """
+
+    def setUp(self) -> None:
+        self.sdk_key = "dvc_server_949e4962-c624-4d20-a1ea-7f2501b2ba79"
+        self.test_config_json = small_config_json()
+        self.test_etag = "2f71454e-3279-4ca7-a8e7-802ce97bef43"
+
+        config_url = "http://localhost/config/v1/server/" + self.sdk_key + ".json"
+
+        responses.add(
+            responses.GET,
+            config_url,
+            headers={"ETag": self.test_etag},
+            json=self.test_config_json,
+            status=200,
+        )
+
+        self.options = DevCycleLocalOptions(
+            config_polling_interval_ms=5000,
+            config_cdn_uri="http://localhost/",
+            disable_custom_event_logging=True,
+            disable_automatic_event_logging=True,
+        )
+        self.client = None
+
+    def tearDown(self) -> None:
+        if self.client:
+            self.client.close()
+        responses.reset()
+
+    def setup_client(self):
+        self.client = DevCycleLocalClient(self.sdk_key, self.options)
+        while not self.client.is_initialized():
+            time.sleep(0.05)
+
+    @responses.activate
+    def test_resolve_boolean_details(self):
+        self.setup_client()
+        provider = self.client.get_openfeature_provider()
+
+        key = "a-cool-new-feature"
+        expected_value = True
+        default_value = False
+
+        context = EvaluationContext(targeting_key="1234")
+        details = provider.resolve_boolean_details(key, default_value, context)
+
+        self.assertIsNotNone(details)
+        self.assertEqual(details.value, expected_value)
+        self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+
+    @responses.activate
+    def test_resolve_integer_details(self):
+        self.setup_client()
+        provider = self.client.get_openfeature_provider()
+
+        key = "num-var"
+        expected_value = 12345
+        default_value = 0
+
+        context = EvaluationContext(targeting_key="1234")
+        details = provider.resolve_integer_details(key, default_value, context)
+
+        self.assertIsNotNone(details)
+        self.assertEqual(details.value, expected_value)
+        self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+
+    @responses.activate
+    def test_resolve_float_details(self):
+        self.setup_client()
+        provider = self.client.get_openfeature_provider()
+
+        key = "float-var"
+        expected_value = 3.14159
+        default_value = 0.0001
+
+        context = EvaluationContext(targeting_key="1234")
+        details = provider.resolve_float_details(key, default_value, context)
+
+        self.assertIsNotNone(details)
+        self.assertEqual(details.value, expected_value)
+        self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+
+    @responses.activate
+    def test_resolve_string_details(self):
+        self.setup_client()
+        provider = self.client.get_openfeature_provider()
+
+        key = "string-var"
+        expected_value = "variationOn"
+        default_value = "default_value"
+
+        context = EvaluationContext(targeting_key="1234")
+        details = provider.resolve_string_details(key, default_value, context)
+
+        self.assertIsNotNone(details)
+        self.assertEqual(details.value, expected_value)
+        self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+
+    @responses.activate
+    def test_resolve_object_details(self):
+        self.setup_client()
+        provider = self.client.get_openfeature_provider()
+
+        key = "json-var"
+        expected_value = {
+            "displayText": "This variation is on",
+            "showDialog": True,
+            "maxUsers": 100,
+        }
+        default_value = {"default": "value"}
+
+        context = EvaluationContext(targeting_key="1234")
+        details = provider.resolve_string_details(key, default_value, context)
+
+        self.assertIsNotNone(details)
+        self.assertEqual(details.value, expected_value)
+        self.assertEqual(details.reason, Reason.TARGETING_MATCH)

test/test_local_client.py

@@ -217,6 +217,7 @@ class DevCycleLocalClientTest(unittest.TestCase):
             ("string-var", "default_value", "variationOn", TypeEnum.STRING),
             ("a-cool-new-feature", False, True, TypeEnum.BOOLEAN),
             ("num-var", 0, 12345, TypeEnum.NUMBER),
+            ("float-var", 0, 3.14159, TypeEnum.NUMBER),
             (
                 "json-var",
                 {"default": "value"},
@@ -333,6 +334,15 @@ class DevCycleLocalClientTest(unittest.TestCase):
                 defaultValue=None,
                 evalReason=None,
             ),
+            "float-var": Variable(
+                _id="61200363125123fca69d3a7a",
+                key="float-var",
+                type="Number",
+                value=3.14159,
+                isDefaulted=None,
+                defaultValue=None,
+                evalReason=None,
+            ),
         }
         self.assertEqual(result, expected_variables)
 

test/util/test_version.py

@@ -10,7 +10,7 @@ logger = logging.getLogger(__name__)
 class VersionTest(unittest.TestCase):
     def test_sdk_version(self):
         version = sdk_version()
-        self.assertRegexpMatches(version, r"^\d+\.\d+\.\d+$")
+        self.assertRegex(version, r"^\d+\.\d+\.\d+$")
 
 
 if __name__ == "__main__":