Merge pull request #322 from splitio/custom-wrapper-validation

added validation and test

Author: chillaq

splitio/client/input_validator.py

@@ -3,6 +3,7 @@
 import logging
 import re
 import math
+import inspect
 
 from splitio.api import APIException
 from splitio.api.commons import FetchOptions
@@ -517,3 +518,51 @@ def valid_properties(properties):
         _LOGGER.warning('Event has more than 300 properties. Some of them will be trimmed' +
                         ' when processed')
     return True, valid_properties if len(valid_properties) else None, size
+
+def validate_pluggable_adapter(config):
+    """
+    Check if pluggable adapter contains the expected method signature
+
+    :param config: config parameters
+    :type config: Dict
+
+    :return: True if no issue found otherwise False
+    :rtype: bool
+    """
+    if config.get('storageType') != 'PLUGGABLE':
+        return True
+
+    if config.get('storageWrapper') is None:
+        _LOGGER.error("Expecting custom storage `wrapper` in options, but no valid wrapper instance was provided.")
+        return False
+
+    if config.get('storagePrefix') is not None:
+        if not isinstance(config.get('storagePrefix'), str):
+            _LOGGER.error("Custom storage prefix should be string type only")
+            return False
+
+    pluggable_adapter = config.get('storageWrapper')
+    if not isinstance(pluggable_adapter, object):
+        _LOGGER.error("Custom storage instance is not inherted from object class")
+        return False
+
+    expected_methods = {'get': 1, 'get_items': 1, 'get_many': 1, 'set': 2, 'push_items': 2,
+                        'delete': 1, 'increment': 2, 'decrement': 2, 'get_keys_by_prefix': 1,
+                        'get_many': 1, 'add_items' : 2, 'remove_items': 2, 'item_contains': 2,
+                        'get_items_count': 1, 'expire': 2}
+    methods = inspect.getmembers(pluggable_adapter, predicate=inspect.ismethod)
+    for exp_method in expected_methods:
+        method_found = False
+        get_method_args = set()
+        for method in methods:
+            if exp_method == method[0]:
+                method_found = True
+                get_method_args = inspect.signature(method[1]).parameters
+                break
+        if not method_found:
+            _LOGGER.error("Pluggable adapter does not have required method: %s" % exp_method)
+            return False
+        if len(get_method_args) < expected_methods[exp_method]:
+            _LOGGER.error("Pluggable adapter method %s has less than required arguments count: %s : " % (exp_method, len(get_method_args)))
+            return False
+    return True

tests/client/test_input_validator.py

@@ -1177,4 +1177,91 @@ def test_input_validation_factory(self, mocker):
         except:
             pass
         assert logger.error.mock_calls == []
-        f.destroy()
+        f.destroy()
+
+class PluggableInputValidationTests(object):  #pylint: disable=too-few-public-methods
+    """Pluggable adapter instance validation test cases."""
+
+    class mock_adapter0():
+        def set(self, key, value):
+            print(key)
+
+    class mock_adapter1(object):
+        def set(self, key, value):
+            print(key)
+
+    class mock_adapter2(mock_adapter1):
+        def get(self, key):
+            print(key)
+
+        def get_items(self, key):
+            print(key)
+
+        def get_many(self, keys):
+            print(keys)
+
+        def push_items(self, key, *value):
+            print(key)
+
+        def delete(self, key):
+            print(key)
+
+        def increment(self, key, value):
+            print(key)
+
+        def decrement(self, key, value):
+            print(key)
+
+        def get_keys_by_prefix(self, prefix):
+            print(prefix)
+
+        def get_many(self, keys):
+            print(keys)
+
+        def add_items(self, key, added_items):
+            print(key)
+
+        def remove_items(self, key, removed_items):
+            print(key)
+
+        def item_contains(self, key, item):
+            print(key)
+
+        def get_items_count(self, key):
+            print(key)
+
+    class mock_adapter3(mock_adapter2):
+        def expire(self, key):
+            print(key)
+
+    class mock_adapter4(mock_adapter2):
+        def expire(self, key, value, till):
+            print(key)
+
+    def test_validate_pluggable_adapter(self):
+        # missing storageWrapper config parameter
+        assert(not input_validator.validate_pluggable_adapter({'storageType': 'PLUGGABLE'}))
+
+        # ignore if storage type is not pluggable
+        assert(input_validator.validate_pluggable_adapter({'storageType': 'memory'}))
+
+        # mock adapter is not derived from object class
+        assert(not input_validator.validate_pluggable_adapter({'storageType': 'PLUGGABLE', 'storageWrapper': self.mock_adapter0()}))
+
+        # mock adapter missing many functions
+        assert(not input_validator.validate_pluggable_adapter({'storageType': 'PLUGGABLE', 'storageWrapper': self.mock_adapter1()}))
+
+        # mock adapter missing expire function
+        assert(not input_validator.validate_pluggable_adapter({'storageType': 'PLUGGABLE', 'storageWrapper': self.mock_adapter2()}))
+
+        # mock adapter expire function has incrrect args count
+        assert(not input_validator.validate_pluggable_adapter({'storageType': 'PLUGGABLE', 'storageWrapper': self.mock_adapter3()}))
+
+        # expected mock adapter should pass
+        assert(input_validator.validate_pluggable_adapter({'storageType': 'PLUGGABLE', 'storageWrapper': self.mock_adapter4()}))
+
+        # using string type prefix should pass
+        assert(input_validator.validate_pluggable_adapter({'storageType': 'PLUGGABLE', 'storagePrefix': 'myprefix', 'storageWrapper': self.mock_adapter4()}))
+
+        # using non-string type prefix should not pass
+        assert(not input_validator.validate_pluggable_adapter({'storageType': 'PLUGGABLE', 'storagePrefix': 'myprefix', 123: self.mock_adapter4()}))