add tests and start working on caching layer for storages

Author: mredolatti

splitio/client/client.py

@@ -208,12 +208,16 @@ def get_treatments_with_config(self, key, features, attributes=None):
         if input_validator.validate_attributes(attributes) is False:
             return input_validator.generate_control_treatments(features)
 
-        features = input_validator.validate_features_get_treatments(features)
+        features, missing = input_validator.validate_features_get_treatments(
+            features,
+            self.ready,
+            self._factory._get_storage('splits')  # pylint: disable=protected-access
+        )
         if features is None:
             return {}
 
         bulk_impressions = []
-        treatments = {}
+        treatments = {name: (CONTROL, None) for name in missing}
 
         for feature in features:
             try:

splitio/client/input_validator.py

@@ -381,22 +381,22 @@ def validate_manager_feature_name(feature_name):
     return feature_name
 
 
-def validate_features_get_treatments(features):  #pylint: disable=invalid-name
+def validate_features_get_treatments(features, should_validate_existance=False, split_storage=None):  #pylint: disable=invalid-name
     """
     Check if features is valid for get_treatments.
 
     :param features: array of features
     :type features: list
     :return: filtered_features
-    :rtype: list|None
+    :rtype: tuple
     """
     operation = _get_first_split_sdk_call()
     if features is None or not isinstance(features, list):
         _LOGGER.error("%s: feature_names must be a non-empty array.", operation)
-        return None
+        return None, None
     if not features:
         _LOGGER.error("%s: feature_names must be a non-empty array.", operation)
-        return []
+        return None, None
     filtered_features = set(
         _remove_empty_spaces(feature, operation) for feature in features
         if feature is not None and
@@ -405,8 +405,20 @@ def validate_features_get_treatments(features):  #pylint: disable=invalid-name
     )
     if not filtered_features:
         _LOGGER.error("%s: feature_names must be a non-empty array.", operation)
-        return None
-    return filtered_features
+        return None, None
+
+    if not should_validate_existance:
+        return filtered_features, []
+
+    valid_missing_features = set(f for f in filtered_features if split_storage.get(f) is None)
+    for missing_feature in valid_missing_features:
+        _LOGGER.error(
+            "%s: you passed \"%s\" that does not exist in this environment, "
+            "please double check what Splits exist in the web console.",
+            operation,
+            missing_feature
+        )
+    return filtered_features - valid_missing_features, valid_missing_features
 
 
 def generate_control_treatments(features):
@@ -418,7 +430,7 @@ def generate_control_treatments(features):
     :return: dict
     :rtype: dict|None
     """
-    return {feature: (CONTROL, None) for feature in validate_features_get_treatments(features)}
+    return {feature: (CONTROL, None) for feature in validate_features_get_treatments(features)[0]}
 
 
 def validate_attributes(attributes):

splitio/storage/adapters/cache_trait.py

@@ -0,0 +1,58 @@
+"""Caching trait module."""
+
+import threading
+import time
+
+
+class ElementExpiredException(Exception):
+    """Exception to be thrown when an element requested is present but expired."""
+
+    pass
+
+
+class ElementNotPresentException(Exception):
+    """Exception to be thrown when an element requested is not present."""
+
+    pass
+
+
+class LocalMemoryCache(object):
+    """Key/Value local memory cache. with deprecation."""
+
+    def __init__(self, max_age_seconds=5):
+        """Class constructor."""
+        self._data = {}
+        self._lock = threading.RLock()
+        self._max_age_seconds = max_age_seconds
+
+    def set(self, key, value):
+        """
+        Set a key/value pair.
+
+        :param key: Key used to reference the value.
+        :type key: str
+        :param value: Value to store.
+        :type value: object
+        """
+        with self._lock:
+            self._data[key] = (value, time.time())
+
+    def get(self, key):
+        """
+        Attempt to get a value based on a key.
+
+        :param key: Key associated with the value.
+        :type key: str
+
+        :return: The value associated with the key. None if it doesn't exist.
+        :rtype: object
+        """
+        try:
+            value, set_time = self._data[key]
+        except KeyError:
+            raise ElementNotPresentException('Element %s not present in local storage' % key)
+
+        if (time.time() - set_time) > self._max_age_seconds:
+            raise ElementExpiredException('Element %s present but expired' % key)
+
+        return value

tests/client/test_input_validator.py

@@ -181,55 +181,68 @@ def _get_storage_mock(storage):
         ]
 
         client._logger.reset_mock()
-        assert client.get_treatment(Key('mathcing_key', None), 'some_feature') == CONTROL
+        assert client.get_treatment(Key('matching_key', None), 'some_feature') == CONTROL
         assert client._logger.error.mock_calls == [
             mocker.call('%s: you passed a null %s, %s must be a non-empty string.', 'get_treatment', 'bucketing_key', 'bucketing_key')
         ]
 
         client._logger.reset_mock()
-        assert client.get_treatment(Key('mathcing_key', True), 'some_feature') == CONTROL
+        assert client.get_treatment(Key('matching_key', True), 'some_feature') == CONTROL
         assert client._logger.error.mock_calls == [
             mocker.call('%s: you passed an invalid %s, %s must be a non-empty string.', 'get_treatment', 'bucketing_key', 'bucketing_key')
         ]
 
         client._logger.reset_mock()
-        assert client.get_treatment(Key('mathcing_key', []), 'some_feature') == CONTROL
+        assert client.get_treatment(Key('matching_key', []), 'some_feature') == CONTROL
         assert client._logger.error.mock_calls == [
             mocker.call('%s: you passed an invalid %s, %s must be a non-empty string.', 'get_treatment', 'bucketing_key', 'bucketing_key')
         ]
 
         client._logger.reset_mock()
-        assert client.get_treatment(Key('mathcing_key', ''), 'some_feature') == CONTROL
+        assert client.get_treatment(Key('matching_key', ''), 'some_feature') == CONTROL
         assert client._logger.error.mock_calls == [
             mocker.call('%s: you passed an empty %s, %s must be a non-empty string.', 'get_treatment', 'bucketing_key', 'bucketing_key')
         ]
 
         client._logger.reset_mock()
-        assert client.get_treatment(Key('mathcing_key', 12345), 'some_feature') == 'default_treatment'
+        assert client.get_treatment(Key('matching_key', 12345), 'some_feature') == 'default_treatment'
         assert client._logger.warning.mock_calls == [
             mocker.call('%s: %s %s is not of type string, converting.', 'get_treatment', 'bucketing_key', 12345)
         ]
 
         client._logger.reset_mock()
-        assert client.get_treatment('mathcing_key', 'some_feature', True) == CONTROL
+        assert client.get_treatment('matching_key', 'some_feature', True) == CONTROL
         assert client._logger.error.mock_calls == [
             mocker.call('%s: attributes must be of type dictionary.', 'get_treatment')
         ]
 
         client._logger.reset_mock()
-        assert client.get_treatment('mathcing_key', 'some_feature', {'test': 'test'}) == 'default_treatment'
+        assert client.get_treatment('matching_key', 'some_feature', {'test': 'test'}) == 'default_treatment'
         assert client._logger.error.mock_calls == []
 
         client._logger.reset_mock()
-        assert client.get_treatment('mathcing_key', 'some_feature', None) == 'default_treatment'
+        assert client.get_treatment('matching_key', 'some_feature', None) == 'default_treatment'
         assert client._logger.error.mock_calls == []
 
         client._logger.reset_mock()
-        assert client.get_treatment('mathcing_key', '  some_feature   ', None) == 'default_treatment'
+        assert client.get_treatment('matching_key', '  some_feature   ', None) == 'default_treatment'
         assert client._logger.warning.mock_calls == [
             mocker.call('%s: feature_name \'%s\' has extra whitespace, trimming.', 'get_treatment', '  some_feature   ')
         ]
 
+        client._logger.reset_mock()
+        storage_mock.get.return_value = None
+        assert client.get_treatment('matching_key', 'some_feature', None) == CONTROL
+        assert client._logger.error.mock_calls == [
+            mocker.call(
+                "%s: you passed \"%s\" that does not exist in this environment, "
+                "please double check what Splits exist in the web console.",
+                'get_treatment',
+                'some_feature'
+            )
+        ]
+
+
     def test_get_treatment_with_config(self, mocker):
         """Test get_treatment validation."""
         split_mock = mocker.Mock(spec=Split)
@@ -396,55 +409,67 @@ def _get_storage_mock(storage):
         ]
 
         client._logger.reset_mock()
-        assert client.get_treatment_with_config(Key('mathcing_key', None), 'some_feature') == (CONTROL, None)
+        assert client.get_treatment_with_config(Key('matching_key', None), 'some_feature') == (CONTROL, None)
         assert client._logger.error.mock_calls == [
             mocker.call('%s: you passed a null %s, %s must be a non-empty string.', 'get_treatment_with_config', 'bucketing_key', 'bucketing_key')
         ]
 
         client._logger.reset_mock()
-        assert client.get_treatment_with_config(Key('mathcing_key', True), 'some_feature') == (CONTROL, None)
+        assert client.get_treatment_with_config(Key('matching_key', True), 'some_feature') == (CONTROL, None)
         assert client._logger.error.mock_calls == [
             mocker.call('%s: you passed an invalid %s, %s must be a non-empty string.', 'get_treatment_with_config', 'bucketing_key', 'bucketing_key')
         ]
 
         client._logger.reset_mock()
-        assert client.get_treatment_with_config(Key('mathcing_key', []), 'some_feature') == (CONTROL, None)
+        assert client.get_treatment_with_config(Key('matching_key', []), 'some_feature') == (CONTROL, None)
         assert client._logger.error.mock_calls == [
             mocker.call('%s: you passed an invalid %s, %s must be a non-empty string.', 'get_treatment_with_config', 'bucketing_key', 'bucketing_key')
         ]
 
         client._logger.reset_mock()
-        assert client.get_treatment_with_config(Key('mathcing_key', ''), 'some_feature') == (CONTROL, None)
+        assert client.get_treatment_with_config(Key('matching_key', ''), 'some_feature') == (CONTROL, None)
         assert client._logger.error.mock_calls == [
             mocker.call('%s: you passed an empty %s, %s must be a non-empty string.', 'get_treatment_with_config', 'bucketing_key', 'bucketing_key')
         ]
 
         client._logger.reset_mock()
-        assert client.get_treatment_with_config(Key('mathcing_key', 12345), 'some_feature') == ('default_treatment', '{"some": "property"}')
+        assert client.get_treatment_with_config(Key('matching_key', 12345), 'some_feature') == ('default_treatment', '{"some": "property"}')
         assert client._logger.warning.mock_calls == [
             mocker.call('%s: %s %s is not of type string, converting.', 'get_treatment_with_config', 'bucketing_key', 12345)
         ]
 
         client._logger.reset_mock()
-        assert client.get_treatment_with_config('mathcing_key', 'some_feature', True) == (CONTROL, None)
+        assert client.get_treatment_with_config('matching_key', 'some_feature', True) == (CONTROL, None)
         assert client._logger.error.mock_calls == [
             mocker.call('%s: attributes must be of type dictionary.', 'get_treatment_with_config')
         ]
 
         client._logger.reset_mock()
-        assert client.get_treatment_with_config('mathcing_key', 'some_feature', {'test': 'test'}) == ('default_treatment', '{"some": "property"}')
+        assert client.get_treatment_with_config('matching_key', 'some_feature', {'test': 'test'}) == ('default_treatment', '{"some": "property"}')
         assert client._logger.error.mock_calls == []
 
         client._logger.reset_mock()
-        assert client.get_treatment_with_config('mathcing_key', 'some_feature', None) == ('default_treatment', '{"some": "property"}')
+        assert client.get_treatment_with_config('matching_key', 'some_feature', None) == ('default_treatment', '{"some": "property"}')
         assert client._logger.error.mock_calls == []
 
         client._logger.reset_mock()
-        assert client.get_treatment_with_config('mathcing_key', '  some_feature   ', None) == ('default_treatment', '{"some": "property"}')
+        assert client.get_treatment_with_config('matching_key', '  some_feature   ', None) == ('default_treatment', '{"some": "property"}')
         assert client._logger.warning.mock_calls == [
             mocker.call('%s: feature_name \'%s\' has extra whitespace, trimming.', 'get_treatment_with_config', '  some_feature   ')
         ]
 
+        client._logger.reset_mock()
+        storage_mock.get.return_value = None
+        assert client.get_treatment_with_config('matching_key', 'some_feature', None) == (CONTROL, None)
+        assert client._logger.error.mock_calls == [
+            mocker.call(
+                "%s: you passed \"%s\" that does not exist in this environment, "
+                "please double check what Splits exist in the web console.",
+                'get_treatment_with_config',
+                'some_feature'
+            )
+        ]
+
     def test_track(self, mocker):
         """Test track method()."""
         events_storage_mock = mocker.Mock(spec=EventStorage)
@@ -660,8 +685,16 @@ def test_get_treatments(self, mocker):
         storage_mock = mocker.Mock(spec=SplitStorage)
         storage_mock.get.return_value = split_mock
 
+        def _get_storage_mock(storage):
+            return {
+                'splits': storage_mock,
+                'segments': mocker.Mock(spec=SegmentStorage),
+                'impressions': mocker.Mock(spec=ImpressionStorage),
+                'events': mocker.Mock(spec=EventStorage),
+                'telemetry': mocker.Mock(spec=TelemetryStorage)
+            }[storage]
         factory_mock = mocker.Mock(spec=SplitFactory)
-        factory_mock._get_storage.return_value = storage_mock
+        factory_mock._get_storage.side_effect = _get_storage_mock
         factory_destroyed = mocker.PropertyMock()
         factory_destroyed.return_value = False
         type(factory_mock).destroyed = factory_destroyed
@@ -750,6 +783,21 @@ def test_get_treatments(self, mocker):
             mocker.call('%s: feature_name \'%s\' has extra whitespace, trimming.', 'get_treatments', 'some   ')
         ]
 
+        client._logger.reset_mock()
+        storage_mock.get.return_value = None
+        ready_mock = mocker.PropertyMock()
+        ready_mock.return_value = True
+        type(factory_mock).ready = ready_mock
+        assert client.get_treatments('matching_key', ['some_feature'], None) == {'some_feature': CONTROL}
+        assert client._logger.error.mock_calls == [
+            mocker.call(
+                "%s: you passed \"%s\" that does not exist in this environment, "
+                "please double check what Splits exist in the web console.",
+                'get_treatments',
+                'some_feature'
+            )
+        ]
+
     def test_get_treatments_with_config(self, mocker):
         """Test getTreatments() method."""
         split_mock = mocker.Mock(spec=Split)
@@ -856,6 +904,22 @@ def _configs(treatment):
             mocker.call('%s: feature_name \'%s\' has extra whitespace, trimming.', 'get_treatments_with_config', 'some_feature   ')
         ]
 
+        client._logger.reset_mock()
+        storage_mock.get.return_value = None
+        ready_mock = mocker.PropertyMock()
+        ready_mock.return_value = True
+        type(factory_mock).ready = ready_mock
+        assert client.get_treatments('matching_key', ['some_feature'], None) == {'some_feature': CONTROL}
+        assert client._logger.error.mock_calls == [
+            mocker.call(
+                "%s: you passed \"%s\" that does not exist in this environment, "
+                "please double check what Splits exist in the web console.",
+                'get_treatments',
+                'some_feature'
+            )
+        ]
+
+
 
 class ManagerInputValidationTests(object):  #pylint: disable=too-few-public-methods
     """Manager input validation test cases."""