fixed tests and pluggable fetching flagset

Author: chillaq

splitio/storage/pluggable.py

@@ -36,7 +36,7 @@ def __init__(self, pluggable_adapter, prefix=None, config_flag_sets=[]):
             self._prefix = prefix + "." + self._prefix
             self._traffic_type_prefix = prefix + "." + self._traffic_type_prefix
             self._feature_flag_till_prefix = prefix + "." + self._feature_flag_till_prefix
-            self._feature_flag_set_prefix = prefix + "." + self._feature_flag_till_prefix
+            self._feature_flag_set_prefix = prefix + "." + self._feature_flag_set_prefix
 
     def get(self, feature_flag_name):
         """
@@ -91,13 +91,14 @@ def get_feature_flags_by_sets(self, flag_sets):
                 return []
 
             keys = [self._feature_flag_set_prefix.format(flag_set=flag_set) for flag_set in sets_to_fetch]
-            return self._pluggable_adapter.get_many(keys)
+            result_sets = []
+            [result_sets.append(set(key)) for key in self._pluggable_adapter.get_many(keys)]
+            return list(combine_valid_flag_sets(result_sets))
         except Exception:
             _LOGGER.error('Error fetching feature flag from storage')
             _LOGGER.debug('Error: ', exc_info=True)
             return None
 
-
     # TODO: To be added when producer mode is supported
 #    def put_many(self, splits, change_number):
 #        """

tests/client/test_client.py

@@ -441,9 +441,9 @@ def test_get_treatments_by_flag_sets(self, mocker):
         mocker.patch('splitio.client.client.utctime_ms', new=lambda: 1000)
         mocker.patch('splitio.client.client.get_latency_bucket_index', new=lambda x: 5)
         def get_feature_flags_by_sets(flag_sets):
-            if flag_sets == ['set1', 'set2']:
+            if sorted(flag_sets) == ['set1', 'set2']:
                 return ['f1', 'f2']
-            if flag_sets == ['set3', 'set4']:
+            if sorted(flag_sets) == ['set3', 'set4']:
                 return ['f3', 'f4']
             if flag_sets == ['set5']:
                 return ['some_feature']
@@ -465,6 +465,7 @@ def evaluate_features(feature_flag_names, matching_key, bucketing_key, attribute
         client._evaluator.evaluate_features = evaluate_features
         _logger = mocker.Mock()
         client._send_impression_to_listener = mocker.Mock()
+#        pytest.set_trace()
         assert client.get_treatments_by_flag_sets('key', ['set1', 'set2']) == {'f1': 'on', 'f2': 'on'}
 
         impressions_called = impmanager.process_impressions.mock_calls[0][1][0]
@@ -623,9 +624,9 @@ def test_get_treatments_with_config_by_flag_sets(self, mocker):
         mocker.patch('splitio.client.client.utctime_ms', new=lambda: 1000)
         mocker.patch('splitio.client.client.get_latency_bucket_index', new=lambda x: 5)
         def get_feature_flags_by_sets(flag_sets):
-            if flag_sets == ['set1', 'set2']:
+            if sorted(flag_sets) == ['set1', 'set2']:
                 return ['f1', 'f2']
-            if flag_sets == ['set3', 'set4']:
+            if sorted(flag_sets) == ['set3', 'set4']:
                 return ['f3', 'f4']
             if flag_sets == ['set5']:
                 return ['some_feature']

tests/integration/test_client_e2e.py

@@ -1179,7 +1179,6 @@ def setup_method(self):
             if split.get('sets') is not None:
                 for flag_set in split.get('sets'):
                     self.pluggable_storage_adapter.push_items(split_storage._feature_flag_set_prefix.format(flag_set=flag_set), split['name'])
-
         self.pluggable_storage_adapter.set(split_storage._feature_flag_till_prefix, data['till'])
 
         segment_fn = os.path.join(os.path.dirname(__file__), 'files', 'segmentEmployeesChanges.json')

tests/storage/test_pluggable.py

@@ -85,10 +85,7 @@ def get_many(self, keys):
             returned_keys = []
             for key in self._keys:
                 if key in keys:
-                    if isinstance(self._keys[key], list):
-                        returned_keys.extend(self._keys[key])
-                    else:
-                        returned_keys.append(self._keys[key])
+                    returned_keys.append(self._keys[key])
             return returned_keys
 
     def add_items(self, key, added_items):

tests/sync/test_splits_synchronizer.py

@@ -63,6 +63,14 @@ def run(x, c):
         run._calls = 0
         api.fetch_splits.side_effect = run
         storage.get_change_number.return_value = -1
+        class flag_set_filter():
+            def should_filter():
+                return False
+
+            def intersect(sets):
+                return True
+        storage.flag_set_filter = flag_set_filter
+        storage.flag_set_filter.flag_sets = {}
 
         split_synchronizer = SplitSynchronizer(api, storage)
 
@@ -87,8 +95,8 @@ def should_filter():
 
             def intersect(sets):
                 return True
-
         storage.flag_set_filter = flag_set_filter
+        storage.flag_set_filter.flag_sets = {}
 
         api = mocker.Mock()
         def get_changes(*args, **kwargs):
@@ -112,8 +120,10 @@ def get_changes(*args, **kwargs):
         split_synchronizer = SplitSynchronizer(api, storage)
         split_synchronizer.synchronize_splits()
 
-        assert mocker.call(-1, FetchOptions(True)) in api.fetch_splits.mock_calls
-        assert mocker.call(123, FetchOptions(True)) in api.fetch_splits.mock_calls
+        assert api.fetch_splits.mock_calls[0][1][0] == -1
+        assert api.fetch_splits.mock_calls[0][1][1].cache_control_headers == True
+        assert api.fetch_splits.mock_calls[1][1][0] == 123
+        assert api.fetch_splits.mock_calls[1][1][1].cache_control_headers == True
 
         inserted_split = storage.update.mock_calls[0][1][0][0]
         assert isinstance(inserted_split, Split)
@@ -122,6 +132,14 @@ def get_changes(*args, **kwargs):
     def test_not_called_on_till(self, mocker):
         """Test that sync is not called when till is less than previous changenumber"""
         storage = mocker.Mock(spec=InMemorySplitStorage)
+        class flag_set_filter():
+            def should_filter():
+                return False
+
+            def intersect(sets):
+                return True
+        storage.flag_set_filter = flag_set_filter
+        storage.flag_set_filter.flag_sets = {}
 
         def change_number_mock():
             return 2
@@ -184,17 +202,21 @@ def intersect(sets):
                 return True
 
         storage.flag_set_filter = flag_set_filter
+        storage.flag_set_filter.flag_sets = {}
 
         split_synchronizer = SplitSynchronizer(api, storage)
         split_synchronizer._backoff = Backoff(1, 1)
         split_synchronizer.synchronize_splits()
 
-        assert mocker.call(-1, FetchOptions(True)) in api.fetch_splits.mock_calls
-        assert mocker.call(123, FetchOptions(True)) in api.fetch_splits.mock_calls
+        assert api.fetch_splits.mock_calls[0][1][0] == -1
+        assert api.fetch_splits.mock_calls[0][1][1].cache_control_headers == True
+        assert api.fetch_splits.mock_calls[1][1][0] == 123
+        assert api.fetch_splits.mock_calls[1][1][1].cache_control_headers == True
 
         split_synchronizer._backoff = Backoff(1, 0.1)
         split_synchronizer.synchronize_splits(12345)
-        assert mocker.call(12345, FetchOptions(True, 1234)) in api.fetch_splits.mock_calls
+        assert api.fetch_splits.mock_calls[3][1][0] == 1234
+        assert api.fetch_splits.mock_calls[3][1][1].cache_control_headers == True
         assert len(api.fetch_splits.mock_calls) == 8 # 2 ok + BACKOFF(2 since==till + 2 re-attempts) + CDN(2 since==till)
 
         inserted_split = storage.update.mock_calls[0][1][0][0]

tests/sync/test_synchronizer.py

@@ -23,6 +23,13 @@ class SynchronizerTests(object):
     def test_sync_all_failed_splits(self, mocker):
         api = mocker.Mock()
         storage = mocker.Mock()
+        class flag_set_filter():
+            def should_filter():
+                return False
+            def intersect(sets):
+                return True
+        storage.flag_set_filter = flag_set_filter
+        storage.flag_set_filter.flag_sets = {}
 
         def run(x, c):
             raise APIException("something broke")
@@ -41,6 +48,13 @@ def run(x, c):
     def test_sync_all_failed_splits_with_flagsets(self, mocker):
         api = mocker.Mock()
         storage = mocker.Mock()
+        class flag_set_filter():
+            def should_filter():
+                return False
+            def intersect(sets):
+                return True
+        storage.flag_set_filter = flag_set_filter
+        storage.flag_set_filter.flag_sets = {}
 
         def run(x, c):
             raise APIException("something broke", 414)
@@ -164,11 +178,11 @@ def test_sync_all(self, mocker):
         class flag_set_filter():
             def should_filter():
                 return False
-
             def intersect(sets):
                 return True
-
         split_storage.flag_set_filter = flag_set_filter
+        split_storage.flag_set_filter.flag_sets = {}
+
         split_api = mocker.Mock()
         split_api.fetch_splits.return_value = {'splits': self.splits, 'since': 123,
                                                'till': 123}

tests/tasks/test_split_sync.py

@@ -32,6 +32,7 @@ def should_filter():
             def intersect(sets):
                 return True
         storage.flag_set_filter = flag_set_filter
+        storage.flag_set_filter.flag_sets = {}
 
         api = mocker.Mock()
         splits = [{
@@ -97,8 +98,12 @@ def get_changes(*args, **kwargs):
         task.stop(stop_event)
         stop_event.wait()
         assert not task.is_running()
-        assert mocker.call(-1, fetch_options) in api.fetch_splits.mock_calls
-        assert mocker.call(123, fetch_options) in api.fetch_splits.mock_calls
+        assert api.fetch_splits.mock_calls[0][1][0] == -1
+        assert api.fetch_splits.mock_calls[0][1][1].cache_control_headers == True
+        assert api.fetch_splits.mock_calls[1][1][0] == 123
+        assert api.fetch_splits.mock_calls[1][1][1].cache_control_headers == True
+#        assert mocker.call(-1, fetch_options) in api.fetch_splits.mock_calls
+#        assert mocker.call(123, fetch_options) in api.fetch_splits.mock_calls
 
         inserted_split = storage.update.mock_calls[0][1][0][0]
         assert isinstance(inserted_split, Split)