fixed tests

Author: Matias Melograno

splitio/client/factory.py

@@ -354,7 +354,7 @@ def _build_redis_factory(api_key, cfg):
         'telemetry': RedisTelemetryStorage(redis_adapter, sdk_metadata)
     }
     recorder = PipelinedRecorder(
-        redis_adapter.pipeline(),
+        redis_adapter.pipeline,
         ImpressionsManager(cfg['impressionsMode'], False,
                            _wrap_impression_listener(cfg['impressionListener'], sdk_metadata)),
         storages['telemetry'],

splitio/recorder/recorder.py

@@ -95,8 +95,8 @@ def __init__(self, pipe, impressions_manager, telemetry_storage, event_storage,
         """
         Class constructor.
 
-        :param pipe: redis pipeline
-        :type pipe: splitio.storage.adapters.redis.RedisPipelineAdapter
+        :param pipe: redis pipeline function
+        :type pipe: callable
         :param impressions_manager: impression manager instance
         :type impressions_manager: splitio.engine.impressions.Manager
         :param telemetry_storage: telemetry storage instance
@@ -106,7 +106,7 @@ def __init__(self, pipe, impressions_manager, telemetry_storage, event_storage,
         :param impression_storage: impression storage instance
         :type impression_storage: splitio.storage.redis.RedisImpressionsStorage
         """
-        self._pipe = pipe
+        self._make_pipe = pipe
         self._impressions_manager = impressions_manager
         self._telemetry_storage = telemetry_storage
         self._event_sotrage = event_storage
@@ -125,9 +125,10 @@ def record_treatment_stats(self, impressions, latency, operation):
         """
         try:
             impressions = self._impressions_manager.process_impressions(impressions)
-            self._impression_storage.add_impressions_to_pipe(impressions, self._pipe)
-            self._telemetry_storage.add_latency_to_pipe(operation, latency, self._pipe)
-            result = self._pipe.execute()
+            pipe = self._make_pipe()
+            self._impression_storage.add_impressions_to_pipe(impressions, pipe)
+            self._telemetry_storage.add_latency_to_pipe(operation, latency, pipe)
+            result = pipe.execute()
             if len(result) == 2:
                 self._impression_storage.expire_key(result[0], len(impressions))
         except Exception:  # pylint: disable=broad-except

tests/client/test_factory.py

@@ -130,11 +130,11 @@ def test_redis_client_creation(self, mocker):
             ssl_cert_reqs='some_cert_req',
             ssl_ca_certs='some_ca_cert',
             max_connections=999
-        ), mocker.call().pipeline()]
+        )]
         assert factory._labels_enabled is False
         assert isinstance(factory._recorder, PipelinedRecorder)
         assert isinstance(factory._recorder._impressions_manager, ImpressionsManager)
-        assert isinstance(factory._recorder._pipe, RedisPipelineAdapter)
+        assert isinstance(factory._recorder._make_pipe(), RedisPipelineAdapter)
         assert isinstance(factory._recorder._telemetry_storage, redis.RedisTelemetryStorage)
         assert isinstance(factory._recorder._event_sotrage, redis.RedisEventsStorage)
         assert isinstance(factory._recorder._impression_storage, redis.RedisImpressionsStorage)

tests/integration/test_client_e2e.py

@@ -519,8 +519,8 @@ def setup_method(self):
             'events': RedisEventsStorage(redis_client, metadata),
             'telemetry': RedisTelemetryStorage(redis_client, metadata)
         }
-        impmanager = ImpressionsManager(storages['impressions'].put, ImpressionsMode.DEBUG)
-        recorder = PipelinedRecorder(redis_client, impmanager, storages['telemetry'],
+        impmanager = ImpressionsManager(ImpressionsMode.DEBUG, False)
+        recorder = PipelinedRecorder(redis_client.pipeline, impmanager, storages['telemetry'],
                                      storages['events'], storages['impressions'])
         self.factory = SplitFactory('some_api_key', storages, True, recorder)  # pylint:disable=attribute-defined-outside-init
 
@@ -802,7 +802,7 @@ def setup_method(self):
             'telemetry': RedisTelemetryStorage(redis_client, metadata)
         }
         impmanager = ImpressionsManager(storages['impressions'].put, ImpressionsMode.DEBUG)
-        recorder = PipelinedRecorder(redis_client, impmanager, storages['telemetry'],
+        recorder = PipelinedRecorder(redis_client.pipeline, impmanager, storages['telemetry'],
                                      storages['events'], storages['impressions'])
         self.factory = SplitFactory('some_api_key', storages, True, recorder)  # pylint:disable=attribute-defined-outside-init