Removed FallbackConfig object and updated config parameter name

Author: chillaq

splitio/client/config.py

@@ -5,7 +5,7 @@
 
 from splitio.engine.impressions import ImpressionsMode
 from splitio.client.input_validator import validate_flag_sets, validate_fallback_treatment, validate_regex_name
-from splitio.models.fallback_config import FallbackConfig, FallbackTreatmentsConfiguration
+from splitio.models.fallback_config import FallbackTreatmentsConfiguration
 
 _LOGGER = logging.getLogger(__name__)
 DEFAULT_DATA_SAMPLING = 1
@@ -71,7 +71,7 @@ class AuthenticateScheme(Enum):
     'httpAuthenticateScheme': AuthenticateScheme.NONE,
     'kerberosPrincipalUser': None,
     'kerberosPrincipalPassword': None,
-    'fallbackTreatmentsConfiguration': FallbackTreatmentsConfiguration(None)
+    'fallbackTreatments': FallbackTreatmentsConfiguration(None)
 }
 
 def _parse_operation_mode(sdk_key, config):
@@ -175,32 +175,26 @@ def sanitize(sdk_key, config):
     return processed
 
 def _sanitize_fallback_config(config, processed):
-    if config.get('fallbackTreatmentsConfiguration') is not None:
-        if not isinstance(config['fallbackTreatmentsConfiguration'], FallbackTreatmentsConfiguration):
-            _LOGGER.warning('Config: fallbackTreatmentsConfiguration parameter should be of `FallbackTreatmentsConfiguration` class.')
-            processed['fallbackTreatmentsConfiguration'] = FallbackTreatmentsConfiguration(None)
+    if config.get('fallbackTreatments') is not None:
+        if not isinstance(config['fallbackTreatments'], FallbackTreatmentsConfiguration):
+            _LOGGER.warning('Config: fallbackTreatments parameter should be of `FallbackTreatmentsConfiguration` class.')
+            processed['fallbackTreatments'] = None
             return processed        
-    
-        if config['fallbackTreatmentsConfiguration'].fallback_config != None:
-            if not isinstance(config['fallbackTreatmentsConfiguration'].fallback_config, FallbackConfig):
-                _LOGGER.warning('Config: fallback_config parameter should be of `FallbackConfig` class.')
-                processed['fallbackTreatmentsConfiguration'].fallback_config = FallbackConfig(None, None)
-                return processed        
-            
-            if config['fallbackTreatmentsConfiguration'].fallback_config.global_fallback_treatment is not None and not validate_fallback_treatment(config['fallbackTreatmentsConfiguration'].fallback_config.global_fallback_treatment):
-                _LOGGER.warning('Config: global fallbacktreatment parameter is discarded.')
-                processed['fallbackTreatmentsConfiguration'].fallback_config.global_fallback_treatment = None
-                return processed
-            
-            if config['fallbackTreatmentsConfiguration'].fallback_config.by_flag_fallback_treatment is not None:
-                sanitized_flag_fallback_treatments = {}
-                for feature_name in config['fallbackTreatmentsConfiguration'].fallback_config.by_flag_fallback_treatment.keys():
-                    if not validate_regex_name(feature_name) or not validate_fallback_treatment(config['fallbackTreatmentsConfiguration'].fallback_config.by_flag_fallback_treatment[feature_name]):
-                        _LOGGER.warning('Config: fallback treatment parameter for feature flag %s is discarded.', feature_name)
-                        continue
-                                    
-                    sanitized_flag_fallback_treatments[feature_name] = config['fallbackTreatmentsConfiguration'].fallback_config.by_flag_fallback_treatment[feature_name]
-
-                processed['fallbackTreatmentsConfiguration'].fallback_config = FallbackConfig(config['fallbackTreatmentsConfiguration'].fallback_config.global_fallback_treatment, sanitized_flag_fallback_treatments)
-    
+        
+        sanitized_global_fallback_treatment = config['fallbackTreatments'].global_fallback_treatment
+        if config['fallbackTreatments'].global_fallback_treatment is not None and not validate_fallback_treatment(config['fallbackTreatments'].global_fallback_treatment):
+            _LOGGER.warning('Config: global fallbacktreatment parameter is discarded.')
+            sanitized_global_fallback_treatment = None
+        
+        sanitized_flag_fallback_treatments = {}
+        if config['fallbackTreatments'].by_flag_fallback_treatment is not None:
+            for feature_name in config['fallbackTreatments'].by_flag_fallback_treatment.keys():
+                if not validate_regex_name(feature_name) or not validate_fallback_treatment(config['fallbackTreatments'].by_flag_fallback_treatment[feature_name]):
+                    _LOGGER.warning('Config: fallback treatment parameter for feature flag %s is discarded.', feature_name)
+                    continue
+                                
+                sanitized_flag_fallback_treatments[feature_name] = config['fallbackTreatments'].by_flag_fallback_treatment[feature_name]
+
+        processed['fallbackTreatments'] = FallbackTreatmentsConfiguration(sanitized_global_fallback_treatment, sanitized_flag_fallback_treatments)
+
     return processed

splitio/client/input_validator.py

@@ -8,6 +8,7 @@
 from splitio.client.key import Key
 from splitio.client import client
 from splitio.engine.evaluator import CONTROL
+from splitio.models.fallback_treatment import FallbackTreatment
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -715,6 +716,10 @@ def validate_flag_sets(flag_sets, method_name):
     return list(sanitized_flag_sets)
 
 def validate_fallback_treatment(fallback_treatment):
+    if not isinstance(fallback_treatment, FallbackTreatment):
+        _LOGGER.warning("Config: Fallback treatment instance should be FallbackTreatment, input is discarded")
+        return False
+        
     if not validate_regex_name(fallback_treatment.treatment):
         _LOGGER.warning("Config: Fallback treatment should match regex %s", _FALLBACK_TREATMENT_REGEX)
         return False

splitio/models/fallback_config.py

@@ -1,32 +1,7 @@
 """Segment module."""
 
 class FallbackTreatmentsConfiguration(object):
-    """FallbackConfiguration object class."""
-
-    def __init__(self, fallback_config):
-        """
-        Class constructor.
-
-        :param fallback_config: fallback config object.
-        :type fallback_config: FallbackConfig
-
-        :param by_flag_fallback_treatment: Dict of flags and their fallback treatment
-        :type by_flag_fallback_treatment: {str: FallbackTreatment}
-        """
-        self._fallback_config = fallback_config
-        
-    @property
-    def fallback_config(self):
-        """Return fallback config."""
-        return self._fallback_config
-    
-    @fallback_config.setter
-    def fallback_config(self, new_value):
-        """Set fallback config."""
-        self._fallback_config = new_value
-
-class FallbackConfig(object):
-    """FallbackConfig object class."""
+    """FallbackTreatmentsConfiguration object class."""
 
     def __init__(self, global_fallback_treatment=None, by_flag_fallback_treatment=None):
         """

splitio/models/fallback_treatment.py

@@ -2,7 +2,7 @@
 import json
 
 class FallbackTreatment(object):
-    """Segment object class."""
+    """FallbackTreatment object class."""
 
     def __init__(self, treatment, config=None):
         """

tests/client/test_config.py

@@ -4,7 +4,7 @@
 from splitio.client import config
 from splitio.engine.impressions.impressions import ImpressionsMode
 from splitio.models.fallback_treatment import FallbackTreatment
-from splitio.models.fallback_config import FallbackConfig, FallbackTreatmentsConfiguration
+from splitio.models.fallback_config import FallbackTreatmentsConfiguration
 
 class ConfigSanitizationTests(object):
     """Inmemory storage-based integration tests."""
@@ -92,34 +92,34 @@ def test_sanitize(self, mocker):
         assert processed['httpAuthenticateScheme'] is config.AuthenticateScheme.NONE
 
         _logger.reset_mock()
-        processed = config.sanitize('some', {'fallbackTreatmentsConfiguration': 'NONE'})
-        assert processed['fallbackTreatmentsConfiguration'].fallback_config == None
-        assert _logger.warning.mock_calls[1] == mocker.call("Config: fallbackTreatmentsConfiguration parameter should be of `FallbackTreatmentsConfiguration` class.")
+        processed = config.sanitize('some', {'fallbackTreatments': 'NONE'})
+        assert processed['fallbackTreatments'] == None
+        assert _logger.warning.mock_calls[1] == mocker.call("Config: fallbackTreatments parameter should be of `FallbackTreatmentsConfiguration` class.")
 
         _logger.reset_mock()
-        processed = config.sanitize('some', {'fallbackTreatmentsConfiguration': FallbackTreatmentsConfiguration(123)})
-        assert processed['fallbackTreatmentsConfiguration'].fallback_config.global_fallback_treatment == None
-        assert _logger.warning.mock_calls[1] == mocker.call("Config: fallback_config parameter should be of `FallbackConfig` class.")
+        processed = config.sanitize('some', {'fallbackTreatments': FallbackTreatmentsConfiguration(123)})
+        assert processed['fallbackTreatments'].global_fallback_treatment == None
+        assert _logger.warning.mock_calls[1] == mocker.call("Config: global fallbacktreatment parameter is discarded.")
 
         _logger.reset_mock()
-        processed = config.sanitize('some', {'fallbackTreatmentsConfiguration': FallbackTreatmentsConfiguration(FallbackConfig(FallbackTreatment("123")))})
-        assert processed['fallbackTreatmentsConfiguration'].fallback_config.global_fallback_treatment == None
+        processed = config.sanitize('some', {'fallbackTreatments': FallbackTreatmentsConfiguration(FallbackTreatment("123"))})
+        assert processed['fallbackTreatments'].global_fallback_treatment == None
         assert _logger.warning.mock_calls[1] == mocker.call("Config: global fallbacktreatment parameter is discarded.")
 
-        fb = FallbackTreatmentsConfiguration(FallbackConfig(FallbackTreatment('on')))
-        processed = config.sanitize('some', {'fallbackTreatmentsConfiguration': fb})
-        assert processed['fallbackTreatmentsConfiguration'].fallback_config.global_fallback_treatment.treatment == fb.fallback_config.global_fallback_treatment.treatment
-        assert processed['fallbackTreatmentsConfiguration'].fallback_config.global_fallback_treatment.label_prefix == "fallback - "
+        fb = FallbackTreatmentsConfiguration(FallbackTreatment('on'))
+        processed = config.sanitize('some', {'fallbackTreatments': fb})
+        assert processed['fallbackTreatments'].global_fallback_treatment.treatment == fb.global_fallback_treatment.treatment
+        assert processed['fallbackTreatments'].global_fallback_treatment.label_prefix == "fallback - "
 
-        fb = FallbackTreatmentsConfiguration(FallbackConfig(FallbackTreatment('on'), {"flag": FallbackTreatment("off")}))
-        processed = config.sanitize('some', {'fallbackTreatmentsConfiguration': fb})
-        assert processed['fallbackTreatmentsConfiguration'].fallback_config.global_fallback_treatment.treatment == fb.fallback_config.global_fallback_treatment.treatment
-        assert processed['fallbackTreatmentsConfiguration'].fallback_config.by_flag_fallback_treatment["flag"] == fb.fallback_config.by_flag_fallback_treatment["flag"]
-        assert processed['fallbackTreatmentsConfiguration'].fallback_config.by_flag_fallback_treatment["flag"].label_prefix == "fallback - "
+        fb = FallbackTreatmentsConfiguration(FallbackTreatment('on'), {"flag": FallbackTreatment("off")})
+        processed = config.sanitize('some', {'fallbackTreatments': fb})
+        assert processed['fallbackTreatments'].global_fallback_treatment.treatment == fb.global_fallback_treatment.treatment
+        assert processed['fallbackTreatments'].by_flag_fallback_treatment["flag"] == fb.by_flag_fallback_treatment["flag"]
+        assert processed['fallbackTreatments'].by_flag_fallback_treatment["flag"].label_prefix == "fallback - "
 
         _logger.reset_mock()
-        fb = FallbackTreatmentsConfiguration(FallbackConfig(None, {"flag#%": FallbackTreatment("off"), "flag2": FallbackTreatment("on")}))
-        processed = config.sanitize('some', {'fallbackTreatmentsConfiguration': fb})
-        assert len(processed['fallbackTreatmentsConfiguration'].fallback_config.by_flag_fallback_treatment) == 1
-        assert processed['fallbackTreatmentsConfiguration'].fallback_config.by_flag_fallback_treatment.get("flag2") == fb.fallback_config.by_flag_fallback_treatment["flag2"]
+        fb = FallbackTreatmentsConfiguration(None, {"flag#%": FallbackTreatment("off"), "flag2": FallbackTreatment("on")})
+        processed = config.sanitize('some', {'fallbackTreatments': fb})
+        assert len(processed['fallbackTreatments'].by_flag_fallback_treatment) == 1
+        assert processed['fallbackTreatments'].by_flag_fallback_treatment.get("flag2") == fb.by_flag_fallback_treatment["flag2"]
         assert _logger.warning.mock_calls[1] == mocker.call('Config: fallback treatment parameter for feature flag %s is discarded.', 'flag#%')

tests/models/test_fallback.py

@@ -1,5 +1,5 @@
 from splitio.models.fallback_treatment import FallbackTreatment
-from splitio.models.fallback_config import FallbackConfig
+from splitio.models.fallback_config import FallbackTreatmentsConfiguration
 
 class FallbackTreatmentModelTests(object):
     """Fallback treatment model tests."""
@@ -13,13 +13,13 @@ def test_working(self):
         assert fallback_treatment.config == None
         assert fallback_treatment.treatment == 'off'
 
-class FallbackConfigModelTests(object):
+class FallbackTreatmentsConfigModelTests(object):
     """Fallback treatment model tests."""
 
     def test_working(self):
         global_fb = FallbackTreatment("on")
         flag_fb = FallbackTreatment("off")
-        fallback_config = FallbackConfig(global_fb, {"flag1": flag_fb})
+        fallback_config = FallbackTreatmentsConfiguration(global_fb, {"flag1": flag_fb})
         assert fallback_config.global_fallback_treatment == global_fb
         assert fallback_config.by_flag_fallback_treatment == {"flag1": flag_fb}