added tests for client, factory and input validator

Author: chillaq

splitio/client/client.py

@@ -18,7 +18,7 @@ class ClientBase(object):  # pylint: disable=too-many-instance-attributes
 
     _FAILED_EVAL_RESULT = {
         'treatment': CONTROL,
-        'config': None,
+        'configurations': None,
         'impression': {
             'label': Label.EXCEPTION,
             'change_number': None,
@@ -86,8 +86,6 @@ def _validate_treatment_input(key, feature, attributes, method):
         matching_key, bucketing_key = input_validator.validate_key(key, 'get_' + method.value)
         if not matching_key:
             raise _InvalidInputError()
-#        if bucketing_key is None:
-#            bucketing_key = matching_key
 
         feature = input_validator.validate_feature_flag_name(feature, 'get_' + method.value)
         if not feature:
@@ -104,8 +102,6 @@ def _validate_treatments_input(key, features, attributes, method):
         matching_key, bucketing_key = input_validator.validate_key(key, 'get_' + method.value)
         if not matching_key:
             raise _InvalidInputError()
-#        if bucketing_key is None:
-#            bucketing_key = matching_key
 
         features = input_validator.validate_feature_flags_get_treatments('get_' + method.value, features)
         if not features:
@@ -426,9 +422,9 @@ def _get_treatments_by_flag_sets(self, key, flag_sets, method, attributes=None):
         :return: Dictionary with the result of all the feature flags provided
         :rtype: dict
         """
-        feature_flags_names = self._get_feature_flag_names_by_flag_sets(flag_sets, method.value)
+        feature_flags_names = self._get_feature_flag_names_by_flag_sets(flag_sets, 'get_' + method.value)
         if feature_flags_names == []:
-            _LOGGER.warning("%s: No valid Flag set or no feature flags found for evaluating treatments" % (method.value))
+            _LOGGER.warning("%s: No valid Flag set or no feature flags found for evaluating treatments", 'get_' + method.value)
             return {}
 
         if 'config' in method.value:
@@ -447,7 +443,7 @@ def _get_feature_flag_names_by_flag_sets(self, flag_sets, method_name):
         :rtype: list
         """
         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)
+        feature_flags_by_set = self._feature_flag_storage.get_feature_flags_by_sets(sanitized_flag_sets)
         if feature_flags_by_set is None:
             _LOGGER.warning("Fetching feature flags for flag set %s encountered an error, skipping this flag set." % (flag_sets))
             return []
@@ -733,6 +729,113 @@ async def get_treatments_with_config(self, key, feature_flag_names, attributes=N
             _LOGGER.error("AA", exc_info=True)
             return {feature: (CONTROL, None) for feature in feature_flag_names}
 
+    async def get_treatments_by_flag_set(self, key, flag_set, attributes=None):
+            """
+            Get treatments for feature flags that contain given flag set.
+            This method never raises an exception. If there's a problem, the appropriate log message
+            will be generated and the method will return the CONTROL treatment.
+            :param key: The key for which to get the treatment
+            :type key: str
+            :param flag_set: flag set
+            :type flag_sets: str
+            :param attributes: An optional dictionary of attributes
+            :type attributes: dict
+            :return: Dictionary with the result of all the feature flags provided
+            :rtype: dict
+            """
+            return await self._get_treatments_by_flag_sets( key, [flag_set], MethodExceptionsAndLatencies.TREATMENTS_BY_FLAG_SET, attributes)
+
+    async def get_treatments_by_flag_sets(self, key, flag_sets, attributes=None):
+        """
+        Get treatments for feature flags that contain given flag sets.
+        This method never raises an exception. If there's a problem, the appropriate log message
+        will be generated and the method will return the CONTROL treatment.
+        :param key: The key for which to get the treatment
+        :type key: str
+        :param flag_sets: list of flag sets
+        :type flag_sets: list
+        :param attributes: An optional dictionary of attributes
+        :type attributes: dict
+        :return: Dictionary with the result of all the feature flags provided
+        :rtype: dict
+        """
+        return await self._get_treatments_by_flag_sets( key, flag_sets, MethodExceptionsAndLatencies.TREATMENTS_BY_FLAG_SETS, attributes)
+
+    async def get_treatments_with_config_by_flag_set(self, key, flag_set, attributes=None):
+        """
+        Get treatments for feature flags that contain given flag set.
+        This method never raises an exception. If there's a problem, the appropriate log message
+        will be generated and the method will return the CONTROL treatment.
+        :param key: The key for which to get the treatment
+        :type key: str
+        :param flag_set: flag set
+        :type flag_sets: str
+        :param attributes: An optional dictionary of attributes
+        :type attributes: dict
+        :return: Dictionary with the result of all the feature flags provided
+        :rtype: dict
+        """
+        return await self._get_treatments_by_flag_sets( key, [flag_set], MethodExceptionsAndLatencies.TREATMENTS_WITH_CONFIG_BY_FLAG_SET, attributes)
+
+    async def get_treatments_with_config_by_flag_sets(self, key, flag_sets, attributes=None):
+        """
+        Get treatments for feature flags that contain given flag set.
+        This method never raises an exception. If there's a problem, the appropriate log message
+        will be generated and the method will return the CONTROL treatment.
+        :param key: The key for which to get the treatment
+        :type key: str
+        :param flag_set: flag set
+        :type flag_sets: str
+        :param attributes: An optional dictionary of attributes
+        :type attributes: dict
+        :return: Dictionary with the result of all the feature flags provided
+        :rtype: dict
+        """
+        return await self._get_treatments_by_flag_sets( key, flag_sets, MethodExceptionsAndLatencies.TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, attributes)
+
+    async def _get_treatments_by_flag_sets(self, key, flag_sets, method, attributes=None):
+        """
+        Get treatments for feature flags that contain given flag sets.
+        This method never raises an exception. If there's a problem, the appropriate log message
+        will be generated and the method will return the CONTROL treatment.
+        :param key: The key for which to get the treatment
+        :type key: str
+        :param flag_sets: list of flag sets
+        :type flag_sets: list
+        :param method: Treatment by flag set method flavor
+        :type method: splitio.models.telemetry.MethodExceptionsAndLatencies
+        :param attributes: An optional dictionary of attributes
+        :type attributes: dict
+        :return: Dictionary with the result of all the feature flags provided
+        :rtype: dict
+        """
+        feature_flags_names = await self._get_feature_flag_names_by_flag_sets(flag_sets, 'get_' + method.value)
+        if feature_flags_names == []:
+            _LOGGER.warning("%s: No valid Flag set or no feature flags found for evaluating treatments", 'get_' + method.value)
+            return {}
+
+        if 'config' in method.value:
+            return await self._get_treatments(key, feature_flags_names, method, attributes)
+
+        with_config = await self._get_treatments(key, feature_flags_names, method, attributes)
+        return {feature_flag: result[0] for (feature_flag, result) in with_config.items()}
+
+
+    async def _get_feature_flag_names_by_flag_sets(self, flag_sets, method_name):
+        """
+        Sanitize given flag sets and return list of feature flag names associated with them
+        :param flag_sets: list of flag sets
+        :type flag_sets: list
+        :return: list of feature flag names
+        :rtype: list
+        """
+        sanitized_flag_sets = input_validator.validate_flag_sets(flag_sets, method_name)
+        feature_flags_by_set = await self._feature_flag_storage.get_feature_flags_by_sets(sanitized_flag_sets)
+        if feature_flags_by_set is None:
+            _LOGGER.warning("Fetching feature flags for flag set %s encountered an error, skipping this flag set." % (flag_sets))
+            return []
+        return feature_flags_by_set
+
     async def _get_treatments(self, key, features, method, attributes=None):
         """
         Validate key, feature flag names and objects, and get the treatments and configs with an optional dictionary of attributes, for async calls

splitio/client/factory.py

@@ -1240,7 +1240,10 @@ def get_factory(api_key, **kwargs):
     _INSTANTIATED_FACTORIES.update([api_key])
     _INSTANTIATED_FACTORIES_LOCK.release()
 
-    config = sanitize_config(api_key, kwargs.get('config', {}))
+    config_raw = kwargs.get('config', {})
+    total_flag_sets, invalid_flag_sets = _get_total_and_invalid_flag_sets(config_raw)
+
+    config = sanitize_config(api_key, config_raw)
 
     if config['operationMode'] == 'localhost':
         split_factory =  _build_localhost_factory(config)
@@ -1256,7 +1259,9 @@ def get_factory(api_key, **kwargs):
         kwargs.get('events_api_base_url'),
         kwargs.get('auth_api_base_url'),
         kwargs.get('streaming_api_base_url'),
-        kwargs.get('telemetry_api_base_url'))
+        kwargs.get('telemetry_api_base_url'),
+        total_flag_sets,
+        invalid_flag_sets)
 
     return split_factory
 
@@ -1285,11 +1290,7 @@ async def get_factory_async(api_key, **kwargs):
     _INSTANTIATED_FACTORIES_LOCK.release()
 
     config_raw = kwargs.get('config', {})
-    total_flag_sets = 0
-    invalid_flag_sets = 0
-    if config_raw.get('flagSetsFilter') is not None and isinstance(config_raw.get('flagSetsFilter'), list):
-        total_flag_sets = len(config_raw.get('flagSetsFilter'))
-        invalid_flag_sets = total_flag_sets - len(input_validator.validate_flag_sets(config_raw.get('flagSetsFilter'), 'Telemetry Init'))
+    total_flag_sets, invalid_flag_sets = _get_total_and_invalid_flag_sets(config_raw)
 
     config = sanitize_config(api_key, config_raw)
     if config['operationMode'] == 'localhost':
@@ -1319,4 +1320,13 @@ def _get_active_and_redundant_count():
         redundant_factory_count += _INSTANTIATED_FACTORIES[item] - 1
         active_factory_count += _INSTANTIATED_FACTORIES[item]
     _INSTANTIATED_FACTORIES_LOCK.release()
-    return redundant_factory_count, active_factory_count
+    return redundant_factory_count, active_factory_count
+
+def _get_total_and_invalid_flag_sets(config_raw):
+    total_flag_sets = 0
+    invalid_flag_sets = 0
+    if config_raw.get('flagSetsFilter') is not None and isinstance(config_raw.get('flagSetsFilter'), list):
+        total_flag_sets = len(config_raw.get('flagSetsFilter'))
+        invalid_flag_sets = total_flag_sets - len(input_validator.validate_flag_sets(config_raw.get('flagSetsFilter'), 'Telemetry Init'))
+
+    return total_flag_sets, invalid_flag_sets

splitio/client/input_validator.py

@@ -95,12 +95,12 @@ def _check_string_matches(value, operation, pattern, name, length):
     """
     if re.search(pattern, value) is None or re.search(pattern, value).group() != value:
         _LOGGER.error(
-            '%s: you passed %s, event_type must ' +
+            '%s: you passed %s, %s must ' +
             'adhere to the regular expression %s. ' +
             'This means %s must be alphanumeric, cannot be more ' +
             'than %s characters long, and can only include a dash, underscore, ' +
             'period, or colon as separators of alphanumeric characters.',
-            operation, value, pattern, name, length
+            operation, value, name, pattern, name, length
         )
         return False
     return True
@@ -166,7 +166,7 @@ def _check_valid_object_key(key, name, operation):
     :return: The result of validation
     :rtype: str|None
     """
-    if not _check_not_null(key, 'key', operation):
+    if not _check_not_null(key, name, operation):
         return None
     if isinstance(key, str):
         if not _check_string_not_empty(key, name, operation):
@@ -196,7 +196,7 @@ def _remove_empty_spaces(value, name, operation):
 def _convert_str_to_lower(value, name, operation):
     lower_value = value.lower()
     if value != lower_value:
-        _LOGGER.warning("%s: %s '%s' should be all lowercase - converting string to lowercase" % (operation, name, value))
+        _LOGGER.warning("%s: %s '%s' should be all lowercase - converting string to lowercase", operation, name, value)
     return lower_value
 
 def validate_key(key, method_name):
@@ -647,7 +647,7 @@ def validate_flag_sets(flag_sets, method_name):
     :rtype: list[str]
     """
     if not isinstance(flag_sets, list):
-        _LOGGER.warning("%s: flag sets parameter type should be list object, parameter is discarded" % (method_name))
+        _LOGGER.warning("%s: flag sets parameter type should be list object, parameter is discarded", method_name)
         return []
 
     sanitized_flag_sets = set()