django/tests/template_tests/syntax_tests/test_include.py

379 lines
14 KiB
Python

from django.template import (
Context,
Engine,
TemplateDoesNotExist,
TemplateSyntaxError,
loader,
)
from django.template.loader_tags import IncludeNode
from django.test import SimpleTestCase
from ..utils import setup
from .test_basic import basic_templates
include_fail_templates = {
"include-fail1": "{% load bad_tag %}{% badtag %}",
"include-fail2": "{% load broken_tag %}",
}
class IncludeTagTests(SimpleTestCase):
libraries = {"bad_tag": "template_tests.templatetags.bad_tag"}
@setup({"include01": '{% include "basic-syntax01" %}'}, basic_templates)
def test_include01(self):
output = self.engine.render_to_string("include01")
self.assertEqual(output, "something cool")
@setup({"include02": '{% include "basic-syntax02" %}'}, basic_templates)
def test_include02(self):
output = self.engine.render_to_string("include02", {"headline": "Included"})
self.assertEqual(output, "Included")
@setup({"include03": "{% include template_name %}"}, basic_templates)
def test_include03(self):
output = self.engine.render_to_string(
"include03",
{"template_name": "basic-syntax02", "headline": "Included"},
)
self.assertEqual(output, "Included")
@setup({"include04": 'a{% include "nonexistent" %}b'})
def test_include04(self):
template = self.engine.get_template("include04")
with self.assertRaises(TemplateDoesNotExist):
template.render(Context({}))
@setup(
{
"include 05": "template with a space",
"include06": '{% include "include 05"%}',
}
)
def test_include06(self):
output = self.engine.render_to_string("include06")
self.assertEqual(output, "template with a space")
@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")
@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")
@setup(
{
"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")
@setup({"include10": '{% include "basic-syntax03" only %}'}, basic_templates)
def test_include10(self):
output = self.engine.render_to_string("include10", {"first": "1"})
if self.engine.string_if_invalid:
self.assertEqual(output, "INVALID --- INVALID")
else:
self.assertEqual(output, " --- ")
@setup(
{"include11": '{% include "basic-syntax03" only with second=2 %}'},
basic_templates,
)
def test_include11(self):
output = self.engine.render_to_string("include11", {"first": "1"})
if self.engine.string_if_invalid:
self.assertEqual(output, "INVALID --- 2")
else:
self.assertEqual(output, " --- 2")
@setup(
{"include12": '{% include "basic-syntax03" with first=1 only %}'},
basic_templates,
)
def test_include12(self):
output = self.engine.render_to_string("include12", {"second": "2"})
if self.engine.string_if_invalid:
self.assertEqual(output, "1 --- INVALID")
else:
self.assertEqual(output, "1 --- ")
@setup(
{
"include13": (
'{% autoescape off %}{% include "basic-syntax03" %}{% endautoescape %}'
)
},
basic_templates,
)
def test_include13(self):
output = self.engine.render_to_string("include13", {"first": "&"})
if self.engine.string_if_invalid:
self.assertEqual(output, "& --- INVALID")
else:
self.assertEqual(output, "& --- ")
@setup(
{
"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": "&"})
if self.engine.string_if_invalid:
self.assertEqual(output, "& --- INVALID")
else:
self.assertEqual(output, "& --- ")
# Include syntax errors
@setup({"include-error01": '{% include "basic-syntax01" with %}'})
def test_include_error01(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("include-error01")
@setup({"include-error02": '{% include "basic-syntax01" with "no key" %}'})
def test_include_error02(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("include-error02")
@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")
@setup({"include-error04": '{% include "basic-syntax01" something_random %}'})
def test_include_error04(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("include-error04")
@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")
@setup({"include-error06": '{% include "basic-syntax01" only only %}'})
def test_include_error06(self):
with self.assertRaises(TemplateSyntaxError):
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")
@setup(include_fail_templates)
def test_include_fail2(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("include-fail2")
@setup({"include-error07": '{% include "include-fail1" %}'}, include_fail_templates)
def test_include_error07(self):
template = self.engine.get_template("include-error07")
with self.assertRaises(RuntimeError):
template.render(Context())
@setup({"include-error08": '{% include "include-fail2" %}'}, include_fail_templates)
def test_include_error08(self):
template = self.engine.get_template("include-error08")
with self.assertRaises(TemplateSyntaxError):
template.render(Context())
@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")
with self.assertRaises(RuntimeError):
template.render(context)
@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")
with self.assertRaises(TemplateSyntaxError):
template.render(context)
@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")
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.render(Context())
def test_extends_include_missing_baseloader(self):
"""
#12787 -- The correct template is identified as not existing
when {% extends %} specifies a template that does exist, but that
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.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",
],
),
],
)
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.render(Context())
def test_include_template_argument(self):
"""
Support any render() supporting object
"""
engine = Engine()
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!")
def test_include_template_iterable(self):
engine = Engine.get_default()
outer_temp = engine.from_string("{% include var %}")
tests = [
("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")
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"
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")
def test_include_immediate_missing(self):
"""
#16417 -- Include tags pointing to missing templates should not raise
an error at parsing time.
"""
Engine(debug=True).from_string('{% include "this_does_not_exist.html" %}')
def test_include_recursive(self):
comments = [
{
"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")
self.assertEqual(
"Recursion! A1 Recursion! B1 B2 B3 Recursion! C1",
t.render(Context({"comments": comments}))
.replace(" ", "")
.replace("\n", " ")
.strip(),
)
def test_include_cache(self):
"""
{% include %} keeps resolved templates constant (#27974). The
CounterNode object in the {% counter %} template tag is created once
if caching works properly. Each iteration increases the counter instead
of restarting it.
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")
class IncludeNodeTests(SimpleTestCase):
def test_repr(self):
include_node = IncludeNode("app/template.html")
self.assertEqual(
repr(include_node),
"<IncludeNode: template='app/template.html'>",
)