import asyncio from django.core.cache import CacheKeyWarning, cache from django.test import SimpleTestCase, override_settings from .tests import KEY_ERRORS_WITH_MEMCACHED_MSG @override_settings(CACHES={ 'default': { 'BACKEND': 'django.core.cache.backends.dummy.DummyCache', } }) class AsyncDummyCacheTests(SimpleTestCase): async def test_simple(self): """Dummy cache backend ignores cache set calls.""" await cache.aset('key', 'value') self.assertIsNone(await cache.aget('key')) async def test_aadd(self): """Add doesn't do anything in dummy cache backend.""" self.assertIs(await cache.aadd('key', 'value'), True) self.assertIs(await cache.aadd('key', 'new_value'), True) self.assertIsNone(await cache.aget('key')) async def test_non_existent(self): """Nonexistent keys aren't found in the dummy cache backend.""" self.assertIsNone(await cache.aget('does_not_exist')) self.assertEqual(await cache.aget('does_not_exist', 'default'), 'default') async def test_aget_many(self): """aget_many() returns nothing for the dummy cache backend.""" await cache.aset_many({'a': 'a', 'b': 'b', 'c': 'c', 'd': 'd'}) self.assertEqual(await cache.aget_many(['a', 'c', 'd']), {}) self.assertEqual(await cache.aget_many(['a', 'b', 'e']), {}) async def test_aget_many_invalid_key(self): msg = KEY_ERRORS_WITH_MEMCACHED_MSG % ':1:key with spaces' with self.assertWarnsMessage(CacheKeyWarning, msg): await cache.aget_many(['key with spaces']) async def test_adelete(self): """ Cache deletion is transparently ignored on the dummy cache backend. """ await cache.aset_many({'key1': 'spam', 'key2': 'eggs'}) self.assertIsNone(await cache.aget('key1')) self.assertIs(await cache.adelete('key1'), False) self.assertIsNone(await cache.aget('key1')) self.assertIsNone(await cache.aget('key2')) async def test_ahas_key(self): """ahas_key() doesn't ever return True for the dummy cache backend.""" await cache.aset('hello1', 'goodbye1') self.assertIs(await cache.ahas_key('hello1'), False) self.assertIs(await cache.ahas_key('goodbye1'), False) async def test_aincr(self): """Dummy cache values can't be incremented.""" await cache.aset('answer', 42) with self.assertRaises(ValueError): await cache.aincr('answer') with self.assertRaises(ValueError): await cache.aincr('does_not_exist') with self.assertRaises(ValueError): await cache.aincr('does_not_exist', -1) async def test_adecr(self): """Dummy cache values can't be decremented.""" await cache.aset('answer', 42) with self.assertRaises(ValueError): await cache.adecr('answer') with self.assertRaises(ValueError): await cache.adecr('does_not_exist') with self.assertRaises(ValueError): await cache.adecr('does_not_exist', -1) async def test_atouch(self): self.assertIs(await cache.atouch('key'), False) async def test_data_types(self): """All data types are ignored equally by the dummy cache.""" def f(): return 42 class C: def m(n): return 24 data = { 'string': 'this is a string', 'int': 42, 'list': [1, 2, 3, 4], 'tuple': (1, 2, 3, 4), 'dict': {'A': 1, 'B': 2}, 'function': f, 'class': C, } await cache.aset('data', data) self.assertIsNone(await cache.aget('data')) async def test_expiration(self): """Expiration has no effect on the dummy cache.""" await cache.aset('expire1', 'very quickly', 1) await cache.aset('expire2', 'very quickly', 1) await cache.aset('expire3', 'very quickly', 1) await asyncio.sleep(2) self.assertIsNone(await cache.aget('expire1')) self.assertIs(await cache.aadd('expire2', 'new_value'), True) self.assertIsNone(await cache.aget('expire2')) self.assertIs(await cache.ahas_key('expire3'), False) async def test_unicode(self): """Unicode values are ignored by the dummy cache.""" tests = { 'ascii': 'ascii_value', 'unicode_ascii': 'Iñtërnâtiônàlizætiøn1', 'Iñtërnâtiônàlizætiøn': 'Iñtërnâtiônàlizætiøn2', 'ascii2': {'x': 1}, } for key, value in tests.items(): with self.subTest(key=key): await cache.aset(key, value) self.assertIsNone(await cache.aget(key)) async def test_aset_many(self): """aset_many() does nothing for the dummy cache backend.""" self.assertEqual(await cache.aset_many({'a': 1, 'b': 2}), []) self.assertEqual( await cache.aset_many({'a': 1, 'b': 2}, timeout=2, version='1'), [], ) async def test_aset_many_invalid_key(self): msg = KEY_ERRORS_WITH_MEMCACHED_MSG % ':1:key with spaces' with self.assertWarnsMessage(CacheKeyWarning, msg): await cache.aset_many({'key with spaces': 'foo'}) async def test_adelete_many(self): """adelete_many() does nothing for the dummy cache backend.""" await cache.adelete_many(['a', 'b']) async def test_adelete_many_invalid_key(self): msg = KEY_ERRORS_WITH_MEMCACHED_MSG % ':1:key with spaces' with self.assertWarnsMessage(CacheKeyWarning, msg): await cache.adelete_many({'key with spaces': 'foo'}) async def test_aclear(self): """aclear() does nothing for the dummy cache backend.""" await cache.aclear() async def test_aclose(self): """aclose() does nothing for the dummy cache backend.""" await cache.aclose() async def test_aincr_version(self): """Dummy cache versions can't be incremented.""" await cache.aset('answer', 42) with self.assertRaises(ValueError): await cache.aincr_version('answer') with self.assertRaises(ValueError): await cache.aincr_version('answer', version=2) with self.assertRaises(ValueError): await cache.aincr_version('does_not_exist') async def test_adecr_version(self): """Dummy cache versions can't be decremented.""" await cache.aset('answer', 42) with self.assertRaises(ValueError): await cache.adecr_version('answer') with self.assertRaises(ValueError): await cache.adecr_version('answer', version=2) with self.assertRaises(ValueError): await cache.adecr_version('does_not_exist') async def test_aget_or_set(self): self.assertEqual(await cache.aget_or_set('key', 'default'), 'default') self.assertIsNone(await cache.aget_or_set('key', None)) async def test_aget_or_set_callable(self): def my_callable(): return 'default' self.assertEqual(await cache.aget_or_set('key', my_callable), 'default') self.assertEqual(await cache.aget_or_set('key', my_callable()), 'default')