added EventStorage class with tests

Author: chillaq

splitio/storage/pluggable.py

@@ -5,7 +5,7 @@
 
 from splitio.models import splits, segments
 from splitio.models.impressions import Impression
-from splitio.storage import SplitStorage, SegmentStorage, ImpressionStorage
+from splitio.storage import SplitStorage, SegmentStorage, ImpressionStorage, EventStorage
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -556,3 +556,76 @@ def clear(self):
         Clear data.
         """
         raise NotImplementedError('Only consumer mode is supported.')
+
+
+class PluggableEventsStorage(EventStorage):
+    """Redis based event storage class."""
+
+    def __init__(self, pluggable_adapter, sdk_metadata, prefix=None):
+        """
+        Class constructor.
+
+        :param redis_client: Redis client or compliant interface.
+        :type redis_client: splitio.storage.adapters.redis.RedisAdapter
+        :param sdk_metadata: SDK & Machine information.
+        :type sdk_metadata: splitio.client.util.SdkMetadata
+        """
+        self._pluggable_adapter = pluggable_adapter
+        self._sdk_metadata = {
+                                's': sdk_metadata.sdk_version,
+                                'n': sdk_metadata.instance_name,
+                                'i': sdk_metadata.instance_ip,
+                            }
+        self._events_queue_key = 'SPLITIO.events'
+        if prefix is not None:
+            self._events_queue_key = prefix + "." + self._events_queue_key
+
+    def _wrap_events(self, events):
+        return [
+        json.dumps({
+            'e': {
+                'key': e.event.key,
+                'trafficTypeName': e.event.traffic_type_name,
+                'eventTypeId': e.event.event_type_id,
+                'value': e.event.value,
+                'timestamp': e.event.timestamp,
+                'properties': e.event.properties,
+            },
+            'm': self._sdk_metadata
+        })
+        for e in events
+    ]
+
+    def put(self, events):
+        """
+        Add an event to the redis storage.
+
+        :param event: Event to add to the queue.
+        :type event: splitio.models.events.Event
+
+        :return: Whether the event has been added or not.
+        :rtype: bool
+        """
+        to_store = self._wrap_events(events)
+        try:
+            self._pluggable_adapter.push_items(self._events_queue_key, *to_store)
+            return True
+        except Exception:
+            _LOGGER.error('Something went wrong when trying to add event to redis')
+            _LOGGER.debug('Error: ', exc_info=True)
+            return False
+
+    def pop_many(self, count):
+        """
+        Pop the oldest N events from storage.
+
+        :param count: Number of events to pop.
+        :type count: int
+        """
+        raise NotImplementedError('Only redis-consumer mode is supported.')
+
+    def clear(self):
+        """
+        Clear data.
+        """
+        raise NotImplementedError('Not supported for redis.')

tests/storage/test_pluggable.py

@@ -5,7 +5,8 @@
 from splitio.models import splits, segments
 from splitio.models.segments import Segment
 from splitio.models.impressions import Impression
-from splitio.storage.pluggable import PluggableSplitStorage, PluggableSegmentStorage, PluggableImpressionsStorage
+from splitio.models.events import Event, EventWrapper
+from splitio.storage.pluggable import PluggableSplitStorage, PluggableSegmentStorage, PluggableImpressionsStorage, PluggableEventsStorage
 from splitio.client.util import get_metadata, SdkMetadata
 
 from tests.integration import splits_json
@@ -403,4 +404,80 @@ def test_wrap_impressions(self):
                     'm': 321654,
                 }
             })
-        ])
+        ])
+
+class PluggableEventsStorageTests(object):
+    """In memory events storage test cases."""
+
+    def setup_method(self):
+        """Prepare storages with test data."""
+        self.mock_adapter = StorageMockAdapter()
+        self.metadata = SdkMetadata('python-1.1.1', 'hostname', 'ip')
+        self.pluggable_events_storage = PluggableEventsStorage(self.mock_adapter, self.metadata, 'myprefix')
+
+    def test_init(self):
+        assert(self.pluggable_events_storage._events_queue_key == "myprefix.SPLITIO.events")
+        assert(self.pluggable_events_storage._sdk_metadata == {
+                                's': self.metadata.sdk_version,
+                                'n': self.metadata.instance_name,
+                                'i': self.metadata.instance_ip,
+                            })
+
+        pluggable2 = PluggableEventsStorage(self.mock_adapter, self.metadata)
+        assert(pluggable2._events_queue_key == "SPLITIO.events")
+
+    def test_put(self):
+        events = [
+            EventWrapper(event=Event('key1', 'user', 'purchase', 10, 123456, None),  size=32768),
+            EventWrapper(event=Event('key2', 'user', 'purchase', 10, 123456, None),  size=32768),
+            EventWrapper(event=Event('key3', 'user', 'purchase', 10, 123456, None),  size=32768),
+            EventWrapper(event=Event('key4', 'user', 'purchase', 10, 123456, None),  size=32768),
+        ]
+        self.pluggable_events_storage.put(events)
+        assert(self.pluggable_events_storage._events_queue_key in self.mock_adapter._keys)
+        assert(self.mock_adapter._keys["myprefix.SPLITIO.events"] == self.pluggable_events_storage._wrap_events(events))
+
+        events2 = [
+            EventWrapper(event=Event('key5', 'user', 'purchase', 10, 123456, None),  size=32768),
+            EventWrapper(event=Event('key6', 'user', 'purchase', 10, 123456, None),  size=32768),
+        ]
+        self.pluggable_events_storage.put(events2)
+        assert(self.mock_adapter._keys["myprefix.SPLITIO.events"] == self.pluggable_events_storage._wrap_events(events + events2))
+
+    def test_wrap_events(self):
+        events = [
+            EventWrapper(event=Event('key1', 'user', 'purchase', 10, 123456, None),  size=32768),
+            EventWrapper(event=Event('key2', 'user', 'purchase', 10, 123456, None),  size=32768),
+        ]
+        assert(self.pluggable_events_storage._wrap_events(events) == [
+            json.dumps({
+                'e': {
+                    'key': 'key1',
+                    'trafficTypeName': 'user',
+                    'eventTypeId': 'purchase',
+                    'value': 10,
+                    'timestamp': 123456,
+                    'properties': None,
+                },
+                'm': {
+                    's': self.metadata.sdk_version,
+                    'n': self.metadata.instance_name,
+                    'i': self.metadata.instance_ip,
+                }
+            }),
+            json.dumps({
+                'e': {
+                    'key': 'key2',
+                    'trafficTypeName': 'user',
+                    'eventTypeId': 'purchase',
+                    'value': 10,
+                    'timestamp': 123456,
+                    'properties': None,
+                },
+                'm': {
+                    's': self.metadata.sdk_version,
+                    'n': self.metadata.instance_name,
+                    'i': self.metadata.instance_ip,
+                }
+            })
+        ])