Fixed #32076 -- Added async methods to BaseCache.

This also makes DummyCache async-compatible.

1 files changed, 187 insertions, 0 deletions

diff --git a/tests/cache/tests_async.py b/tests/cache/tests_async.py
new file mode 100644
index 0000000000..4e84f35db2
--- /dev/null
+++ b/tests/cache/tests_async.py
@@ -0,0 +1,187 @@
+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')