Merge pull request #466 from splitio/flagsets-test-integration

Fixed all tests

Author: chillaq

splitio/client/client.py

@@ -431,11 +431,10 @@ def _get_feature_flag_names_by_flag_sets(self, flag_sets, method_name):
         sanitized_flag_sets = input_validator.validate_flag_sets(flag_sets, method_name)
         feature_flags_by_set = self._split_storage.get_feature_flags_by_sets(sanitized_flag_sets)
         if feature_flags_by_set is None:
-            _LOGGER.warning("%s: Fetching feature flags for flag set %s encountered an error, skipping this flag set." % (method_name, flag_sets))
+            _LOGGER.warning("Fetching feature flags for flag set %s encountered an error, skipping this flag set." % (flag_sets))
             return []
         return feature_flags_by_set
 
-
     def _build_impression(  # pylint: disable=too-many-arguments
             self,
             matching_key,

splitio/client/config.py

@@ -143,6 +143,6 @@ def sanitize(sdk_key, config):
         _LOGGER.warning('metricRefreshRate parameter minimum value is 60 seconds, defaulting to 3600 seconds.')
         processed['metricsRefreshRate'] = 3600
 
-    processed['flagSetsFilter'] = validate_flag_sets(processed['flagSetsFilter'], 'SDK Config') if processed['flagSetsFilter'] is not None else None
+    processed['flagSetsFilter'] = sorted(validate_flag_sets(processed['flagSetsFilter'], 'SDK Config')) if processed['flagSetsFilter'] is not None else None
 
     return processed

splitio/client/factory.py

@@ -600,7 +600,7 @@ def _build_localhost_factory(cfg):
     telemetry_evaluation_producer = telemetry_producer.get_telemetry_evaluation_producer()
 
     storages = {
-        'splits': InMemorySplitStorage(),
+        'splits': InMemorySplitStorage(cfg['flagSetsFilter'] if cfg['flagSetsFilter'] is not None else []),
         'segments': InMemorySegmentStorage(),  # not used, just to avoid possible future errors.
         'impressions': LocalhostImpressionsStorage(),
         'events': LocalhostEventsStorage(),

splitio/client/input_validator.py

@@ -80,6 +80,7 @@ def _check_string_not_empty(value, name, operation):
     return True
 
 
+
 def _check_string_matches(value, operation, pattern, name, length):
     """
     Check if value is adhere to a regular expression passed.

splitio/engine/telemetry.py

@@ -222,17 +222,27 @@ def pop_formatted_stats(self):
         exceptions = self.pop_exceptions()['methodExceptions']
         latencies = self.pop_latencies()['methodLatencies']
         return {
-            'mE': {'t': exceptions['treatment'],
-                      'ts': exceptions['treatments'],
-                      'tc': exceptions['treatment_with_config'],
-                      'tcs': exceptions['treatments_with_config'],
-                      'tr': exceptions['track']
+            'mE': {
+                't': exceptions['treatment'],
+                'ts': exceptions['treatments'],
+                'tc': exceptions['treatment_with_config'],
+                'tcs': exceptions['treatments_with_config'],
+                'tf': exceptions['treatments_by_flag_set'],
+                'tfs': exceptions['treatments_by_flag_sets'],
+                'tcf': exceptions['treatments_with_config_by_flag_set'],
+                'tcfs': exceptions['treatments_with_config_by_flag_sets'],
+                'tr': exceptions['track']
                },
-            'mL':  {'t': latencies['treatment'],
-                      'ts': latencies['treatments'],
-                      'tc': latencies['treatment_with_config'],
-                      'tcs': latencies['treatments_with_config'],
-                      'tr': latencies['track']
+            'mL':  {
+                't': latencies['treatment'],
+                'ts': latencies['treatments'],
+                'tc': latencies['treatment_with_config'],
+                'tcs': latencies['treatments_with_config'],
+                'tf': latencies['treatments_by_flag_set'],
+                'tfs': latencies['treatments_by_flag_sets'],
+                'tcf': latencies['treatments_with_config_by_flag_set'],
+                'tcfs': latencies['treatments_with_config_by_flag_sets'],
+                'tr': latencies['track']
                },
         }
 

splitio/models/splits.py

@@ -183,7 +183,7 @@ def to_json(self):
             'algo': self.algo.value,
             'conditions': [c.to_json() for c in self.conditions],
             'configurations': self._configurations,
-            'sets': self._sets
+            'sets': list(self._sets)
         }
 
     def to_split_view(self):
@@ -200,7 +200,7 @@ def to_split_view(self):
             list(set(part.treatment for cond in self.conditions for part in cond.partitions)),
             self.change_number,
             self._configurations if self._configurations is not None else {},
-            self._sets if self._sets is not None else []
+            list(self._sets) if self._sets is not None else []
         )
 
     def local_kill(self, default_treatment, change_number):
@@ -250,5 +250,5 @@ def from_raw(raw_split):
         traffic_allocation=raw_split.get('trafficAllocation'),
         traffic_allocation_seed=raw_split.get('trafficAllocationSeed'),
         configurations=raw_split.get('configurations'),
-        sets=raw_split.get('sets')
+        sets=set(raw_split.get('sets')) if raw_split.get('sets') is not None else []
     )

splitio/models/telemetry.py

@@ -41,7 +41,6 @@ class _ConfigParams(Enum):
     EVENTS_QUEUE_SIZE = 'eventsQueueSize'
     IMPRESSIONS_MODE = 'impressionsMode'
     IMPRESSIONS_LISTENER = 'impressionListener'
-    FLAG_SETS = 'flagSetsFilter'
 
 class _ExtraConfig(Enum):
     """Extra config constants"""
@@ -829,7 +828,6 @@ def record_config(self, config, extra_config):
             self._impressions_mode = self._get_impressions_mode(config[_ConfigParams.IMPRESSIONS_MODE.value])
             self._impression_listener = True if config[_ConfigParams.IMPRESSIONS_LISTENER.value] is not None else False
             self._http_proxy = self._check_if_proxy_detected()
-            self._flag_sets = len(config[_ConfigParams.FLAG_SETS.value]) if config[_ConfigParams.FLAG_SETS.value] is not None else 0
 
     def record_active_and_redundant_factories(self, active_factory_count, redundant_factory_count):
         with self._lock:

splitio/push/manager.py

@@ -143,7 +143,8 @@ def _trigger_connection_flow(self):
             self._feedback_loop.put(Status.PUSH_RETRYABLE_ERROR)
             return
 
-        if not token.push_enabled:
+
+        if token is None or not token.push_enabled:
             self._feedback_loop.put(Status.PUSH_NONRETRYABLE_ERROR)
             return
         self._telemetry_runtime_producer.record_token_refreshes()

splitio/storage/__init__.py

@@ -1,5 +1,6 @@
 """Base storage interfaces."""
 import abc
+import threading
 
 
 class SplitStorage(object, metaclass=abc.ABCMeta):
@@ -315,3 +316,42 @@ def record_bur_time_out(self):
 
         """
         pass
+
+class FlagSetsFilter(object):
+    """Config Flagsets Filter storage."""
+
+    def __init__(self, flag_sets=[]):
+        """Constructor."""
+        self.flag_sets = set(flag_sets)
+        self.should_filter = any(flag_sets)
+
+    def set_exist(self, flag_set):
+        """
+        Check if a flagset exist in flagset filter
+
+        :param flag_set: set name
+        :type flag_set: str
+
+        :rtype: bool
+        """
+        if not self.should_filter:
+            return True
+        if not isinstance(flag_set, str) or flag_set == '':
+            return False
+
+        return any(self.flag_sets.intersection(set([flag_set])))
+
+    def intersect(self, flag_sets):
+        """
+        Check if a set exist in config flagset filter
+
+        :param flag_set: set of flagsets
+        :type flag_set: set
+
+        :rtype: bool
+        """
+        if not self.should_filter:
+            return True
+        if not isinstance(flag_sets, set) or len(flag_sets) == 0:
+            return False
+        return any(self.flag_sets.intersection(flag_sets))

splitio/storage/inmemmory.py

@@ -6,7 +6,7 @@
 
 from splitio.models.segments import Segment
 from splitio.models.telemetry import HTTPErrors, HTTPLatencies, MethodExceptions, MethodLatencies, LastSynchronization, StreamingEvents, TelemetryConfig, TelemetryCounters, CounterConstants
-from splitio.models.flag_sets import FlagSets, FlagSetsFilter
+from splitio.storage import FlagSetsFilter
 from splitio.storage import SplitStorage, SegmentStorage, ImpressionStorage, EventStorage, TelemetryStorage
 
 MAX_SIZE_BYTES = 5 * 1024 * 1024