added asyc lock and cache tests

Author: chillaq

splitio/storage/adapters/cache_trait.py

@@ -3,7 +3,7 @@
 import threading
 import time
 from functools import update_wrapper
-
+from splitio.optional.loaders import asyncio
 
 DEFAULT_MAX_AGE = 5
 DEFAULT_MAX_SIZE = 100
@@ -84,7 +84,7 @@ def get(self, *args, **kwargs):
             self._rollover()
             return node.value
 
-    def get_key(self, key):
+    async def get_key(self, key):
         """
         Fetch an item from the cache, return None if does not exist
 
@@ -94,7 +94,7 @@ def get_key(self, key):
         :return: Cached/Fetched object
         :rtype: object
         """
-        with self._lock:
+        async with asyncio.Lock():
             node = self._data.get(key)
             if node is not None:
                 if self._is_expired(node):
@@ -104,7 +104,7 @@ def get_key(self, key):
             node = self._bubble_up(node)
             return node.value
 
-    def add_key(self, key, value):
+    async def add_key(self, key, value):
         """
         Add an item from the cache.
 
@@ -114,7 +114,7 @@ def add_key(self, key, value):
         :param value: key value
         :type value: str
         """
-        with self._lock:
+        async with asyncio.Lock():
             node = LocalMemoryCache._Node(key, value, time.time(), None, None)
             node = self._bubble_up(node)
             self._data[key] = node

splitio/storage/redis.py

@@ -289,12 +289,12 @@ async def get(self, split_name):  # pylint: disable=method-hidden
         :rtype: splitio.models.splits.Split
         """
         try:
-            if self._enable_caching and self._cache.get_key(split_name) is not None:
-                raw = self._cache.get_key(split_name)
+            if self._enable_caching and await self._cache.get_key(split_name) is not None:
+                raw = await self._cache.get_key(split_name)
             else:
                 raw = await self._redis.get(self._get_key(split_name))
                 if self._enable_caching:
-                    self._cache.add_key(split_name, raw)
+                    await self._cache.add_key(split_name, raw)
                 _LOGGER.debug("Fetchting Split [%s] from redis" % split_name)
                 _LOGGER.debug(raw)
             return splits.from_raw(json.loads(raw)) if raw is not None else None
@@ -315,13 +315,13 @@ async def fetch_many(self, split_names):
         """
         to_return = dict()
         try:
-            if self._enable_caching and self._cache.get_key(frozenset(split_names)) is not None:
-                raw_splits = self._cache.get_key(frozenset(split_names))
+            if self._enable_caching and await self._cache.get_key(frozenset(split_names)) is not None:
+                raw_splits = await self._cache.get_key(frozenset(split_names))
             else:
                 keys = [self._get_key(split_name) for split_name in split_names]
                 raw_splits = await self._redis.mget(keys)
                 if self._enable_caching:
-                    self._cache.add_key(frozenset(split_names), raw_splits)
+                    await self._cache.add_key(frozenset(split_names), raw_splits)
             for i in range(len(split_names)):
                 split = None
                 try:
@@ -346,12 +346,12 @@ async def is_valid_traffic_type(self, traffic_type_name):  # pylint: disable=met
         :rtype: bool
         """
         try:
-            if self._enable_caching and self._cache.get_key(traffic_type_name) is not None:
-                raw = self._cache.get_key(traffic_type_name)
+            if self._enable_caching and await self._cache.get_key(traffic_type_name) is not None:
+                raw = await self._cache.get_key(traffic_type_name)
             else:
                 raw = await self._redis.get(self._get_traffic_type_key(traffic_type_name))
                 if self._enable_caching:
-                    self._cache.add_key(traffic_type_name, raw)
+                    await self._cache.add_key(traffic_type_name, raw)
             count = json.loads(raw) if raw else 0
             return count > 0
         except RedisAdapterException:

tests/storage/adapters/test_cache_trait.py

@@ -6,6 +6,7 @@
 import pytest
 
 from splitio.storage.adapters import cache_trait
+from splitio.optional.loaders import asyncio
 
 class  CacheTraitTests(object):
     """Cache trait test cases."""
@@ -130,3 +131,11 @@ def test_decorate(self, mocker):
         assert cache_trait.decorate(key_func, 0, 10)(user_func) is user_func
         assert cache_trait.decorate(key_func, 10, 0)(user_func) is user_func
         assert cache_trait.decorate(key_func, 0, 0)(user_func) is user_func
+
+    @pytest.mark.asyncio
+    async def test_async_add_and_get_key(self, mocker):
+        cache = cache_trait.LocalMemoryCache(None, None, 1, 1)
+        await cache.add_key('split', {'split_name': 'split'})
+        assert await cache.get_key('split') == {'split_name': 'split'}
+        await asyncio.sleep(1)
+        assert await cache.get_key('split') == None