adding test coverage

Author: Matias Melograno

splitio/client/factory.py

@@ -441,6 +441,10 @@ def _build_uwsgi_factory(api_key, cfg):
         storages['events'],
         storages['impressions'],
     )
+    _LOGGER.warning(
+        "Beware: uwsgi-cache based operation mode is soon to be deprecated. Please consider " +
+        "redis if you need a centralized point of syncrhonization, or in-memory (with preforking " +
+        "support enabled) if running uwsgi with a master and several http workers)")
     return SplitFactory(
         api_key,
         storages,

tests/client/test_client.py

@@ -3,7 +3,7 @@
 
 import json
 import os
-from splitio.client.client import Client, _LOGGER as _logger
+from splitio.client.client import Client, _LOGGER as _logger, CONTROL
 from splitio.client.factory import SplitFactory
 from splitio.engine.evaluator import Evaluator
 from splitio.models.impressions import Impression, Label
@@ -357,40 +357,38 @@ def _get_storage_mock(name):
         assert client.destroyed is not None
         assert destroyed_mock.mock_calls == [mocker.call()]
 
-    def test_track(self, mocker):
-        """Test that destroy/destroyed calls are forwarded to the factory."""
-        split_storage = mocker.Mock(spec=SplitStorage)
-        segment_storage = mocker.Mock(spec=SegmentStorage)
-        impression_storage = mocker.Mock(spec=ImpressionStorage)
-        event_storage = mocker.Mock(spec=EventStorage)
-        event_storage.put.return_value = True
-        telemetry_storage = mocker.Mock(spec=TelemetryStorage)
+    def test_evaluations_before_running_post_fork(self, mocker):
+        destroyed_property = mocker.PropertyMock()
+        destroyed_property.return_value = False
 
-        def _get_storage_mock(name):
-            return {
-                'splits': split_storage,
-                'segments': segment_storage,
-                'impressions': impression_storage,
-                'events': event_storage,
-                'telemetry': telemetry_storage
-            }[name]
         factory = mocker.Mock(spec=SplitFactory)
-        factory._get_storage = _get_storage_mock
-        destroyed_mock = mocker.PropertyMock()
-        destroyed_mock.return_value = False
-        factory._waiting_fork.return_value = False
-        type(factory).destroyed = destroyed_mock
-        factory._apikey = 'test'
-        mocker.patch('splitio.client.client.utctime_ms', new=lambda: 1000)
+        factory._waiting_fork.return_value = True
+        type(factory).destroyed = destroyed_property
 
-        impmanager = mocker.Mock(spec=ImpressionManager)
-        recorder = StandardRecorder(impmanager, telemetry_storage, event_storage,
-                                    impression_storage)
-        client = Client(factory, recorder, True)
-        assert client.track('key', 'user', 'purchase', 12) is True
-        assert mocker.call([
-            EventWrapper(
-                event=Event('key', 'user', 'purchase', 12, 1000, None),
-                size=1024
-            )
-        ]) in event_storage.put.mock_calls
+        expected_msg = [
+            mocker.call('Client is not ready - no calls possible')
+        ]
+
+        client = Client(factory, mocker.Mock())
+        _logger = mocker.Mock()
+        mocker.patch('splitio.client.client._LOGGER', new=_logger)
+
+        assert client.get_treatment('some_key', 'some_feature') == CONTROL
+        assert _logger.error.mock_calls == expected_msg
+        _logger.reset_mock()
+
+        assert client.get_treatment_with_config('some_key', 'some_feature') == (CONTROL, None)
+        assert _logger.error.mock_calls == expected_msg
+        _logger.reset_mock()
+
+        assert client.track("some_key", "traffic_type", "event_type", None) is False
+        assert _logger.error.mock_calls == expected_msg
+        _logger.reset_mock()
+
+        assert client.get_treatments(None, ['some_feature']) == {'some_feature': CONTROL}
+        assert _logger.error.mock_calls == expected_msg
+        _logger.reset_mock()
+
+        assert client.get_treatments_with_config('some_key', ['some_feature']) == {'some_feature': (CONTROL, None)}
+        assert _logger.error.mock_calls == expected_msg
+        _logger.reset_mock()

tests/client/test_factory.py

@@ -4,7 +4,7 @@
 
 import time
 import threading
-from splitio.client.factory import get_factory, SplitFactory, _INSTANTIATED_FACTORIES
+from splitio.client.factory import get_factory, SplitFactory, _INSTANTIATED_FACTORIES, Status
 from splitio.client.config import DEFAULT_CONFIG
 from splitio.storage import redis, inmemmory, uwsgi
 from splitio.tasks import events_sync, impressions_sync, split_sync, segment_sync, telemetry_sync
@@ -161,6 +161,28 @@ def test_uwsgi_client_creation(self):
         assert factory.ready
         factory.destroy()
 
+    def test_uwsgi_forked_client_creation(self):
+        """Test client with preforked initialization."""
+        factory = get_factory('some_api_key', config={'preforkedInitialization': True})
+        assert isinstance(factory._storages['splits'], inmemmory.InMemorySplitStorage)
+        assert isinstance(factory._storages['segments'], inmemmory.InMemorySegmentStorage)
+        assert isinstance(factory._storages['impressions'], inmemmory.InMemoryImpressionStorage)
+        assert factory._storages['impressions']._impressions.maxsize == 10000
+        assert isinstance(factory._storages['events'], inmemmory.InMemoryEventStorage)
+        assert factory._storages['events']._events.maxsize == 10000
+        assert isinstance(factory._storages['telemetry'], inmemmory.InMemoryTelemetryStorage)
+
+        assert isinstance(factory._sync_manager, Manager)
+
+        assert isinstance(factory._recorder, StandardRecorder)
+        assert isinstance(factory._recorder._impressions_manager, ImpressionsManager)
+        assert isinstance(factory._recorder._telemetry_storage, inmemmory.TelemetryStorage)
+        assert isinstance(factory._recorder._event_sotrage, inmemmory.EventStorage)
+        assert isinstance(factory._recorder._impression_storage, inmemmory.ImpressionStorage)
+
+        assert factory._status == Status.WAITING_FORK
+        factory.destroy()
+
     def test_destroy(self, mocker):
         """Test that tasks are shutdown and data is flushed when destroy is called."""
 
@@ -461,3 +483,42 @@ def _make_factory_with_apikey(apikey, *_, **__):
         factory2.destroy()
         factory3.destroy()
         factory4.destroy()
+
+    def test_uwsgi_preforked(self, mocker):
+        """Test preforked initializations."""
+        global called_sync_all
+        called_sync_all = 0
+        global called_start
+        called_start = 0
+        global called_recreate
+        called_recreate = 0
+
+        # Mocking
+        def _sync_all(self):
+            print('here')
+            global called_sync_all
+            called_sync_all += 1
+        mocker.patch('splitio.sync.synchronizer.Synchronizer.sync_all', new=_sync_all)
+
+        def _start(self):
+            global called_start
+            called_start += 1
+        mocker.patch('splitio.sync.manager.Manager.start', new=_start)
+
+        def _recreate(self):
+            global called_recreate
+            called_recreate += 1
+        mocker.patch('splitio.sync.manager.Manager.recreate', new=_recreate)
+
+        config = {
+            'preforkedInitialization': True,
+        }
+        factory = get_factory("none", config=config)
+        factory.block_until_ready(10)
+        assert factory._status == Status.WAITING_FORK
+        assert called_sync_all == 1
+        assert called_start == 0
+
+        factory.handle_post_fork()
+        assert called_recreate == 1
+        assert called_start == 1

tests/sync/test_segments_synchronizer.py

@@ -128,3 +128,10 @@ def fetch_segment_mock(segment_name, change_number):
         api_calls = [call for call in api.fetch_segment.mock_calls]
         assert mocker.call('segmentA', -1) in api_calls
         assert mocker.call('segmentA', 123) in api_calls
+
+    def test_recreate(self, mocker):
+        """Test recreate logic."""
+        segments_synchronizer = SegmentSynchronizer(mocker.Mock(), mocker.Mock(), mocker.Mock())
+        current_pool = segments_synchronizer._worker_pool
+        segments_synchronizer.recreate()
+        assert segments_synchronizer._worker_pool != current_pool