changed 'custom' to 'pluggable'

Author: chillaq

splitio/client/config.py

@@ -58,7 +58,7 @@
     'dataSampling': DEFAULT_DATA_SAMPLING,
     'storageWrapper': None,
     'storagePrefix': None,
-    'strageType': None
+    'storageType': None
 }
 
 
@@ -81,11 +81,11 @@ def _parse_operation_mode(apikey, config):
         return 'redis-consumer'
 
     if 'storageType' in config:
-        if config.get('storageType').lower() == 'custom':
-            _LOGGER.debug('Using Custom storage operation mode')
-            return 'custom'
+        if config.get('storageType').lower() == 'pluggable':
+            _LOGGER.debug('Using Pluggable storage operation mode')
+            return 'pluggable'
         _LOGGER.warning('You passed an invalid storageType, acceptable value is '
-                            '`custom`. Defaulting storage to In-Memory mode.')
+                            '`pluggable`. Defaulting storage to In-Memory mode.')
 
     _LOGGER.debug('Using In-Memory operation mode')
     return 'inmemory-standalone'
@@ -110,9 +110,9 @@ def _sanitize_impressions_mode(operation_mode, mode, refresh_rate=None):
                             'one of the following values: `debug`, `none` or `optimized`. '
                             ' Defaulting to `optimized` mode.')
 
-    if operation_mode == 'custom' and mode != ImpressionsMode.DEBUG:
+    if operation_mode == 'pluggable' and mode != ImpressionsMode.DEBUG:
         mode = ImpressionsMode.DEBUG
-        _LOGGER.warning('`custom` storageMode only support `debug` impressionMode, adjusting impressionsMode to `debug`. ')
+        _LOGGER.warning('`pluggable` storageMode only support `debug` impressionMode, adjusting impressionsMode to `debug`. ')
 
     if mode == ImpressionsMode.DEBUG:
         refresh_rate = max(1, refresh_rate) if refresh_rate is not None else 60

splitio/client/factory.py

@@ -675,7 +675,7 @@ def get_factory(api_key, **kwargs):
         split_factory =  _build_localhost_factory(config)
     elif config['operationMode'] == 'redis-consumer':
         split_factory = _build_redis_factory(api_key, config)
-    elif config['operationMode'] == 'custom':
+    elif config['operationMode'] == 'pluggable':
         split_factory = _build_pluggable_factory(api_key, config)
     else:
         split_factory = _build_in_memory_factory(

splitio/client/input_validator.py

@@ -529,21 +529,21 @@ def validate_pluggable_adapter(config):
     :return: True if no issue found otherwise False
     :rtype: bool
     """
-    if config.get('storageType') != 'CUSTOM':
+    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.")
+        _LOGGER.error("Expecting pluggable 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")
+            _LOGGER.error("Pluggable 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")
+        _LOGGER.error("Pluggable 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,

splitio/models/telemetry.py

@@ -124,13 +124,13 @@ class StorageType(Enum):
     MEMORY = 'memory'
     REDIS = 'redis'
     LOCALHOST = 'localhost'
-    CUSTOM = 'custom'
+    PLUGGABLE = 'pluggable'
 
 class OperationMode(Enum):
     """Storage modes constants"""
     MEMORY = 'inmemory'
     REDIS = 'redis-consumer'
-    CUSTOM = 'custom'
+    PLUGGABLE = 'pluggable'
 
 def get_latency_bucket_index(micros):
     """
@@ -876,7 +876,7 @@ def _get_storage_type(self, op_mode):
             elif StorageType.REDIS.value in op_mode:
                 return StorageType.REDIS.value
             else:
-                return StorageType.CUSTOM.value
+                return StorageType.PLUGGABLE.value
 
     def _get_refresh_rates(self, config):
         """

tests/client/test_config.py

@@ -13,7 +13,7 @@ def test_parse_operation_mode(self):
         assert config._parse_operation_mode('some', {}) == 'inmemory-standalone'
         assert config._parse_operation_mode('localhost', {}) == 'localhost-standalone'
         assert config._parse_operation_mode('some', {'redisHost': 'x'}) == 'redis-consumer'
-        assert config._parse_operation_mode('some', {'storageType': 'custom'}) == 'custom'
+        assert config._parse_operation_mode('some', {'storageType': 'pluggable'}) == 'pluggable'
         assert config._parse_operation_mode('some', {'storageType': 'custom2'}) == 'inmemory-standalone'
 
     def test_sanitize_imp_mode(self):
@@ -34,15 +34,15 @@ def test_sanitize_imp_mode(self):
         assert mode == ImpressionsMode.OPTIMIZED
         assert rate == 200
 
-        mode, rate = config._sanitize_impressions_mode('custom', 'ANYTHING', 200)
+        mode, rate = config._sanitize_impressions_mode('pluggable', 'ANYTHING', 200)
         assert mode == ImpressionsMode.DEBUG
         assert rate == 200
 
-        mode, rate = config._sanitize_impressions_mode('custom', 'NONE', 200)
+        mode, rate = config._sanitize_impressions_mode('pluggable', 'NONE', 200)
         assert mode == ImpressionsMode.DEBUG
         assert rate == 200
 
-        mode, rate = config._sanitize_impressions_mode('custom', 'OPTIMIZED', 200)
+        mode, rate = config._sanitize_impressions_mode('pluggable', 'OPTIMIZED', 200)
         assert mode == ImpressionsMode.DEBUG
         assert rate == 200
 

tests/client/test_factory.py

@@ -548,7 +548,7 @@ def test_pluggable_client_creation(self, mocker):
         config = {
             'labelsEnabled': False,
             'impressionListener': 123,
-            'storageType': 'custom',
+            'storageType': 'pluggable',
             'storageWrapper': StorageMockAdapter()
         }
         factory = get_factory('some_api_key', config=config)
@@ -578,7 +578,7 @@ def test_destroy_with_event_pluggable(self, mocker):
         config = {
             'labelsEnabled': False,
             'impressionListener': 123,
-            'storageType': 'custom',
+            'storageType': 'pluggable',
             'storageWrapper': StorageMockAdapter()
         }
 

tests/client/test_input_validator.py

@@ -1240,28 +1240,28 @@ def expire(self, key, value, till):
 
     def test_validate_pluggable_adapter(self):
         # missing storageWrapper config parameter
-        assert(not input_validator.validate_pluggable_adapter({'storageType': 'CUSTOM'}))
+        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': 'CUSTOM', 'pe': self.mock_adapter0()}))
+        assert(not input_validator.validate_pluggable_adapter({'storageType': 'pluggable', 'pe': self.mock_adapter0()}))
 
         # mock adapter missing many functions
-        assert(not input_validator.validate_pluggable_adapter({'storageType': 'CUSTOM', 'storageWrapper': self.mock_adapter1()}))
+        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': 'CUSTOM', 'storageWrapper': self.mock_adapter2()}))
+        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': 'CUSTOM', 'storageWrapper': self.mock_adapter3()}))
+        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': 'CUSTOM', 'storageWrapper': self.mock_adapter4()}))
+        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': 'CUSTOM', 'storagePrefix': 'myprefix', 'storageWrapper': self.mock_adapter4()}))
+        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': 'CUSTOM', 'storagePrefix': 'myprefix', 123: self.mock_adapter4()}))
+        assert(not input_validator.validate_pluggable_adapter({'storageType': 'pluggable', 'storagePrefix': 'myprefix', 123: self.mock_adapter4()}))