Refs #33476 -- Reformatted code with Black.

1 files changed, 175 insertions, 130 deletions

diff --git a/tests/template_tests/syntax_tests/test_include.py b/tests/template_tests/syntax_tests/test_include.py
index 6dac87b7f2..add2ca139f 100644
--- a/tests/template_tests/syntax_tests/test_include.py
+++ b/tests/template_tests/syntax_tests/test_include.py
@@ -1,5 +1,9 @@
 from django.template import (
-    Context, Engine, TemplateDoesNotExist, TemplateSyntaxError, loader,
+    Context,
+    Engine,
+    TemplateDoesNotExist,
+    TemplateSyntaxError,
+    loader,
 )
 from django.template.loader_tags import IncludeNode
 from django.test import SimpleTestCase
@@ -8,201 +12,227 @@ from ..utils import setup
 from .test_basic import basic_templates
 
 include_fail_templates = {
-    'include-fail1': '{% load bad_tag %}{% badtag %}',
-    'include-fail2': '{% load broken_tag %}',
+    "include-fail1": "{% load bad_tag %}{% badtag %}",
+    "include-fail2": "{% load broken_tag %}",
 }
 
 
 class IncludeTagTests(SimpleTestCase):
-    libraries = {'bad_tag': 'template_tests.templatetags.bad_tag'}
+    libraries = {"bad_tag": "template_tests.templatetags.bad_tag"}
 
-    @setup({'include01': '{% include "basic-syntax01" %}'}, basic_templates)
+    @setup({"include01": '{% include "basic-syntax01" %}'}, basic_templates)
     def test_include01(self):
-        output = self.engine.render_to_string('include01')
-        self.assertEqual(output, 'something cool')
+        output = self.engine.render_to_string("include01")
+        self.assertEqual(output, "something cool")
 
-    @setup({'include02': '{% include "basic-syntax02" %}'}, basic_templates)
+    @setup({"include02": '{% include "basic-syntax02" %}'}, basic_templates)
     def test_include02(self):
-        output = self.engine.render_to_string('include02', {'headline': 'Included'})
-        self.assertEqual(output, 'Included')
+        output = self.engine.render_to_string("include02", {"headline": "Included"})
+        self.assertEqual(output, "Included")
 
-    @setup({'include03': '{% include template_name %}'}, basic_templates)
+    @setup({"include03": "{% include template_name %}"}, basic_templates)
     def test_include03(self):
         output = self.engine.render_to_string(
-            'include03',
-            {'template_name': 'basic-syntax02', 'headline': 'Included'},
+            "include03",
+            {"template_name": "basic-syntax02", "headline": "Included"},
         )
-        self.assertEqual(output, 'Included')
+        self.assertEqual(output, "Included")
 
-    @setup({'include04': 'a{% include "nonexistent" %}b'})
+    @setup({"include04": 'a{% include "nonexistent" %}b'})
     def test_include04(self):
-        template = self.engine.get_template('include04')
+        template = self.engine.get_template("include04")
         with self.assertRaises(TemplateDoesNotExist):
             template.render(Context({}))
 
-    @setup({
-        'include 05': 'template with a space',
-        'include06': '{% include "include 05"%}',
-    })
+    @setup(
+        {
+            "include 05": "template with a space",
+            "include06": '{% include "include 05"%}',
+        }
+    )
     def test_include06(self):
-        output = self.engine.render_to_string('include06')
+        output = self.engine.render_to_string("include06")
         self.assertEqual(output, "template with a space")
 
-    @setup({'include07': '{% include "basic-syntax02" with headline="Inline" %}'}, basic_templates)
+    @setup(
+        {"include07": '{% include "basic-syntax02" with headline="Inline" %}'},
+        basic_templates,
+    )
     def test_include07(self):
-        output = self.engine.render_to_string('include07', {'headline': 'Included'})
-        self.assertEqual(output, 'Inline')
+        output = self.engine.render_to_string("include07", {"headline": "Included"})
+        self.assertEqual(output, "Inline")
 
-    @setup({'include08': '{% include headline with headline="Dynamic" %}'}, basic_templates)
+    @setup(
+        {"include08": '{% include headline with headline="Dynamic" %}'}, basic_templates
+    )
     def test_include08(self):
-        output = self.engine.render_to_string('include08', {'headline': 'basic-syntax02'})
-        self.assertEqual(output, 'Dynamic')
+        output = self.engine.render_to_string(
+            "include08", {"headline": "basic-syntax02"}
+        )
+        self.assertEqual(output, "Dynamic")
 
     @setup(
-        {'include09': '{{ first }}--'
-                      '{% include "basic-syntax03" with first=second|lower|upper second=first|upper %}'
-                      '--{{ second }}'},
+        {
+            "include09": "{{ first }}--"
+            '{% include "basic-syntax03" with first=second|lower|upper second=first|upper %}'
+            "--{{ second }}"
+        },
         basic_templates,
     )
     def test_include09(self):
-        output = self.engine.render_to_string('include09', {'first': 'Ul', 'second': 'lU'})
-        self.assertEqual(output, 'Ul--LU --- UL--lU')
+        output = self.engine.render_to_string(
+            "include09", {"first": "Ul", "second": "lU"}
+        )
+        self.assertEqual(output, "Ul--LU --- UL--lU")
 
-    @setup({'include10': '{% include "basic-syntax03" only %}'}, basic_templates)
+    @setup({"include10": '{% include "basic-syntax03" only %}'}, basic_templates)
     def test_include10(self):
-        output = self.engine.render_to_string('include10', {'first': '1'})
+        output = self.engine.render_to_string("include10", {"first": "1"})
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'INVALID --- INVALID')
+            self.assertEqual(output, "INVALID --- INVALID")
         else:
-            self.assertEqual(output, ' --- ')
+            self.assertEqual(output, " --- ")
 
-    @setup({'include11': '{% include "basic-syntax03" only with second=2 %}'}, basic_templates)
+    @setup(
+        {"include11": '{% include "basic-syntax03" only with second=2 %}'},
+        basic_templates,
+    )
     def test_include11(self):
-        output = self.engine.render_to_string('include11', {'first': '1'})
+        output = self.engine.render_to_string("include11", {"first": "1"})
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'INVALID --- 2')
+            self.assertEqual(output, "INVALID --- 2")
         else:
-            self.assertEqual(output, ' --- 2')
+            self.assertEqual(output, " --- 2")
 
-    @setup({'include12': '{% include "basic-syntax03" with first=1 only %}'}, basic_templates)
+    @setup(
+        {"include12": '{% include "basic-syntax03" with first=1 only %}'},
+        basic_templates,
+    )
     def test_include12(self):
-        output = self.engine.render_to_string('include12', {'second': '2'})
+        output = self.engine.render_to_string("include12", {"second": "2"})
         if self.engine.string_if_invalid:
-            self.assertEqual(output, '1 --- INVALID')
+            self.assertEqual(output, "1 --- INVALID")
         else:
-            self.assertEqual(output, '1 --- ')
+            self.assertEqual(output, "1 --- ")
 
     @setup(
-        {'include13': '{% autoescape off %}{% include "basic-syntax03" %}{% endautoescape %}'},
+        {
+            "include13": '{% autoescape off %}{% include "basic-syntax03" %}{% endautoescape %}'
+        },
         basic_templates,
     )
     def test_include13(self):
-        output = self.engine.render_to_string('include13', {'first': '&'})
+        output = self.engine.render_to_string("include13", {"first": "&"})
         if self.engine.string_if_invalid:
-            self.assertEqual(output, '& --- INVALID')
+            self.assertEqual(output, "& --- INVALID")
         else:
-            self.assertEqual(output, '& --- ')
+            self.assertEqual(output, "& --- ")
 
     @setup(
-        {'include14': '{% autoescape off %}'
-                      '{% include "basic-syntax03" with first=var1 only %}'
-                      '{% endautoescape %}'},
+        {
+            "include14": "{% autoescape off %}"
+            '{% include "basic-syntax03" with first=var1 only %}'
+            "{% endautoescape %}"
+        },
         basic_templates,
     )
     def test_include14(self):
-        output = self.engine.render_to_string('include14', {'var1': '&'})
+        output = self.engine.render_to_string("include14", {"var1": "&"})
         if self.engine.string_if_invalid:
-            self.assertEqual(output, '& --- INVALID')
+            self.assertEqual(output, "& --- INVALID")
         else:
-            self.assertEqual(output, '& --- ')
+            self.assertEqual(output, "& --- ")
 
     # Include syntax errors
-    @setup({'include-error01': '{% include "basic-syntax01" with %}'})
+    @setup({"include-error01": '{% include "basic-syntax01" with %}'})
     def test_include_error01(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('include-error01')
+            self.engine.get_template("include-error01")
 
-    @setup({'include-error02': '{% include "basic-syntax01" with "no key" %}'})
+    @setup({"include-error02": '{% include "basic-syntax01" with "no key" %}'})
     def test_include_error02(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('include-error02')
+            self.engine.get_template("include-error02")
 
-    @setup({'include-error03': '{% include "basic-syntax01" with dotted.arg="error" %}'})
+    @setup(
+        {"include-error03": '{% include "basic-syntax01" with dotted.arg="error" %}'}
+    )
     def test_include_error03(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('include-error03')
+            self.engine.get_template("include-error03")
 
-    @setup({'include-error04': '{% include "basic-syntax01" something_random %}'})
+    @setup({"include-error04": '{% include "basic-syntax01" something_random %}'})
     def test_include_error04(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('include-error04')
+            self.engine.get_template("include-error04")
 
-    @setup({'include-error05': '{% include "basic-syntax01" foo="duplicate" foo="key" %}'})
+    @setup(
+        {"include-error05": '{% include "basic-syntax01" foo="duplicate" foo="key" %}'}
+    )
     def test_include_error05(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('include-error05')
+            self.engine.get_template("include-error05")
 
-    @setup({'include-error06': '{% include "basic-syntax01" only only %}'})
+    @setup({"include-error06": '{% include "basic-syntax01" only only %}'})
     def test_include_error06(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('include-error06')
+            self.engine.get_template("include-error06")
 
     @setup(include_fail_templates)
     def test_include_fail1(self):
         with self.assertRaises(RuntimeError):
-            self.engine.get_template('include-fail1')
+            self.engine.get_template("include-fail1")
 
     @setup(include_fail_templates)
     def test_include_fail2(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('include-fail2')
+            self.engine.get_template("include-fail2")
 
-    @setup({'include-error07': '{% include "include-fail1" %}'}, include_fail_templates)
+    @setup({"include-error07": '{% include "include-fail1" %}'}, include_fail_templates)
     def test_include_error07(self):
-        template = self.engine.get_template('include-error07')
+        template = self.engine.get_template("include-error07")
         with self.assertRaises(RuntimeError):
             template.render(Context())
 
-    @setup({'include-error08': '{% include "include-fail2" %}'}, include_fail_templates)
+    @setup({"include-error08": '{% include "include-fail2" %}'}, include_fail_templates)
     def test_include_error08(self):
-        template = self.engine.get_template('include-error08')
+        template = self.engine.get_template("include-error08")
         with self.assertRaises(TemplateSyntaxError):
             template.render(Context())
 
-    @setup({'include-error09': '{% include failed_include %}'}, include_fail_templates)
+    @setup({"include-error09": "{% include failed_include %}"}, include_fail_templates)
     def test_include_error09(self):
-        context = Context({'failed_include': 'include-fail1'})
-        template = self.engine.get_template('include-error09')
+        context = Context({"failed_include": "include-fail1"})
+        template = self.engine.get_template("include-error09")
         with self.assertRaises(RuntimeError):
             template.render(context)
 
-    @setup({'include-error10': '{% include failed_include %}'}, include_fail_templates)
+    @setup({"include-error10": "{% include failed_include %}"}, include_fail_templates)
     def test_include_error10(self):
-        context = Context({'failed_include': 'include-fail2'})
-        template = self.engine.get_template('include-error10')
+        context = Context({"failed_include": "include-fail2"})
+        template = self.engine.get_template("include-error10")
         with self.assertRaises(TemplateSyntaxError):
             template.render(context)
 
-    @setup({'include_empty': '{% include %}'})
+    @setup({"include_empty": "{% include %}"})
     def test_include_empty(self):
         msg = (
             "'include' tag takes at least one argument: the name of the "
             "template to be included."
         )
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.get_template('include_empty')
+            self.engine.get_template("include_empty")
 
 
 class IncludeTests(SimpleTestCase):
-
     def test_include_missing_template(self):
         """
         The correct template is identified as not existing
         when {% include %} specifies a template that does not exist.
         """
         engine = Engine(app_dirs=True, debug=True)
-        template = engine.get_template('test_include_error.html')
-        with self.assertRaisesMessage(TemplateDoesNotExist, 'missing.html'):
+        template = engine.get_template("test_include_error.html")
+        with self.assertRaisesMessage(TemplateDoesNotExist, "missing.html"):
             template.render(Context())
 
     def test_extends_include_missing_baseloader(self):
@@ -212,24 +242,30 @@ class IncludeTests(SimpleTestCase):
         template has an {% include %} of something that does not exist.
         """
         engine = Engine(app_dirs=True, debug=True)
-        template = engine.get_template('test_extends_error.html')
-        with self.assertRaisesMessage(TemplateDoesNotExist, 'missing.html'):
+        template = engine.get_template("test_extends_error.html")
+        with self.assertRaisesMessage(TemplateDoesNotExist, "missing.html"):
             template.render(Context())
 
     def test_extends_include_missing_cachedloader(self):
-        engine = Engine(debug=True, loaders=[
-            ('django.template.loaders.cached.Loader', [
-                'django.template.loaders.app_directories.Loader',
-            ]),
-        ])
+        engine = Engine(
+            debug=True,
+            loaders=[
+                (
+                    "django.template.loaders.cached.Loader",
+                    [
+                        "django.template.loaders.app_directories.Loader",
+                    ],
+                ),
+            ],
+        )
 
-        template = engine.get_template('test_extends_error.html')
-        with self.assertRaisesMessage(TemplateDoesNotExist, 'missing.html'):
+        template = engine.get_template("test_extends_error.html")
+        with self.assertRaisesMessage(TemplateDoesNotExist, "missing.html"):
             template.render(Context())
 
         # Repeat to ensure it still works when loading from the cache
-        template = engine.get_template('test_extends_error.html')
-        with self.assertRaisesMessage(TemplateDoesNotExist, 'missing.html'):
+        template = engine.get_template("test_extends_error.html")
+        with self.assertRaisesMessage(TemplateDoesNotExist, "missing.html"):
             template.render(Context())
 
     def test_include_template_argument(self):
@@ -237,37 +273,39 @@ class IncludeTests(SimpleTestCase):
         Support any render() supporting object
         """
         engine = Engine()
-        ctx = Context({
-            'tmpl': engine.from_string('This worked!'),
-        })
-        outer_tmpl = engine.from_string('{% include tmpl %}')
+        ctx = Context(
+            {
+                "tmpl": engine.from_string("This worked!"),
+            }
+        )
+        outer_tmpl = engine.from_string("{% include tmpl %}")
         output = outer_tmpl.render(ctx)
-        self.assertEqual(output, 'This worked!')
+        self.assertEqual(output, "This worked!")
 
     def test_include_template_iterable(self):
         engine = Engine.get_default()
-        outer_temp = engine.from_string('{% include var %}')
+        outer_temp = engine.from_string("{% include var %}")
         tests = [
-            ('admin/fail.html', 'index.html'),
-            ['admin/fail.html', 'index.html'],
+            ("admin/fail.html", "index.html"),
+            ["admin/fail.html", "index.html"],
         ]
         for template_names in tests:
             with self.subTest(template_names):
-                output = outer_temp.render(Context({'var': template_names}))
-                self.assertEqual(output, 'index\n')
+                output = outer_temp.render(Context({"var": template_names}))
+                self.assertEqual(output, "index\n")
 
     def test_include_template_none(self):
         engine = Engine.get_default()
-        outer_temp = engine.from_string('{% include var %}')
-        ctx = Context({'var': None})
-        msg = 'No template names provided'
+        outer_temp = engine.from_string("{% include var %}")
+        ctx = Context({"var": None})
+        msg = "No template names provided"
         with self.assertRaisesMessage(TemplateDoesNotExist, msg):
             outer_temp.render(ctx)
 
     def test_include_from_loader_get_template(self):
-        tmpl = loader.get_template('include_tpl.html')  # {% include tmpl %}
-        output = tmpl.render({'tmpl': loader.get_template('index.html')})
-        self.assertEqual(output, 'index\n\n')
+        tmpl = loader.get_template("include_tpl.html")  # {% include tmpl %}
+        output = tmpl.render({"tmpl": loader.get_template("index.html")})
+        self.assertEqual(output, "index\n\n")
 
     def test_include_immediate_missing(self):
         """
@@ -279,21 +317,22 @@ class IncludeTests(SimpleTestCase):
     def test_include_recursive(self):
         comments = [
             {
-                'comment': 'A1',
-                'children': [
-                    {'comment': 'B1', 'children': []},
-                    {'comment': 'B2', 'children': []},
-                    {'comment': 'B3', 'children': [
-                        {'comment': 'C1', 'children': []}
-                    ]},
-                ]
+                "comment": "A1",
+                "children": [
+                    {"comment": "B1", "children": []},
+                    {"comment": "B2", "children": []},
+                    {"comment": "B3", "children": [{"comment": "C1", "children": []}]},
+                ],
             }
         ]
         engine = Engine(app_dirs=True)
-        t = engine.get_template('recursive_include.html')
+        t = engine.get_template("recursive_include.html")
         self.assertEqual(
             "Recursion!  A1  Recursion!  B1   B2   B3  Recursion!  C1",
-            t.render(Context({'comments': comments})).replace(' ', '').replace('\n', ' ').strip(),
+            t.render(Context({"comments": comments}))
+            .replace(" ", "")
+            .replace("\n", " ")
+            .strip(),
         )
 
     def test_include_cache(self):
@@ -306,20 +345,26 @@ class IncludeTests(SimpleTestCase):
         This works as a regression test only if the cached loader
         isn't used, so the @setup decorator isn't used.
         """
-        engine = Engine(loaders=[
-            ('django.template.loaders.locmem.Loader', {
-                'template': '{% for x in vars %}{% include "include" %}{% endfor %}',
-                'include': '{% include "next" %}',
-                'next': '{% load custom %}{% counter %}'
-            }),
-        ], libraries={'custom': 'template_tests.templatetags.custom'})
-        output = engine.render_to_string('template', {'vars': range(9)})
-        self.assertEqual(output, '012345678')
+        engine = Engine(
+            loaders=[
+                (
+                    "django.template.loaders.locmem.Loader",
+                    {
+                        "template": '{% for x in vars %}{% include "include" %}{% endfor %}',
+                        "include": '{% include "next" %}',
+                        "next": "{% load custom %}{% counter %}",
+                    },
+                ),
+            ],
+            libraries={"custom": "template_tests.templatetags.custom"},
+        )
+        output = engine.render_to_string("template", {"vars": range(9)})
+        self.assertEqual(output, "012345678")
 
 
 class IncludeNodeTests(SimpleTestCase):
     def test_repr(self):
-        include_node = IncludeNode('app/template.html')
+        include_node = IncludeNode("app/template.html")
         self.assertEqual(
             repr(include_node),
             "<IncludeNode: template='app/template.html'>",