General bug fixes, will add more tests later

Author: chillaq

splitio/client/factory.py

@@ -327,20 +327,12 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
     }
     imp_counter = ImpressionsCounter() if cfg['impressionsMode'] != ImpressionsMode.DEBUG else None
 
-    strategies = {
-        ImpressionsMode.OPTIMIZED : StrategyOptimizedMode(imp_counter),
-        ImpressionsMode.DEBUG : StrategyDebugMode(),
-        ImpressionsMode.NONE : StrategyNoneMode(imp_counter),
-    }
-    imp_strategy = strategies[cfg['impressionsMode']]
-
-    imp_counter = ImpressionsCounter() if cfg['impressionsMode'] != ImpressionsMode.DEBUG else None
-
-    strategies = {
-        ImpressionsMode.OPTIMIZED : StrategyOptimizedMode(imp_counter),
-        ImpressionsMode.DEBUG : StrategyDebugMode(),
-    }
-    imp_strategy = strategies[cfg['impressionsMode']]
+    if cfg['impressionsMode'] == ImpressionsMode.NONE:
+        imp_strategy = StrategyNoneMode(imp_counter)
+    elif cfg['impressionsMode'] == ImpressionsMode.DEBUG:
+        imp_strategy = StrategyDebugMode()
+    else:
+        imp_strategy = StrategyOptimizedMode(imp_counter)
 
     imp_manager = ImpressionsManager(
         _wrap_impression_listener(cfg['impressionListener'], sdk_metadata),
@@ -354,7 +346,6 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
         EventSynchronizer(apis['events'], storages['events'], cfg['eventsBulkSize']),
         ImpressionsCountSynchronizer(apis['impressions'], imp_manager),
     )
-    imp_count_sync_task = ImpressionsCountSyncTask(synchronizers.impressions_count_sync.synchronize_counters) if cfg['impressionsMode'] == 'OPTIMIZED' else None
 
     tasks = SplitTasks(
         SplitSynchronizationTask(
@@ -452,6 +443,7 @@ def _build_redis_factory(api_key, cfg):
         recorder,
     )
 
+
 def _build_localhost_factory(cfg):
     """Build and return a localhost factory for testing/development purposes."""
     storages = {
@@ -478,7 +470,6 @@ def _build_localhost_factory(cfg):
     synchronizer = LocalhostSynchronizer(synchronizers, tasks)
     manager = Manager(ready_event, synchronizer, None, False, sdk_metadata)
     manager.start()
-
     recorder = StandardRecorder(
         ImpressionsManager(None, StrategyDebugMode()),
         storages['events'],

splitio/engine/sender_adapters/in_memory_sender_adapter.py

@@ -33,14 +33,9 @@ def _uniques_formatter(self, uniques):
         :return: unique keys JSON
         :rtype: json
         """
-        formatted_uniques = json.loads('{"keys": []}')
         if len(uniques) == 0:
             return json.loads('{"keys": []}')
 
         return {
             'keys':  [{'f': feature, 'ks': list(keys)} for feature, keys in uniques.items()]
-        }
-#        for key in uniques:
-#            formatted_uniques["keys"].append(json.loads('{"f":"' + key +'", "ks":' + json.dumps(list(uniques[key])) + '}'))
-
-#        return formatted_uniques
+        }

splitio/engine/strategies/strategy_none_mode.py

@@ -1,5 +1,5 @@
 from splitio.engine.strategies.base_strategy import BaseStrategy
-from splitio.engine.strategies import Observer, Counter, truncate_time
+from splitio.engine.strategies import  Counter, truncate_time
 from splitio.engine.unique_keys_tracker import UniqueKeysTracker
 from splitio import util
 
@@ -14,7 +14,6 @@ def __init__(self, counter=None):
         Construct a strategy instance for none mode.
 
         """
-        self._observer = Observer(_IMPRESSION_OBSERVER_CACHE_SIZE)
         self._counter = counter
         self._unique_keys_tracker = UniqueKeysTracker(_UNIQUE_KEYS_CACHE_SIZE)
 
@@ -31,9 +30,6 @@ def process_impressions(self, impressions):
         :returns: Empty list, no impressions to post
         :rtype: list[]
         """
-        imps = [(self._observer.test_and_set(imp), attrs) for imp, attrs in impressions]
-        self._counter.track([imp for imp, _ in imps])
-        this_hour = truncate_time(util.utctime_ms())
-        [self._unique_keys_tracker.track(i.matching_key, i.feature_name) for i, _ in imps if i.previous_time is None or i.previous_time < this_hour]
-
-        return [], imps
+        self._counter.track([imp for imp, _ in impressions])
+        [self._unique_keys_tracker.track(i.matching_key, i.feature_name) for i, _ in impressions]
+        return [], impressions

splitio/sync/impression.py

@@ -4,7 +4,6 @@
 from splitio.api import APIException
 from splitio.engine.strategies import Counter
 
-
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -69,21 +68,25 @@ def synchronize_impressions(self):
 
 
 class ImpressionsCountSynchronizer(object):
-    def __init__(self, impressions_api, impressions_counter):
+    def __init__(self, impressions_api, impressions_manager):
         """
         Class constructor.
 
         :param impressions_api: Impressions Api object to send data to the backend
         :type impressions_api: splitio.api.impressions.ImpressionsAPI
         :param impressions_manager: Impressions manager instance
-        :type impressions_counter: splitio.engine.strategies
+        :type impressions_manager: splitio.engine.impressions.Manager
 
         """
         self._impressions_api = impressions_api
-        self._impressions_counter = impressions_counter
+        self._impressions_manager = impressions_manager
 
     def synchronize_counters(self):
         """Send impressions from both the failed and new queues."""
+
+        if not isinstance(self._impressions_manager._strategy._counter, Counter):
+            return
+
         to_send = self._impressions_manager._strategy._counter.pop_all()
         if not to_send:
             return

splitio/tasks/unique_keys_sync.py

@@ -6,7 +6,7 @@
 
 
 _LOGGER = logging.getLogger(__name__)
-
+_PERIOD = 15 * 60  # 15 minutes
 
 class UniqueKeysSyncTask(BaseSynchronizationTask):
     """Unique Keys synchronization task uses an asynctask.AsyncTask to send MTKs."""
@@ -20,8 +20,8 @@ def __init__(self, synchronize_unique_keys):
         :param period: How many seconds to wait between subsequent unique keys pushes to the BE.
         :type period: int
         """
-        _period = 15 * 60  # 15 minutes
-        self._task = AsyncTask(synchronize_unique_keys, _period,
+
+        self._task = AsyncTask(synchronize_unique_keys, _PERIOD,
                                on_stop=synchronize_unique_keys)
 
     def start(self):

tests/engine/test_send_adapters.py

@@ -0,0 +1,38 @@
+import unittest.mock as mock
+
+from splitio.engine.sender_adapters.in_memory_sender_adapter import InMemorySenderAdapter
+from splitio.api.telemetry import TelemetryAPI
+
+import pytest
+
+class InMemorySenderAdapterTests(object):
+    """In memory sender adapter test."""
+
+    def test_uniques_formatter(self, mocker):
+        """Test formatting dict to json."""
+
+        uniques = {"feature1": set({'key1', 'key2', 'key3'}),
+                   "feature2": set({'key6', 'key1', 'key10'}),
+                   }
+        formatted = {'keys':  [
+            {'f': 'feature1', 'ks': ['key1', 'key2', 'key3']},
+            {'f': 'feature2', 'ks': ['key1', 'key6', 'key10']},
+        ]}
+
+        sender_adapter = InMemorySenderAdapter(mocker.Mock())
+        for i in range(0,1):
+            assert(sorted(sender_adapter._uniques_formatter(uniques)["keys"][i]["ks"]) == sorted(formatted["keys"][i]["ks"]))
+
+
+    @mock.patch('splitio.api.telemetry.TelemetryAPI.record_unique_keys')
+    def test_record_unique_keys(self, mocker):
+        """Test sending unique keys."""
+
+        uniques = {"feature1": set({'key1', 'key2', 'key3'}),
+                   "feature2": set({'key1', 'key2', 'key3'}),
+                   }
+        telemetry_api = TelemetryAPI(mocker.Mock(), 'some_api_key', mocker.Mock())
+        sender_adapter = InMemorySenderAdapter(telemetry_api)
+        sender_adapter.record_unique_keys(uniques)
+
+        assert(mocker.called)