devcycle-python-server-sdk 3.3.5__py3-none-any.whl → 3.5.0__py3-none-any.whl

example/openfeature_example.py

@@ -0,0 +1,77 @@
+import logging
+import time
+import os
+
+from devcycle_python_sdk import DevCycleLocalClient, DevCycleLocalOptions
+
+from openfeature import api
+from openfeature.evaluation_context import EvaluationContext
+
+FLAG_KEY = "test-boolean-variable"
+
+logger = logging.getLogger(__name__)
+
+
+def main():
+    """
+    Sample usage of the DevCycle OpenFeature Provider along with the Python Server SDK using Local Bucketing.
+    """
+    logging.basicConfig(level="INFO", format="%(levelname)s: %(message)s")
+
+    # create an instance of the DevCycle Client object
+    server_sdk_key = os.environ["DEVCYCLE_SERVER_SDK_KEY"]
+    devcycle_client = DevCycleLocalClient(server_sdk_key, DevCycleLocalOptions())
+
+    # Wait for DevCycle to initialize and load the configuration
+    for i in range(10):
+        if devcycle_client.is_initialized():
+            break
+        logger.info("Waiting for DevCycle to initialize...")
+        time.sleep(0.5)
+    else:
+        logger.error("DevCycle failed to initialize")
+        exit(1)
+
+    # set the provider for OpenFeature
+    api.set_provider(devcycle_client.get_openfeature_provider())
+
+    # get the OpenFeature client
+    open_feature_client = api.get_client()
+
+    # create the request context for the user
+    context = EvaluationContext(
+        targeting_key="test-1234",
+        attributes={
+            "email": "test-user@domain.com",
+            "name": "Test User",
+            "language": "en",
+            "country": "CA",
+            "appVersion": "1.0.11",
+            "appBuild": 1000,
+            "customData": {"custom": "data"},
+            "privateCustomData": {"private": "data"},
+        },
+    )
+
+    # Look up the value of the flag
+    if open_feature_client.get_boolean_value(FLAG_KEY, False, context):
+        logger.info(f"Variable {FLAG_KEY} is enabled")
+    else:
+        logger.info(f"Variable {FLAG_KEY} is not enabled")
+
+    # Fetch a JSON object variable
+    json_object = open_feature_client.get_object_value(
+        "test-json-variable", {"default": "value"}, context
+    )
+    logger.info(f"JSON Object Value: {json_object}")
+
+    # Retrieve a string variable along with resolution details
+    details = open_feature_client.get_string_details("doesnt-exist", "default", context)
+    logger.info(f"String Value: {details.value}")
+    logger.info(f"Eval Reason: {details.reason}")
+
+    devcycle_client.close()
+
+
+if __name__ == "__main__":
+    main()

test/api/test_bucketing_client.py

@@ -28,6 +28,10 @@ class BucketingClientTest(unittest.TestCase):
         self.test_client = BucketingAPIClient(sdk_key, options)
         self.test_user = DevCycleUser(user_id="test_user_id")
 
+    def test_url(self):
+        result = self.test_client._url("variable", "ABC")
+        self.assertEqual(result, "https://bucketing-api.devcycle.com/v1/variable/ABC")
+
     @responses.activate
     def test_variable(self):
         responses.add(
@@ -224,7 +228,7 @@ class BucketingClientTest(unittest.TestCase):
         )
         self.assertEqual(result, "success")
         data = json.loads(responses.calls[0].request.body)
-        self.assertTrue(type(data["events"][0]["date"]) == int)
+        self.assertTrue(isinstance(data["events"][0]["date"], int))
         self.assertEqual(len(data["events"]), 1)
         self.assertEqual(data["events"][0]["type"], "sample-event")
 

test/api/test_config_client.py

@@ -1,7 +1,6 @@
 import logging
 import unittest
 import uuid
-from os.path import join
 from http import HTTPStatus
 
 import requests
@@ -15,6 +14,7 @@ from devcycle_python_sdk.exceptions import (
     APIClientUnauthorizedError,
     NotFoundError,
 )
+from devcycle_python_sdk.util.strings import slash_join
 from test.fixture.data import small_config_json
 
 logger = logging.getLogger(__name__)
@@ -24,7 +24,7 @@ class ConfigAPIClientTest(unittest.TestCase):
     def setUp(self) -> None:
         self.sdk_key = "dvc_server_" + str(uuid.uuid4())
         self.config_url = (
-            join(
+            slash_join(
                 "https://config-cdn.devcycle.com/",
                 "config",
                 "v1",
@@ -39,6 +39,9 @@ class ConfigAPIClientTest(unittest.TestCase):
         self.test_etag = str(uuid.uuid4())
         self.test_config_json: dict = small_config_json()
 
+    def test_url(self):
+        self.assertEqual(self.test_client.config_file_url, self.config_url)
+
     @responses.activate
     def test_get_config(self):
         new_etag = str(uuid.uuid4())

test/api/test_event_client.py

@@ -42,6 +42,9 @@ class EventAPIClientTest(unittest.TestCase):
         ]
         self.test_batch = [UserEventsBatchRecord(user=self.test_user, events=events)]
 
+    def test_url(self):
+        self.assertEqual(self.test_client.batch_url, self.test_batch_url)
+
     @responses.activate
     def test_publish_events(self):
         responses.add(

test/api/test_local_bucketing.py

@@ -5,10 +5,7 @@ import unittest
 from devcycle_python_sdk.api.local_bucketing import LocalBucketing, WASMAbortError
 from devcycle_python_sdk.models.bucketed_config import (
     Environment,
-    EdgeDBSettings,
     FeatureVariation,
-    OptInColors,
-    OptInSettings,
     Project,
     ProjectSettings,
 )
@@ -197,27 +194,29 @@ class LocalBucketingTest(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.assertIsNotNone(result)
         self.assertEqual(result.user, user)
         self.assertEqual(
-            result.project,
             Project(
                 id="61f97628ff4afcb6d057dbf0",
                 key="emma-project",
                 a0_organization="org_tPyJN5dvNNirKar7",
                 settings=ProjectSettings(
-                    edge_db=EdgeDBSettings(enabled=False),
-                    opt_in=OptInSettings(
-                        enabled=True,
-                        title="EarlyAccess",
-                        description="Getearlyaccesstobetafeaturesbelow!",
-                        image_url="",
-                        colors=OptInColors(primary="#531cd9", secondary="#16dec0"),
-                    ),
+                    edge_db=None, opt_in=None, disable_passthrough_rollouts=False
                 ),
             ),
+            result.project,
         )
         self.assertEqual(
             result.environment,
@@ -250,6 +249,10 @@ class LocalBucketingTest(unittest.TestCase):
                     feature="62fbf6566f1ba302829f9e32",
                     variation="62fbf6566f1ba302829f9e39",
                 ),
+                "float-var": FeatureVariation(
+                    feature="62fbf6566f1ba302829f9e32",
+                    variation="62fbf6566f1ba302829f9e39",
+                ),
             },
         )
         self.assertEqual(

test/fixture/data.py

@@ -6,7 +6,7 @@ def small_config() -> str:
     config_filename = os.path.join(
         os.path.dirname(__file__), "fixture_small_config.json"
     )
-    with open(config_filename, "r") as f:
+    with open(config_filename, "r", encoding="utf-8") as f:
         return f.read()
 
 
@@ -19,7 +19,7 @@ def special_character_config() -> str:
     config_filename = os.path.join(
         os.path.dirname(__file__), "fixture_small_config_special_characters.json"
     )
-    with open(config_filename, "r") as f:
+    with open(config_filename, "r", encoding="utf-8") as f:
         return f.read()
 
 
@@ -32,7 +32,7 @@ def large_config() -> str:
     config_filename = os.path.join(
         os.path.dirname(__file__), "fixture_large_config.json"
     )
-    with open(config_filename, "r") as f:
+    with open(config_filename, "r", encoding="utf-8") as f:
         return f.read()
 
 
@@ -45,7 +45,7 @@ def bucketed_config() -> str:
     config_filename = os.path.join(
         os.path.dirname(__file__), "fixture_bucketed_config.json"
     )
-    with open(config_filename, "r") as f:
+    with open(config_filename, "r", encoding="utf-8") as f:
         return f.read()
 
 
@@ -53,5 +53,5 @@ def bucketed_config_minimal() -> str:
     config_filename = os.path.join(
         os.path.dirname(__file__), "fixture_bucketed_config_minimal.json"
     )
-    with open(config_filename, "r") as f:
+    with open(config_filename, "r", encoding="utf-8") as f:
         return f.read()

test/models/test_user.py

@@ -0,0 +1,188 @@
+import logging
+import unittest
+
+from devcycle_python_sdk.models.user import DevCycleUser
+
+from openfeature.provider import EvaluationContext
+from openfeature.exception import TargetingKeyMissingError, InvalidContextError
+
+
+logger = logging.getLogger(__name__)
+
+
+class DevCycleUserTest(unittest.TestCase):
+    def test_create_user_from_context_no_context(self):
+        with self.assertRaises(TargetingKeyMissingError):
+            DevCycleUser.create_user_from_context(None)
+
+    def test_create_user_from_context_no_user_id(self):
+        with self.assertRaises(TargetingKeyMissingError):
+            DevCycleUser.create_user_from_context(
+                EvaluationContext(targeting_key=None, attributes={})
+            )
+
+        with self.assertRaises(TargetingKeyMissingError):
+            DevCycleUser.create_user_from_context(
+                EvaluationContext(targeting_key=None, attributes=None)
+            )
+
+        with self.assertRaises(TargetingKeyMissingError):
+            DevCycleUser.create_user_from_context(
+                EvaluationContext(targeting_key=None, attributes={"user_id": None})
+            )
+
+    def test_create_user_from_context_only_user_id(self):
+        test_user_id = "12345"
+        context = EvaluationContext(targeting_key=test_user_id, attributes=None)
+        user = DevCycleUser.create_user_from_context(context)
+        self.assertIsNotNone(user)
+        self.assertEqual(user.user_id, test_user_id)
+
+        context = EvaluationContext(
+            targeting_key=None, attributes={"user_id": test_user_id}
+        )
+        user = DevCycleUser.create_user_from_context(context)
+        self.assertIsNotNone(user)
+        self.assertEqual(user.user_id, test_user_id)
+
+        # ensure that targeting_key takes precedence over user_id
+        context = EvaluationContext(
+            targeting_key=test_user_id, attributes={"user_id": "99999"}
+        )
+        user = DevCycleUser.create_user_from_context(context)
+        self.assertIsNotNone(user)
+        self.assertEqual(user.user_id, test_user_id)
+
+    def test_create_user_from_context_with_attributes(self):
+        test_user_id = "12345"
+        context = EvaluationContext(
+            targeting_key=test_user_id,
+            attributes={
+                "user_id": "1234",
+                "email": "someone@example.com",
+                "name": "John Doe",
+                "language": "en",
+                "country": "US",
+                "appVersion": "1.0.0",
+                "appBuild": "1",
+                "deviceModel": "iPhone X21",
+            },
+        )
+        user = DevCycleUser.create_user_from_context(context)
+        self.assertIsNotNone(user)
+        self.assertEqual(user.user_id, test_user_id)
+        self.assertEqual(user.email, context.attributes["email"])
+        self.assertEqual(user.name, context.attributes["name"])
+        self.assertEqual(user.language, context.attributes["language"])
+        self.assertEqual(user.country, context.attributes["country"])
+        self.assertEqual(user.appVersion, context.attributes["appVersion"])
+        self.assertEqual(user.appBuild, context.attributes["appBuild"])
+        self.assertEqual(user.deviceModel, context.attributes["deviceModel"])
+
+    def test_create_user_from_context_with_custom_data(self):
+        test_user_id = "12345"
+        context = EvaluationContext(
+            targeting_key=test_user_id,
+            attributes={
+                "customData": {
+                    "strValue": "hello",
+                    "intValue": 123,
+                    "floatValue": 3.1456,
+                    "boolValue": True,
+                },
+                "privateCustomData": {
+                    "strValue": "world",
+                    "intValue": 789,
+                    "floatValue": 0.0001,
+                    "BoolValue": False,
+                },
+            },
+        )
+        user = DevCycleUser.create_user_from_context(context)
+        self.assertIsNotNone(user)
+        self.assertEqual(user.user_id, test_user_id)
+
+        self.assertEqual(
+            user.customData,
+            {
+                "strValue": "hello",
+                "intValue": 123,
+                "floatValue": 3.1456,
+                "boolValue": True,
+            },
+        )
+        self.assertEqual(
+            user.privateCustomData,
+            {
+                "strValue": "world",
+                "intValue": 789,
+                "floatValue": 0.0001,
+                "BoolValue": False,
+            },
+        )
+
+    def test_create_user_from_context_with_unknown_data_fields(self):
+        test_user_id = "12345"
+        context = EvaluationContext(
+            targeting_key=test_user_id,
+            attributes={
+                "strValue": "hello",
+                "intValue": 123,
+                "floatValue": 3.1456,
+                "boolValue": True,
+            },
+        )
+        user = DevCycleUser.create_user_from_context(context)
+        self.assertIsNotNone(user)
+        self.assertEqual(user.user_id, test_user_id)
+
+        # the fields should get reassigned to custom_data
+        self.assertEqual(
+            user.customData,
+            {
+                "strValue": "hello",
+                "intValue": 123,
+                "floatValue": 3.1456,
+                "boolValue": True,
+            },
+        )
+        self.assertEqual(user.privateCustomData, None)
+
+    def test_set_custom_value(self):
+        custom_data = {}
+        with self.assertRaises(InvalidContextError):
+            DevCycleUser._set_custom_value(custom_data, None, None)
+
+        custom_data = {}
+        DevCycleUser._set_custom_value(custom_data, "key1", None)
+        self.assertDictEqual(custom_data, {"key1": None})
+
+        custom_data = {}
+        DevCycleUser._set_custom_value(custom_data, "key1", "value1")
+        self.assertDictEqual(custom_data, {"key1": "value1"})
+
+        custom_data = {}
+        DevCycleUser._set_custom_value(custom_data, "key1", 1)
+        self.assertDictEqual(custom_data, {"key1": 1})
+
+        custom_data = {}
+        DevCycleUser._set_custom_value(custom_data, "key1", 3.1456)
+        self.assertDictEqual(custom_data, {"key1": 3.1456})
+
+        custom_data = {}
+        DevCycleUser._set_custom_value(custom_data, "key1", True)
+        self.assertDictEqual(custom_data, {"key1": True})
+
+        custom_data = {}
+        with self.assertRaises(InvalidContextError):
+            DevCycleUser._set_custom_value(custom_data, "map_data", {"hello": "world"})
+
+        custom_data = {}
+        with self.assertRaises(InvalidContextError):
+            DevCycleUser._set_custom_value(
+                custom_data, "list_data", ["one", "two", "three"]
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()

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()