Moved all methods outside strategy class except one.

Author: chillaq

splitio/engine/impressions.py

@@ -4,10 +4,13 @@
 from splitio.client.listener import ImpressionListenerException
 from splitio.engine.strategies.strategy_debug_mode import StrategyDebugMode
 from splitio.engine.strategies.strategy_optimized_mode import StrategyOptimizedMode
+from splitio.engine.strategies import Observer, Counter
 
 import logging
 _LOGGER = logging.getLogger(__name__)
 
+_IMPRESSION_OBSERVER_CACHE_SIZE = 500000
+
 class ImpressionsMode(Enum):
     """Impressions tracking mode."""
 
@@ -30,6 +33,8 @@ def __init__(self, mode=ImpressionsMode.OPTIMIZED, standalone=True, listener=Non
         :param listener: Optional impressions listener that will capture all seen impressions.
         :type listener: splitio.client.listener.ImpressionListenerWrapper
         """
+        self._observer = Observer(_IMPRESSION_OBSERVER_CACHE_SIZE) if standalone else None
+        self._counter = Counter() if standalone else None
         self._strategy = self.get_strategy(mode, standalone)
         self._listener = listener
 
@@ -40,7 +45,7 @@ def get_strategy(self, mode, standalone):
         :returns: A strategy object
         :rtype: (BaseStrategy)
         """
-        return StrategyOptimizedMode(standalone) if mode == ImpressionsMode.OPTIMIZED else StrategyDebugMode(standalone)
+        return StrategyOptimizedMode(self._counter, self._observer, standalone) if mode == ImpressionsMode.OPTIMIZED else StrategyDebugMode(self._observer, standalone)
 
     def process_impressions(self, impressions):
         """
@@ -51,9 +56,9 @@ def process_impressions(self, impressions):
         :param impressions: List of impression objects with attributes
         :type impressions: list[tuple[splitio.models.impression.Impression, dict]]
         """
-        imps = self._strategy.process_impressions(impressions)
-        self._send_impressions_to_listener(imps)
-        return self._strategy.truncate_impressions_time(imps)
+        for_log, for_listener = self._strategy.process_impressions(impressions)
+        self._send_impressions_to_listener(for_listener)
+        return for_log
 
     def get_counts(self):
         """
@@ -62,7 +67,7 @@ def get_counts(self):
         :returns: A list of counter objects.
         :rtype: list[Counter.CountPerFeature]
         """
-        return self._strategy.get_counts()
+        return self._counter.pop_all() if self._counter is not None else []
 
     def _send_impressions_to_listener(self, impressions):
         """

splitio/engine/strategies/__init__.py

@@ -19,6 +19,22 @@ def truncate_time(timestamp_ms):
     """
     return timestamp_ms - (timestamp_ms % _TIME_INTERVAL_MS)
 
+def truncate_impressions_time(imps, counter = None):
+    """
+    Process impressions.
+
+    Impressions are truncated based on time
+
+    :param impressions: List of impression objects with attributes
+    :type impressions: list[tuple[splitio.models.impression.Impression, dict]]
+
+    :returns: truncated list of impressions
+    :rtype: list[splitio.models.impression.Impression]
+    """
+    this_hour = truncate_time(util.utctime_ms())
+    return [imp for imp, _ in imps] if counter is None \
+        else [i for i, _ in imps if i.previous_time is None or i.previous_time < this_hour]
+
 
 class Hasher(object):  # pylint:disable=too-few-public-methods
     """Impression hasher."""

splitio/engine/strategies/strategy_debug_mode.py

@@ -1,18 +1,18 @@
 from splitio.engine.strategies.base_strategy import BaseStrategy
-from splitio.engine.strategies import Observer
+from splitio.engine.strategies import Observer, truncate_impressions_time
 
 _IMPRESSION_OBSERVER_CACHE_SIZE = 500000
 
 class StrategyDebugMode(BaseStrategy):
     """Debug mode strategy."""
 
-    def __init__(self, standalone=True):
+    def __init__(self, observer=None, standalone=True):
         """
         Construct a strategy instance for debug mode.
 
         """
         self._standalone = standalone
-        self._observer =  Observer(_IMPRESSION_OBSERVER_CACHE_SIZE) if self._standalone else None
+        self._observer =  observer
 
     def process_impressions(self, impressions):
         """
@@ -26,23 +26,5 @@ def process_impressions(self, impressions):
         :returns: Observed list of impressions
         :rtype: list[tuple[splitio.models.impression.Impression, dict]]
         """
-        imps = [(self._observer.test_and_set(imp), attrs) for imp, attrs in impressions] if self._observer is not None else impressions
-        return imps
-
-    def truncate_impressions_time(self, imps):
-        """
-        No counter implemented, return same impresisons passed.
-
-        :returns: list of impressions
-        :rtype: list[splitio.models.impression.Impression]
-        """
-        return [imp for imp, _ in imps]
-
-    def get_counts(self):
-        """
-        No counter implemented, return empty array
-
-        :returns: empty list
-        :rtype: list[]
-        """
-        return []
+        for_listener = [(self._observer.test_and_set(imp), attrs) for imp, attrs in impressions] if self._observer is not None else impressions
+        return truncate_impressions_time(for_listener, None), for_listener

splitio/engine/strategies/strategy_optimized_mode.py

@@ -1,20 +1,18 @@
 from splitio.engine.strategies.base_strategy import BaseStrategy
-from splitio.engine.strategies import Observer, Counter, truncate_time
+from splitio.engine.strategies import Observer, Counter, truncate_impressions_time
 from splitio import util
 
-_IMPRESSION_OBSERVER_CACHE_SIZE = 500000
-
 class StrategyOptimizedMode(BaseStrategy):
     """Optimized mode strategy."""
 
-    def __init__(self, standalone=True):
+    def __init__(self, counter=None, observer=None, standalone=True):
         """
         Construct a strategy instance for optimized mode.
 
         """
         self._standalone = standalone
-        self._counter = Counter() if self._standalone else None
-        self._observer =  Observer(_IMPRESSION_OBSERVER_CACHE_SIZE) if self._standalone else None
+        self._counter = counter
+        self._observer =  observer
 
     def process_impressions(self, impressions):
         """
@@ -28,33 +26,7 @@ def process_impressions(self, impressions):
         :returns: Observed list of impressions
         :rtype: list[tuple[splitio.models.impression.Impression, dict]]
         """
-        imps = [(self._observer.test_and_set(imp), attrs) for imp, attrs in impressions] \
-        if self._observer else impressions
+        forListener = [(self._observer.test_and_set(imp), attrs) for imp, attrs in impressions] if self._observer else impressions
         if self._counter is not None:
-            self._counter.track([imp for imp, _ in imps])
-        return imps
-
-    def truncate_impressions_time(self, imps):
-        """
-        Process impressions.
-
-        Impressions are truncated based on time
-
-        :param impressions: List of impression objects with attributes
-        :type impressions: list[tuple[splitio.models.impression.Impression, dict]]
-
-        :returns: truncated list of impressions
-        :rtype: list[splitio.models.impression.Impression]
-        """
-        this_hour = truncate_time(util.utctime_ms())
-        return [imp for imp, _ in imps] if self._counter is None \
-            else [i for i, _ in imps if i.previous_time is None or i.previous_time < this_hour]
-
-    def get_counts(self):
-        """
-        Return counts of impressions per features.
-
-        :returns: A list of counter objects.
-        :rtype: list[Counter.CountPerFeature]
-        """
-        return self._counter.pop_all() if self._counter is not None else []
+            self._counter.track([imp for imp, _ in forListener])
+        return truncate_impressions_time(forListener, self._counter), forListener

tests/engine/test_impressions.py

@@ -6,6 +6,7 @@
 from splitio.engine.strategies.strategy_optimized_mode import StrategyOptimizedMode
 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."""
@@ -100,7 +101,7 @@ def test_standalone_optimized(self, mocker):
         mocker.patch('splitio.util.utctime_ms', new=utc_time_mock)
 
         manager = Manager()  # no listener
-        assert manager._strategy._counter is not None
+        assert manager._counter is not None
         assert manager._strategy._observer is not None
         assert manager._listener is None
         assert isinstance(manager._strategy, StrategyOptimizedMode)
@@ -115,7 +116,7 @@ def test_standalone_optimized(self, mocker):
                         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()] == [
+                for (k, v) in manager._counter._data.items()] == [
             Counter.CountPerFeature('f1', truncate_time(utc_now-3), 1),
             Counter.CountPerFeature('f2', truncate_time(utc_now-3), 1)]
 
@@ -145,9 +146,9 @@ def test_standalone_optimized(self, mocker):
                         Impression('k2', 'f1', 'on', 'l1', 123, None, utc_now-2, old_utc-1)]
 
         assert len(manager._strategy._observer._cache._data) == 3  # distinct impressions seen
-        assert len(manager._strategy._counter._data) == 3  # 2 distinct features. 1 seen in 2 different timeframes
+        assert len(manager._counter._data) == 3  # 2 distinct features. 1 seen in 2 different timeframes
 
-        assert set(manager._strategy._counter.pop_all()) == set([
+        assert set(manager._counter.pop_all()) == set([
             Counter.CountPerFeature('f1', truncate_time(old_utc), 3),
             Counter.CountPerFeature('f2', truncate_time(old_utc), 1),
             Counter.CountPerFeature('f1', truncate_time(utc_now), 2)
@@ -163,7 +164,7 @@ def test_standalone_debug(self, mocker):
         mocker.patch('splitio.util.utctime_ms', new=utc_time_mock)
 
         manager = Manager(ImpressionsMode.DEBUG)  # no listener
-        assert manager._strategy.get_counts() == []
+        assert manager.get_counts() == []
         assert manager._strategy._observer is not None
         assert manager._listener is None
         assert isinstance(manager._strategy, StrategyDebugMode)
@@ -213,7 +214,7 @@ def test_non_standalone_optimized(self, mocker):
         mocker.patch('splitio.util.utctime_ms', new=utc_time_mock)
 
         manager = Manager(ImpressionsMode.OPTIMIZED, False)  # no listener
-        assert manager._strategy._counter is None
+        assert manager._counter is None
         assert manager._strategy._observer is None
         assert manager._listener is None
         assert isinstance(manager._strategy, StrategyOptimizedMode)
@@ -260,7 +261,7 @@ def test_non_standalone_debug(self, mocker):
         mocker.patch('splitio.util.utctime_ms', new=utc_time_mock)
 
         manager = Manager(ImpressionsMode.DEBUG, False)  # no listener
-        assert manager._strategy.get_counts() == []
+        assert manager.get_counts() == []
         assert manager._strategy._observer is None
         assert manager._listener is None
         assert isinstance(manager._strategy, StrategyDebugMode)
@@ -309,7 +310,7 @@ def test_standalone_optimized_listener(self, mocker):
         listener = mocker.Mock(spec=ImpressionListenerWrapper)
 
         manager = Manager(listener=listener)  # no listener
-        assert manager._strategy._counter is not None
+        assert manager._counter is not None
         assert manager._strategy._observer is not None
         assert manager._listener is not None
         assert isinstance(manager._strategy, StrategyOptimizedMode)
@@ -322,7 +323,7 @@ def test_standalone_optimized_listener(self, mocker):
         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()] == [
+                for (k, v) in manager._counter._data.items()] == [
             Counter.CountPerFeature('f1', truncate_time(utc_now-3), 1),
             Counter.CountPerFeature('f2', truncate_time(utc_now-3), 1)]
 
@@ -352,9 +353,9 @@ def test_standalone_optimized_listener(self, mocker):
                         Impression('k2', 'f1', 'on', 'l1', 123, None, utc_now-2, old_utc-1)]
 
         assert len(manager._strategy._observer._cache._data) == 3  # distinct impressions seen
-        assert len(manager._strategy._counter._data) == 3  # 2 distinct features. 1 seen in 2 different timeframes
+        assert len(manager._counter._data) == 3  # 2 distinct features. 1 seen in 2 different timeframes
 
-        assert set(manager._strategy._counter.pop_all()) == set([
+        assert set(manager._counter.pop_all()) == set([
             Counter.CountPerFeature('f1', truncate_time(old_utc), 3),
             Counter.CountPerFeature('f2', truncate_time(old_utc), 1),
             Counter.CountPerFeature('f1', truncate_time(utc_now), 2)
@@ -381,7 +382,7 @@ def test_standalone_debug_listener(self, mocker):
         imps = []
         listener = mocker.Mock(spec=ImpressionListenerWrapper)
         manager = Manager(ImpressionsMode.DEBUG, listener=listener)
-        assert manager._strategy.get_counts() == []
+        assert manager.get_counts() == []
         assert manager._strategy._observer is not None
         assert manager._listener is not None
         assert isinstance(manager._strategy, StrategyDebugMode)
@@ -442,7 +443,7 @@ def test_non_standalone_optimized_listener(self, mocker):
         imps = []
         listener = mocker.Mock(spec=ImpressionListenerWrapper)
         manager = Manager(ImpressionsMode.OPTIMIZED, False, listener)  # no listener
-        assert manager._strategy._counter is None
+        assert manager._counter is None
         assert manager._strategy._observer is None
         assert manager._listener is not None
         assert isinstance(manager._strategy, StrategyOptimizedMode)
@@ -500,7 +501,7 @@ def test_non_standalone_debug_listener(self, mocker):
 
         listener = mocker.Mock(spec=ImpressionListenerWrapper)
         manager = Manager(ImpressionsMode.DEBUG, False, listener)  # no listener
-        assert manager._strategy.get_counts() == []
+        assert manager.get_counts() == []
         assert manager._strategy._observer is None
         assert manager._listener is not None
         assert isinstance(manager._strategy, StrategyDebugMode)