mirror of
https://github.com/django/django.git
synced 2025-10-31 01:25:32 +00:00
605 lines
21 KiB
Python
605 lines
21 KiB
Python
import os
|
|
from unittest import mock
|
|
|
|
from django.http import HttpResponse
|
|
from django.template import (
|
|
Context,
|
|
NodeList,
|
|
Origin,
|
|
PartialTemplate,
|
|
Template,
|
|
TemplateDoesNotExist,
|
|
TemplateSyntaxError,
|
|
engines,
|
|
)
|
|
from django.template.backends.django import DjangoTemplates
|
|
from django.template.loader import render_to_string
|
|
from django.test import TestCase, override_settings
|
|
from django.urls import path, reverse
|
|
|
|
from .utils import setup
|
|
|
|
engine = engines["django"]
|
|
|
|
|
|
class PartialTagsTests(TestCase):
|
|
|
|
def test_invalid_template_name_raises_template_does_not_exist(self):
|
|
for template_name in [123, None, "", "#", "#name"]:
|
|
with (
|
|
self.subTest(template_name=template_name),
|
|
self.assertRaisesMessage(TemplateDoesNotExist, str(template_name)),
|
|
):
|
|
engine.get_template(template_name)
|
|
|
|
def test_full_template_from_loader(self):
|
|
template = engine.get_template("partial_examples.html")
|
|
rendered = template.render({})
|
|
|
|
# Check the partial was rendered twice
|
|
self.assertEqual(2, rendered.count("TEST-PARTIAL-CONTENT"))
|
|
self.assertEqual(1, rendered.count("INLINE-CONTENT"))
|
|
|
|
def test_chained_exception_forwarded(self):
|
|
with self.assertRaises(TemplateDoesNotExist) as ctx:
|
|
engine.get_template("not_there.html#not-a-partial")
|
|
|
|
exception = ctx.exception
|
|
self.assertGreater(len(exception.tried), 0)
|
|
origin, _ = exception.tried[0]
|
|
self.assertEqual(origin.template_name, "not_there.html")
|
|
|
|
def test_partials_use_cached_loader_when_configured(self):
|
|
template_dir = os.path.join(os.path.dirname(__file__), "templates")
|
|
backend = DjangoTemplates(
|
|
{
|
|
"NAME": "django",
|
|
"DIRS": [template_dir],
|
|
"APP_DIRS": False,
|
|
"OPTIONS": {
|
|
"loaders": [
|
|
(
|
|
"django.template.loaders.cached.Loader",
|
|
["django.template.loaders.filesystem.Loader"],
|
|
),
|
|
],
|
|
},
|
|
}
|
|
)
|
|
cached_loader = backend.engine.template_loaders[0]
|
|
filesystem_loader = cached_loader.loaders[0]
|
|
|
|
with mock.patch.object(
|
|
filesystem_loader, "get_contents", wraps=filesystem_loader.get_contents
|
|
) as mock_get_contents:
|
|
full_template = backend.get_template("partial_examples.html")
|
|
self.assertIn("TEST-PARTIAL-CONTENT", full_template.render({}))
|
|
|
|
partial_template = backend.get_template(
|
|
"partial_examples.html#test-partial"
|
|
)
|
|
self.assertEqual(
|
|
"TEST-PARTIAL-CONTENT", partial_template.render({}).strip()
|
|
)
|
|
|
|
mock_get_contents.assert_called_once()
|
|
|
|
def test_context_available_in_response_for_partial_template(self):
|
|
def sample_view(request):
|
|
return HttpResponse(
|
|
render_to_string("partial_examples.html#test-partial", {"foo": "bar"})
|
|
)
|
|
|
|
class PartialUrls:
|
|
urlpatterns = [path("sample/", sample_view, name="sample-view")]
|
|
|
|
with override_settings(ROOT_URLCONF=PartialUrls):
|
|
response = self.client.get(reverse("sample-view"))
|
|
|
|
self.assertContains(response, "TEST-PARTIAL-CONTENT")
|
|
self.assertEqual(response.context.get("foo"), "bar")
|
|
|
|
def test_response_with_multiple_parts(self):
|
|
context = {}
|
|
template_partials = ["partial_child.html", "partial_child.html#extra-content"]
|
|
|
|
response_whole_content_at_once = HttpResponse(
|
|
"".join(
|
|
render_to_string(template_name, context)
|
|
for template_name in template_partials
|
|
)
|
|
)
|
|
|
|
response_with_multiple_writes = HttpResponse()
|
|
for template_name in template_partials:
|
|
response_with_multiple_writes.write(
|
|
render_to_string(template_name, context)
|
|
)
|
|
|
|
response_with_generator = HttpResponse(
|
|
render_to_string(template_name, context)
|
|
for template_name in template_partials
|
|
)
|
|
|
|
for label, response in [
|
|
("response_whole_content_at_once", response_whole_content_at_once),
|
|
("response_with_multiple_writes", response_with_multiple_writes),
|
|
("response_with_generator", response_with_generator),
|
|
]:
|
|
with self.subTest(response=label):
|
|
self.assertIn(b"Main Content", response.content)
|
|
self.assertIn(b"Extra Content", response.content)
|
|
|
|
def test_partial_engine_assignment_with_real_template(self):
|
|
template_with_partial = engine.get_template(
|
|
"partial_examples.html#test-partial"
|
|
)
|
|
self.assertEqual(template_with_partial.template.engine, engine.engine)
|
|
rendered_content = template_with_partial.render({})
|
|
self.assertEqual("TEST-PARTIAL-CONTENT", rendered_content.strip())
|
|
|
|
def test_template_source_warning(self):
|
|
partial = engine.get_template("partial_examples.html#test-partial")
|
|
with self.assertWarnsMessage(
|
|
RuntimeWarning,
|
|
"PartialTemplate.source is only available when template "
|
|
"debugging is enabled.",
|
|
) as ctx:
|
|
self.assertEqual(partial.template.source, "")
|
|
self.assertEqual(ctx.filename, __file__)
|
|
|
|
|
|
class RobustPartialHandlingTests(TestCase):
|
|
|
|
def override_get_template(self, **kwargs):
|
|
class TemplateWithCustomAttrs:
|
|
def __init__(self, **kwargs):
|
|
for k, v in kwargs.items():
|
|
setattr(self, k, v)
|
|
|
|
def render(self, context):
|
|
return "rendered content"
|
|
|
|
template = TemplateWithCustomAttrs(**kwargs)
|
|
origin = self.id()
|
|
return mock.patch.object(
|
|
engine.engine,
|
|
"find_template",
|
|
return_value=(template, origin),
|
|
)
|
|
|
|
def test_template_without_extra_data_attribute(self):
|
|
partial_name = "some_partial_name"
|
|
with (
|
|
self.override_get_template(),
|
|
self.assertRaisesMessage(TemplateDoesNotExist, partial_name),
|
|
):
|
|
engine.get_template(f"some_template.html#{partial_name}")
|
|
|
|
def test_template_extract_extra_data_robust(self):
|
|
partial_name = "some_partial_name"
|
|
for extra_data in (
|
|
None,
|
|
0,
|
|
[],
|
|
{},
|
|
{"wrong-key": {}},
|
|
{"partials": None},
|
|
{"partials": {}},
|
|
{"partials": []},
|
|
{"partials": 0},
|
|
):
|
|
with (
|
|
self.subTest(extra_data=extra_data),
|
|
self.override_get_template(extra_data=extra_data),
|
|
self.assertRaisesMessage(TemplateDoesNotExist, partial_name),
|
|
):
|
|
engine.get_template(f"template.html#{partial_name}")
|
|
|
|
def test_nested_partials_rendering_with_context(self):
|
|
template_source = """
|
|
{% partialdef outer inline %}
|
|
Hello {{ name }}!
|
|
{% partialdef inner inline %}
|
|
Your age is {{ age }}.
|
|
{% endpartialdef inner %}
|
|
Nice to meet you.
|
|
{% endpartialdef outer %}
|
|
"""
|
|
template = Template(template_source, origin=Origin(name="template.html"))
|
|
|
|
context = Context({"name": "Alice", "age": 25})
|
|
rendered = template.render(context)
|
|
|
|
self.assertIn("Hello Alice!", rendered)
|
|
self.assertIn("Your age is 25.", rendered)
|
|
self.assertIn("Nice to meet you.", rendered)
|
|
|
|
|
|
class FindPartialSourceTests(TestCase):
|
|
|
|
@setup(
|
|
{
|
|
"partial_source_success_template": (
|
|
"{% partialdef test-partial %}\n"
|
|
"TEST-PARTIAL-CONTENT\n"
|
|
"{% endpartialdef %}\n"
|
|
),
|
|
},
|
|
debug_only=True,
|
|
)
|
|
def test_find_partial_source_success(self):
|
|
template = self.engine.get_template("partial_source_success_template")
|
|
partial_proxy = template.extra_data["partials"]["test-partial"]
|
|
|
|
expected = """{% partialdef test-partial %}
|
|
TEST-PARTIAL-CONTENT
|
|
{% endpartialdef %}"""
|
|
self.assertEqual(partial_proxy.source.strip(), expected.strip())
|
|
|
|
@setup(
|
|
{
|
|
"partial_source_with_inline_template": (
|
|
"{% partialdef inline-partial inline %}\n"
|
|
"INLINE-CONTENT\n"
|
|
"{% endpartialdef %}\n"
|
|
),
|
|
},
|
|
debug_only=True,
|
|
)
|
|
def test_find_partial_source_with_inline(self):
|
|
template = self.engine.get_template("partial_source_with_inline_template")
|
|
partial_proxy = template.extra_data["partials"]["inline-partial"]
|
|
|
|
expected = """{% partialdef inline-partial inline %}
|
|
INLINE-CONTENT
|
|
{% endpartialdef %}"""
|
|
self.assertEqual(partial_proxy.source.strip(), expected.strip())
|
|
|
|
def test_find_partial_source_fallback_cases(self):
|
|
cases = {"None offsets": (None, None), "Out of bounds offsets": (10, 20)}
|
|
for name, (source_start, source_end) in cases.items():
|
|
with self.subTest(name):
|
|
partial = PartialTemplate(
|
|
NodeList(),
|
|
Origin("test"),
|
|
"test",
|
|
source_start=source_start,
|
|
source_end=source_end,
|
|
)
|
|
result = partial.find_partial_source("nonexistent-partial")
|
|
self.assertEqual(result, "")
|
|
|
|
@setup(
|
|
{
|
|
"empty_partial_template": ("{% partialdef empty %}{% endpartialdef %}"),
|
|
},
|
|
debug_only=True,
|
|
)
|
|
def test_find_partial_source_empty_partial(self):
|
|
template = self.engine.get_template("empty_partial_template")
|
|
partial_proxy = template.extra_data["partials"]["empty"]
|
|
|
|
result = partial_proxy.find_partial_source(template.source)
|
|
self.assertEqual(result, "{% partialdef empty %}{% endpartialdef %}")
|
|
|
|
@setup(
|
|
{
|
|
"consecutive_partials_template": (
|
|
"{% partialdef empty %}{% endpartialdef %}"
|
|
"{% partialdef other %}...{% endpartialdef %}"
|
|
),
|
|
},
|
|
debug_only=True,
|
|
)
|
|
def test_find_partial_source_multiple_consecutive_partials(self):
|
|
template = self.engine.get_template("consecutive_partials_template")
|
|
|
|
empty_proxy = template.extra_data["partials"]["empty"]
|
|
other_proxy = template.extra_data["partials"]["other"]
|
|
|
|
empty_result = empty_proxy.find_partial_source(template.source)
|
|
self.assertEqual(empty_result, "{% partialdef empty %}{% endpartialdef %}")
|
|
|
|
other_result = other_proxy.find_partial_source(template.source)
|
|
self.assertEqual(other_result, "{% partialdef other %}...{% endpartialdef %}")
|
|
|
|
def test_partials_with_duplicate_names(self):
|
|
test_cases = [
|
|
(
|
|
"nested",
|
|
"""
|
|
{% partialdef duplicate %}{% partialdef duplicate %}
|
|
CONTENT
|
|
{% endpartialdef %}{% endpartialdef %}
|
|
""",
|
|
),
|
|
(
|
|
"conditional",
|
|
"""
|
|
{% if ... %}
|
|
{% partialdef duplicate %}
|
|
CONTENT
|
|
{% endpartialdef %}
|
|
{% else %}
|
|
{% partialdef duplicate %}
|
|
OTHER-CONTENT
|
|
{% endpartialdef %}
|
|
{% endif %}
|
|
""",
|
|
),
|
|
]
|
|
|
|
for test_name, template_source in test_cases:
|
|
with self.subTest(test_name=test_name):
|
|
with self.assertRaisesMessage(
|
|
TemplateSyntaxError,
|
|
"Partial 'duplicate' is already defined in the "
|
|
"'template.html' template.",
|
|
):
|
|
Template(template_source, origin=Origin(name="template.html"))
|
|
|
|
@setup(
|
|
{
|
|
"named_end_tag_template": (
|
|
"{% partialdef thing %}CONTENT{% endpartialdef thing %}"
|
|
),
|
|
},
|
|
debug_only=True,
|
|
)
|
|
def test_find_partial_source_supports_named_end_tag(self):
|
|
template = self.engine.get_template("named_end_tag_template")
|
|
partial_proxy = template.extra_data["partials"]["thing"]
|
|
|
|
result = partial_proxy.find_partial_source(template.source)
|
|
self.assertEqual(
|
|
result, "{% partialdef thing %}CONTENT{% endpartialdef thing %}"
|
|
)
|
|
|
|
@setup(
|
|
{
|
|
"nested_partials_basic_template": (
|
|
"{% partialdef outer %}"
|
|
"{% partialdef inner %}...{% endpartialdef %}"
|
|
"{% endpartialdef %}"
|
|
),
|
|
},
|
|
debug_only=True,
|
|
)
|
|
def test_find_partial_source_supports_nested_partials(self):
|
|
template = self.engine.get_template("nested_partials_basic_template")
|
|
|
|
empty_proxy = template.extra_data["partials"]["outer"]
|
|
other_proxy = template.extra_data["partials"]["inner"]
|
|
|
|
outer_result = empty_proxy.find_partial_source(template.source)
|
|
self.assertEqual(
|
|
outer_result,
|
|
(
|
|
"{% partialdef outer %}{% partialdef inner %}"
|
|
"...{% endpartialdef %}{% endpartialdef %}"
|
|
),
|
|
)
|
|
|
|
inner_result = other_proxy.find_partial_source(template.source)
|
|
self.assertEqual(inner_result, "{% partialdef inner %}...{% endpartialdef %}")
|
|
|
|
@setup(
|
|
{
|
|
"nested_partials_named_end_template": (
|
|
"{% partialdef outer %}"
|
|
"{% partialdef inner %}...{% endpartialdef inner %}"
|
|
"{% endpartialdef outer %}"
|
|
),
|
|
},
|
|
debug_only=True,
|
|
)
|
|
def test_find_partial_source_supports_nested_partials_and_named_end_tags(self):
|
|
template = self.engine.get_template("nested_partials_named_end_template")
|
|
|
|
empty_proxy = template.extra_data["partials"]["outer"]
|
|
other_proxy = template.extra_data["partials"]["inner"]
|
|
|
|
outer_result = empty_proxy.find_partial_source(template.source)
|
|
self.assertEqual(
|
|
outer_result,
|
|
(
|
|
"{% partialdef outer %}{% partialdef inner %}"
|
|
"...{% endpartialdef inner %}{% endpartialdef outer %}"
|
|
),
|
|
)
|
|
|
|
inner_result = other_proxy.find_partial_source(template.source)
|
|
self.assertEqual(
|
|
inner_result, "{% partialdef inner %}...{% endpartialdef inner %}"
|
|
)
|
|
|
|
@setup(
|
|
{
|
|
"nested_partials_mixed_end_1_template": (
|
|
"{% partialdef outer %}"
|
|
"{% partialdef inner %}...{% endpartialdef %}"
|
|
"{% endpartialdef outer %}"
|
|
),
|
|
},
|
|
debug_only=True,
|
|
)
|
|
def test_find_partial_source_supports_nested_partials_and_mixed_end_tags_1(self):
|
|
template = self.engine.get_template("nested_partials_mixed_end_1_template")
|
|
|
|
empty_proxy = template.extra_data["partials"]["outer"]
|
|
other_proxy = template.extra_data["partials"]["inner"]
|
|
|
|
outer_result = empty_proxy.find_partial_source(template.source)
|
|
self.assertEqual(
|
|
outer_result,
|
|
(
|
|
"{% partialdef outer %}{% partialdef inner %}"
|
|
"...{% endpartialdef %}{% endpartialdef outer %}"
|
|
),
|
|
)
|
|
|
|
inner_result = other_proxy.find_partial_source(template.source)
|
|
self.assertEqual(inner_result, "{% partialdef inner %}...{% endpartialdef %}")
|
|
|
|
@setup(
|
|
{
|
|
"nested_partials_mixed_end_2_template": (
|
|
"{% partialdef outer %}"
|
|
"{% partialdef inner %}...{% endpartialdef inner %}"
|
|
"{% endpartialdef %}"
|
|
),
|
|
},
|
|
debug_only=True,
|
|
)
|
|
def test_find_partial_source_supports_nested_partials_and_mixed_end_tags_2(self):
|
|
template = self.engine.get_template("nested_partials_mixed_end_2_template")
|
|
|
|
empty_proxy = template.extra_data["partials"]["outer"]
|
|
other_proxy = template.extra_data["partials"]["inner"]
|
|
|
|
outer_result = empty_proxy.find_partial_source(template.source)
|
|
self.assertEqual(
|
|
outer_result,
|
|
(
|
|
"{% partialdef outer %}{% partialdef inner %}"
|
|
"...{% endpartialdef inner %}{% endpartialdef %}"
|
|
),
|
|
)
|
|
|
|
inner_result = other_proxy.find_partial_source(template.source)
|
|
self.assertEqual(
|
|
inner_result, "{% partialdef inner %}...{% endpartialdef inner %}"
|
|
)
|
|
|
|
@setup(
|
|
{
|
|
"partial_embedded_in_verbatim": (
|
|
"{% verbatim %}\n"
|
|
"{% partialdef testing-name %}\n"
|
|
"<p>Should be ignored</p>"
|
|
"{% endpartialdef testing-name %}\n"
|
|
"{% endverbatim %}\n"
|
|
"{% partialdef testing-name %}\n"
|
|
"<p>Content</p>\n"
|
|
"{% endpartialdef %}\n"
|
|
),
|
|
},
|
|
debug_only=True,
|
|
)
|
|
def test_partial_template_embedded_in_verbatim(self):
|
|
template = self.engine.get_template("partial_embedded_in_verbatim")
|
|
partial_template = template.extra_data["partials"]["testing-name"]
|
|
self.assertEqual(
|
|
partial_template.source,
|
|
"{% partialdef testing-name %}\n<p>Content</p>\n{% endpartialdef %}",
|
|
)
|
|
|
|
@setup(
|
|
{
|
|
"partial_debug_source": (
|
|
"{% partialdef testing-name %}\n"
|
|
"<p>Content</p>\n"
|
|
"{% endpartialdef %}\n"
|
|
),
|
|
},
|
|
debug_only=True,
|
|
)
|
|
def test_partial_source_uses_offsets_in_debug(self):
|
|
template = self.engine.get_template("partial_debug_source")
|
|
partial_template = template.extra_data["partials"]["testing-name"]
|
|
|
|
self.assertEqual(partial_template._source_start, 0)
|
|
self.assertEqual(partial_template._source_end, 64)
|
|
expected = template.source[
|
|
partial_template._source_start : partial_template._source_end
|
|
]
|
|
self.assertEqual(partial_template.source, expected)
|
|
|
|
@setup(
|
|
{
|
|
"partial_embedded_in_named_verbatim": (
|
|
"{% verbatim block1 %}\n"
|
|
"{% partialdef testing-name %}\n"
|
|
"{% endverbatim block1 %}\n"
|
|
"{% partialdef testing-name %}\n"
|
|
"<p>Named Content</p>\n"
|
|
"{% endpartialdef %}\n"
|
|
),
|
|
},
|
|
debug_only=True,
|
|
)
|
|
def test_partial_template_embedded_in_named_verbatim(self):
|
|
template = self.engine.get_template("partial_embedded_in_named_verbatim")
|
|
partial_template = template.extra_data["partials"]["testing-name"]
|
|
self.assertEqual(
|
|
"{% partialdef testing-name %}\n<p>Named Content</p>\n{% endpartialdef %}",
|
|
partial_template.source,
|
|
)
|
|
|
|
@setup(
|
|
{
|
|
"partial_embedded_in_comment_block": (
|
|
"{% comment %}\n"
|
|
"{% partialdef testing-name %}\n"
|
|
"{% endcomment %}\n"
|
|
"{% partialdef testing-name %}\n"
|
|
"<p>Comment Content</p>\n"
|
|
"{% endpartialdef %}\n"
|
|
),
|
|
},
|
|
debug_only=True,
|
|
)
|
|
def test_partial_template_embedded_in_comment_block(self):
|
|
template = self.engine.get_template("partial_embedded_in_comment_block")
|
|
partial_template = template.extra_data["partials"]["testing-name"]
|
|
self.assertEqual(
|
|
partial_template.source,
|
|
"{% partialdef testing-name %}\n"
|
|
"<p>Comment Content</p>\n"
|
|
"{% endpartialdef %}",
|
|
)
|
|
|
|
@setup(
|
|
{
|
|
"partial_embedded_in_inline_comment": (
|
|
"{# {% partialdef testing-name %} #}\n"
|
|
"{% partialdef testing-name %}\n"
|
|
"<p>Inline Comment Content</p>\n"
|
|
"{% endpartialdef %}\n"
|
|
),
|
|
},
|
|
debug_only=True,
|
|
)
|
|
def test_partial_template_embedded_in_inline_comment(self):
|
|
template = self.engine.get_template("partial_embedded_in_inline_comment")
|
|
partial_template = template.extra_data["partials"]["testing-name"]
|
|
self.assertEqual(
|
|
partial_template.source,
|
|
"{% partialdef testing-name %}\n"
|
|
"<p>Inline Comment Content</p>\n"
|
|
"{% endpartialdef %}",
|
|
)
|
|
|
|
@setup(
|
|
{
|
|
"partial_contains_fake_end_inside_verbatim": (
|
|
"{% partialdef testing-name %}\n"
|
|
"{% verbatim %}{% endpartialdef %}{% endverbatim %}\n"
|
|
"<p>Body</p>\n"
|
|
"{% endpartialdef %}\n"
|
|
),
|
|
},
|
|
debug_only=True,
|
|
)
|
|
def test_partial_template_contains_fake_end_inside_verbatim(self):
|
|
template = self.engine.get_template("partial_contains_fake_end_inside_verbatim")
|
|
partial_template = template.extra_data["partials"]["testing-name"]
|
|
self.assertEqual(
|
|
partial_template.source,
|
|
"{% partialdef testing-name %}\n"
|
|
"{% verbatim %}{% endpartialdef %}{% endverbatim %}\n"
|
|
"<p>Body</p>\n"
|
|
"{% endpartialdef %}",
|
|
)
|