Refs #33476 -- Reformatted code with Black.

1 files changed, 76 insertions, 73 deletions

diff --git a/tests/cache/tests_async.py b/tests/cache/tests_async.py
index 4e84f35db2..3ac4e446e6 100644
--- a/tests/cache/tests_async.py
+++ b/tests/cache/tests_async.py
@@ -6,80 +6,83 @@ 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',
+@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'))
+        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'))
+        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')
+        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']), {})
+        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'
+        msg = KEY_ERRORS_WITH_MEMCACHED_MSG % ":1:key with spaces"
         with self.assertWarnsMessage(CacheKeyWarning, msg):
-            await cache.aget_many(['key with spaces'])
+            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'))
+        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)
+        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)
+        await cache.aset("answer", 42)
         with self.assertRaises(ValueError):
-            await cache.aincr('answer')
+            await cache.aincr("answer")
         with self.assertRaises(ValueError):
-            await cache.aincr('does_not_exist')
+            await cache.aincr("does_not_exist")
         with self.assertRaises(ValueError):
-            await cache.aincr('does_not_exist', -1)
+            await cache.aincr("does_not_exist", -1)
 
     async def test_adecr(self):
         """Dummy cache values can't be decremented."""
-        await cache.aset('answer', 42)
+        await cache.aset("answer", 42)
         with self.assertRaises(ValueError):
-            await cache.adecr('answer')
+            await cache.adecr("answer")
         with self.assertRaises(ValueError):
-            await cache.adecr('does_not_exist')
+            await cache.adecr("does_not_exist")
         with self.assertRaises(ValueError):
-            await cache.adecr('does_not_exist', -1)
+            await cache.adecr("does_not_exist", -1)
 
     async def test_atouch(self):
-        self.assertIs(await cache.atouch('key'), False)
+        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
 
@@ -88,37 +91,37 @@ class AsyncDummyCacheTests(SimpleTestCase):
                 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,
+            "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'))
+        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 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.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)
+        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},
+            "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):
@@ -127,25 +130,25 @@ class AsyncDummyCacheTests(SimpleTestCase):
 
     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}), [])
         self.assertEqual(
-            await cache.aset_many({'a': 1, 'b': 2}, timeout=2, version='1'),
+            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'
+        msg = KEY_ERRORS_WITH_MEMCACHED_MSG % ":1:key with spaces"
         with self.assertWarnsMessage(CacheKeyWarning, msg):
-            await cache.aset_many({'key with spaces': 'foo'})
+            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'])
+        await cache.adelete_many(["a", "b"])
 
     async def test_adelete_many_invalid_key(self):
-        msg = KEY_ERRORS_WITH_MEMCACHED_MSG % ':1:key with spaces'
+        msg = KEY_ERRORS_WITH_MEMCACHED_MSG % ":1:key with spaces"
         with self.assertWarnsMessage(CacheKeyWarning, msg):
-            await cache.adelete_many({'key with spaces': 'foo'})
+            await cache.adelete_many({"key with spaces": "foo"})
 
     async def test_aclear(self):
         """aclear() does nothing for the dummy cache backend."""
@@ -157,31 +160,31 @@ class AsyncDummyCacheTests(SimpleTestCase):
 
     async def test_aincr_version(self):
         """Dummy cache versions can't be incremented."""
-        await cache.aset('answer', 42)
+        await cache.aset("answer", 42)
         with self.assertRaises(ValueError):
-            await cache.aincr_version('answer')
+            await cache.aincr_version("answer")
         with self.assertRaises(ValueError):
-            await cache.aincr_version('answer', version=2)
+            await cache.aincr_version("answer", version=2)
         with self.assertRaises(ValueError):
-            await cache.aincr_version('does_not_exist')
+            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)
+        await cache.aset("answer", 42)
         with self.assertRaises(ValueError):
-            await cache.adecr_version('answer')
+            await cache.adecr_version("answer")
         with self.assertRaises(ValueError):
-            await cache.adecr_version('answer', version=2)
+            await cache.adecr_version("answer", version=2)
         with self.assertRaises(ValueError):
-            await cache.adecr_version('does_not_exist')
+            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))
+        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'
+            return "default"
 
-        self.assertEqual(await cache.aget_or_set('key', my_callable), 'default')
-        self.assertEqual(await cache.aget_or_set('key', my_callable()), 'default')
+        self.assertEqual(await cache.aget_or_set("key", my_callable), "default")
+        self.assertEqual(await cache.aget_or_set("key", my_callable()), "default")