| 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") |
|
|
