def test_lock(cache: RedisCache): key = 'test_key_8' lock = cache.lock(key) lock.acquire(blocking=True) assert cache.has_key(key) lock.release() assert not cache.has_key(key)
def test_iter_keys( self, key_prefix_cache: RedisCache, with_prefix_cache: RedisCache ): if isinstance(key_prefix_cache.client, ShardClient): pytest.skip("ShardClient doesn't support iter_keys") key_prefix_cache.set("a", "1") with_prefix_cache.set("b", "2") assert list(key_prefix_cache.iter_keys("*")) == ["a"]
def test_setnx(cache: RedisCache): assert isinstance(cache, RedisSentinelCache) key = 'test_key_nx' cache.delete(key) assert cache.get(key) is None assert cache.set(key, 1, nx=True) assert not cache.set(key, 2, nx=True) assert cache.get(key) == 1 cache.delete(key) assert cache.get(key) is None
def test_delete_pattern( self, key_prefix_cache: RedisCache, with_prefix_cache: RedisCache ): key_prefix_cache.set("a", "1") with_prefix_cache.set("b", "2") key_prefix_cache.delete_pattern("*") assert key_prefix_cache.has_key("a") is False assert with_prefix_cache.get("b") == "2"
def test_django_redis_custom_key_fun(cache: RedisCache): assert isinstance(cache, RedisSentinelCache) for key in ["foo-aa", "foo-ab", "foo-bb", "foo-bc"]: cache.set(key, "foo") res = cache.delete_pattern("*foo-a*") assert res keys = cache.keys("foo*") assert set(keys) == {"foo-bb", "foo-bc"} # ensure our custom function was actually called try: assert (set(k.decode('utf-8') for k in cache.raw_client.keys('*')), {':1:foo-bc', ':1:foo-bb'}) except (NotImplementedError, AttributeError): # not all clients support .keys() pass
def test_save_str(cache: RedisCache): assert isinstance(cache, RedisSentinelCache) key = 'test_key_4' str1 = "hello" * 1000 cache.set(key, str1) assert cache.get(key) == str1 str2 = "2" cache.set(key, str2) assert cache.get(key) == str2 str3 = "some chinese 有一些中文" cache.set(key, str3) assert cache.get(key) == str3
def __init__(self, server, params): """ Instantiate the Redis Cache with server and params and retrieve the cache with alias "fallback" """ super().__init__(params) self._redis_cache = RedisCache(server, params) self._fallback_cache = caches["fallback"]
def test_setnx_timeout(cache: RedisCache): assert isinstance(cache, RedisSentinelCache) # test timeout works key = 'test_key_nx2' assert cache.set(key, 1, timeout=2, nx=True) time.sleep(3) assert cache.get(key) is None # test timeout will not affect key,if it was there cache.set(key, 1) assert not cache.set(key, 2, timeout=2, nx=True) time.sleep(3) assert cache.get(key) == 1 cache.delete(key) assert cache.get(key) is None
def test_custom_key_function(cache: RedisCache, settings: SettingsWrapper): caches_setting = copy.deepcopy(settings.CACHES) caches_setting["default"]["KEY_FUNCTION"] = "test_cache_options.make_key" caches_setting["default"]["REVERSE_KEY_FUNCTION"] = "test_cache_options.reverse_key" settings.CACHES = caches_setting if isinstance(cache.client, ShardClient): pytest.skip("ShardClient doesn't support get_client") for key in ["foo-aa", "foo-ab", "foo-bb", "foo-bc"]: cache.set(key, "foo") res = cache.delete_pattern("*foo-a*") assert bool(res) is True keys = cache.keys("foo*") assert set(keys) == {"foo-bb", "foo-bc"} # ensure our custom function was actually called assert {k.decode() for k in cache.client.get_client(write=False).keys("*")} == ( {"#1#foo-bc", "#1#foo-bb"} )
class NRRedisCache(object): _redis: RedisCache = RedisCache(settings.REDIS_SERVER, {}) @classmethod def get(cls, key, default_value=None, timeout=REDIS_DEFAULT_TIMEOUT): return cls._redis.get_or_set(key, default=default_value, timeout=timeout) @classmethod def get_from_json(cls, key, default_value=None, timeout=REDIS_DEFAULT_TIMEOUT): r = cls._redis.get_or_set(key, default=default_value, timeout=timeout) if r is not None: r = JsonUtil.deserialize(r) return r @classmethod def set(cls, key, data, timeout=REDIS_DEFAULT_TIMEOUT): cls._redis.set(key, data, timeout=timeout) @classmethod def set_to_json(cls, key, data, timeout=REDIS_DEFAULT_TIMEOUT): cls._redis.set(key, JsonUtil.serialize(data), timeout=timeout) @classmethod def has_key(cls, key): return cls._redis.has_key(key) @classmethod def expire(cls, key, timeout): cls._redis.expire(key, timeout) @classmethod def ttl(cls, key): return cls._redis.ttl(key)
from string import ascii_lowercase from timeit import timeit from django.core.cache.backends.locmem import LocMemCache from django_redis.cache import RedisCache from shared_memory_dict.caches.django import SharedMemoryCache cache_smc_django = SharedMemoryCache( 'django', params={'OPTIONS': { 'MEMORY_BLOCK_SIZE': 64 }}) cache_django_redis = RedisCache(server='redis://127.0.0.1:6379/1', params={}) cache_django_locmem = LocMemCache('locmem', params={}) def agressive(cache): for c in ascii_lowercase: for i in range(5): cache.set(f'{c}{i}', '1') for i in range(10, 0, -1): cache.get(f'{c}{i}') def fun(cache): cache.set('fun', 'uhull') for _ in range(3): cache.get('fun') def collect(cache_var_name): time_of_agressive = timeit(stmt=f'agressive({cache_var_name})',
def test_expire(cache: RedisCache): key = 'test_key_7' cache.set(key, 'bar', timeout=None) cache.expire(key, 20) ttl = cache.ttl(key) assert 18 < ttl <= 20
def test_persist(cache: RedisCache): key = 'test_key_6' cache.set(key, 'bar', timeout=20) cache.persist(key) assert cache.ttl(key) is None
def test_get_django_omit_exceptions(ignore_exceptions_cache: RedisCache): assert ignore_exceptions_cache._ignore_exceptions is True assert ignore_exceptions_cache.get("key") is None assert ignore_exceptions_cache.get("key", "default") == "default" assert ignore_exceptions_cache.get("key", default="default") == "default"
def test_get_django_omit_exceptions_many_returns_default_arg( ignore_exceptions_cache: RedisCache, ): assert ignore_exceptions_cache._ignore_exceptions is True assert ignore_exceptions_cache.get_many(["key1", "key2", "key3"]) == {}
def test_save_and_int(cache: RedisCache): assert isinstance(cache, RedisSentinelCache) key = 'test_key_3' cache.set(key, 2) res = cache.get(key, 'astr') assert res == 2
def test_keys(self, key_prefix_cache: RedisCache, with_prefix_cache: RedisCache): key_prefix_cache.set("a", "1") with_prefix_cache.set("b", "2") keys = key_prefix_cache.keys("*") assert "a" in keys assert "b" not in keys
def test_save_dict(cache: RedisCache): key = 'test_key_5' d1 = {"id": 1, "name": "CodeTalks", "memo": "生活真美好"} cache.set(key, d1) assert cache.get(key) == d1