[4.0.x] Refs #33476 -- Reformatted code with Black.

Backport of 9c19aff7c7561e3a82978a272ecdaad40dda5c00 from main.

1 files changed, 114 insertions, 87 deletions

diff --git a/tests/template_tests/syntax_tests/test_cache.py b/tests/template_tests/syntax_tests/test_cache.py
index 80af1c2bd6..a722420637 100644
--- a/tests/template_tests/syntax_tests/test_cache.py
+++ b/tests/template_tests/syntax_tests/test_cache.py
@@ -7,176 +7,203 @@ from ..utils import setup
 
 class CacheTagTests(SimpleTestCase):
     libraries = {
-        'cache': 'django.templatetags.cache',
-        'custom': 'template_tests.templatetags.custom',
+        "cache": "django.templatetags.cache",
+        "custom": "template_tests.templatetags.custom",
     }
 
     def tearDown(self):
         cache.clear()
 
-    @setup({'cache03': '{% load cache %}{% cache 2 test %}cache03{% endcache %}'})
+    @setup({"cache03": "{% load cache %}{% cache 2 test %}cache03{% endcache %}"})
     def test_cache03(self):
-        output = self.engine.render_to_string('cache03')
-        self.assertEqual(output, 'cache03')
+        output = self.engine.render_to_string("cache03")
+        self.assertEqual(output, "cache03")
 
-    @setup({
-        'cache03': '{% load cache %}{% cache 2 test %}cache03{% endcache %}',
-        'cache04': '{% load cache %}{% cache 2 test %}cache04{% endcache %}',
-    })
+    @setup(
+        {
+            "cache03": "{% load cache %}{% cache 2 test %}cache03{% endcache %}",
+            "cache04": "{% load cache %}{% cache 2 test %}cache04{% endcache %}",
+        }
+    )
     def test_cache04(self):
-        self.engine.render_to_string('cache03')
-        output = self.engine.render_to_string('cache04')
-        self.assertEqual(output, 'cache03')
+        self.engine.render_to_string("cache03")
+        output = self.engine.render_to_string("cache04")
+        self.assertEqual(output, "cache03")
 
-    @setup({'cache05': '{% load cache %}{% cache 2 test foo %}cache05{% endcache %}'})
+    @setup({"cache05": "{% load cache %}{% cache 2 test foo %}cache05{% endcache %}"})
     def test_cache05(self):
-        output = self.engine.render_to_string('cache05', {'foo': 1})
-        self.assertEqual(output, 'cache05')
+        output = self.engine.render_to_string("cache05", {"foo": 1})
+        self.assertEqual(output, "cache05")
 
-    @setup({'cache06': '{% load cache %}{% cache 2 test foo %}cache06{% endcache %}'})
+    @setup({"cache06": "{% load cache %}{% cache 2 test foo %}cache06{% endcache %}"})
     def test_cache06(self):
-        output = self.engine.render_to_string('cache06', {'foo': 2})
-        self.assertEqual(output, 'cache06')
+        output = self.engine.render_to_string("cache06", {"foo": 2})
+        self.assertEqual(output, "cache06")
 
-    @setup({
-        'cache05': '{% load cache %}{% cache 2 test foo %}cache05{% endcache %}',
-        'cache07': '{% load cache %}{% cache 2 test foo %}cache07{% endcache %}',
-    })
+    @setup(
+        {
+            "cache05": "{% load cache %}{% cache 2 test foo %}cache05{% endcache %}",
+            "cache07": "{% load cache %}{% cache 2 test foo %}cache07{% endcache %}",
+        }
+    )
     def test_cache07(self):
-        context = {'foo': 1}
-        self.engine.render_to_string('cache05', context)
-        output = self.engine.render_to_string('cache07', context)
-        self.assertEqual(output, 'cache05')
+        context = {"foo": 1}
+        self.engine.render_to_string("cache05", context)
+        output = self.engine.render_to_string("cache07", context)
+        self.assertEqual(output, "cache05")
 
-    @setup({
-        'cache06': '{% load cache %}{% cache 2 test foo %}cache06{% endcache %}',
-        'cache08': '{% load cache %}{% cache time test foo %}cache08{% endcache %}',
-    })
+    @setup(
+        {
+            "cache06": "{% load cache %}{% cache 2 test foo %}cache06{% endcache %}",
+            "cache08": "{% load cache %}{% cache time test foo %}cache08{% endcache %}",
+        }
+    )
     def test_cache08(self):
         """
         Allow first argument to be a variable.
         """
-        context = {'foo': 2, 'time': 2}
-        self.engine.render_to_string('cache06', context)
-        output = self.engine.render_to_string('cache08', context)
-        self.assertEqual(output, 'cache06')
+        context = {"foo": 2, "time": 2}
+        self.engine.render_to_string("cache06", context)
+        output = self.engine.render_to_string("cache08", context)
+        self.assertEqual(output, "cache06")
 
     # Raise exception if we don't have at least 2 args, first one integer.
-    @setup({'cache11': '{% load cache %}{% cache %}{% endcache %}'})
+    @setup({"cache11": "{% load cache %}{% cache %}{% endcache %}"})
     def test_cache11(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('cache11')
+            self.engine.get_template("cache11")
 
-    @setup({'cache12': '{% load cache %}{% cache 1 %}{% endcache %}'})
+    @setup({"cache12": "{% load cache %}{% cache 1 %}{% endcache %}"})
     def test_cache12(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('cache12')
+            self.engine.get_template("cache12")
 
-    @setup({'cache13': '{% load cache %}{% cache foo bar %}{% endcache %}'})
+    @setup({"cache13": "{% load cache %}{% cache foo bar %}{% endcache %}"})
     def test_cache13(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.render_to_string('cache13')
+            self.engine.render_to_string("cache13")
 
-    @setup({'cache14': '{% load cache %}{% cache foo bar %}{% endcache %}'})
+    @setup({"cache14": "{% load cache %}{% cache foo bar %}{% endcache %}"})
     def test_cache14(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.render_to_string('cache14', {'foo': 'fail'})
+            self.engine.render_to_string("cache14", {"foo": "fail"})
 
-    @setup({'cache15': '{% load cache %}{% cache foo bar %}{% endcache %}'})
+    @setup({"cache15": "{% load cache %}{% cache foo bar %}{% endcache %}"})
     def test_cache15(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.render_to_string('cache15', {'foo': []})
+            self.engine.render_to_string("cache15", {"foo": []})
 
-    @setup({'cache16': '{% load cache %}{% cache 1 foo bar %}{% endcache %}'})
+    @setup({"cache16": "{% load cache %}{% cache 1 foo bar %}{% endcache %}"})
     def test_cache16(self):
         """
         Regression test for #7460.
         """
-        output = self.engine.render_to_string('cache16', {'foo': 'foo', 'bar': 'with spaces'})
-        self.assertEqual(output, '')
+        output = self.engine.render_to_string(
+            "cache16", {"foo": "foo", "bar": "with spaces"}
+        )
+        self.assertEqual(output, "")
 
-    @setup({'cache17': '{% load cache %}{% cache 10 long_cache_key poem %}Some Content{% endcache %}'})
+    @setup(
+        {
+            "cache17": "{% load cache %}{% cache 10 long_cache_key poem %}Some Content{% endcache %}"
+        }
+    )
     def test_cache17(self):
         """
         Regression test for #11270.
         """
         output = self.engine.render_to_string(
-            'cache17',
+            "cache17",
             {
-                'poem': (
-                    'Oh freddled gruntbuggly/Thy micturations are to me/'
-                    'As plurdled gabbleblotchits/On a lurgid bee/'
-                    'That mordiously hath bitled out/Its earted jurtles/'
-                    'Into a rancid festering/Or else I shall rend thee in the gobberwarts'
-                    'with my blurglecruncheon/See if I don\'t.'
+                "poem": (
+                    "Oh freddled gruntbuggly/Thy micturations are to me/"
+                    "As plurdled gabbleblotchits/On a lurgid bee/"
+                    "That mordiously hath bitled out/Its earted jurtles/"
+                    "Into a rancid festering/Or else I shall rend thee in the gobberwarts"
+                    "with my blurglecruncheon/See if I don't."
                 ),
-            }
+            },
         )
-        self.assertEqual(output, 'Some Content')
+        self.assertEqual(output, "Some Content")
 
-    @setup({'cache18': '{% load cache custom %}{% cache 2|noop:"x y" cache18 %}cache18{% endcache %}'})
+    @setup(
+        {
+            "cache18": '{% load cache custom %}{% cache 2|noop:"x y" cache18 %}cache18{% endcache %}'
+        }
+    )
     def test_cache18(self):
         """
         Test whitespace in filter arguments
         """
-        output = self.engine.render_to_string('cache18')
-        self.assertEqual(output, 'cache18')
+        output = self.engine.render_to_string("cache18")
+        self.assertEqual(output, "cache18")
 
-    @setup({
-        'first': '{% load cache %}{% cache None fragment19 %}content{% endcache %}',
-        'second': '{% load cache %}{% cache None fragment19 %}not rendered{% endcache %}'
-    })
+    @setup(
+        {
+            "first": "{% load cache %}{% cache None fragment19 %}content{% endcache %}",
+            "second": "{% load cache %}{% cache None fragment19 %}not rendered{% endcache %}",
+        }
+    )
     def test_none_timeout(self):
         """A timeout of None means "cache forever"."""
-        output = self.engine.render_to_string('first')
-        self.assertEqual(output, 'content')
-        output = self.engine.render_to_string('second')
-        self.assertEqual(output, 'content')
+        output = self.engine.render_to_string("first")
+        self.assertEqual(output, "content")
+        output = self.engine.render_to_string("second")
+        self.assertEqual(output, "content")
 
 
 class CacheTests(SimpleTestCase):
-
     @classmethod
     def setUpClass(cls):
-        cls.engine = Engine(libraries={'cache': 'django.templatetags.cache'})
+        cls.engine = Engine(libraries={"cache": "django.templatetags.cache"})
         super().setUpClass()
 
     def test_cache_regression_20130(self):
-        t = self.engine.from_string('{% load cache %}{% cache 1 regression_20130 %}foo{% endcache %}')
+        t = self.engine.from_string(
+            "{% load cache %}{% cache 1 regression_20130 %}foo{% endcache %}"
+        )
         cachenode = t.nodelist[1]
-        self.assertEqual(cachenode.fragment_name, 'regression_20130')
+        self.assertEqual(cachenode.fragment_name, "regression_20130")
 
-    @override_settings(CACHES={
-        'default': {
-            'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
-            'LOCATION': 'default',
-        },
-        'template_fragments': {
-            'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
-            'LOCATION': 'fragments',
-        },
-    })
+    @override_settings(
+        CACHES={
+            "default": {
+                "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
+                "LOCATION": "default",
+            },
+            "template_fragments": {
+                "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
+                "LOCATION": "fragments",
+            },
+        }
+    )
     def test_cache_fragment_cache(self):
         """
         When a cache called "template_fragments" is present, the cache tag
         will use it in preference to 'default'
         """
-        t1 = self.engine.from_string('{% load cache %}{% cache 1 fragment %}foo{% endcache %}')
-        t2 = self.engine.from_string('{% load cache %}{% cache 1 fragment using="default" %}bar{% endcache %}')
+        t1 = self.engine.from_string(
+            "{% load cache %}{% cache 1 fragment %}foo{% endcache %}"
+        )
+        t2 = self.engine.from_string(
+            '{% load cache %}{% cache 1 fragment using="default" %}bar{% endcache %}'
+        )
 
         ctx = Context()
         o1 = t1.render(ctx)
         o2 = t2.render(ctx)
 
-        self.assertEqual(o1, 'foo')
-        self.assertEqual(o2, 'bar')
+        self.assertEqual(o1, "foo")
+        self.assertEqual(o2, "bar")
 
     def test_cache_missing_backend(self):
         """
         When a cache that doesn't exist is specified, the cache tag will
         raise a TemplateSyntaxError
         '"""
-        t = self.engine.from_string('{% load cache %}{% cache 1 backend using="unknown" %}bar{% endcache %}')
+        t = self.engine.from_string(
+            '{% load cache %}{% cache 1 backend using="unknown" %}bar{% endcache %}'
+        )
 
         ctx = Context()
         with self.assertRaises(TemplateSyntaxError):