devcycle-python-server-sdk 3.11.3__py3-none-any.whl → 3.12.0__py3-none-any.whl

test/openfeature_test/test_provider.py

@@ -12,6 +12,10 @@ from openfeature.exception import (
 )
 
 from devcycle_python_sdk.models.variable import Variable, TypeEnum
+from devcycle_python_sdk.models.eval_reason import (
+    EvalReason,
+    DefaultReasonDetails,
+)
 
 from devcycle_python_sdk.open_feature_provider.provider import (
     DevCycleProvider,
@@ -69,7 +73,9 @@ class DevCycleProviderTest(unittest.TestCase):
 
     def test_resolve_details_client_returns_default_variable(self):
         self.client.variable.return_value = Variable.create_default_variable(
-            key="test-flag", default_value=False
+            key="test-flag",
+            default_value=False,
+            default_reason_detail=DefaultReasonDetails.USER_NOT_TARGETED,
         )
         context = EvaluationContext(targeting_key="user-1234")
         details = self.provider._resolve("test-flag", False, context)
@@ -77,6 +83,9 @@ class DevCycleProviderTest(unittest.TestCase):
         self.assertIsNotNone(details)
         self.assertEqual(details.value, False)
         self.assertEqual(details.reason, Reason.DEFAULT)
+        self.assertEqual(
+            details.flag_metadata["evalReasonDetails"], "User Not Targeted"
+        )
 
     def test_resolve_boolean_details(self):
         key = "test-flag"
@@ -90,6 +99,9 @@ class DevCycleProviderTest(unittest.TestCase):
             type=TypeEnum.BOOLEAN,
             isDefaulted=False,
             defaultValue=False,
+            eval=EvalReason(
+                reason="TARGETING_MATCH", details="All Users", target_id="targetId"
+            ),
         )
 
         context = EvaluationContext(targeting_key="user-1234")
@@ -98,6 +110,9 @@ class DevCycleProviderTest(unittest.TestCase):
         self.assertIsNotNone(details)
         self.assertEqual(details.value, variable_value)
         self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+        self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+        self.assertEqual(details.flag_metadata["evalReasonDetails"], "All Users")
+        self.assertEqual(details.flag_metadata["evalReasonTargetId"], "targetId")
 
     def test_resolve_string_details(self):
         key = "test-flag"
@@ -111,6 +126,9 @@ class DevCycleProviderTest(unittest.TestCase):
             type=TypeEnum.STRING,
             isDefaulted=False,
             defaultValue=False,
+            eval=EvalReason(
+                reason="TARGETING_MATCH", details="All Users", target_id="targetId"
+            ),
         )
 
         context = EvaluationContext(targeting_key="user-1234")
@@ -120,6 +138,8 @@ class DevCycleProviderTest(unittest.TestCase):
         self.assertEqual(details.value, variable_value)
         self.assertIsInstance(details.value, str)
         self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+        self.assertEqual(details.flag_metadata["evalReasonDetails"], "All Users")
+        self.assertEqual(details.flag_metadata["evalReasonTargetId"], "targetId")
 
     def test_resolve_integer_details(self):
         key = "test-flag"
@@ -133,6 +153,9 @@ class DevCycleProviderTest(unittest.TestCase):
             type=TypeEnum.STRING,
             isDefaulted=False,
             defaultValue=False,
+            eval=EvalReason(
+                reason="TARGETING_MATCH", details="All Users", target_id="targetId"
+            ),
         )
 
         context = EvaluationContext(targeting_key="user-1234")
@@ -142,6 +165,8 @@ class DevCycleProviderTest(unittest.TestCase):
         self.assertIsInstance(details.value, int)
         self.assertEqual(details.value, variable_value)
         self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+        self.assertEqual(details.flag_metadata["evalReasonDetails"], "All Users")
+        self.assertEqual(details.flag_metadata["evalReasonTargetId"], "targetId")
 
     def test_resolve_float_details(self):
         key = "test-flag"
@@ -155,6 +180,7 @@ class DevCycleProviderTest(unittest.TestCase):
             type=TypeEnum.STRING,
             isDefaulted=False,
             defaultValue=False,
+            eval=EvalReason(reason="SPLIT", details="Rollout", target_id="targetId"),
         )
 
         context = EvaluationContext(targeting_key="user-1234")
@@ -163,7 +189,9 @@ class DevCycleProviderTest(unittest.TestCase):
         self.assertIsNotNone(details)
         self.assertIsInstance(details.value, float)
         self.assertEqual(details.value, variable_value)
-        self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+        self.assertEqual(details.reason, Reason.SPLIT)
+        self.assertEqual(details.flag_metadata["evalReasonDetails"], "Rollout")
+        self.assertEqual(details.flag_metadata["evalReasonTargetId"], "targetId")
 
     def test_resolve_object_details_verify_default_value(self):
         key = "test-flag"
@@ -204,6 +232,9 @@ class DevCycleProviderTest(unittest.TestCase):
             type=TypeEnum.STRING,
             isDefaulted=False,
             defaultValue=False,
+            eval=EvalReason(
+                reason="TARGETING_MATCH", details="Rollout", target_id="targetId"
+            ),
         )
 
         context = EvaluationContext(targeting_key="user-1234")
@@ -213,6 +244,52 @@ class DevCycleProviderTest(unittest.TestCase):
         self.assertIsInstance(details.value, dict)
         self.assertDictEqual(details.value, variable_value)
         self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+        self.assertIsNotNone(details.flag_metadata)
+        self.assertEqual(details.flag_metadata["evalReasonDetails"], "Rollout")
+        self.assertEqual(details.flag_metadata["evalReasonTargetId"], "targetId")
+
+    def test_resolve_string_details_null_eval(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_default_string_details_null_eval(self):
+        key = "test-flag"
+        default_value = "default string"
+
+        self.client.variable.return_value = Variable(
+            _id=None,
+            value=default_value,
+            key=key,
+            type=TypeEnum.STRING,
+            isDefaulted=True,
+            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, default_value)
+        self.assertIsInstance(details.value, str)
+        self.assertEqual(details.reason, Reason.DEFAULT)
 
 
 if __name__ == "__main__":

test/openfeature_test/test_provider_local_sdk.py

@@ -66,6 +66,11 @@ class DevCycleProviderWithLocalSDKTest(unittest.TestCase):
         self.assertIsNotNone(details)
         self.assertEqual(details.value, expected_value)
         self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+        self.assertIsNotNone(details.flag_metadata)
+        self.assertEqual(details.flag_metadata["evalReasonDetails"], "All Users")
+        self.assertEqual(
+            details.flag_metadata["evalReasonTargetId"], "63125321d31c601f992288bc"
+        )
 
     @responses.activate
     def test_resolve_integer_details(self):
@@ -82,6 +87,11 @@ class DevCycleProviderWithLocalSDKTest(unittest.TestCase):
         self.assertIsNotNone(details)
         self.assertEqual(details.value, expected_value)
         self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+        self.assertIsNotNone(details.flag_metadata)
+        self.assertEqual(details.flag_metadata["evalReasonDetails"], "All Users")
+        self.assertEqual(
+            details.flag_metadata["evalReasonTargetId"], "63125321d31c601f992288bc"
+        )
 
     @responses.activate
     def test_resolve_float_details(self):
@@ -98,6 +108,11 @@ class DevCycleProviderWithLocalSDKTest(unittest.TestCase):
         self.assertIsNotNone(details)
         self.assertEqual(details.value, expected_value)
         self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+        self.assertIsNotNone(details.flag_metadata)
+        self.assertEqual(details.flag_metadata["evalReasonDetails"], "All Users")
+        self.assertEqual(
+            details.flag_metadata["evalReasonTargetId"], "63125321d31c601f992288bc"
+        )
 
     @responses.activate
     def test_resolve_string_details(self):
@@ -114,6 +129,11 @@ class DevCycleProviderWithLocalSDKTest(unittest.TestCase):
         self.assertIsNotNone(details)
         self.assertEqual(details.value, expected_value)
         self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+        self.assertIsNotNone(details.flag_metadata)
+        self.assertEqual(details.flag_metadata["evalReasonDetails"], "All Users")
+        self.assertEqual(
+            details.flag_metadata["evalReasonTargetId"], "63125321d31c601f992288bc"
+        )
 
     @responses.activate
     def test_resolve_object_details(self):
@@ -134,3 +154,8 @@ class DevCycleProviderWithLocalSDKTest(unittest.TestCase):
         self.assertIsNotNone(details)
         self.assertEqual(details.value, expected_value)
         self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+        self.assertIsNotNone(details.flag_metadata)
+        self.assertEqual(details.flag_metadata["evalReasonDetails"], "All Users")
+        self.assertEqual(
+            details.flag_metadata["evalReasonTargetId"], "63125321d31c601f992288bc"
+        )

test/test_cloud_client.py

@@ -5,7 +5,9 @@ import uuid
 from time import time
 from unittest.mock import patch
 
+
 from devcycle_python_sdk import DevCycleCloudClient, DevCycleCloudOptions
+from devcycle_python_sdk.models.eval_hook import EvalHook
 from devcycle_python_sdk.models.user import DevCycleUser
 from devcycle_python_sdk.models.variable import Variable, TypeEnum
 from devcycle_python_sdk.models.event import DevCycleEvent
@@ -27,6 +29,7 @@ class DevCycleCloudClientTest(unittest.TestCase):
         self.test_user_empty_id = DevCycleUser(user_id="")
 
     def tearDown(self) -> None:
+        self.test_client.clear_hooks()
         pass
 
     def test_create_client_invalid_sdk_key(self):
@@ -95,6 +98,8 @@ class DevCycleCloudClientTest(unittest.TestCase):
         self.assertIsNotNone(result)
         self.assertEqual(result.value, "default_value")
         self.assertTrue(result.isDefaulted)
+        self.assertEqual(result.eval.reason, "DEFAULT")
+        self.assertEqual(result.eval.details, "Missing Variable")
 
         # other exception - return default
         mock_variable_call.reset_mock()
@@ -103,6 +108,8 @@ class DevCycleCloudClientTest(unittest.TestCase):
         self.assertIsNotNone(result)
         self.assertEqual(result.value, "default_value")
         self.assertTrue(result.isDefaulted)
+        self.assertEqual(result.eval.reason, "DEFAULT")
+        self.assertEqual(result.eval.details, "Error")
 
     @patch("devcycle_python_sdk.api.bucketing_client.BucketingAPIClient.variable")
     def test_variable_type_mismatch(self, mock_variable_call):
@@ -114,6 +121,8 @@ class DevCycleCloudClientTest(unittest.TestCase):
         self.assertIsNotNone(result)
         self.assertEqual(result.value, "default_value")
         self.assertTrue(result.isDefaulted)
+        self.assertEqual(result.eval.reason, "DEFAULT")
+        self.assertEqual(result.eval.details, "Variable Type Mismatch")
 
     @patch("devcycle_python_sdk.api.bucketing_client.BucketingAPIClient.variable")
     def test_variable_value_defaults(self, mock_variable_call):
@@ -281,6 +290,86 @@ class DevCycleCloudClientTest(unittest.TestCase):
             ),
         )
 
+    @patch("devcycle_python_sdk.api.bucketing_client.BucketingAPIClient.variable")
+    def test_hooks(self, mock_variable_call):
+        mock_variable_call.return_value = Variable(
+            _id="123", key="strKey", value=999, type=TypeEnum.NUMBER
+        )
+        # Test adding hooks
+        hook_called = {
+            "before": False,
+            "after": False,
+            "finally": False,
+            "error": False,
+        }
+
+        def before_hook(context):
+            hook_called["before"] = True
+            return context
+
+        def after_hook(context, variable):
+            hook_called["after"] = True
+
+        def finally_hook(context, variable):
+            hook_called["finally"] = True
+
+        def error_hook(context, error):
+            hook_called["error"] = True
+
+        self.test_client.add_hook(
+            EvalHook(before_hook, after_hook, finally_hook, error_hook)
+        )
+
+        # Test hooks called during variable evaluation
+        variable = self.test_client.variable(self.test_user, "strKey", 42)
+        self.assertTrue(variable.value == 999)
+        self.assertFalse(variable.isDefaulted)
+
+        self.assertTrue(hook_called["before"])
+        self.assertTrue(hook_called["after"])
+        self.assertTrue(hook_called["finally"])
+        self.assertFalse(hook_called["error"])
+
+    @patch("devcycle_python_sdk.api.bucketing_client.BucketingAPIClient.variable")
+    def test_hook_exceptions(self, mock_variable_call):
+        mock_variable_call.return_value = Variable(
+            _id="123", key="strKey", value=999, type=TypeEnum.NUMBER
+        )
+        # Test adding hooks
+        hook_called = {
+            "before": False,
+            "after": False,
+            "finally": False,
+            "error": False,
+        }
+
+        def before_hook(context):
+            hook_called["before"] = True
+            raise Exception("Before hook failed")
+
+        def after_hook(context, variable):
+            hook_called["after"] = True
+
+        def finally_hook(context, variable):
+            hook_called["finally"] = True
+
+        def error_hook(context, error):
+            hook_called["error"] = True
+
+        self.test_client.add_hook(
+            EvalHook(before_hook, after_hook, finally_hook, error_hook)
+        )
+
+        # Test hooks called during variable evaluation
+        variable = self.test_client.variable(self.test_user, "strKey", 42)
+        self.assertTrue(variable.value == 999)
+        self.assertFalse(variable.isDefaulted)
+
+        self.assertTrue(hook_called["before"])
+        self.assertFalse(hook_called["after"])
+        self.assertTrue(hook_called["finally"])
+        self.assertTrue(hook_called["error"])
+
 
 if __name__ == "__main__":
     unittest.main()

test/test_local_client.py

@@ -9,6 +9,8 @@ import responses
 from devcycle_python_sdk import DevCycleLocalClient, DevCycleLocalOptions
 from devcycle_python_sdk.local_client import _validate_user, _validate_sdk_key
 from devcycle_python_sdk.exceptions import MalformedConfigError
+from devcycle_python_sdk.models.eval_hook import EvalHook
+from devcycle_python_sdk.models.eval_reason import EvalReason
 from devcycle_python_sdk.models.event import DevCycleEvent
 from devcycle_python_sdk.models.feature import Feature
 from devcycle_python_sdk.api.local_bucketing import LocalBucketing
@@ -207,6 +209,8 @@ class DevCycleLocalClientTest(unittest.TestCase):
             self.assertEqual(result.defaultValue, test_value)
             self.assertEqual(result.value, test_value)
             self.assertEqual(result.type, value_type)
+            self.assertEqual(result.eval.reason, "DEFAULT")
+            self.assertEqual(result.eval.details, "User Not Targeted")
 
     @responses.activate
     def test_variable_with_bucketing(self):
@@ -240,6 +244,9 @@ class DevCycleLocalClientTest(unittest.TestCase):
                 self.assertDictEqual(result.value, expected, msg="Test key: " + key)
             else:
                 self.assertEqual(result.value, expected, msg="Test key: " + key)
+            self.assertEqual(result.eval.reason, "TARGETING_MATCH")
+            self.assertEqual(result.eval.details, "All Users")
+            self.assertEqual(result.eval.target_id, "63125321d31c601f992288bc")
 
     @responses.activate
     def test_variable_with_events(self):
@@ -293,7 +300,11 @@ class DevCycleLocalClientTest(unittest.TestCase):
         user = DevCycleUser(user_id="1234")
 
         result = self.client.all_variables(user)
-
+        expected_eval = EvalReason(
+            reason="TARGETING_MATCH",
+            details="All Users",
+            target_id="63125321d31c601f992288bc",
+        )
         expected_variables = {
             "a-cool-new-feature": Variable(
                 _id="62fbf6566f1ba302829f9e34",
@@ -303,6 +314,7 @@ class DevCycleLocalClientTest(unittest.TestCase):
                 isDefaulted=None,
                 defaultValue=None,
                 evalReason=None,
+                eval=expected_eval,
             ),
             "string-var": Variable(
                 _id="63125320a4719939fd57cb2b",
@@ -312,6 +324,7 @@ class DevCycleLocalClientTest(unittest.TestCase):
                 isDefaulted=None,
                 defaultValue=None,
                 evalReason=None,
+                eval=expected_eval,
             ),
             "json-var": Variable(
                 _id="64372363125123fca69d3f7b",
@@ -325,6 +338,7 @@ class DevCycleLocalClientTest(unittest.TestCase):
                 isDefaulted=None,
                 defaultValue=None,
                 evalReason=None,
+                eval=expected_eval,
             ),
             "num-var": Variable(
                 _id="65272363125123fca69d3a7d",
@@ -334,6 +348,7 @@ class DevCycleLocalClientTest(unittest.TestCase):
                 isDefaulted=None,
                 defaultValue=None,
                 evalReason=None,
+                eval=expected_eval,
             ),
             "float-var": Variable(
                 _id="61200363125123fca69d3a7a",
@@ -343,6 +358,7 @@ class DevCycleLocalClientTest(unittest.TestCase):
                 isDefaulted=None,
                 defaultValue=None,
                 evalReason=None,
+                eval=expected_eval,
             ),
         }
         self.assertEqual(result, expected_variables)
@@ -361,6 +377,86 @@ class DevCycleLocalClientTest(unittest.TestCase):
         result = self.client.all_variables(user)
         self.assertEqual(result, {})
 
+    @responses.activate
+    def test_hooks(self):
+        self.setup_client()
+        # Test adding hooks
+        hook_called = {
+            "before": False,
+            "after": False,
+            "finally": False,
+            "error": False,
+        }
+
+        def before_hook(context):
+            hook_called["before"] = True
+            return context
+
+        def after_hook(context, variable):
+            hook_called["after"] = True
+
+        def finally_hook(context, variable):
+            hook_called["finally"] = True
+
+        def error_hook(context, error):
+            hook_called["error"] = True
+
+        self.client.add_hook(
+            EvalHook(before_hook, after_hook, finally_hook, error_hook)
+        )
+
+        user = DevCycleUser(user_id="1234")
+
+        # Test hooks called during variable evaluation
+        variable = self.client.variable(user, "num-var", 42)
+        self.assertTrue(variable.value == 12345)
+        self.assertFalse(variable.isDefaulted)
+
+        self.assertTrue(hook_called["before"])
+        self.assertTrue(hook_called["after"])
+        self.assertTrue(hook_called["finally"])
+        self.assertFalse(hook_called["error"])
+
+    @responses.activate
+    def test_hook_exceptions(self):
+        self.setup_client()
+        # Test adding hooks
+        hook_called = {
+            "before": False,
+            "after": False,
+            "finally": False,
+            "error": False,
+        }
+
+        def before_hook(context):
+            hook_called["before"] = True
+            raise Exception("Before hook failed")
+
+        def after_hook(context, variable):
+            hook_called["after"] = True
+
+        def finally_hook(context, variable):
+            hook_called["finally"] = True
+
+        def error_hook(context, error):
+            hook_called["error"] = True
+
+        self.client.add_hook(
+            EvalHook(before_hook, after_hook, finally_hook, error_hook)
+        )
+
+        user = DevCycleUser(user_id="1234")
+
+        # Test hooks called during variable evaluation
+        variable = self.client.variable(user, "num-var", 42)
+        self.assertTrue(variable.value == 12345)
+        self.assertFalse(variable.isDefaulted)
+
+        self.assertTrue(hook_called["before"])
+        self.assertFalse(hook_called["after"])
+        self.assertTrue(hook_called["finally"])
+        self.assertTrue(hook_called["error"])
+
 
 def _benchmark_variable_call(client: DevCycleLocalClient, user: DevCycleUser, key: str):
     return client.variable(user, key, "default_value")