added tests

Author: chillaq

splitio/engine/impressions/__init__.py

@@ -1,13 +1,11 @@
-import imp
-from splitio.engine.impressions.impressions import Manager as ImpressionsManager
 from splitio.engine.impressions.impressions import ImpressionsMode
 from splitio.engine.impressions.manager import Counter as ImpressionsCounter
 from splitio.engine.impressions.strategies import StrategyNoneMode, StrategyDebugMode, StrategyOptimizedMode
 from splitio.engine.impressions.adapters import InMemorySenderAdapter, RedisSenderAdapter
 from splitio.tasks.unique_keys_sync import UniqueKeysSyncTask, ClearFilterSyncTask
 from splitio.sync.unique_keys import UniqueKeysSynchronizer, ClearFilterSynchronizer
-from splitio.sync.impression import ImpressionSynchronizer, ImpressionsCountSynchronizer
-from splitio.tasks.impressions_sync import ImpressionsSyncTask, ImpressionsCountSyncTask
+from splitio.sync.impression import ImpressionsCountSynchronizer
+from splitio.tasks.impressions_sync import ImpressionsCountSyncTask
 
 
 def set_classes(storage_mode, impressions_mode, api_adapter):

splitio/engine/impressions/adapters.py

@@ -135,12 +135,12 @@ def _build_counters(self, counters):
         :return: dict with list of impression count dtos
         :rtype: dict
         """
-        return [json.dumps({
+        return json.dumps({
             'pf': [
                 {
                     'f': pf_count.feature,
                     'm': pf_count.timeframe,
                     'rc': pf_count.count
                 } for pf_count in counters
             ]
-        })]
+        })

splitio/engine/impressions/impressions.py

@@ -17,14 +17,11 @@ def __init__(self, listener=None, strategy=None):
         """
         Construct a manger to track and forward impressions to the queue.
 
-        :param mode: Impressions capturing mode.
-        :type mode: ImpressionsMode
-
-        :param standalone: whether the SDK is running in standalone sending impressions by itself
-        :type standalone: bool
-
         :param listener: Optional impressions listener that will capture all seen impressions.
         :type listener: splitio.client.listener.ImpressionListenerWrapper
+
+        :param strategy: Impressions stragetgy instance
+        :type strategy: (BaseStrategy)
         """
 
         self._strategy = strategy

tests/client/test_factory.py

@@ -95,8 +95,6 @@ def test_redis_client_creation(self, mocker):
         assert isinstance(factory._get_storage('impressions'), redis.RedisImpressionsStorage)
         assert isinstance(factory._get_storage('events'), redis.RedisEventsStorage)
 
-        assert factory._sync_manager is None
-
         adapter = factory._get_storage('splits')._redis
         assert adapter == factory._get_storage('segments')._redis
         assert adapter == factory._get_storage('impressions')._redis

tests/engine/test_impressions.py

@@ -6,8 +6,6 @@
 from splitio.models.impressions import Impression
 from splitio.client.listener import ImpressionListenerWrapper
 
-import pytest
-
 def utctime_ms_reimplement():
     """Re-implementation of utctime_ms to avoid conflicts with mock/patching."""
     return int((datetime.utcnow() - datetime(1970, 1, 1)).total_seconds() * 1000)
@@ -155,7 +153,7 @@ def test_standalone_optimized(self, mocker):
         ])
 
     def test_standalone_debug(self, mocker):
-        """Test impressions manager in optimized mode with sdk in standalone mode."""
+        """Test impressions manager in debug mode with sdk in standalone mode."""
 
         # Mock utc_time function to be able to play with the clock
         utc_now = truncate_time(utctime_ms_reimplement()) + 1800 * 1000
@@ -204,7 +202,7 @@ def test_standalone_debug(self, mocker):
         assert len(manager._strategy._observer._cache._data) == 3  # distinct impressions seen
 
     def test_standalone_none(self, mocker):
-        """Test impressions manager in optimized mode with sdk in standalone mode."""
+        """Test impressions manager in none mode with sdk in standalone mode."""
 
         # Mock utc_time function to be able to play with the clock
         utc_now = truncate_time(utctime_ms_reimplement()) + 1800 * 1000
@@ -270,111 +268,6 @@ def test_standalone_none(self, mocker):
             Counter.CountPerFeature('f1', truncate_time(utc_now), 2)
         ])
 
-    def test_non_standalone_optimized(self, mocker):
-        """Test impressions manager in optimized mode with sdk in standalone mode."""
-
-        # Mock utc_time function to be able to play with the clock
-        utc_now = truncate_time(utctime_ms_reimplement()) + 1800 * 1000
-        utc_time_mock = mocker.Mock()
-        utc_time_mock.return_value = utc_now
-        mocker.patch('splitio.util.utctime_ms', new=utc_time_mock)
-
-        manager = Manager(None, StrategyOptimizedMode(Counter()))  # no listener
-        assert manager._strategy._counter is not None
-        assert manager._strategy._observer is not None
-        assert manager._listener is None
-        assert isinstance(manager._strategy, StrategyOptimizedMode)
-
-        # An impression that hasn't happened in the last hour (pt = None) should be tracked
-        imps = manager.process_impressions([
-            (Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-3), None),
-            (Impression('k1', 'f2', 'on', 'l1', 123, None, utc_now-3), None)
-        ])
-        assert imps == [Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-3),
-                        Impression('k1', 'f2', 'on', 'l1', 123, None, utc_now-3)]
-
-        assert [Counter.CountPerFeature(k.feature, k.timeframe, v)
-                for (k, v) in manager._strategy._counter._data.items()] == [
-            Counter.CountPerFeature('f1', truncate_time(utc_now-3), 1),
-            Counter.CountPerFeature('f2', truncate_time(utc_now-3), 1)]
-
-        # Tracking the same impression a ms later should be empty
-        imps = manager.process_impressions([
-            (Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-2), None)
-        ])
-        assert imps == []
-
-        # Tracking a in impression with a different key makes it to the queue
-        imps = manager.process_impressions([
-            (Impression('k2', 'f1', 'on', 'l1', 123, None, utc_now-1), None)
-        ])
-        assert imps == [Impression('k2', 'f1', 'on', 'l1', 123, None, utc_now-1)]
-
-
-        # Advance the perceived clock one hour
-        old_utc = utc_now  # save it to compare captured impressions
-        utc_now += 3600 * 1000
-        utc_time_mock.return_value = utc_now
-
-        # Track the same impressions but "one hour later"
-        imps = manager.process_impressions([
-            (Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-1), None),
-            (Impression('k2', 'f1', 'on', 'l1', 123, None, utc_now-2), None)
-        ])
-        assert imps == [Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-1, old_utc-3),
-                        Impression('k2', 'f1', 'on', 'l1', 123, None, utc_now-2, old_utc-1)]
-
-    def test_non_standalone_debug(self, mocker):
-        """Test impressions manager in optimized mode with sdk in standalone mode."""
-
-        # Mock utc_time function to be able to play with the clock
-        utc_now = truncate_time(utctime_ms_reimplement()) + 1800 * 1000
-        utc_time_mock = mocker.Mock()
-        utc_time_mock.return_value = utc_now
-        mocker.patch('splitio.util.utctime_ms', new=utc_time_mock)
-
-        manager = Manager(None, StrategyDebugMode())  # no listener
-        assert manager._listener is None
-        assert manager._strategy._observer is not None
-        assert isinstance(manager._strategy, StrategyDebugMode)
-
-        # An impression that hasn't happened in the last hour (pt = None) should be tracked
-        imps = manager.process_impressions([
-            (Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-3), None),
-            (Impression('k1', 'f2', 'on', 'l1', 123, None, utc_now-3), None)
-        ])
-        assert imps == [Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-3),
-                        Impression('k1', 'f2', 'on', 'l1', 123, None, utc_now-3)]
-
-        # Tracking the same impression a ms later should not be empty
-        imps = manager.process_impressions([
-            (Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-2), None)
-        ])
-        assert imps == [Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-2, utc_now-3)]
-
-        # Tracking a in impression with a different key makes it to the queue
-        imps = manager.process_impressions([
-            (Impression('k2', 'f1', 'on', 'l1', 123, None, utc_now-1), None)
-        ])
-        assert imps == [Impression('k2', 'f1', 'on', 'l1', 123, None, utc_now-1)]
-
-        # Advance the perceived clock one hour
-        old_utc = utc_now  # save it to compare captured impressions
-        utc_now += 3600 * 1000
-        utc_time_mock.return_value = utc_now
-
-        # Track the same impressions but "one hour later"
-        imps = manager.process_impressions([
-            (Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-1), None),
-            (Impression('k2', 'f1', 'on', 'l1', 123, None, utc_now-2), None)
-        ])
-        assert imps == [Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-1, old_utc-3),
-                        Impression('k2', 'f1', 'on', 'l1', 123, None, utc_now-2, old_utc-1)]
-
-    def test_non_standalone_optimized(self, mocker):
-        """Test impressions manager in none mode with sdk in none-standalone mode."""
-        # TODO: Will add details here when add redis implementation
-
     def test_standalone_optimized_listener(self, mocker):
         """Test impressions manager in optimized mode with sdk in standalone mode."""
 
@@ -582,127 +475,4 @@ def test_standalone_none_listener(self, mocker):
             mocker.call(Impression('k2', 'f1', 'on', 'l1', 123, None, old_utc-1), None),
             mocker.call(Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-1, None), None),
             mocker.call(Impression('k2', 'f1', 'on', 'l1', 123, None, utc_now-2, None), None)
-        ]
-
-    def test_non_standalone_optimized_listener(self, mocker):
-        """Test impressions manager in optimized mode with sdk in standalone mode."""
-
-        # Mock utc_time function to be able to play with the clock
-        utc_now = truncate_time(utctime_ms_reimplement()) + 1800 * 1000
-        utc_time_mock = mocker.Mock()
-        utc_time_mock.return_value = utc_now
-        mocker.patch('splitio.util.utctime_ms', new=utc_time_mock)
-
-        imps = []
-        listener = mocker.Mock(spec=ImpressionListenerWrapper)
-        manager = Manager(listener, StrategyOptimizedMode(Counter()))
-        assert manager._strategy._counter is not None
-        assert manager._strategy._observer is not None
-        assert manager._listener is not None
-        assert isinstance(manager._strategy, StrategyOptimizedMode)
-
-        # An impression that hasn't happened in the last hour (pt = None) should be tracked
-        imps = manager.process_impressions([
-            (Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-3), None),
-            (Impression('k1', 'f2', 'on', 'l1', 123, None, utc_now-3), None)
-        ])
-        assert imps == [Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-3),
-                        Impression('k1', 'f2', 'on', 'l1', 123, None, utc_now-3)]
-
-        assert [Counter.CountPerFeature(k.feature, k.timeframe, v)
-                for (k, v) in manager._strategy._counter._data.items()] == [
-            Counter.CountPerFeature('f1', truncate_time(utc_now-3), 1),
-            Counter.CountPerFeature('f2', truncate_time(utc_now-3), 1)]
-
-        # Tracking the same impression a ms later should be empty
-        imps = manager.process_impressions([
-            (Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-2), None)
-        ])
-        assert imps == []
-
-        # Tracking a in impression with a different key makes it to the queue
-        imps = manager.process_impressions([
-            (Impression('k2', 'f1', 'on', 'l1', 123, None, utc_now-1), None)
-        ])
-        assert imps == [Impression('k2', 'f1', 'on', 'l1', 123, None, utc_now-1)]
-
-        old_utc = utc_now  # save it to compare captured impressions
-        utc_now += 3600 * 1000
-        utc_time_mock.return_value = utc_now
-
-        # Track the same impressions but "one hour later"
-        imps = manager.process_impressions([
-            (Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-1), None),
-            (Impression('k2', 'f1', 'on', 'l1', 123, None, utc_now-2), None)
-        ])
-        assert imps == [Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-1, old_utc-3),
-                        Impression('k2', 'f1', 'on', 'l1', 123, None, utc_now-2, old_utc-1)]
-
-        assert listener.log_impression.mock_calls == [
-            mocker.call(Impression('k1', 'f1', 'on', 'l1', 123, None, old_utc-3), None),
-            mocker.call(Impression('k1', 'f2', 'on', 'l1', 123, None, old_utc-3), None),
-            mocker.call(Impression('k1', 'f1', 'on', 'l1', 123, None, old_utc-2, old_utc-3), None),
-            mocker.call(Impression('k2', 'f1', 'on', 'l1', 123, None, old_utc-1), None),
-            mocker.call(Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-1, old_utc-3), None),
-            mocker.call(Impression('k2', 'f1', 'on', 'l1', 123, None, utc_now-2, old_utc-1), None)
-        ]
-
-    def test_non_standalone_debug_listener(self, mocker):
-        """Test impressions manager in optimized mode with sdk in standalone mode."""
-
-        # Mock utc_time function to be able to play with the clock
-        utc_now = truncate_time(utctime_ms_reimplement()) + 1800 * 1000
-        utc_time_mock = mocker.Mock()
-        utc_time_mock.return_value = utc_now
-        mocker.patch('splitio.util.utctime_ms', new=utc_time_mock)
-
-        listener = mocker.Mock(spec=ImpressionListenerWrapper)
-        manager = Manager(listener, StrategyDebugMode())
-        assert manager._listener is not None
-        assert isinstance(manager._strategy, StrategyDebugMode)
-
-        # An impression that hasn't happened in the last hour (pt = None) should be tracked
-        imps = manager.process_impressions([
-            (Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-3), None),
-            (Impression('k1', 'f2', 'on', 'l1', 123, None, utc_now-3), None)
-        ])
-        assert imps == [Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-3),
-                        Impression('k1', 'f2', 'on', 'l1', 123, None, utc_now-3)]
-
-        # Tracking the same impression a ms later should return the imp
-        imps = manager.process_impressions([
-            (Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-2), None)
-        ])
-        assert imps == [Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-2, utc_now-3)]
-
-        # Tracking a in impression with a different key makes it to the queue
-        imps = manager.process_impressions([
-            (Impression('k2', 'f1', 'on', 'l1', 123, None, utc_now-1), None)
-        ])
-        assert imps == [Impression('k2', 'f1', 'on', 'l1', 123, None, utc_now-1)]
-
-        # Advance the perceived clock one hour
-        old_utc = utc_now  # save it to compare captured impressions
-        utc_now += 3600 * 1000
-        utc_time_mock.return_value = utc_now
-
-        # Track the same impressions but "one hour later"
-        imps = manager.process_impressions([
-            (Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-1), None),
-            (Impression('k2', 'f1', 'on', 'l1', 123, None, utc_now-2), None)
-        ])
-        assert imps == [Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-1, old_utc-3),
-                        Impression('k2', 'f1', 'on', 'l1', 123, None, utc_now-2, old_utc-1)]
-
-        assert listener.log_impression.mock_calls == [
-            mocker.call(Impression('k1', 'f1', 'on', 'l1', 123, None, old_utc-3), None),
-            mocker.call(Impression('k1', 'f2', 'on', 'l1', 123, None, old_utc-3), None),
-            mocker.call(Impression('k1', 'f1', 'on', 'l1', 123, None, old_utc-2, old_utc-3), None),
-            mocker.call(Impression('k2', 'f1', 'on', 'l1', 123, None, old_utc-1), None),
-            mocker.call(Impression('k1', 'f1', 'on', 'l1', 123, None, utc_now-1, old_utc-3), None),
-            mocker.call(Impression('k2', 'f1', 'on', 'l1', 123, None, utc_now-2, old_utc-1), None)
-        ]
-
-    def test_non_standalone_none_listener(self, mocker):
-        """Test impressions manager in none mode with sdk in non-standalone mode."""
-        # TODO: Will add details here when add redis implementation
+        ]