async def test_prefix(self, cache_instance_factory):
simple_prefix = 'project1'
cache_instance = await cache_instance_factory(prefix=simple_prefix)
await cache_instance.set('key1', 'value1')
assert await cache_instance.get('key1') == 'value1'
keys = await cache_instance.get_all_keys()
assert len(keys) == 1
assert create_cache_key(simple_prefix, 'key1') == keys[0]
await cache_instance.clear()
cache_data = {
'key2': 'value2',
'key3': 'value3',
}
await cache_instance.set_many(cache_data)
keys = await cache_instance.get_all_keys()
assert len(keys) == len(cache_data)
assert (sorted([
create_cache_key(simple_prefix, key) for key in cache_data
]) == sorted(keys))
data = await cache_instance.get_many(cache_data.keys())
assert data == cache_data
async def test_default_cache_key(self):
cache_callable = self.user.instance_default_cache_key
cache_key = create_cache_key(
__test_name__ +
'.{}.instance_default_cache_key'.format(self.user_class_name), 1,
2, 8)
await self._check_base(cache_callable)
await self._check_cache_key(cache_callable, cache_key, 1, 2)
await self._check_timeout(cache_key, DEFAULT_TIMEOUT)
cache_callable = self.user_class.class_method_default_cache_key
cache_key = create_cache_key(
__test_name__ +
'.{}.class_method_default_cache_key'.format(self.user_class_name),
2, 3, 9, 'Иван')
await self._check_base(cache_callable)
await self._check_cache_key(cache_callable, cache_key, 2, 3)
await self._check_timeout(cache_key, DEFAULT_TIMEOUT)
cache_callable = computation
cache_key = create_cache_key(__name__ + '.computation', 'a', 'b', 'c')
await self._check_base(cache_callable)
await self._check_cache_key(cache_callable, cache_key, 'a', 'b', 'c')
await self._check_timeout(cache_key, 100)
async def test_instance_method_dynamic_timeout(self):
cache_callable = self.user.instance_dynamic_timeout
await self._check_base(cache_callable)
cache_key = create_cache_key('dyn_timeout', 2)
await self._check_cache_key(cache_callable, cache_key, 2, 3, 4)
await self._check_timeout(cache_key, 2 * 100)
self.cache_mock.reset_mock()
cache_key = create_cache_key('dyn_timeout', 4)
await self._check_cache_key(cache_callable, cache_key, 4, 5, 6)
await self._check_timeout(cache_key, 4 * 100)
async def test_class_method_full_spec(self):
cache_callable = self.user_class.class_method_full_spec
a = 'ф'
b = 'ю'
c = 10
cache_prefix = create_cache_key('USER', a, b)
cache_key = create_cache_key(cache_prefix, self.user_class.name, a)
await self._check_base(cache_callable)
await self._check_cache_key(cache_callable, cache_key, a, b, c)
await self._check_timeout(cache_key, 500)
await self._check_tags(
cache_callable,
['tag4', create_cache_key('tag5', self.user_class.name)], a, b, c)
await self._check_cache_prefix(cache_callable, cache_prefix, a, b, c)
async def test_default_cache_key_for_property(self):
async def check_property():
assert await self._get_awaitable_value(self.user.test_property
) == 'property'
await check_property()
cache_callable = lambda: getattr(self.user, 'test_property')
cache_callable.property = True
cache_key = create_cache_key(
__test_name__ + '.{}.test_property'.format(self.user_class_name))
await self._check_cache_key(cache_callable, cache_key)
await self.local_cache.clear()
self.cache_mock.reset_mock()
await check_property()
self.cache_mock.assert_called_once_with('property')
self.cache_mock.reset_mock()
await check_property()
self.cache_mock.assert_not_called()
# invalidate cache
await self.user_class.test_property.invalidate_cache_by_key()
await check_property()
self.cache_mock.assert_called_once_with('property')
async def test_method_prefixed(self):
cache_callable = self.user.instance_method_prefixed
cache_prefix = create_cache_key('USER', self.user.id)
# prefix should ba attached
cache_key = create_cache_key(cache_prefix, 'p1', 1, 2, 3)
await self._check_base(cache_callable)
await self._check_cache_key(cache_callable, cache_key, 1, 2, 3)
await self._check_timeout(cache_key, 3600)
# prefix is a tag actually
await self._check_cache_prefix(cache_callable, cache_prefix, 1, 2, 3)
await self._check_tags(cache_callable,
[create_cache_key(self.user.id, 'tag1')], 1, 2,
3)
async def test_not_default_timeout(self):
cache_callable = self.user.instance_method_timeout
cache_key = create_cache_key(self.user.id, 5, 5)
await self._check_base(cache_callable)
await self._check_cache_key(cache_callable, cache_key, 5, 5)
await self._check_timeout(cache_key, 400)
async def test_cache_key_as_list(self):
cache_callable = self.user.instance_method_list
cache_key = create_cache_key(self.user.id, 2, 3)
await self._check_base(cache_callable)
await self._check_cache_key(cache_callable, cache_key, 2, 3)
await self._check_timeout(cache_key, DEFAULT_TIMEOUT)
async def test_propery_with_parametrized_cache_key(self):
async def check_property():
assert await self._get_awaitable_value(
self.user.test_manufacture_property) == 'manufacture_property'
await check_property()
cache_callable = lambda: getattr(self.user, 'test_manufacture_property'
)
cache_callable.property = True
cache_key = create_cache_key('manufacturer:{}'.format(self.user.id))
await self._check_cache_key(cache_callable, cache_key)
await self.local_cache.clear()
self.cache_mock.reset_mock()
await check_property()
self.cache_mock.assert_called_once_with('manufacture_property')
self.cache_mock.reset_mock()
await check_property()
self.cache_mock.assert_not_called()
# invalidate cache
await self.user_class.test_manufacture_property.invalidate_cache_by_key(
self.user)
await check_property()
self.cache_mock.assert_called_once_with('manufacture_property')
async def test_ordinal_func(self):
cache_callable = ordinal_func
cache_prefix = ordinal_func.prefix
cache_key = create_cache_key(cache_prefix, 10, 20)
result = self.cache_mock.create_args(a=10, b=10)
assert await cache_callable(a=10, b=10) == result
self.cache_mock.assert_called_once_with(result)
self.cache_mock.reset_mock()
# cached version
assert await cache_callable(a=10, b=10) == result
self.cache_mock.assert_not_called()
self.cache_mock.reset_mock()
result = self.cache_mock.create_args(a=10, b=22)
# different params, no cache
assert await cache_callable(a=10, b=22) == result
self.cache_mock.assert_called_once_with(result)
self.cache_mock.reset_mock()
await self._check_cache_key(cache_callable, cache_key, a=10, b=20)
await self._check_cache_prefix(cache_callable,
cache_prefix,
a=10,
b=20)
async def test_second_func(self):
cache_callable = second_func
cache_key = create_cache_key('second', 100)
await self._check_base(cache_callable, param_to_change='c')
await self._check_cache_key(cache_callable, cache_key, 1, 2, c=100)
await self._check_timeout(cache_key, 450)
await self._check_tags(cache_callable, ['yyy'], 'yyy', 111)
async def test_cache_custom_tags(self):
cache_callable = self.user.instance_method_custom_tags
cache_key = create_cache_key(10, 11)
cache_tags = await self._get_awaitable_value(
self.user.generate_custom_tags(MetaCallable(args=(self.user, 10))))
await self._check_cache_key(cache_callable, cache_key, 10, 11)
await self._check_tags(cache_callable, cache_tags, 10, 11)
async def test_cache_tags(self):
cache_callable = self.user.instance_method_tags
cache_key = create_cache_key(self.user.id, 5, 5)
await self._check_base(cache_callable)
await self._check_cache_key(cache_callable, cache_key, 5, 5)
await self._check_timeout(cache_key, 500)
await self._check_tags(cache_callable, ['tag1', 'tag2'], 6, 7)
async def test_cache_key_as_string(self):
cache_callable = self.user.instance_method_string
cache_key = create_cache_key(self.user.id, 1, 2, 3)
await self._check_base(self.user.instance_method_string)
await self._check_cache_key(cache_callable, cache_key, 1, 2, c=3)
await self._check_timeout(cache_key, DEFAULT_TIMEOUT)
assert await self.local_cache.get_len() == 1
async def test_property_no_tags(self):
assert await self._get_awaitable_value(self.user.property_no_tags
) == '42'
cache_callable = lambda: getattr(self.user, 'property_no_tags')
cache_callable.property = True
cache_key = create_cache_key('static_key')
await self._check_cache_key(cache_callable, cache_key)
async def test_instance_method_and_meta_accepted_decorator(self):
cache_callable = self.user.instance_method_meta_test
cache_key = create_cache_key(1, 2, 5)
await self._check_base(cache_callable)
await self._check_cache_key(cache_callable, cache_key, 1, 2, c=5)
await self._check_timeout(cache_key, DEFAULT_TIMEOUT)
assert await self.local_cache.get_len() == 1
async def test_class_method_key_string(self):
cache_callable = self.user_class.class_method_cache_key_string
cache_key = create_cache_key(self.user_class.name, 17)
await self._check_base(cache_callable, param_to_change='c')
await self._check_cache_key(cache_callable, cache_key, 1, 2)
await self._check_timeout(cache_key, DEFAULT_TIMEOUT)
cache_callable = self.user.class_method_cache_key_string
await self._check_base(cache_callable, param_to_change='c')
await self._check_cache_key(cache_callable, cache_key, 4, 5)
async def test_static_method(self):
cache_callable = self.user_class.static_method
hg = 123
test = 'ЫЮЯ'
cache_prefix = cache_callable.prefix
cache_key = create_cache_key(cache_prefix, hg, hg, test)
await self._check_base(cache_callable)
await self._check_cache_key(cache_callable, cache_key, hg, test)
await self._check_timeout(cache_key, DEFAULT_TIMEOUT)
await self._check_cache_prefix(cache_callable, cache_prefix, hg, test)
async def test_static_method_default_key(self):
cache_callable = self.user_class.static_method_default_key
cache_prefix = create_cache_key('ppp', 2)
cache_key = create_cache_key(
cache_prefix, __test_name__ +
'.{}.static_method_default_key'.format(self.user_class_name), 1, 2,
11)
await self._check_base(cache_callable, param_to_change='b')
await self._check_cache_key(cache_callable, cache_key, a=1, b=2)
# check partial invalidation
self.cache_mock.reset_mock()
self.cache_mock.assert_not_called()
await cache_callable(1, 2, 3)
self.cache_mock.assert_called_once_with(
self.cache_mock.create_args(1, 2, 3))
self.cache_mock.reset_mock()
await cache_callable(1, 2, 3)
self.cache_mock.assert_not_called()
self.cache_mock.reset_mock()
await cache_callable.invalidate_cache_by_tags(c=3)
await cache_callable(1, 2, 3)
self.cache_mock.assert_called_once_with(
self.cache_mock.create_args(1, 2, 3))
self.cache_mock.reset_mock()
await cache_callable.invalidate_cache_by_prefix(b=2)
await cache_callable(1, 2, 3)
self.cache_mock.assert_called_once_with(
self.cache_mock.create_args(1, 2, 3))
self.cache_mock.reset_mock()
await cache_callable.invalidate_cache_by_key(1, b=2, c=3)
await cache_callable(1, 2, 3)
self.cache_mock.assert_called_once_with(
self.cache_mock.create_args(1, 2, 3))
async def test_property_friends_count(self):
assert await self._get_awaitable_value(self.user.friends_count) == 15
cache_callable = lambda: getattr(self.user, 'friends_count')
cache_callable.property = True
cache_callable.invalidate_cache_by_prefix = (
self.user_class.friends_count.invalidate_cache_by_prefix)
cache_prefix = 'USER_PROPERTY'
cache_key = create_cache_key(cache_prefix, self.user.id,
'friends_count')
await self._check_cache_key(cache_callable, cache_key)
await self._check_timeout(cache_key, 100)
await self._check_cache_prefix(cache_callable, cache_prefix)
async def test_invalidators(self):
a, b = 'a', 'b'
cache_callable = ordinal_func
cache_prefix = ordinal_func.prefix
cache_key = create_cache_key(cache_prefix, a, b)
result = self.cache_mock.create_args(a=a, b=b)
assert await cache_callable(a=a, b=b) == result
self.cache_mock.assert_called_once_with(result)
self.cache_mock.reset_mock()
# cached version
assert await cache_callable(a=a, b=b) == result
self.cache_mock.assert_not_called()
self.cache_mock.reset_mock()
# invalidate cache via cache key
await invalidate_cache_key(cache_key)
# second invalidation should fail silently
await invalidate_cache_key(cache_key)
assert await cache_callable(a=a, b=b) == result
self.cache_mock.assert_called_once_with(result)
self.cache_mock.reset_mock()
# cached version
assert await cache_callable(a=a, b=b) == result
self.cache_mock.assert_not_called()
self.cache_mock.reset_mock()
# invalidate cache via prefix
await invalidate_cache_prefix(cache_prefix)
assert await cache_callable(a=a, b=b) == result
self.cache_mock.assert_called_once_with(result)
self.cache_mock.reset_mock()
# cached version
assert await cache_callable(a=a, b=b) == result
self.cache_mock.assert_not_called()
self.cache_mock.reset_mock()
# invalidate cache via attached invalidator
await cache_callable.invalidate_cache_by_key(a=a, b=b)
assert await cache_callable(a=a, b=b) == result
self.cache_mock.assert_called_once_with(result)
self.cache_mock.reset_mock()
def key_maker(key):
return create_cache_key('hello', 'world', key)
