devcycle-python-server-sdk 2.0.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

test/managers/test_event_queue_manager.py

@@ -0,0 +1,271 @@
+import logging
+import time
+import uuid
+import unittest
+from unittest.mock import MagicMock, patch
+
+from devcycle_python_sdk import DevCycleLocalOptions
+from devcycle_python_sdk.managers.event_queue_manager import (
+    EventQueueManager,
+    QueueFullError,
+)
+from devcycle_python_sdk.models.event import (
+    FlushPayload,
+    UserEventsBatchRecord,
+    RequestEvent,
+    DevCycleEvent,
+    EventType,
+)
+from devcycle_python_sdk.models.user import DevCycleUser
+
+from devcycle_python_sdk.exceptions import APIClientError, APIClientUnauthorizedError
+
+logger = logging.getLogger(__name__)
+
+
+class EventQueueManagerTest(unittest.TestCase):
+    def setUp(self) -> None:
+        self.sdk_key = "dvc_server_" + str(uuid.uuid4())
+
+        # mock out the local bucketing to test event queue logic directly
+        self.test_local_bucketing = MagicMock()
+        self.test_local_bucketing.flush_event_queue = MagicMock()
+        self.test_local_bucketing.flush_event_queue.return_value = []
+        self.test_local_bucketing.get_event_queue_size = MagicMock()
+        self.test_local_bucketing.get_event_queue_size.return_value = 0
+        self.test_local_bucketing.on_event_payload_success = MagicMock()
+        self.test_local_bucketing.on_event_payload_failure = MagicMock()
+
+        self.test_options = DevCycleLocalOptions(
+            disable_automatic_event_logging=False, disable_custom_event_logging=False
+        )
+        self.test_options_no_thread = DevCycleLocalOptions(
+            disable_automatic_event_logging=True, disable_custom_event_logging=True
+        )
+        self.test_payload = FlushPayload(
+            payloadId="123",
+            records=[
+                UserEventsBatchRecord(
+                    user=DevCycleUser.from_json(
+                        {
+                            "user_id": "999-000-111",
+                            "createdDate": "1970-01-20T12:50:19.871Z",
+                            "lastSeenDate": "1970-01-20T12:50:19.871Z",
+                            "platform": "Python",
+                            "platformVersion": "3.11.4",
+                            "sdkType": "local",
+                            "sdkVersion": "2.0.1",
+                            "hostname": "Chris-DevCycle-MacBook.local",
+                        }
+                    ),
+                    events=[
+                        RequestEvent.from_json(
+                            {
+                                "type": "aggVariableEvaluated",
+                                "target": "string-var",
+                                "user_id": "999-000-111",
+                                "date": "1970-01-20T12:50:19.871Z",
+                                "clientDate": "1970-01-20T12:50:19.871Z",
+                                "value": 1.0,
+                                "featureVars": {},
+                                "metaData": {
+                                    "_feature": "62fbf6566f1ba302829f9e32",
+                                    "_variation": "62fbf6566f1ba302829f9e39",
+                                },
+                            }
+                        )
+                    ],
+                )
+            ],
+            eventCount=1,
+        )
+
+    def test_init(self):
+        self.test_local_bucketing.flush_event_queue.return_value = []
+        self.test_options.event_flush_interval_ms = 100
+        manager = EventQueueManager(
+            self.sdk_key, self.test_options, self.test_local_bucketing
+        )
+        self.assertTrue(manager._should_run())
+        self.assertTrue(manager.is_alive())
+        self.assertTrue(manager.daemon)
+
+    def test_close(self):
+        self.test_local_bucketing.flush_event_queue.return_value = []
+        self.test_options.event_flush_interval_ms = 100
+        manager = EventQueueManager(
+            self.sdk_key, self.test_options, self.test_local_bucketing
+        )
+
+        manager.close()
+        # let the thread wake up from sleep and react to the close
+        time.sleep(0.5)
+        self.assertFalse(manager._should_run())
+        self.assertFalse(manager.is_alive())
+
+    @patch("devcycle_python_sdk.api.event_client.EventAPIClient.publish_events")
+    def test_publish_event_payload_retryable_api_error(self, mock_publish_events):
+        self.test_local_bucketing.on_event_payload_success = MagicMock()
+        self.test_local_bucketing.on_event_payload_failure = MagicMock()
+
+        mock_publish_events.side_effect = APIClientError("Some retryable error")
+
+        manager = EventQueueManager(
+            self.sdk_key, self.test_options_no_thread, self.test_local_bucketing
+        )
+        manager._publish_event_payload(self.test_payload)
+
+        # should try and publish events, get the error and then report the failure to local bucketing
+        mock_publish_events.assert_called_once()
+        self.test_local_bucketing.on_event_payload_failure.assert_called_with(
+            self.test_payload.payloadId, True
+        )
+        self.test_local_bucketing.on_event_payload_success.assert_not_called()
+
+    @patch("devcycle_python_sdk.api.event_client.EventAPIClient.publish_events")
+    def test_publish_event_payload_non_retryable_api_error(self, mock_publish_events):
+        mock_publish_events.side_effect = APIClientUnauthorizedError(
+            "Some retryable error"
+        )
+
+        manager = EventQueueManager(
+            self.sdk_key, self.test_options_no_thread, self.test_local_bucketing
+        )
+        manager._publish_event_payload(self.test_payload)
+
+        # should try and publish events, get the error and then report the failure to local bucketing
+        mock_publish_events.assert_called_once()
+        self.test_local_bucketing.on_event_payload_failure.assert_called_with(
+            self.test_payload.payloadId, False
+        )
+        self.test_local_bucketing.on_event_payload_success.assert_not_called()
+
+    @patch("devcycle_python_sdk.api.event_client.EventAPIClient.publish_events")
+    def test_flush_events_no_events(self, mock_publish_events):
+        self.test_local_bucketing.flush_event_queue = MagicMock()
+        self.test_local_bucketing.flush_event_queue.return_value = []
+
+        manager = EventQueueManager(
+            self.sdk_key, self.test_options_no_thread, self.test_local_bucketing
+        )
+        manager._flush_events()
+
+        self.test_local_bucketing.flush_event_queue.assert_called_once()
+        mock_publish_events.assert_not_called()
+
+    @patch("devcycle_python_sdk.api.event_client.EventAPIClient.publish_events")
+    def test_flush_events(self, mock_publish_events):
+        self.test_local_bucketing.flush_event_queue.return_value = [self.test_payload]
+
+        manager = EventQueueManager(
+            self.sdk_key, self.test_options_no_thread, self.test_local_bucketing
+        )
+        result = manager._flush_events()
+
+        self.assertEqual(result, 1)
+        self.test_local_bucketing.flush_event_queue.assert_called_once()
+        mock_publish_events.assert_called_once()
+        self.test_local_bucketing.on_event_payload_success.assert_called_once()
+
+    def test_queue_event_bad_data(self):
+        manager = EventQueueManager(
+            self.sdk_key, self.test_options_no_thread, self.test_local_bucketing
+        )
+        with self.assertRaises(ValueError):
+            manager.queue_event(user=None, event=None)
+
+        with self.assertRaises(ValueError):
+            manager.queue_event(user=DevCycleUser(user_id="test"), event=None)
+
+        # Events must have a type
+        with self.assertRaises(ValueError):
+            manager.queue_event(
+                user=DevCycleUser(user_id="test"), event=DevCycleEvent()
+            )
+
+    def test_queue_event(self):
+        self.test_local_bucketing.queue_event = MagicMock()
+        self.test_local_bucketing.get_event_queue_size.return_value = 1
+
+        manager = EventQueueManager(
+            self.sdk_key, self.test_options_no_thread, self.test_local_bucketing
+        )
+        DevCycleUser(user_id="test_user_id")
+        event = DevCycleEvent(
+            type=EventType.CustomEvent,
+            target="string-var",
+            value=1,
+            metaData={"test": "test"},
+        )
+        manager.queue_event(DevCycleUser(user_id="test"), event)
+
+        self.test_local_bucketing.queue_event.assert_called_once()
+        self.assertEqual(self.test_local_bucketing.get_event_queue_size.call_count, 2)
+
+    def test_check_queue_status(self):
+        self.test_options_no_thread.flush_event_queue_size = 5
+        self.test_options_no_thread.max_event_queue_size = 100
+
+        manager = EventQueueManager(
+            self.sdk_key, self.test_options_no_thread, self.test_local_bucketing
+        )
+
+        # queue empty, no issues
+        self.test_local_bucketing.get_event_queue_size.return_value = 0
+        manager._check_queue_status()
+        self.test_local_bucketing.flush_event_queue.assert_not_called()
+
+        # queue needs flush
+        self.test_local_bucketing.flush_event_queue.reset_mock()
+        self.test_local_bucketing.get_event_queue_size.return_value = 6
+        manager._check_queue_status()
+        self.test_local_bucketing.flush_event_queue.assert_called_once()
+
+        # queue full - should flush and then throw error if queue is still full
+        self.test_local_bucketing.flush_event_queue.reset_mock()
+
+        self.test_local_bucketing.get_event_queue_size.return_value = 100
+        with self.assertRaises(QueueFullError):
+            manager._check_queue_status()
+        self.test_local_bucketing.flush_event_queue.assert_called_once()
+
+    def test_queue_aggregate_event_bad_data(self):
+        manager = EventQueueManager(
+            self.sdk_key, self.test_options_no_thread, self.test_local_bucketing
+        )
+        with self.assertRaises(ValueError):
+            manager.queue_aggregate_event(event=None, bucketed_config=None)
+
+        # agg event must have a type
+        with self.assertRaises(ValueError):
+            manager.queue_aggregate_event(event=DevCycleEvent(), bucketed_config=None)
+
+        # agg event must have a target
+        with self.assertRaises(ValueError):
+            manager.queue_aggregate_event(
+                event=DevCycleEvent(type=EventType.AggVariableDefaulted),
+                bucketed_config=None,
+            )
+
+    def test_queue_aggregate_event(self):
+        self.test_local_bucketing.queue_aggregate_event = MagicMock()
+        self.test_local_bucketing.get_event_queue_size.return_value = 1
+
+        manager = EventQueueManager(
+            self.sdk_key, self.test_options_no_thread, self.test_local_bucketing
+        )
+        event = DevCycleEvent(
+            type=EventType.AggVariableDefaulted,
+            target="string-var",
+            value=1,
+            metaData={"test": "test"},
+        )
+
+        manager.queue_aggregate_event(event, None)
+
+        self.test_local_bucketing.queue_aggregate_event.assert_called_once()
+        self.assertEqual(self.test_local_bucketing.get_event_queue_size.call_count, 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

test/models/test_bucketed_config.py

@@ -0,0 +1,26 @@
+import json
+import logging
+import unittest
+
+from devcycle_python_sdk.models.bucketed_config import BucketedConfig
+from test.fixture.data import bucketed_config, bucketed_config_minimal
+
+logger = logging.getLogger(__name__)
+
+
+class BucketedConfigTest(unittest.TestCase):
+    def test_bucketed_config_all_fields(self) -> None:
+        bucketed_config_parsed = json.loads(bucketed_config())
+        result = BucketedConfig.from_json(bucketed_config_parsed)
+
+        # Fields are already checked in the local bucketing tests, no need to repeat here
+        self.assertIsNotNone(result)
+
+    def test_bucketed_config_minimal(self) -> None:
+        bucketed_config_parsed = json.loads(bucketed_config_minimal())
+        result = BucketedConfig.from_json(bucketed_config_parsed)
+        self.assertIsNotNone(result)
+
+
+if __name__ == "__main__":
+    unittest.main()

test/{test_dvc_cloud_client.py → test_cloud_client.py}

@@ -6,9 +6,9 @@ from time import time
 from unittest.mock import patch
 
 from devcycle_python_sdk import DevCycleCloudClient, DevCycleCloudOptions
-from devcycle_python_sdk.models.user import User
+from devcycle_python_sdk.models.user import DevCycleUser
 from devcycle_python_sdk.models.variable import Variable, TypeEnum
-from devcycle_python_sdk.models.event import Event
+from devcycle_python_sdk.models.event import DevCycleEvent
 from devcycle_python_sdk.exceptions import (
     CloudClientUnauthorizedError,
     NotFoundError,
@@ -17,14 +17,14 @@ from devcycle_python_sdk.exceptions import (
 logger = logging.getLogger(__name__)
 
 
-class DVCCloudClientTest(unittest.TestCase):
+class DevCycleCloudClientTest(unittest.TestCase):
     def setUp(self) -> None:
         sdk_key = "dvc_server_" + str(uuid.uuid4())
         options = DevCycleCloudOptions()
         self.test_client = DevCycleCloudClient(sdk_key, options)
-        self.test_user = User(user_id="test_user_id")
-        self.test_user_no_id = User(user_id=None)
-        self.test_user_empty_id = User(user_id="")
+        self.test_user = DevCycleUser(user_id="test_user_id")
+        self.test_user_no_id = DevCycleUser(user_id=None)  # type: ignore
+        self.test_user_empty_id = DevCycleUser(user_id="")
 
     def tearDown(self) -> None:
         pass
@@ -55,8 +55,6 @@ class DVCCloudClientTest(unittest.TestCase):
         option_with_data = DevCycleCloudOptions(
             enable_edge_db=False,
             bucketing_api_uri="https://localhost:8080",
-            config_cdn_uri="https://localhost:8080",
-            events_api_uri="https://localhost:8080",
         )
         client = DevCycleCloudClient(sdk_key, option_with_data)
         self.assertIsNotNone(client)
@@ -210,7 +208,7 @@ class DVCCloudClientTest(unittest.TestCase):
 
     @patch("devcycle_python_sdk.api.bucketing_client.BucketingAPIClient.track")
     def test_track_event_bad_user(self, mock_track_call):
-        event = Event(
+        event = DevCycleEvent(
             type="user",
             target="test_target",
             date=time(),
@@ -236,10 +234,9 @@ class DVCCloudClientTest(unittest.TestCase):
             self.test_client.track(self.test_user, None)
         mock_track_call.assert_not_called()
 
-        event = Event(
+        event = DevCycleEvent(
             type=None,
             target="test_target",
-            date=time(),
             value=42,
             metaData={"key": "value"},
         )
@@ -247,10 +244,9 @@ class DVCCloudClientTest(unittest.TestCase):
             self.test_client.track(self.test_user, event)
         mock_track_call.assert_not_called()
 
-        event = Event(
+        event = DevCycleEvent(
             type="",
             target="test_target",
-            date=time(),
             value=42,
             metaData={"key": "value"},
         )
@@ -265,10 +261,9 @@ class DVCCloudClientTest(unittest.TestCase):
         with self.assertRaises(CloudClientUnauthorizedError):
             self.test_client.track(
                 self.test_user,
-                Event(
+                DevCycleEvent(
                     type="user",
                     target="test_target",
-                    date=time(),
                     value=42,
                     metaData={"key": "value"},
                 ),
@@ -278,10 +273,9 @@ class DVCCloudClientTest(unittest.TestCase):
         mock_track_call.side_effect = Exception("Some error")
         self.test_client.track(
             self.test_user,
-            Event(
+            DevCycleEvent(
                 type="user",
                 target="test_target",
-                date=time(),
                 value=42,
                 metaData={"key": "value"},
             ),