repo stringlengths 7 90 | file_url stringlengths 81 315 | file_path stringlengths 4 228 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 14:38:15 2026-01-05 02:33:18 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/tests.py | tests/template_tests/tests.py | import sys
from django.template import Context, Engine, TemplateDoesNotExist, TemplateSyntaxError
from django.template.base import UNKNOWN_SOURCE
from django.test import SimpleTestCase, override_settings
from django.urls import NoReverseMatch
from django.utils import translation
class TemplateTestMixin:
def _engine(self, **kwargs):
return Engine(debug=self.debug_engine, **kwargs)
def test_string_origin(self):
template = self._engine().from_string("string template")
self.assertEqual(template.origin.name, UNKNOWN_SOURCE)
self.assertIsNone(template.origin.loader_name)
self.assertEqual(template.source, "string template")
@override_settings(SETTINGS_MODULE=None)
def test_url_reverse_no_settings_module(self):
"""
#9005 -- url tag shouldn't require settings.SETTINGS_MODULE to
be set.
"""
t = self._engine().from_string("{% url will_not_match %}")
c = Context()
with self.assertRaises(NoReverseMatch):
t.render(c)
def test_url_reverse_view_name(self):
"""
#19827 -- url tag should keep original stack trace when reraising
exception.
"""
t = self._engine().from_string("{% url will_not_match %}")
c = Context()
try:
t.render(c)
except NoReverseMatch:
tb = sys.exc_info()[2]
depth = 0
while tb.tb_next is not None:
tb = tb.tb_next
depth += 1
self.assertGreater(
depth, 5, "The traceback context was lost when reraising the traceback."
)
def test_no_wrapped_exception(self):
"""
# 16770 -- The template system doesn't wrap exceptions, but annotates
them.
"""
engine = self._engine()
c = Context({"coconuts": lambda: 42 / 0})
t = engine.from_string("{{ coconuts }}")
with self.assertRaises(ZeroDivisionError) as e:
t.render(c)
if self.debug_engine:
debug = e.exception.template_debug
self.assertEqual(debug["start"], 0)
self.assertEqual(debug["end"], 14)
def test_invalid_block_suggestion(self):
"""
Error messages should include the unexpected block name and be in all
English.
"""
engine = self._engine()
msg = (
"Invalid block tag on line 1: 'endblock', expected 'elif', 'else' "
"or 'endif'. Did you forget to register or load this tag?"
)
with self.settings(USE_I18N=True), translation.override("de"):
with self.assertRaisesMessage(TemplateSyntaxError, msg):
engine.from_string("{% if 1 %}lala{% endblock %}{% endif %}")
def test_unknown_block_tag(self):
engine = self._engine()
msg = (
"Invalid block tag on line 1: 'foobar'. Did you forget to "
"register or load this tag?"
)
with self.assertRaisesMessage(TemplateSyntaxError, msg):
engine.from_string("lala{% foobar %}")
def test_compile_filter_expression_error(self):
"""
19819 -- Make sure the correct token is highlighted for
FilterExpression errors.
"""
engine = self._engine()
msg = "Could not parse the remainder: '@bar' from 'foo@bar'"
with self.assertRaisesMessage(TemplateSyntaxError, msg) as e:
engine.from_string("{% if 1 %}{{ foo@bar }}{% endif %}")
if self.debug_engine:
debug = e.exception.template_debug
self.assertEqual((debug["start"], debug["end"]), (10, 23))
self.assertEqual((debug["during"]), "{{ foo@bar }}")
def test_compile_tag_error(self):
"""
Errors raised while compiling nodes should include the token
information.
"""
engine = self._engine(
libraries={"bad_tag": "template_tests.templatetags.bad_tag"},
)
with self.assertRaises(RuntimeError) as e:
engine.from_string("{% load bad_tag %}{% badtag %}")
if self.debug_engine:
self.assertEqual(e.exception.template_debug["during"], "{% badtag %}")
def test_compile_tag_error_27584(self):
engine = self._engine(
app_dirs=True,
libraries={"tag_27584": "template_tests.templatetags.tag_27584"},
)
t = engine.get_template("27584_parent.html")
with self.assertRaises(TemplateSyntaxError) as e:
t.render(Context())
if self.debug_engine:
self.assertEqual(e.exception.template_debug["during"], "{% badtag %}")
def test_compile_tag_error_27956(self):
"""Errors in a child of {% extends %} are displayed correctly."""
engine = self._engine(
app_dirs=True,
libraries={"tag_27584": "template_tests.templatetags.tag_27584"},
)
t = engine.get_template("27956_child.html")
with self.assertRaises(TemplateSyntaxError) as e:
t.render(Context())
if self.debug_engine:
self.assertEqual(e.exception.template_debug["during"], "{% badtag %}")
def test_compile_tag_extra_data(self):
"""Custom tags can pass extra data back to template."""
engine = self._engine(
app_dirs=True,
libraries={"custom": "template_tests.templatetags.custom"},
)
t = engine.from_string("{% load custom %}{% extra_data %}")
self.assertEqual(t.extra_data["extra_data"], "CUSTOM_DATA")
def test_render_tag_error_in_extended_block(self):
"""Errors in extended block are displayed correctly."""
e = self._engine(app_dirs=True)
template = e.get_template("test_extends_block_error.html")
context = Context()
with self.assertRaises(TemplateDoesNotExist) as cm:
template.render(context)
if self.debug_engine:
self.assertEqual(
cm.exception.template_debug["before"],
'{% block content %}{% include "index.html" %}',
)
self.assertEqual(
cm.exception.template_debug["during"],
'{% include "missing.html" %}',
)
self.assertEqual(
cm.exception.template_debug["after"],
'{% include "index.html" %}{% endblock %}\n',
)
self.assertEqual(
cm.exception.template_debug["source_lines"][0],
(1, '{% extends "test_extends_block_error_parent.html" %}\n'),
)
self.assertEqual(
cm.exception.template_debug["source_lines"][1],
(
2,
'{% block content %}{% include "index.html" %}'
'{% include "missing.html" %}'
'{% include "index.html" %}{% endblock %}\n',
),
)
self.assertEqual(cm.exception.template_debug["source_lines"][2], (3, ""))
def test_super_errors(self):
"""
#18169 -- NoReverseMatch should not be silence in block.super.
"""
engine = self._engine(app_dirs=True)
t = engine.get_template("included_content.html")
with self.assertRaises(NoReverseMatch):
t.render(Context())
def test_extends_generic_template(self):
"""
#24338 -- Allow extending django.template.backends.django.Template
objects.
"""
engine = self._engine()
parent = engine.from_string("{% block content %}parent{% endblock %}")
child = engine.from_string(
"{% extends parent %}{% block content %}child{% endblock %}"
)
self.assertEqual(child.render(Context({"parent": parent})), "child")
def test_node_origin(self):
"""
#25848 -- Set origin on Node so debugging tools can determine which
template the node came from even if extending or including templates.
"""
template = self._engine().from_string("content")
for node in template.nodelist:
self.assertEqual(node.origin, template.origin)
def test_render_built_in_type_method(self):
"""
Templates should not crash when rendering methods for built-in types
without required arguments.
"""
template = self._engine().from_string("{{ description.count }}")
self.assertEqual(template.render(Context({"description": "test"})), "")
class TemplateTests(TemplateTestMixin, SimpleTestCase):
debug_engine = False
class DebugTemplateTests(TemplateTestMixin, SimpleTestCase):
debug_engine = True
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/test_partials.py | tests/template_tests/test_partials.py | 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 %}",
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/test_autoreloader.py | tests/template_tests/test_autoreloader.py | from pathlib import Path
from unittest import mock
from django.template import autoreload
from django.test import SimpleTestCase, override_settings
from django.test.utils import require_jinja2
ROOT = Path(__file__).parent.absolute()
EXTRA_TEMPLATES_DIR = ROOT / "templates_extra"
@override_settings(
INSTALLED_APPS=["template_tests"],
TEMPLATES=[
{
"BACKEND": "django.template.backends.dummy.TemplateStrings",
"APP_DIRS": True,
},
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"DIRS": [EXTRA_TEMPLATES_DIR],
"OPTIONS": {
"context_processors": [
"django.template.context_processors.request",
],
"loaders": [
"django.template.loaders.filesystem.Loader",
"django.template.loaders.app_directories.Loader",
],
},
},
],
)
class TemplateReloadTests(SimpleTestCase):
@mock.patch("django.template.autoreload.reset_loaders")
def test_template_changed(self, mock_reset):
template_path = Path(__file__).parent / "templates" / "index.html"
self.assertTrue(autoreload.template_changed(None, template_path))
mock_reset.assert_called_once()
@mock.patch("django.template.autoreload.reset_loaders")
def test_non_template_changed(self, mock_reset):
self.assertIsNone(autoreload.template_changed(None, Path(__file__)))
mock_reset.assert_not_called()
@override_settings(
TEMPLATES=[
{
"DIRS": [ROOT],
"BACKEND": "django.template.backends.django.DjangoTemplates",
}
]
)
@mock.patch("django.template.autoreload.reset_loaders")
def test_non_template_changed_in_template_directory(self, mock_reset):
self.assertIsNone(autoreload.template_changed(None, Path(__file__)))
mock_reset.assert_not_called()
@mock.patch("django.forms.renderers.get_default_renderer")
def test_form_template_reset_template_change(self, mock_renderer):
template_path = Path(__file__).parent / "templates" / "index.html"
self.assertIs(autoreload.template_changed(None, template_path), True)
mock_renderer.assert_called_once()
@mock.patch("django.template.loaders.cached.Loader.reset")
def test_form_template_reset_template_change_reset_call(self, mock_loader_reset):
template_path = Path(__file__).parent / "templates" / "index.html"
self.assertIs(autoreload.template_changed(None, template_path), True)
mock_loader_reset.assert_called_once()
@override_settings(FORM_RENDERER="django.forms.renderers.TemplatesSetting")
@mock.patch("django.template.loaders.cached.Loader.reset")
def test_form_template_reset_template_change_no_djangotemplates(
self, mock_loader_reset
):
template_path = Path(__file__).parent / "templates" / "index.html"
self.assertIs(autoreload.template_changed(None, template_path), True)
mock_loader_reset.assert_not_called()
@mock.patch("django.forms.renderers.get_default_renderer")
def test_form_template_reset_non_template_change(self, mock_renderer):
self.assertIsNone(autoreload.template_changed(None, Path(__file__)))
mock_renderer.assert_not_called()
def test_watch_for_template_changes(self):
mock_reloader = mock.MagicMock()
autoreload.watch_for_template_changes(mock_reloader)
self.assertSequenceEqual(
sorted(mock_reloader.watch_dir.call_args_list),
[
mock.call(ROOT / "templates", "**/*"),
mock.call(ROOT / "templates_extra", "**/*"),
],
)
def test_get_template_directories(self):
self.assertSetEqual(
autoreload.get_template_directories(),
{
ROOT / "templates_extra",
ROOT / "templates",
},
)
@mock.patch("django.template.loaders.base.Loader.reset")
def test_reset_all_loaders(self, mock_reset):
autoreload.reset_loaders()
self.assertEqual(mock_reset.call_count, 2)
@override_settings(
TEMPLATES=[
{
"DIRS": [""],
"BACKEND": "django.template.backends.django.DjangoTemplates",
}
]
)
def test_template_dirs_ignore_empty_path(self):
self.assertEqual(autoreload.get_template_directories(), set())
@override_settings(
TEMPLATES=[
{
"DIRS": [
str(ROOT) + "/absolute_str",
"template_tests/relative_str",
Path("template_tests/relative_path"),
],
"BACKEND": "django.template.backends.django.DjangoTemplates",
}
]
)
def test_template_dirs_normalized_to_paths(self):
self.assertSetEqual(
autoreload.get_template_directories(),
{
ROOT / "absolute_str",
Path.cwd() / "template_tests/relative_str",
Path.cwd() / "template_tests/relative_path",
},
)
@require_jinja2
@override_settings(INSTALLED_APPS=["template_tests"])
class Jinja2TemplateReloadTests(SimpleTestCase):
def test_watch_for_template_changes(self):
mock_reloader = mock.MagicMock()
autoreload.watch_for_template_changes(mock_reloader)
self.assertSequenceEqual(
sorted(mock_reloader.watch_dir.call_args_list),
[
mock.call(ROOT / "templates", "**/*"),
],
)
def test_get_template_directories(self):
self.assertSetEqual(
autoreload.get_template_directories(),
{
ROOT / "templates",
},
)
@mock.patch("django.template.loaders.base.Loader.reset")
def test_reset_all_loaders(self, mock_reset):
autoreload.reset_loaders()
self.assertEqual(mock_reset.call_count, 0)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/test_smartif.py | tests/template_tests/test_smartif.py | import unittest
from django.template.smartif import IfParser
class SmartIfTests(unittest.TestCase):
def assertCalcEqual(self, expected, tokens):
self.assertEqual(expected, IfParser(tokens).parse().eval({}))
# We only test things here that are difficult to test elsewhere
# Many other tests are found in the main tests for builtin template tags
# Test parsing via the printed parse tree
def test_not(self):
var = IfParser(["not", False]).parse()
self.assertEqual("(not (literal False))", repr(var))
self.assertTrue(var.eval({}))
self.assertFalse(IfParser(["not", True]).parse().eval({}))
def test_or(self):
var = IfParser([True, "or", False]).parse()
self.assertEqual("(or (literal True) (literal False))", repr(var))
self.assertTrue(var.eval({}))
def test_in(self):
list_ = [1, 2, 3]
self.assertCalcEqual(True, [1, "in", list_])
self.assertCalcEqual(False, [1, "in", None])
self.assertCalcEqual(False, [None, "in", list_])
def test_not_in(self):
list_ = [1, 2, 3]
self.assertCalcEqual(False, [1, "not", "in", list_])
self.assertCalcEqual(True, [4, "not", "in", list_])
self.assertCalcEqual(False, [1, "not", "in", None])
self.assertCalcEqual(True, [None, "not", "in", list_])
def test_precedence(self):
# (False and False) or True == True <- we want this one, like Python
# False and (False or True) == False
self.assertCalcEqual(True, [False, "and", False, "or", True])
# True or (False and False) == True <- we want this one, like Python
# (True or False) and False == False
self.assertCalcEqual(True, [True, "or", False, "and", False])
# (1 or 1) == 2 -> False
# 1 or (1 == 2) -> True <- we want this one
self.assertCalcEqual(True, [1, "or", 1, "==", 2])
self.assertCalcEqual(True, [True, "==", True, "or", True, "==", False])
self.assertEqual(
"(or (and (== (literal 1) (literal 2)) (literal 3)) (literal 4))",
repr(IfParser([1, "==", 2, "and", 3, "or", 4]).parse()),
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/urls.py | tests/template_tests/urls.py | from django.urls import include, path, re_path
from . import views
ns_patterns = [
# Test urls for testing reverse lookups
path("", views.index, name="index"),
re_path(r"^client/([0-9,]+)/$", views.client, name="client"),
re_path(
r"^client/(?P<id>[0-9]+)/(?P<action>[^/]+)/$",
views.client_action,
name="client_action",
),
re_path(
r"^client/(?P<client_id>[0-9]+)/(?P<action>[^/]+)/$",
views.client_action,
name="client_action",
),
re_path(r"^named-client/([0-9]+)/$", views.client2, name="named.client"),
]
urlpatterns = ns_patterns + [
# Unicode strings are permitted everywhere.
re_path(r"^Юникод/(\w+)/$", views.client2, name="метка_оператора"),
re_path(r"^Юникод/(?P<tag>\S+)/$", views.client2, name="метка_оператора_2"),
# Test urls for namespaces and current_app
path("ns1/", include((ns_patterns, "app"), "ns1")),
path("ns2/", include((ns_patterns, "app"))),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/templatetags/bad_tag.py | tests/template_tests/templatetags/bad_tag.py | from django import template
register = template.Library()
@register.tag
def badtag(parser, token):
raise RuntimeError("I am a bad tag")
@register.simple_tag
def badsimpletag():
raise RuntimeError("I am a bad simpletag")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/templatetags/tag_27584.py | tests/template_tests/templatetags/tag_27584.py | from django import template
register = template.Library()
@register.tag
def badtag(parser, token):
parser.parse(("endbadtag",))
parser.delete_first_token()
return BadNode()
class BadNode(template.Node):
def render(self, context):
raise template.TemplateSyntaxError("error")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/templatetags/__init__.py | tests/template_tests/templatetags/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/templatetags/testtags.py | tests/template_tests/templatetags/testtags.py | from django.template import Library, Node
register = Library()
class EchoNode(Node):
def __init__(self, contents):
self.contents = contents
def render(self, context):
return " ".join(self.contents)
@register.tag
def echo(parser, token):
return EchoNode(token.contents.split()[1:])
register.tag("other_echo", echo)
@register.filter
def upper(value):
return value.upper()
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/templatetags/custom.py | tests/template_tests/templatetags/custom.py | from django import template
from django.template.base import TextNode
from django.template.defaultfilters import stringfilter
from django.utils.html import escape, format_html
from django.utils.safestring import mark_safe
register = template.Library()
@register.filter
@stringfilter
def trim(value, num):
return value[:num]
@register.filter
@mark_safe
def make_data_div(value):
"""A filter that uses a decorator (@mark_safe)."""
return '<div data-name="%s"></div>' % value
@register.simple_block_tag
def div(content, id="test"):
return format_html("<div id='{}'>{}</div>", id, content)
@register.simple_block_tag(end_name="divend")
def div_custom_end(content):
return format_html("<div>{}</div>", content)
@register.filter
def noop(value, param=None):
"""A noop filter that always return its first argument and does nothing
with its second (optional) one. Useful for testing out whitespace in filter
arguments (see #19882)."""
return value
@register.simple_tag(takes_context=True)
def context_stack_length(context):
return len(context.dicts)
@register.simple_tag
def no_params():
"""Expected no_params __doc__"""
return "no_params - Expected result"
no_params.anything = "Expected no_params __dict__"
@register.simple_tag
def one_param(arg):
"""Expected one_param __doc__"""
return "one_param - Expected result: %s" % arg
one_param.anything = "Expected one_param __dict__"
@register.simple_block_tag
def one_param_block(content, arg):
"""Expected one_param_block __doc__"""
return f"one_param_block - Expected result: {arg} with content {content}"
@register.simple_tag(takes_context=False)
def explicit_no_context(arg):
"""Expected explicit_no_context __doc__"""
return "explicit_no_context - Expected result: %s" % arg
explicit_no_context.anything = "Expected explicit_no_context __dict__"
@register.simple_block_tag(takes_context=False)
def explicit_no_context_block(content, arg):
"""Expected explicit_no_context_block __doc__"""
return f"explicit_no_context_block - Expected result: {arg} with content {content}"
@register.simple_tag(takes_context=True)
def no_params_with_context(context):
"""Expected no_params_with_context __doc__"""
return (
"no_params_with_context - Expected result (context value: %s)"
% context["value"]
)
no_params_with_context.anything = "Expected no_params_with_context __dict__"
@register.simple_block_tag(takes_context=True)
def no_params_with_context_block(context, content):
"""Expected no_params_with_context_block __doc__"""
return (
"no_params_with_context_block - Expected result (context value: %s) "
"(content value: %s)" % (context["value"], content)
)
@register.simple_tag(takes_context=True)
def params_and_context(context, arg):
"""Expected params_and_context __doc__"""
return "params_and_context - Expected result (context value: %s): %s" % (
context["value"],
arg,
)
params_and_context.anything = "Expected params_and_context __dict__"
@register.simple_block_tag(takes_context=True)
def params_and_context_block(context, content, arg):
"""Expected params_and_context_block __doc__"""
return (
"params_and_context_block - Expected result (context value: %s) "
"(content value: %s): %s"
% (
context["value"],
content,
arg,
)
)
@register.simple_tag
def simple_two_params(one, two):
"""Expected simple_two_params __doc__"""
return "simple_two_params - Expected result: %s, %s" % (one, two)
simple_two_params.anything = "Expected simple_two_params __dict__"
@register.simple_block_tag
def simple_two_params_block(content, one, two):
"""Expected simple_two_params_block __doc__"""
return "simple_two_params_block - Expected result (content value: %s): %s, %s" % (
content,
one,
two,
)
@register.simple_tag
def simple_keyword_only_param(*, kwarg):
return "simple_keyword_only_param - Expected result: %s" % kwarg
@register.simple_block_tag
def simple_keyword_only_param_block(content, *, kwarg):
return (
"simple_keyword_only_param_block - Expected result (content value: %s): %s"
% (
content,
kwarg,
)
)
@register.simple_tag
def simple_keyword_only_default(*, kwarg=42):
return "simple_keyword_only_default - Expected result: %s" % kwarg
@register.simple_block_tag
def simple_keyword_only_default_block(content, *, kwarg=42):
return (
"simple_keyword_only_default_block - Expected result (content value: %s): %s"
% (
content,
kwarg,
)
)
@register.simple_tag
def simple_one_default(one, two="hi"):
"""Expected simple_one_default __doc__"""
return "simple_one_default - Expected result: %s, %s" % (one, two)
simple_one_default.anything = "Expected simple_one_default __dict__"
@register.simple_block_tag
def simple_one_default_block(content, one, two="hi"):
"""Expected simple_one_default_block __doc__"""
return "simple_one_default_block - Expected result (content value: %s): %s, %s" % (
content,
one,
two,
)
@register.simple_tag
def simple_unlimited_args(one, two="hi", *args):
"""Expected simple_unlimited_args __doc__"""
return "simple_unlimited_args - Expected result: %s" % (
", ".join(str(arg) for arg in [one, two, *args])
)
simple_unlimited_args.anything = "Expected simple_unlimited_args __dict__"
@register.simple_block_tag
def simple_unlimited_args_block(content, one, two="hi", *args):
"""Expected simple_unlimited_args_block __doc__"""
return "simple_unlimited_args_block - Expected result (content value: %s): %s" % (
content,
", ".join(str(arg) for arg in [one, two, *args]),
)
@register.simple_tag
def simple_only_unlimited_args(*args):
"""Expected simple_only_unlimited_args __doc__"""
return "simple_only_unlimited_args - Expected result: %s" % ", ".join(
str(arg) for arg in args
)
simple_only_unlimited_args.anything = "Expected simple_only_unlimited_args __dict__"
@register.simple_block_tag
def simple_only_unlimited_args_block(content, *args):
"""Expected simple_only_unlimited_args_block __doc__"""
return (
"simple_only_unlimited_args_block - Expected result (content value: %s): %s"
% (
content,
", ".join(str(arg) for arg in args),
)
)
@register.simple_tag
def simple_unlimited_args_kwargs(one, two="hi", *args, **kwargs):
"""Expected simple_unlimited_args_kwargs __doc__"""
return "simple_unlimited_args_kwargs - Expected result: %s / %s" % (
", ".join(str(arg) for arg in [one, two, *args]),
", ".join("%s=%s" % (k, v) for (k, v) in kwargs.items()),
)
simple_unlimited_args_kwargs.anything = "Expected simple_unlimited_args_kwargs __dict__"
@register.simple_block_tag
def simple_unlimited_args_kwargs_block(content, one, two="hi", *args, **kwargs):
"""Expected simple_unlimited_args_kwargs_block __doc__"""
return (
"simple_unlimited_args_kwargs_block - Expected result (content value: %s): "
"%s / %s"
% (
content,
", ".join(str(arg) for arg in [one, two, *args]),
", ".join("%s=%s" % (k, v) for (k, v) in kwargs.items()),
)
)
@register.simple_tag(takes_context=True)
def escape_naive(context):
"""A tag that doesn't even think about escaping issues"""
return "Hello {}!".format(context["name"])
@register.simple_block_tag(takes_context=True)
def escape_naive_block(context, content):
"""A block tag that doesn't even think about escaping issues"""
return "Hello {}: {}!".format(context["name"], content)
@register.simple_tag(takes_context=True)
def escape_explicit(context):
"""A tag that uses escape explicitly"""
return escape("Hello {}!".format(context["name"]))
@register.simple_block_tag(takes_context=True)
def escape_explicit_block(context, content):
"""A block tag that uses escape explicitly"""
return escape("Hello {}: {}!".format(context["name"], content))
@register.simple_tag(takes_context=True)
def escape_format_html(context):
"""A tag that uses format_html"""
return format_html("Hello {0}!", context["name"])
@register.simple_block_tag(takes_context=True)
def escape_format_html_block(context, content):
"""A block tag that uses format_html"""
return format_html("Hello {0}: {1}!", context["name"], content)
@register.simple_tag(takes_context=True)
def current_app(context):
return str(context.current_app)
@register.simple_tag(takes_context=True)
def use_l10n(context):
return str(context.use_l10n)
@register.simple_tag(name="minustwo")
def minustwo_overridden_name(value):
return value - 2
register.simple_tag(lambda x: x - 1, name="minusone")
@register.tag("counter")
def counter(parser, token):
return CounterNode()
class CounterNode(template.Node):
def __init__(self):
self.count = 0
def render(self, context):
count = self.count
self.count = count + 1
return str(count)
@register.tag("extra_data")
def do_extra_data(parser, token):
parser.extra_data["extra_data"] = "CUSTOM_DATA"
return TextNode("")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/templatetags/inclusion.py | tests/template_tests/templatetags/inclusion.py | from django.template import Engine, Library
engine = Engine(app_dirs=True)
register = Library()
@register.inclusion_tag("inclusion.html")
def inclusion_no_params():
"""Expected inclusion_no_params __doc__"""
return {"result": "inclusion_no_params - Expected result"}
inclusion_no_params.anything = "Expected inclusion_no_params __dict__"
@register.inclusion_tag(engine.get_template("inclusion.html"))
def inclusion_no_params_from_template():
"""Expected inclusion_no_params_from_template __doc__"""
return {"result": "inclusion_no_params_from_template - Expected result"}
inclusion_no_params_from_template.anything = (
"Expected inclusion_no_params_from_template __dict__"
)
@register.inclusion_tag("inclusion.html")
def inclusion_one_param(arg):
"""Expected inclusion_one_param __doc__"""
return {"result": "inclusion_one_param - Expected result: %s" % arg}
inclusion_one_param.anything = "Expected inclusion_one_param __dict__"
@register.inclusion_tag(engine.get_template("inclusion.html"))
def inclusion_one_param_from_template(arg):
"""Expected inclusion_one_param_from_template __doc__"""
return {"result": "inclusion_one_param_from_template - Expected result: %s" % arg}
inclusion_one_param_from_template.anything = (
"Expected inclusion_one_param_from_template __dict__"
)
@register.inclusion_tag("inclusion.html", takes_context=False)
def inclusion_explicit_no_context(arg):
"""Expected inclusion_explicit_no_context __doc__"""
return {"result": "inclusion_explicit_no_context - Expected result: %s" % arg}
inclusion_explicit_no_context.anything = (
"Expected inclusion_explicit_no_context __dict__"
)
@register.inclusion_tag(engine.get_template("inclusion.html"), takes_context=False)
def inclusion_explicit_no_context_from_template(arg):
"""Expected inclusion_explicit_no_context_from_template __doc__"""
return {
"result": "inclusion_explicit_no_context_from_template - Expected result: %s"
% arg
}
inclusion_explicit_no_context_from_template.anything = (
"Expected inclusion_explicit_no_context_from_template __dict__"
)
@register.inclusion_tag("inclusion.html", takes_context=True)
def inclusion_no_params_with_context(context):
"""Expected inclusion_no_params_with_context __doc__"""
return {
"result": (
"inclusion_no_params_with_context - Expected result (context value: %s)"
)
% context["value"]
}
inclusion_no_params_with_context.anything = (
"Expected inclusion_no_params_with_context __dict__"
)
@register.inclusion_tag(engine.get_template("inclusion.html"), takes_context=True)
def inclusion_no_params_with_context_from_template(context):
"""Expected inclusion_no_params_with_context_from_template __doc__"""
return {
"result": (
"inclusion_no_params_with_context_from_template - Expected result (context "
"value: %s)"
)
% context["value"]
}
inclusion_no_params_with_context_from_template.anything = (
"Expected inclusion_no_params_with_context_from_template __dict__"
)
@register.inclusion_tag("inclusion.html", takes_context=True)
def inclusion_params_and_context(context, arg):
"""Expected inclusion_params_and_context __doc__"""
return {
"result": (
"inclusion_params_and_context - Expected result (context value: %s): %s"
)
% (context["value"], arg)
}
inclusion_params_and_context.anything = "Expected inclusion_params_and_context __dict__"
@register.inclusion_tag(engine.get_template("inclusion.html"), takes_context=True)
def inclusion_params_and_context_from_template(context, arg):
"""Expected inclusion_params_and_context_from_template __doc__"""
return {
"result": (
"inclusion_params_and_context_from_template - Expected result "
"(context value: %s): %s" % (context["value"], arg)
)
}
inclusion_params_and_context_from_template.anything = (
"Expected inclusion_params_and_context_from_template __dict__"
)
@register.inclusion_tag("inclusion.html")
def inclusion_two_params(one, two):
"""Expected inclusion_two_params __doc__"""
return {"result": "inclusion_two_params - Expected result: %s, %s" % (one, two)}
inclusion_two_params.anything = "Expected inclusion_two_params __dict__"
@register.inclusion_tag(engine.get_template("inclusion.html"))
def inclusion_two_params_from_template(one, two):
"""Expected inclusion_two_params_from_template __doc__"""
return {
"result": "inclusion_two_params_from_template - Expected result: %s, %s"
% (one, two)
}
inclusion_two_params_from_template.anything = (
"Expected inclusion_two_params_from_template __dict__"
)
@register.inclusion_tag("inclusion.html")
def inclusion_one_default(one, two="hi"):
"""Expected inclusion_one_default __doc__"""
return {"result": "inclusion_one_default - Expected result: %s, %s" % (one, two)}
inclusion_one_default.anything = "Expected inclusion_one_default __dict__"
@register.inclusion_tag("inclusion.html")
def inclusion_keyword_only_default(*, kwarg=42):
return {
"result": ("inclusion_keyword_only_default - Expected result: %s" % kwarg),
}
@register.inclusion_tag(engine.get_template("inclusion.html"))
def inclusion_one_default_from_template(one, two="hi"):
"""Expected inclusion_one_default_from_template __doc__"""
return {
"result": "inclusion_one_default_from_template - Expected result: %s, %s"
% (one, two)
}
inclusion_one_default_from_template.anything = (
"Expected inclusion_one_default_from_template __dict__"
)
@register.inclusion_tag("inclusion.html")
def inclusion_unlimited_args(one, two="hi", *args):
"""Expected inclusion_unlimited_args __doc__"""
return {
"result": (
"inclusion_unlimited_args - Expected result: %s"
% (", ".join(str(arg) for arg in [one, two, *args]))
)
}
inclusion_unlimited_args.anything = "Expected inclusion_unlimited_args __dict__"
@register.inclusion_tag(engine.get_template("inclusion.html"))
def inclusion_unlimited_args_from_template(one, two="hi", *args):
"""Expected inclusion_unlimited_args_from_template __doc__"""
return {
"result": (
"inclusion_unlimited_args_from_template - Expected result: %s"
% (", ".join(str(arg) for arg in [one, two, *args]))
)
}
inclusion_unlimited_args_from_template.anything = (
"Expected inclusion_unlimited_args_from_template __dict__"
)
@register.inclusion_tag("inclusion.html")
def inclusion_only_unlimited_args(*args):
"""Expected inclusion_only_unlimited_args __doc__"""
return {
"result": "inclusion_only_unlimited_args - Expected result: %s"
% (", ".join(str(arg) for arg in args))
}
inclusion_only_unlimited_args.anything = (
"Expected inclusion_only_unlimited_args __dict__"
)
@register.inclusion_tag(engine.get_template("inclusion.html"))
def inclusion_only_unlimited_args_from_template(*args):
"""Expected inclusion_only_unlimited_args_from_template __doc__"""
return {
"result": "inclusion_only_unlimited_args_from_template - Expected result: %s"
% (", ".join(str(arg) for arg in args))
}
inclusion_only_unlimited_args_from_template.anything = (
"Expected inclusion_only_unlimited_args_from_template __dict__"
)
@register.inclusion_tag("test_incl_tag_use_l10n.html", takes_context=True)
def inclusion_tag_use_l10n(context):
"""Expected inclusion_tag_use_l10n __doc__"""
return {}
inclusion_tag_use_l10n.anything = "Expected inclusion_tag_use_l10n __dict__"
@register.inclusion_tag("inclusion.html")
def inclusion_unlimited_args_kwargs(one, two="hi", *args, **kwargs):
"""Expected inclusion_unlimited_args_kwargs __doc__"""
return {
"result": "inclusion_unlimited_args_kwargs - Expected result: %s / %s"
% (
", ".join(str(arg) for arg in [one, two, *args]),
", ".join("%s=%s" % (k, v) for (k, v) in kwargs.items()),
)
}
inclusion_unlimited_args_kwargs.anything = (
"Expected inclusion_unlimited_args_kwargs __dict__"
)
@register.inclusion_tag("inclusion_extends1.html")
def inclusion_extends1():
return {}
@register.inclusion_tag("inclusion_extends2.html")
def inclusion_extends2():
return {}
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/templatetags/subpackage/echo.py | tests/template_tests/templatetags/subpackage/echo.py | from django import template
register = template.Library()
@register.simple_tag
def echo2(arg):
return arg
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/templatetags/subpackage/__init__.py | tests/template_tests/templatetags/subpackage/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_linebreaks.py | tests/template_tests/filter_tests/test_linebreaks.py | from django.template.defaultfilters import linebreaks_filter
from django.test import SimpleTestCase
from django.utils.functional import lazy
from django.utils.safestring import mark_safe
from ..utils import setup
class LinebreaksTests(SimpleTestCase):
"""
The contents in "linebreaks" are escaped according to the current
autoescape setting.
"""
@setup({"linebreaks01": "{{ a|linebreaks }} {{ b|linebreaks }}"})
def test_linebreaks01(self):
output = self.engine.render_to_string(
"linebreaks01", {"a": "x&\ny", "b": mark_safe("x&\ny")}
)
self.assertEqual(output, "<p>x&<br>y</p> <p>x&<br>y</p>")
@setup(
{
"linebreaks02": (
"{% autoescape off %}{{ a|linebreaks }} {{ b|linebreaks }}"
"{% endautoescape %}"
)
}
)
def test_linebreaks02(self):
output = self.engine.render_to_string(
"linebreaks02", {"a": "x&\ny", "b": mark_safe("x&\ny")}
)
self.assertEqual(output, "<p>x&<br>y</p> <p>x&<br>y</p>")
class FunctionTests(SimpleTestCase):
def test_line(self):
self.assertEqual(linebreaks_filter("line 1"), "<p>line 1</p>")
def test_newline(self):
self.assertEqual(linebreaks_filter("line 1\nline 2"), "<p>line 1<br>line 2</p>")
def test_carriage(self):
self.assertEqual(linebreaks_filter("line 1\rline 2"), "<p>line 1<br>line 2</p>")
def test_carriage_newline(self):
self.assertEqual(
linebreaks_filter("line 1\r\nline 2"), "<p>line 1<br>line 2</p>"
)
def test_non_string_input(self):
self.assertEqual(linebreaks_filter(123), "<p>123</p>")
def test_autoescape(self):
self.assertEqual(
linebreaks_filter("foo\n<a>bar</a>\nbuz"),
"<p>foo<br><a>bar</a><br>buz</p>",
)
def test_autoescape_off(self):
self.assertEqual(
linebreaks_filter("foo\n<a>bar</a>\nbuz", autoescape=False),
"<p>foo<br><a>bar</a><br>buz</p>",
)
def test_lazy_string_input(self):
add_header = lazy(lambda string: "Header\n\n" + string, str)
self.assertEqual(
linebreaks_filter(add_header("line 1\r\nline2")),
"<p>Header</p>\n\n<p>line 1<br>line2</p>",
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_urlize.py | tests/template_tests/filter_tests/test_urlize.py | from unittest import mock
from django.template.defaultfilters import urlize
from django.test import SimpleTestCase
from django.test.utils import override_settings
from django.utils.functional import lazy
from django.utils.html import Urlizer
from django.utils.safestring import mark_safe
from ..utils import setup
class UrlizeTests(SimpleTestCase):
@setup(
{
"urlize01": (
"{% autoescape off %}{{ a|urlize }} {{ b|urlize }}{% endautoescape %}"
)
}
)
def test_urlize01(self):
output = self.engine.render_to_string(
"urlize01",
{
"a": "http://example.com/?x=&y=",
"b": mark_safe("http://example.com?x=&y=<2>"),
},
)
self.assertEqual(
output,
'<a href="http://example.com/?x=&y=" rel="nofollow">'
"http://example.com/?x=&y=</a> "
'<a href="http://example.com?x=&y=%3C2%3E" rel="nofollow">'
"http://example.com?x=&y=<2></a>",
)
@setup({"urlize02": "{{ a|urlize }} {{ b|urlize }}"})
def test_urlize02(self):
output = self.engine.render_to_string(
"urlize02",
{
"a": "http://example.com/?x=&y=",
"b": mark_safe("http://example.com?x=&y="),
},
)
self.assertEqual(
output,
'<a href="http://example.com/?x=&y=" rel="nofollow">'
"http://example.com/?x=&y=</a> "
'<a href="http://example.com?x=&y=" rel="nofollow">'
"http://example.com?x=&y=</a>",
)
@setup({"urlize03": "{% autoescape off %}{{ a|urlize }}{% endautoescape %}"})
def test_urlize03(self):
output = self.engine.render_to_string("urlize03", {"a": mark_safe("a & b")})
self.assertEqual(output, "a & b")
@setup({"urlize04": "{{ a|urlize }}"})
def test_urlize04(self):
output = self.engine.render_to_string("urlize04", {"a": mark_safe("a & b")})
self.assertEqual(output, "a & b")
# This will lead to a nonsense result, but at least it won't be
# exploitable for XSS purposes when auto-escaping is on.
@setup({"urlize05": "{% autoescape off %}{{ a|urlize }}{% endautoescape %}"})
def test_urlize05(self):
output = self.engine.render_to_string(
"urlize05", {"a": "<script>alert('foo')</script>"}
)
self.assertEqual(output, "<script>alert('foo')</script>")
@setup({"urlize06": "{{ a|urlize }}"})
def test_urlize06(self):
output = self.engine.render_to_string(
"urlize06", {"a": "<script>alert('foo')</script>"}
)
self.assertEqual(output, "<script>alert('foo')</script>")
# mailto: testing for urlize
@setup({"urlize07": "{{ a|urlize }}"})
def test_urlize07(self):
output = self.engine.render_to_string(
"urlize07", {"a": "Email me at me@example.com"}
)
self.assertEqual(
output,
'Email me at <a href="mailto:me@example.com">me@example.com</a>',
)
@setup({"urlize08": "{{ a|urlize }}"})
def test_urlize08(self):
output = self.engine.render_to_string(
"urlize08", {"a": "Email me at <me@example.com>"}
)
self.assertEqual(
output,
'Email me at <<a href="mailto:me@example.com">me@example.com</a>>',
)
@setup({"urlize09": "{% autoescape off %}{{ a|urlize }}{% endautoescape %}"})
def test_urlize09(self):
output = self.engine.render_to_string(
"urlize09", {"a": "http://example.com/?x=&y=<2>"}
)
self.assertEqual(
output,
'<a href="http://example.com/?x=&y=%3C2%3E" rel="nofollow">'
"http://example.com/?x=&y=<2></a>",
)
@override_settings(URLIZE_ASSUME_HTTPS=True)
class FunctionTests(SimpleTestCase):
def test_urls(self):
self.assertEqual(
urlize("http://google.com"),
'<a href="http://google.com" rel="nofollow">http://google.com</a>',
)
self.assertEqual(
urlize("http://google.com/"),
'<a href="http://google.com/" rel="nofollow">http://google.com/</a>',
)
self.assertEqual(
urlize("www.google.com"),
'<a href="https://www.google.com" rel="nofollow">www.google.com</a>',
)
self.assertEqual(
urlize("djangoproject.org"),
'<a href="https://djangoproject.org" rel="nofollow">djangoproject.org</a>',
)
self.assertEqual(
urlize("djangoproject.org/"),
'<a href="https://djangoproject.org/" rel="nofollow">'
"djangoproject.org/</a>",
)
def test_url_split_chars(self):
# Quotes (single and double) and angle brackets shouldn't be considered
# part of URLs.
self.assertEqual(
urlize('www.server.com"abc'),
'<a href="https://www.server.com" rel="nofollow">www.server.com</a>"'
"abc",
)
self.assertEqual(
urlize("www.server.com'abc"),
'<a href="https://www.server.com" rel="nofollow">www.server.com</a>''
"abc",
)
self.assertEqual(
urlize("www.server.com<abc"),
'<a href="https://www.server.com" rel="nofollow">www.server.com</a><abc',
)
self.assertEqual(
urlize("www.server.com>abc"),
'<a href="https://www.server.com" rel="nofollow">www.server.com</a>>abc',
)
def test_email(self):
self.assertEqual(
urlize("info@djangoproject.org"),
'<a href="mailto:info@djangoproject.org">info@djangoproject.org</a>',
)
def test_word_with_dot(self):
self.assertEqual(urlize("some.organization"), "some.organization")
def test_https(self):
self.assertEqual(
urlize("https://google.com"),
'<a href="https://google.com" rel="nofollow">https://google.com</a>',
)
def test_quoting(self):
"""
#9655 - Check urlize doesn't overquote already quoted urls. The
teststring is the urlquoted version of 'http://hi.baidu.com/重新开始'
"""
self.assertEqual(
urlize("http://hi.baidu.com/%E9%87%8D%E6%96%B0%E5%BC%80%E5%A7%8B"),
'<a href="http://hi.baidu.com/%E9%87%8D%E6%96%B0%E5%BC%80%E5%A7%8B" '
'rel="nofollow">http://hi.baidu.com/%E9%87%8D%E6%96%B0%E5%BC%80%E5%A7%8B'
"</a>",
)
def test_urlencoded(self):
self.assertEqual(
urlize("www.mystore.com/30%OffCoupons!"),
'<a href="https://www.mystore.com/30%25OffCoupons" rel="nofollow">'
"www.mystore.com/30%OffCoupons</a>!",
)
self.assertEqual(
urlize("https://en.wikipedia.org/wiki/Caf%C3%A9"),
'<a href="https://en.wikipedia.org/wiki/Caf%C3%A9" rel="nofollow">'
"https://en.wikipedia.org/wiki/Caf%C3%A9</a>",
)
def test_unicode(self):
self.assertEqual(
urlize("https://en.wikipedia.org/wiki/Café"),
'<a href="https://en.wikipedia.org/wiki/Caf%C3%A9" rel="nofollow">'
"https://en.wikipedia.org/wiki/Café</a>",
)
def test_parenthesis(self):
"""
#11911 - Check urlize keeps balanced parentheses
"""
self.assertEqual(
urlize("https://en.wikipedia.org/wiki/Django_(web_framework)"),
'<a href="https://en.wikipedia.org/wiki/Django_(web_framework)" '
'rel="nofollow">https://en.wikipedia.org/wiki/Django_(web_framework)</a>',
)
self.assertEqual(
urlize("(see https://en.wikipedia.org/wiki/Django_(web_framework))"),
'(see <a href="https://en.wikipedia.org/wiki/Django_(web_framework)" '
'rel="nofollow">https://en.wikipedia.org/wiki/Django_(web_framework)</a>)',
)
def test_parenthesis_and_bracket(self):
self.assertEqual(
urlize("[(https://en.wikipedia.org/)]"),
'[(<a href="https://en.wikipedia.org/" '
'rel="nofollow">https://en.wikipedia.org/</a>)]',
)
def test_nofollow(self):
"""
#12183 - Check urlize adds nofollow properly - see #12183
"""
self.assertEqual(
urlize("foo@bar.com or www.bar.com"),
'<a href="mailto:foo@bar.com">foo@bar.com</a> or '
'<a href="https://www.bar.com" rel="nofollow">www.bar.com</a>',
)
def test_idn(self):
"""
#13704 - Check urlize handles IDN correctly
"""
# The "✶" below is \N{SIX POINTED BLACK STAR}, not "*" \N{ASTERISK}.
self.assertEqual(
urlize("http://c✶.ws"),
'<a href="http://c%E2%9C%B6.ws" rel="nofollow">http://c✶.ws</a>',
)
self.assertEqual(
urlize("www.c✶.ws"),
'<a href="https://www.c%E2%9C%B6.ws" rel="nofollow">www.c✶.ws</a>',
)
self.assertEqual(
urlize("c✶.org"),
'<a href="https://c%E2%9C%B6.org" rel="nofollow">c✶.org</a>',
)
self.assertEqual(
urlize("info@c✶.org"),
'<a href="mailto:info@c%E2%9C%B6.org">info@c✶.org</a>',
)
# Pre-encoded IDNA is urlized but not re-encoded.
self.assertEqual(
urlize("www.xn--iny-zx5a.com/idna2003"),
'<a href="https://www.xn--iny-zx5a.com/idna2003"'
' rel="nofollow">www.xn--iny-zx5a.com/idna2003</a>',
)
self.assertEqual(
urlize("www.xn--fa-hia.com/idna2008"),
'<a href="https://www.xn--fa-hia.com/idna2008"'
' rel="nofollow">www.xn--fa-hia.com/idna2008</a>',
)
def test_malformed(self):
"""
#16395 - Check urlize doesn't highlight malformed URIs
"""
self.assertEqual(urlize("http:///www.google.com"), "http:///www.google.com")
self.assertEqual(urlize("http://.google.com"), "http://.google.com")
self.assertEqual(urlize("http://@foo.com"), "http://@foo.com")
def test_tlds(self):
"""
#16656 - Check urlize accepts more TLDs
"""
self.assertEqual(
urlize("usa.gov"), '<a href="https://usa.gov" rel="nofollow">usa.gov</a>'
)
def test_invalid_email(self):
"""
#17592 - Check urlize don't crash on invalid email with dot-starting
domain
"""
self.assertEqual(urlize("email@.stream.ru"), "email@.stream.ru")
def test_uppercase(self):
"""
#18071 - Check urlize accepts uppercased URL schemes
"""
self.assertEqual(
urlize("HTTPS://github.com/"),
'<a href="https://github.com/" rel="nofollow">HTTPS://github.com/</a>',
)
def test_trailing_period(self):
"""
#18644 - Check urlize trims trailing period when followed by
parenthesis
"""
self.assertEqual(
urlize("(Go to http://www.example.com/foo.)"),
'(Go to <a href="http://www.example.com/foo" rel="nofollow">'
"http://www.example.com/foo</a>.)",
)
def test_trailing_multiple_punctuation(self):
self.assertEqual(
urlize("A test http://testing.com/example.."),
'A test <a href="http://testing.com/example" rel="nofollow">'
"http://testing.com/example</a>..",
)
self.assertEqual(
urlize("A test http://testing.com/example!!"),
'A test <a href="http://testing.com/example" rel="nofollow">'
"http://testing.com/example</a>!!",
)
self.assertEqual(
urlize("A test http://testing.com/example!!!"),
'A test <a href="http://testing.com/example" rel="nofollow">'
"http://testing.com/example</a>!!!",
)
self.assertEqual(
urlize('A test http://testing.com/example.,:;)"!'),
'A test <a href="http://testing.com/example" rel="nofollow">'
"http://testing.com/example</a>.,:;)"!",
)
def test_trailing_semicolon(self):
self.assertEqual(
urlize("http://example.com?x=&", autoescape=False),
'<a href="http://example.com?x=" rel="nofollow">'
"http://example.com?x=&</a>",
)
self.assertEqual(
urlize("http://example.com?x=&;", autoescape=False),
'<a href="http://example.com?x=" rel="nofollow">'
"http://example.com?x=&</a>;",
)
self.assertEqual(
urlize("http://example.com?x=&;;", autoescape=False),
'<a href="http://example.com?x=" rel="nofollow">'
"http://example.com?x=&</a>;;",
)
self.assertEqual(
urlize("http://example.com?x=&.;...;", autoescape=False),
'<a href="http://example.com?x=" rel="nofollow">'
"http://example.com?x=&</a>.;...;",
)
def test_brackets(self):
"""
#19070 - Check urlize handles brackets properly
"""
self.assertEqual(
urlize("[see www.example.com]"),
'[see <a href="https://www.example.com" rel="nofollow">'
"www.example.com</a>]",
)
self.assertEqual(
urlize("see test[at[example.com"), # Invalid hostname.
"see test[at[example.com",
)
self.assertEqual(
urlize("[http://168.192.0.1](http://168.192.0.1)"),
'[<a href="http://168.192.0.1](http://168.192.0.1)" rel="nofollow">'
"http://168.192.0.1](http://168.192.0.1)</a>",
)
def test_wrapping_characters(self):
wrapping_chars = (
("()", ("(", ")")),
("<>", ("<", ">")),
("[]", ("[", "]")),
('""', (""", """)),
("''", ("'", "'")),
)
for wrapping_in, (start_out, end_out) in wrapping_chars:
with self.subTest(wrapping_in=wrapping_in):
start_in, end_in = wrapping_in
self.assertEqual(
urlize(start_in + "https://www.example.org/" + end_in),
f'{start_out}<a href="https://www.example.org/" rel="nofollow">'
f"https://www.example.org/</a>{end_out}",
)
def test_ipv4(self):
self.assertEqual(
urlize("http://192.168.0.15/api/9"),
'<a href="http://192.168.0.15/api/9" rel="nofollow">'
"http://192.168.0.15/api/9</a>",
)
def test_ipv6(self):
self.assertEqual(
urlize("http://[2001:db8:cafe::2]/api/9"),
'<a href="http://[2001:db8:cafe::2]/api/9" rel="nofollow">'
"http://[2001:db8:cafe::2]/api/9</a>",
)
def test_quotation_marks(self):
"""
#20364 - Check urlize correctly include quotation marks in links
"""
self.assertEqual(
urlize('before "hi@example.com" afterward', autoescape=False),
'before "<a href="mailto:hi@example.com">hi@example.com</a>" afterward',
)
self.assertEqual(
urlize('before hi@example.com" afterward', autoescape=False),
'before <a href="mailto:hi@example.com">hi@example.com</a>" afterward',
)
self.assertEqual(
urlize('before "hi@example.com afterward', autoescape=False),
'before "<a href="mailto:hi@example.com">hi@example.com</a> afterward',
)
self.assertEqual(
urlize("before 'hi@example.com' afterward", autoescape=False),
"before '<a href=\"mailto:hi@example.com\">hi@example.com</a>' afterward",
)
self.assertEqual(
urlize("before hi@example.com' afterward", autoescape=False),
'before <a href="mailto:hi@example.com">hi@example.com</a>\' afterward',
)
self.assertEqual(
urlize("before 'hi@example.com afterward", autoescape=False),
'before \'<a href="mailto:hi@example.com">hi@example.com</a> afterward',
)
def test_quote_commas(self):
"""
#20364 - Check urlize copes with commas following URLs in quotes
"""
self.assertEqual(
urlize(
'Email us at "hi@example.com", or phone us at +xx.yy', autoescape=False
),
'Email us at "<a href="mailto:hi@example.com">hi@example.com</a>", or '
"phone us at +xx.yy",
)
def test_exclamation_marks(self):
"""
#23715 - Check urlize correctly handles exclamation marks after TLDs
or query string
"""
self.assertEqual(
urlize("Go to djangoproject.com! and enjoy."),
'Go to <a href="https://djangoproject.com" rel="nofollow">djangoproject.com'
"</a>! and enjoy.",
)
self.assertEqual(
urlize("Search for google.com/?q=! and see."),
'Search for <a href="https://google.com/?q=" rel="nofollow">google.com/?q='
"</a>! and see.",
)
self.assertEqual(
urlize("Search for google.com/?q=dj!`? and see."),
'Search for <a href="https://google.com/?q=dj%21%60%3F" rel="nofollow">'
"google.com/?q=dj!`?</a> and see.",
)
self.assertEqual(
urlize("Search for google.com/?q=dj!`?! and see."),
'Search for <a href="https://google.com/?q=dj%21%60%3F" rel="nofollow">'
"google.com/?q=dj!`?</a>! and see.",
)
def test_non_string_input(self):
self.assertEqual(urlize(123), "123")
def test_autoescape(self):
self.assertEqual(
urlize('foo<a href=" google.com ">bar</a>buz'),
'foo<a href=" <a href="https://google.com" rel="nofollow">'
"google.com</a> ">bar</a>buz",
)
def test_autoescape_off(self):
self.assertEqual(
urlize('foo<a href=" google.com ">bar</a>buz', autoescape=False),
'foo<a href=" <a href="https://google.com" rel="nofollow">google.com</a> ">'
"bar</a>buz",
)
def test_lazystring(self):
prepend_www = lazy(lambda url: "www." + url, str)
self.assertEqual(
urlize(prepend_www("google.com")),
'<a href="https://www.google.com" rel="nofollow">www.google.com</a>',
)
@mock.patch.object(Urlizer, "handle_word", return_value="test")
def test_caching_repeated_words(self, mock_handle_word):
urlize("test test test test")
common_handle_word_args = {
"safe_input": False,
"trim_url_limit": None,
"nofollow": True,
"autoescape": True,
}
self.assertEqual(
mock_handle_word.mock_calls,
[
mock.call("test", **common_handle_word_args),
mock.call(" ", **common_handle_word_args),
],
)
@mock.patch.object(Urlizer, "handle_word", return_value="test")
def test_caching_repeated_calls(self, mock_handle_word):
urlize("test")
handle_word_test = mock.call(
"test",
safe_input=False,
trim_url_limit=None,
nofollow=True,
autoescape=True,
)
self.assertEqual(mock_handle_word.mock_calls, [handle_word_test])
urlize("test")
self.assertEqual(
mock_handle_word.mock_calls, [handle_word_test, handle_word_test]
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_time.py | tests/template_tests/filter_tests/test_time.py | from datetime import time
from django.template.defaultfilters import time as time_filter
from django.test import SimpleTestCase
from django.utils import timezone, translation
from ..utils import setup
from .timezone_utils import TimezoneTestCase
class TimeTests(TimezoneTestCase):
"""
#20693: Timezone support for the time template filter
"""
@setup({"time00": "{{ dt|time }}"})
def test_time00(self):
output = self.engine.render_to_string("time00", {"dt": time(16, 25)})
self.assertEqual(output, "4:25 p.m.")
@setup({"time00_l10n": "{{ dt|time }}"})
def test_time00_l10n(self):
with translation.override("fr"):
output = self.engine.render_to_string("time00_l10n", {"dt": time(16, 25)})
self.assertEqual(output, "16:25")
@setup({"time01": '{{ dt|time:"e:O:T:Z" }}'})
def test_time01(self):
output = self.engine.render_to_string("time01", {"dt": self.now_tz_i})
self.assertEqual(output, "+0315:+0315:+0315:11700")
@setup({"time02": '{{ dt|time:"e:T" }}'})
def test_time02(self):
output = self.engine.render_to_string("time02", {"dt": self.now})
self.assertEqual(output, ":" + self.now_tz.tzinfo.tzname(self.now_tz))
@setup({"time03": '{{ t|time:"P:e:O:T:Z" }}'})
def test_time03(self):
output = self.engine.render_to_string(
"time03", {"t": time(4, 0, tzinfo=timezone.get_fixed_timezone(30))}
)
self.assertEqual(output, "4 a.m.::::")
@setup({"time04": '{{ t|time:"P:e:O:T:Z" }}'})
def test_time04(self):
output = self.engine.render_to_string("time04", {"t": time(4, 0)})
self.assertEqual(output, "4 a.m.::::")
@setup({"time05": '{{ d|time:"P:e:O:T:Z" }}'})
def test_time05(self):
output = self.engine.render_to_string("time05", {"d": self.today})
self.assertEqual(output, "")
@setup({"time06": '{{ obj|time:"P:e:O:T:Z" }}'})
def test_time06(self):
output = self.engine.render_to_string("time06", {"obj": "non-datetime-value"})
self.assertEqual(output, "")
class FunctionTests(SimpleTestCase):
def test_no_args(self):
self.assertEqual(time_filter(""), "")
self.assertEqual(time_filter(None), "")
def test_inputs(self):
self.assertEqual(time_filter(time(13), "h"), "01")
self.assertEqual(time_filter(time(0), "h"), "12")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_join.py | tests/template_tests/filter_tests/test_join.py | from django.template.defaultfilters import join
from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class JoinTests(SimpleTestCase):
@setup({"join01": '{{ a|join:", " }}'})
def test_join01(self):
output = self.engine.render_to_string("join01", {"a": ["alpha", "beta & me"]})
self.assertEqual(output, "alpha, beta & me")
@setup({"join02": '{% autoescape off %}{{ a|join:", " }}{% endautoescape %}'})
def test_join02(self):
output = self.engine.render_to_string("join02", {"a": ["alpha", "beta & me"]})
self.assertEqual(output, "alpha, beta & me")
@setup({"join03": '{{ a|join:" & " }}'})
def test_join03(self):
output = self.engine.render_to_string("join03", {"a": ["alpha", "beta & me"]})
self.assertEqual(output, "alpha & beta & me")
@setup({"join04": '{% autoescape off %}{{ a|join:" & " }}{% endautoescape %}'})
def test_join04(self):
output = self.engine.render_to_string("join04", {"a": ["alpha", "beta & me"]})
self.assertEqual(output, "alpha & beta & me")
# Joining with unsafe joiners doesn't result in unsafe strings.
@setup({"join05": "{{ a|join:var }}"})
def test_join05(self):
output = self.engine.render_to_string(
"join05", {"a": ["alpha", "beta & me"], "var": " & "}
)
self.assertEqual(output, "alpha & beta & me")
@setup({"join06": "{{ a|join:var }}"})
def test_join06(self):
output = self.engine.render_to_string(
"join06", {"a": ["alpha", "beta & me"], "var": mark_safe(" & ")}
)
self.assertEqual(output, "alpha & beta & me")
@setup({"join07": "{{ a|join:var|lower }}"})
def test_join07(self):
output = self.engine.render_to_string(
"join07", {"a": ["Alpha", "Beta & me"], "var": " & "}
)
self.assertEqual(output, "alpha & beta & me")
@setup({"join08": "{{ a|join:var|lower }}"})
def test_join08(self):
output = self.engine.render_to_string(
"join08", {"a": ["Alpha", "Beta & me"], "var": mark_safe(" & ")}
)
self.assertEqual(output, "alpha & beta & me")
@setup(
{
"join_autoescape_off": (
"{% autoescape off %}"
"{{ var_list|join:var_joiner }}"
"{% endautoescape %}"
),
}
)
def test_join_autoescape_off(self):
var_list = ["<p>Hello World!</p>", "beta & me", "<script>Hi!</script>"]
context = {"var_list": var_list, "var_joiner": "<br/>"}
output = self.engine.render_to_string("join_autoescape_off", context)
expected_result = "<p>Hello World!</p><br/>beta & me<br/><script>Hi!</script>"
self.assertEqual(output, expected_result)
class FunctionTests(SimpleTestCase):
def test_list(self):
self.assertEqual(join([0, 1, 2], "glue"), "0glue1glue2")
def test_autoescape(self):
self.assertEqual(
join(["<a>", "<img>", "</a>"], "<br>"),
"<a><br><img><br></a>",
)
def test_autoescape_off(self):
self.assertEqual(
join(["<a>", "<img>", "</a>"], "<br>", autoescape=False),
"<a><br><img><br></a>",
)
def test_noniterable_arg(self):
obj = object()
self.assertEqual(join(obj, "<br>"), obj)
def test_noniterable_arg_autoescape_off(self):
obj = object()
self.assertEqual(join(obj, "<br>", autoescape=False), obj)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_force_escape.py | tests/template_tests/filter_tests/test_force_escape.py | from django.template.defaultfilters import force_escape
from django.test import SimpleTestCase
from django.utils.safestring import SafeData
from ..utils import setup
class ForceEscapeTests(SimpleTestCase):
"""
Force_escape is applied immediately. It can be used to provide
double-escaping, for example.
"""
@setup(
{
"force-escape01": (
"{% autoescape off %}{{ a|force_escape }}{% endautoescape %}"
)
}
)
def test_force_escape01(self):
output = self.engine.render_to_string("force-escape01", {"a": "x&y"})
self.assertEqual(output, "x&y")
@setup({"force-escape02": "{{ a|force_escape }}"})
def test_force_escape02(self):
output = self.engine.render_to_string("force-escape02", {"a": "x&y"})
self.assertEqual(output, "x&y")
@setup(
{
"force-escape03": (
"{% autoescape off %}{{ a|force_escape|force_escape }}"
"{% endautoescape %}"
)
}
)
def test_force_escape03(self):
output = self.engine.render_to_string("force-escape03", {"a": "x&y"})
self.assertEqual(output, "x&amp;y")
@setup({"force-escape04": "{{ a|force_escape|force_escape }}"})
def test_force_escape04(self):
output = self.engine.render_to_string("force-escape04", {"a": "x&y"})
self.assertEqual(output, "x&amp;y")
# Because the result of force_escape is "safe", an additional
# escape filter has no effect.
@setup(
{
"force-escape05": (
"{% autoescape off %}{{ a|force_escape|escape }}{% endautoescape %}"
)
}
)
def test_force_escape05(self):
output = self.engine.render_to_string("force-escape05", {"a": "x&y"})
self.assertEqual(output, "x&y")
@setup({"force-escape06": "{{ a|force_escape|escape }}"})
def test_force_escape06(self):
output = self.engine.render_to_string("force-escape06", {"a": "x&y"})
self.assertEqual(output, "x&y")
@setup(
{
"force-escape07": (
"{% autoescape off %}{{ a|escape|force_escape }}{% endautoescape %}"
)
}
)
def test_force_escape07(self):
output = self.engine.render_to_string("force-escape07", {"a": "x&y"})
self.assertEqual(output, "x&amp;y")
@setup({"force-escape08": "{{ a|escape|force_escape }}"})
def test_force_escape08(self):
output = self.engine.render_to_string("force-escape08", {"a": "x&y"})
self.assertEqual(output, "x&amp;y")
class FunctionTests(SimpleTestCase):
def test_escape(self):
escaped = force_escape("<some html & special characters > here")
self.assertEqual(escaped, "<some html & special characters > here")
self.assertIsInstance(escaped, SafeData)
def test_unicode(self):
self.assertEqual(
force_escape("<some html & special characters > here ĐÅ€£"),
"<some html & special characters > here \u0110\xc5\u20ac\xa3",
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_divisibleby.py | tests/template_tests/filter_tests/test_divisibleby.py | from django.template.defaultfilters import divisibleby
from django.test import SimpleTestCase
class FunctionTests(SimpleTestCase):
def test_true(self):
self.assertIs(divisibleby(4, 2), True)
def test_false(self):
self.assertIs(divisibleby(4, 3), False)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_upper.py | tests/template_tests/filter_tests/test_upper.py | from django.template.defaultfilters import upper
from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class UpperTests(SimpleTestCase):
"""
The "upper" filter messes up entities (which are case-sensitive),
so it's not safe for non-escaping purposes.
"""
@setup(
{
"upper01": (
"{% autoescape off %}{{ a|upper }} {{ b|upper }}{% endautoescape %}"
)
}
)
def test_upper01(self):
output = self.engine.render_to_string(
"upper01", {"a": "a & b", "b": mark_safe("a & b")}
)
self.assertEqual(output, "A & B A & B")
@setup({"upper02": "{{ a|upper }} {{ b|upper }}"})
def test_upper02(self):
output = self.engine.render_to_string(
"upper02", {"a": "a & b", "b": mark_safe("a & b")}
)
self.assertEqual(output, "A & B A &AMP; B")
class FunctionTests(SimpleTestCase):
def test_upper(self):
self.assertEqual(upper("Mixed case input"), "MIXED CASE INPUT")
def test_unicode(self):
# lowercase e umlaut
self.assertEqual(upper("\xeb"), "\xcb")
def test_non_string_input(self):
self.assertEqual(upper(123), "123")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_first.py | tests/template_tests/filter_tests/test_first.py | from django.template.defaultfilters import first
from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class FirstTests(SimpleTestCase):
@setup({"first01": "{{ a|first }} {{ b|first }}"})
def test_first01(self):
output = self.engine.render_to_string(
"first01", {"a": ["a&b", "x"], "b": [mark_safe("a&b"), "x"]}
)
self.assertEqual(output, "a&b a&b")
@setup(
{
"first02": (
"{% autoescape off %}{{ a|first }} {{ b|first }}{% endautoescape %}"
)
}
)
def test_first02(self):
output = self.engine.render_to_string(
"first02", {"a": ["a&b", "x"], "b": [mark_safe("a&b"), "x"]}
)
self.assertEqual(output, "a&b a&b")
class FunctionTests(SimpleTestCase):
def test_list(self):
self.assertEqual(first([0, 1, 2]), 0)
def test_empty_string(self):
self.assertEqual(first(""), "")
def test_string(self):
self.assertEqual(first("test"), "t")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_yesno.py | tests/template_tests/filter_tests/test_yesno.py | from django.template.defaultfilters import yesno
from django.test import SimpleTestCase
from ..utils import setup
class YesNoTests(SimpleTestCase):
@setup({"t": '{{ var|yesno:"yup,nup,mup" }} {{ var|yesno }}'})
def test_true(self):
output = self.engine.render_to_string("t", {"var": True})
self.assertEqual(output, "yup yes")
class FunctionTests(SimpleTestCase):
def test_true(self):
self.assertEqual(yesno(True), "yes")
def test_false(self):
self.assertEqual(yesno(False), "no")
def test_none(self):
self.assertEqual(yesno(None), "maybe")
def test_true_arguments(self):
self.assertEqual(yesno(True, "certainly,get out of town,perhaps"), "certainly")
def test_false_arguments(self):
self.assertEqual(
yesno(False, "certainly,get out of town,perhaps"), "get out of town"
)
def test_none_two_arguments(self):
self.assertEqual(yesno(None, "certainly,get out of town"), "get out of town")
def test_none_three_arguments(self):
self.assertEqual(yesno(None, "certainly,get out of town,perhaps"), "perhaps")
def test_invalid_value(self):
self.assertIs(yesno(True, "yes"), True)
self.assertIs(yesno(False, "yes"), False)
self.assertIsNone(yesno(None, "yes"))
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_escapejs.py | tests/template_tests/filter_tests/test_escapejs.py | from django.template.defaultfilters import escapejs_filter
from django.test import SimpleTestCase
from django.utils.functional import lazy
from ..utils import setup
class EscapejsTests(SimpleTestCase):
@setup({"escapejs01": "{{ a|escapejs }}"})
def test_escapejs01(self):
output = self.engine.render_to_string(
"escapejs01", {"a": "testing\r\njavascript 'string\" <b>escaping</b>"}
)
self.assertEqual(
output,
"testing\\u000D\\u000Ajavascript "
"\\u0027string\\u0022 \\u003Cb\\u003E"
"escaping\\u003C/b\\u003E",
)
@setup({"escapejs02": "{% autoescape off %}{{ a|escapejs }}{% endautoescape %}"})
def test_escapejs02(self):
output = self.engine.render_to_string(
"escapejs02", {"a": "testing\r\njavascript 'string\" <b>escaping</b>"}
)
self.assertEqual(
output,
"testing\\u000D\\u000Ajavascript "
"\\u0027string\\u0022 \\u003Cb\\u003E"
"escaping\\u003C/b\\u003E",
)
class FunctionTests(SimpleTestCase):
def test_quotes(self):
self.assertEqual(
escapejs_filter("\"double quotes\" and 'single quotes'"),
"\\u0022double quotes\\u0022 and \\u0027single quotes\\u0027",
)
def test_backslashes(self):
self.assertEqual(
escapejs_filter(r"\ : backslashes, too"), "\\u005C : backslashes, too"
)
def test_whitespace(self):
self.assertEqual(
escapejs_filter("and lots of whitespace: \r\n\t\v\f\b"),
"and lots of whitespace: \\u000D\\u000A\\u0009\\u000B\\u000C\\u0008",
)
def test_script(self):
self.assertEqual(
escapejs_filter(r"<script>and this</script>"),
"\\u003Cscript\\u003Eand this\\u003C/script\\u003E",
)
def test_paragraph_separator(self):
self.assertEqual(
escapejs_filter("paragraph separator:\u2029and line separator:\u2028"),
"paragraph separator:\\u2029and line separator:\\u2028",
)
def test_lazy_string(self):
append_script = lazy(lambda string: r"<script>this</script>" + string, str)
self.assertEqual(
escapejs_filter(append_script("whitespace: \r\n\t\v\f\b")),
"\\u003Cscript\\u003Ethis\\u003C/script\\u003E"
"whitespace: \\u000D\\u000A\\u0009\\u000B\\u000C\\u0008",
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_unordered_list.py | tests/template_tests/filter_tests/test_unordered_list.py | from django.template.defaultfilters import unordered_list
from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from django.utils.translation import gettext_lazy
from ..utils import setup
class UnorderedListTests(SimpleTestCase):
@setup({"unordered_list01": "{{ a|unordered_list }}"})
def test_unordered_list01(self):
output = self.engine.render_to_string("unordered_list01", {"a": ["x>", ["<y"]]})
self.assertEqual(
output, "\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>"
)
@setup(
{
"unordered_list02": (
"{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}"
)
}
)
def test_unordered_list02(self):
output = self.engine.render_to_string("unordered_list02", {"a": ["x>", ["<y"]]})
self.assertEqual(output, "\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>")
@setup({"unordered_list03": "{{ a|unordered_list }}"})
def test_unordered_list03(self):
output = self.engine.render_to_string(
"unordered_list03", {"a": ["x>", [mark_safe("<y")]]}
)
self.assertEqual(
output, "\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>"
)
@setup(
{
"unordered_list04": (
"{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}"
)
}
)
def test_unordered_list04(self):
output = self.engine.render_to_string(
"unordered_list04", {"a": ["x>", [mark_safe("<y")]]}
)
self.assertEqual(output, "\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>")
@setup(
{
"unordered_list05": (
"{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}"
)
}
)
def test_unordered_list05(self):
output = self.engine.render_to_string("unordered_list05", {"a": ["x>", ["<y"]]})
self.assertEqual(output, "\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>")
class FunctionTests(SimpleTestCase):
def test_list(self):
self.assertEqual(
unordered_list(["item 1", "item 2"]), "\t<li>item 1</li>\n\t<li>item 2</li>"
)
def test_list_gettext(self):
self.assertEqual(
unordered_list(["item 1", gettext_lazy("item 2")]),
"\t<li>item 1</li>\n\t<li>item 2</li>",
)
def test_nested(self):
self.assertEqual(
unordered_list(["item 1", ["item 1.1"]]),
"\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t</ul>\n\t</li>",
)
def test_nested2(self):
self.assertEqual(
unordered_list(["item 1", ["item 1.1", "item1.2"], "item 2"]),
"\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t\t<li>item1.2"
"</li>\n\t</ul>\n\t</li>\n\t<li>item 2</li>",
)
def test_nested3(self):
self.assertEqual(
unordered_list(["item 1", "item 2", ["item 2.1"]]),
"\t<li>item 1</li>\n\t<li>item 2\n\t<ul>\n\t\t<li>item 2.1"
"</li>\n\t</ul>\n\t</li>",
)
def test_nested_multiple(self):
self.assertEqual(
unordered_list(["item 1", ["item 1.1", ["item 1.1.1", ["item 1.1.1.1"]]]]),
"\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1\n\t\t<ul>\n\t\t\t<li>"
"item 1.1.1\n\t\t\t<ul>\n\t\t\t\t<li>item 1.1.1.1</li>\n\t\t\t"
"</ul>\n\t\t\t</li>\n\t\t</ul>\n\t\t</li>\n\t</ul>\n\t</li>",
)
def test_nested_multiple2(self):
self.assertEqual(
unordered_list(["States", ["Kansas", ["Lawrence", "Topeka"], "Illinois"]]),
"\t<li>States\n\t<ul>\n\t\t<li>Kansas\n\t\t<ul>\n\t\t\t<li>"
"Lawrence</li>\n\t\t\t<li>Topeka</li>\n\t\t</ul>\n\t\t</li>"
"\n\t\t<li>Illinois</li>\n\t</ul>\n\t</li>",
)
def test_autoescape(self):
self.assertEqual(
unordered_list(["<a>item 1</a>", "item 2"]),
"\t<li><a>item 1</a></li>\n\t<li>item 2</li>",
)
def test_autoescape_off(self):
self.assertEqual(
unordered_list(["<a>item 1</a>", "item 2"], autoescape=False),
"\t<li><a>item 1</a></li>\n\t<li>item 2</li>",
)
def test_ulitem(self):
class ULItem:
def __init__(self, title):
self.title = title
def __str__(self):
return "ulitem-%s" % str(self.title)
a = ULItem("a")
b = ULItem("b")
c = ULItem("<a>c</a>")
self.assertEqual(
unordered_list([a, b, c]),
"\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>\n\t"
"<li>ulitem-<a>c</a></li>",
)
def item_generator():
yield from (a, b, c)
self.assertEqual(
unordered_list(item_generator()),
"\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>\n\t"
"<li>ulitem-<a>c</a></li>",
)
def test_nested_generators(self):
def inner_generator():
yield from ("B", "C")
def item_generator():
yield "A"
yield inner_generator()
yield "D"
self.assertEqual(
unordered_list(item_generator()),
"\t<li>A\n\t<ul>\n\t\t<li>B</li>\n\t\t<li>C</li>\n\t</ul>\n\t</li>\n\t"
"<li>D</li>",
)
def test_ulitem_autoescape_off(self):
class ULItem:
def __init__(self, title):
self.title = title
def __str__(self):
return "ulitem-%s" % str(self.title)
a = ULItem("a")
b = ULItem("b")
c = ULItem("<a>c</a>")
self.assertEqual(
unordered_list([a, b, c], autoescape=False),
"\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>\n\t<li>ulitem-<a>c</a></li>",
)
def item_generator():
yield from (a, b, c)
self.assertEqual(
unordered_list(item_generator(), autoescape=False),
"\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>\n\t<li>ulitem-<a>c</a></li>",
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_add.py | tests/template_tests/filter_tests/test_add.py | from datetime import date, timedelta
from django.template.defaultfilters import add
from django.test import SimpleTestCase
from django.utils.translation import gettext_lazy
from ..utils import setup
class AddTests(SimpleTestCase):
"""
Tests for #11687 and #16676
"""
@setup({"add01": '{{ i|add:"5" }}'})
def test_add01(self):
output = self.engine.render_to_string("add01", {"i": 2000})
self.assertEqual(output, "2005")
@setup({"add02": '{{ i|add:"napis" }}'})
def test_add02(self):
output = self.engine.render_to_string("add02", {"i": 2000})
self.assertEqual(output, "")
@setup({"add03": "{{ i|add:16 }}"})
def test_add03(self):
output = self.engine.render_to_string("add03", {"i": "not_an_int"})
self.assertEqual(output, "")
@setup({"add04": '{{ i|add:"16" }}'})
def test_add04(self):
output = self.engine.render_to_string("add04", {"i": "not_an_int"})
self.assertEqual(output, "not_an_int16")
@setup({"add05": "{{ l1|add:l2 }}"})
def test_add05(self):
output = self.engine.render_to_string("add05", {"l1": [1, 2], "l2": [3, 4]})
self.assertEqual(output, "[1, 2, 3, 4]")
@setup({"add06": "{{ t1|add:t2 }}"})
def test_add06(self):
output = self.engine.render_to_string("add06", {"t1": (3, 4), "t2": (1, 2)})
self.assertEqual(output, "(3, 4, 1, 2)")
@setup({"add07": "{{ d|add:t }}"})
def test_add07(self):
output = self.engine.render_to_string(
"add07", {"d": date(2000, 1, 1), "t": timedelta(10)}
)
self.assertEqual(output, "Jan. 11, 2000")
@setup({"add08": "{{ s1|add:lazy_s2 }}"})
def test_add08(self):
output = self.engine.render_to_string(
"add08",
{"s1": "string", "lazy_s2": gettext_lazy("lazy")},
)
self.assertEqual(output, "stringlazy")
@setup({"add09": "{{ lazy_s1|add:lazy_s2 }}"})
def test_add09(self):
output = self.engine.render_to_string(
"add09",
{"lazy_s1": gettext_lazy("string"), "lazy_s2": gettext_lazy("lazy")},
)
self.assertEqual(output, "stringlazy")
class FunctionTests(SimpleTestCase):
def test_add(self):
self.assertEqual(add("1", "2"), 3)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_iriencode.py | tests/template_tests/filter_tests/test_iriencode.py | from django.template.defaultfilters import iriencode, urlencode
from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class IriencodeTests(SimpleTestCase):
"""
Ensure iriencode keeps safe strings.
"""
@setup({"iriencode01": "{{ url|iriencode }}"})
def test_iriencode01(self):
output = self.engine.render_to_string("iriencode01", {"url": "?test=1&me=2"})
self.assertEqual(output, "?test=1&me=2")
@setup(
{"iriencode02": "{% autoescape off %}{{ url|iriencode }}{% endautoescape %}"}
)
def test_iriencode02(self):
output = self.engine.render_to_string("iriencode02", {"url": "?test=1&me=2"})
self.assertEqual(output, "?test=1&me=2")
@setup({"iriencode03": "{{ url|iriencode }}"})
def test_iriencode03(self):
output = self.engine.render_to_string(
"iriencode03", {"url": mark_safe("?test=1&me=2")}
)
self.assertEqual(output, "?test=1&me=2")
@setup(
{"iriencode04": "{% autoescape off %}{{ url|iriencode }}{% endautoescape %}"}
)
def test_iriencode04(self):
output = self.engine.render_to_string(
"iriencode04", {"url": mark_safe("?test=1&me=2")}
)
self.assertEqual(output, "?test=1&me=2")
class FunctionTests(SimpleTestCase):
def test_unicode(self):
self.assertEqual(iriencode("S\xf8r-Tr\xf8ndelag"), "S%C3%B8r-Tr%C3%B8ndelag")
def test_urlencoded(self):
self.assertEqual(
iriencode(urlencode("fran\xe7ois & jill")), "fran%C3%A7ois%20%26%20jill"
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_random.py | tests/template_tests/filter_tests/test_random.py | from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class RandomTests(SimpleTestCase):
@setup({"random01": "{{ a|random }} {{ b|random }}"})
def test_random01(self):
output = self.engine.render_to_string(
"random01", {"a": ["a&b", "a&b"], "b": [mark_safe("a&b"), mark_safe("a&b")]}
)
self.assertEqual(output, "a&b a&b")
@setup(
{
"random02": (
"{% autoescape off %}{{ a|random }} {{ b|random }}{% endautoescape %}"
)
}
)
def test_random02(self):
output = self.engine.render_to_string(
"random02", {"a": ["a&b", "a&b"], "b": [mark_safe("a&b"), mark_safe("a&b")]}
)
self.assertEqual(output, "a&b a&b")
@setup({"empty_list": "{{ list|random }}"})
def test_empty_list(self):
output = self.engine.render_to_string("empty_list", {"list": []})
self.assertEqual(output, "")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_slice.py | tests/template_tests/filter_tests/test_slice.py | from django.template.defaultfilters import slice_filter
from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class SliceTests(SimpleTestCase):
@setup({"slice01": '{{ a|slice:"1:3" }} {{ b|slice:"1:3" }}'})
def test_slice01(self):
output = self.engine.render_to_string(
"slice01", {"a": "a&b", "b": mark_safe("a&b")}
)
self.assertEqual(output, "&b &b")
@setup(
{
"slice02": (
'{% autoescape off %}{{ a|slice:"1:3" }} {{ b|slice:"1:3" }}'
"{% endautoescape %}"
)
}
)
def test_slice02(self):
output = self.engine.render_to_string(
"slice02", {"a": "a&b", "b": mark_safe("a&b")}
)
self.assertEqual(output, "&b &b")
class FunctionTests(SimpleTestCase):
def test_zero_length(self):
self.assertEqual(slice_filter("abcdefg", "0"), "")
def test_index(self):
self.assertEqual(slice_filter("abcdefg", "1"), "a")
def test_index_integer(self):
self.assertEqual(slice_filter("abcdefg", 1), "a")
def test_negative_index(self):
self.assertEqual(slice_filter("abcdefg", "-1"), "abcdef")
def test_range(self):
self.assertEqual(slice_filter("abcdefg", "1:2"), "b")
def test_range_multiple(self):
self.assertEqual(slice_filter("abcdefg", "1:3"), "bc")
def test_range_step(self):
self.assertEqual(slice_filter("abcdefg", "0::2"), "aceg")
def test_fail_silently(self):
obj = object()
self.assertEqual(slice_filter(obj, "0::2"), obj)
def test_empty_dict(self):
self.assertEqual(slice_filter({}, "1"), {})
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_truncatewords.py | tests/template_tests/filter_tests/test_truncatewords.py | from django.template.defaultfilters import truncatewords
from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class TruncatewordsTests(SimpleTestCase):
@setup(
{
"truncatewords01": (
'{% autoescape off %}{{ a|truncatewords:"2" }} {{ b|truncatewords:"2"}}'
"{% endautoescape %}"
)
}
)
def test_truncatewords01(self):
output = self.engine.render_to_string(
"truncatewords01",
{"a": "alpha & bravo", "b": mark_safe("alpha & bravo")},
)
self.assertEqual(output, "alpha & … alpha & …")
@setup({"truncatewords02": '{{ a|truncatewords:"2" }} {{ b|truncatewords:"2"}}'})
def test_truncatewords02(self):
output = self.engine.render_to_string(
"truncatewords02",
{"a": "alpha & bravo", "b": mark_safe("alpha & bravo")},
)
self.assertEqual(output, "alpha & … alpha & …")
class FunctionTests(SimpleTestCase):
def test_truncate(self):
self.assertEqual(truncatewords("A sentence with a few words in it", 1), "A …")
def test_truncate2(self):
self.assertEqual(
truncatewords("A sentence with a few words in it", 5),
"A sentence with a few …",
)
def test_overtruncate(self):
self.assertEqual(
truncatewords("A sentence with a few words in it", 100),
"A sentence with a few words in it",
)
def test_invalid_number(self):
self.assertEqual(
truncatewords("A sentence with a few words in it", "not a number"),
"A sentence with a few words in it",
)
def test_non_string_input(self):
self.assertEqual(truncatewords(123, 2), "123")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_truncatechars_html.py | tests/template_tests/filter_tests/test_truncatechars_html.py | from django.template.defaultfilters import truncatechars_html
from django.test import SimpleTestCase
class FunctionTests(SimpleTestCase):
def test_truncate_zero(self):
self.assertEqual(
truncatechars_html(
'<p>one <a href="#">two - three <br>four</a> five</p>', 0
),
"",
)
def test_truncate(self):
self.assertEqual(
truncatechars_html(
'<p>one <a href="#">two - three <br>four</a> five</p>', 4
),
"<p>one…</p>",
)
def test_truncate2(self):
self.assertEqual(
truncatechars_html(
'<p>one <a href="#">two - three <br>four</a> five</p>', 9
),
'<p>one <a href="#">two …</a></p>',
)
def test_truncate3(self):
self.assertEqual(
truncatechars_html(
'<p>one <a href="#">two - three <br>four</a> five</p>', 100
),
'<p>one <a href="#">two - three <br>four</a> five</p>',
)
def test_truncate_unicode(self):
self.assertEqual(
truncatechars_html("<b>\xc5ngstr\xf6m</b> was here", 3), "<b>\xc5n…</b>"
)
def test_truncate_something(self):
self.assertEqual(truncatechars_html("a<b>b</b>c", 3), "a<b>b</b>c")
def test_invalid_arg(self):
html = '<p>one <a href="#">two - three <br>four</a> five</p>'
self.assertEqual(truncatechars_html(html, "a"), html)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_rjust.py | tests/template_tests/filter_tests/test_rjust.py | from django.template.defaultfilters import rjust
from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class RjustTests(SimpleTestCase):
@setup(
{
"rjust01": (
'{% autoescape off %}.{{ a|rjust:"5" }}. .{{ b|rjust:"5" }}.'
"{% endautoescape %}"
)
}
)
def test_rjust01(self):
output = self.engine.render_to_string(
"rjust01", {"a": "a&b", "b": mark_safe("a&b")}
)
self.assertEqual(output, ". a&b. . a&b.")
@setup({"rjust02": '.{{ a|rjust:"5" }}. .{{ b|rjust:"5" }}.'})
def test_rjust02(self):
output = self.engine.render_to_string(
"rjust02", {"a": "a&b", "b": mark_safe("a&b")}
)
self.assertEqual(output, ". a&b. . a&b.")
class FunctionTests(SimpleTestCase):
def test_rjust(self):
self.assertEqual(rjust("test", 10), " test")
def test_less_than_string_length(self):
self.assertEqual(rjust("test", 3), "test")
def test_non_string_input(self):
self.assertEqual(rjust(123, 4), " 123")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_center.py | tests/template_tests/filter_tests/test_center.py | from django.template.defaultfilters import center
from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class CenterTests(SimpleTestCase):
@setup(
{
"center01": (
'{% autoescape off %}.{{ a|center:"5" }}. .{{ b|center:"5" }}.'
"{% endautoescape %}"
)
}
)
def test_center01(self):
output = self.engine.render_to_string(
"center01", {"a": "a&b", "b": mark_safe("a&b")}
)
self.assertEqual(output, ". a&b . . a&b .")
@setup({"center02": '.{{ a|center:"5" }}. .{{ b|center:"5" }}.'})
def test_center02(self):
output = self.engine.render_to_string(
"center02", {"a": "a&b", "b": mark_safe("a&b")}
)
self.assertEqual(output, ". a&b . . a&b .")
class FunctionTests(SimpleTestCase):
def test_center(self):
self.assertEqual(center("test", 6), " test ")
def test_non_string_input(self):
self.assertEqual(center(123, 5), " 123 ")
def test_odd_input(self):
self.assertEqual(center("odd", 6), " odd ")
def test_even_input(self):
self.assertEqual(center("even", 7), " even ")
def test_widths(self):
value = "something"
for i in range(-1, len(value) + 1):
with self.subTest(i=i):
self.assertEqual(center(value, i), value)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_filesizeformat.py | tests/template_tests/filter_tests/test_filesizeformat.py | from django.template.defaultfilters import filesizeformat
from django.test import SimpleTestCase
from django.utils import translation
class FunctionTests(SimpleTestCase):
def test_formats(self):
tests = [
(0, "0\xa0bytes"),
(1, "1\xa0byte"),
(1023, "1023\xa0bytes"),
(1024, "1.0\xa0KB"),
(10 * 1024, "10.0\xa0KB"),
(1024 * 1024 - 1, "1024.0\xa0KB"),
(1024 * 1024, "1.0\xa0MB"),
(1024 * 1024 * 50, "50.0\xa0MB"),
(1024 * 1024 * 1024 - 1, "1024.0\xa0MB"),
(1024 * 1024 * 1024, "1.0\xa0GB"),
(1024 * 1024 * 1024 * 1024, "1.0\xa0TB"),
(1024 * 1024 * 1024 * 1024 * 1024, "1.0\xa0PB"),
(1024 * 1024 * 1024 * 1024 * 1024 * 2000, "2000.0\xa0PB"),
(complex(1, -1), "0\xa0bytes"),
("", "0\xa0bytes"),
("\N{GREEK SMALL LETTER ALPHA}", "0\xa0bytes"),
]
for value, expected in tests:
with self.subTest(value=value):
self.assertEqual(filesizeformat(value), expected)
def test_localized_formats(self):
tests = [
(0, "0\xa0Bytes"),
(1, "1\xa0Byte"),
(1023, "1023\xa0Bytes"),
(1024, "1,0\xa0KB"),
(10 * 1024, "10,0\xa0KB"),
(1024 * 1024 - 1, "1024,0\xa0KB"),
(1024 * 1024, "1,0\xa0MB"),
(1024 * 1024 * 50, "50,0\xa0MB"),
(1024 * 1024 * 1024 - 1, "1024,0\xa0MB"),
(1024 * 1024 * 1024, "1,0\xa0GB"),
(1024 * 1024 * 1024 * 1024, "1,0\xa0TB"),
(1024 * 1024 * 1024 * 1024 * 1024, "1,0\xa0PB"),
(1024 * 1024 * 1024 * 1024 * 1024 * 2000, "2000,0\xa0PB"),
(complex(1, -1), "0\xa0Bytes"),
("", "0\xa0Bytes"),
("\N{GREEK SMALL LETTER ALPHA}", "0\xa0Bytes"),
]
with translation.override("de"):
for value, expected in tests:
with self.subTest(value=value):
self.assertEqual(filesizeformat(value), expected)
def test_negative_numbers(self):
tests = [
(-1, "-1\xa0byte"),
(-100, "-100\xa0bytes"),
(-1024 * 1024 * 50, "-50.0\xa0MB"),
]
for value, expected in tests:
with self.subTest(value=value):
self.assertEqual(filesizeformat(value), expected)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_lower.py | tests/template_tests/filter_tests/test_lower.py | from django.template.defaultfilters import lower
from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class LowerTests(SimpleTestCase):
@setup(
{
"lower01": (
"{% autoescape off %}{{ a|lower }} {{ b|lower }}{% endautoescape %}"
)
}
)
def test_lower01(self):
output = self.engine.render_to_string(
"lower01", {"a": "Apple & banana", "b": mark_safe("Apple & banana")}
)
self.assertEqual(output, "apple & banana apple & banana")
@setup({"lower02": "{{ a|lower }} {{ b|lower }}"})
def test_lower02(self):
output = self.engine.render_to_string(
"lower02", {"a": "Apple & banana", "b": mark_safe("Apple & banana")}
)
self.assertEqual(output, "apple & banana apple & banana")
class FunctionTests(SimpleTestCase):
def test_lower(self):
self.assertEqual(lower("TEST"), "test")
def test_unicode(self):
# uppercase E umlaut
self.assertEqual(lower("\xcb"), "\xeb")
def test_non_string_input(self):
self.assertEqual(lower(123), "123")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_length.py | tests/template_tests/filter_tests/test_length.py | from django.template.defaultfilters import length
from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class LengthTests(SimpleTestCase):
@setup({"length01": "{{ list|length }}"})
def test_length01(self):
output = self.engine.render_to_string(
"length01", {"list": ["4", None, True, {}]}
)
self.assertEqual(output, "4")
@setup({"length02": "{{ list|length }}"})
def test_length02(self):
output = self.engine.render_to_string("length02", {"list": []})
self.assertEqual(output, "0")
@setup({"length03": "{{ string|length }}"})
def test_length03(self):
output = self.engine.render_to_string("length03", {"string": ""})
self.assertEqual(output, "0")
@setup({"length04": "{{ string|length }}"})
def test_length04(self):
output = self.engine.render_to_string("length04", {"string": "django"})
self.assertEqual(output, "6")
@setup({"length05": "{% if string|length == 6 %}Pass{% endif %}"})
def test_length05(self):
output = self.engine.render_to_string(
"length05", {"string": mark_safe("django")}
)
self.assertEqual(output, "Pass")
# Invalid uses that should fail silently.
@setup({"length06": "{{ int|length }}"})
def test_length06(self):
output = self.engine.render_to_string("length06", {"int": 7})
self.assertEqual(output, "0")
@setup({"length07": "{{ None|length }}"})
def test_length07(self):
output = self.engine.render_to_string("length07", {"None": None})
self.assertEqual(output, "0")
class FunctionTests(SimpleTestCase):
def test_string(self):
self.assertEqual(length("1234"), 4)
def test_safestring(self):
self.assertEqual(length(mark_safe("1234")), 4)
def test_list(self):
self.assertEqual(length([1, 2, 3, 4]), 4)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_last.py | tests/template_tests/filter_tests/test_last.py | from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class LastTests(SimpleTestCase):
@setup({"last01": "{{ a|last }} {{ b|last }}"})
def test_last01(self):
output = self.engine.render_to_string(
"last01", {"a": ["x", "a&b"], "b": ["x", mark_safe("a&b")]}
)
self.assertEqual(output, "a&b a&b")
@setup(
{"last02": "{% autoescape off %}{{ a|last }} {{ b|last }}{% endautoescape %}"}
)
def test_last02(self):
output = self.engine.render_to_string(
"last02", {"a": ["x", "a&b"], "b": ["x", mark_safe("a&b")]}
)
self.assertEqual(output, "a&b a&b")
@setup({"empty_list": "{% autoescape off %}{{ a|last }}{% endautoescape %}"})
def test_empty_list(self):
output = self.engine.render_to_string("empty_list", {"a": []})
self.assertEqual(output, "")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_cut.py | tests/template_tests/filter_tests/test_cut.py | from django.template.defaultfilters import cut
from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class CutTests(SimpleTestCase):
@setup(
{
"cut01": (
'{% autoescape off %}{{ a|cut:"x" }} {{ b|cut:"x" }}{% endautoescape %}'
)
}
)
def test_cut01(self):
output = self.engine.render_to_string(
"cut01", {"a": "x&y", "b": mark_safe("x&y")}
)
self.assertEqual(output, "&y &y")
@setup({"cut02": '{{ a|cut:"x" }} {{ b|cut:"x" }}'})
def test_cut02(self):
output = self.engine.render_to_string(
"cut02", {"a": "x&y", "b": mark_safe("x&y")}
)
self.assertEqual(output, "&y &y")
@setup(
{
"cut03": (
'{% autoescape off %}{{ a|cut:"&" }} {{ b|cut:"&" }}{% endautoescape %}'
)
}
)
def test_cut03(self):
output = self.engine.render_to_string(
"cut03", {"a": "x&y", "b": mark_safe("x&y")}
)
self.assertEqual(output, "xy xamp;y")
@setup({"cut04": '{{ a|cut:"&" }} {{ b|cut:"&" }}'})
def test_cut04(self):
output = self.engine.render_to_string(
"cut04", {"a": "x&y", "b": mark_safe("x&y")}
)
self.assertEqual(output, "xy xamp;y")
# Passing ';' to cut can break existing HTML entities, so those strings
# are auto-escaped.
@setup(
{
"cut05": (
'{% autoescape off %}{{ a|cut:";" }} {{ b|cut:";" }}{% endautoescape %}'
)
}
)
def test_cut05(self):
output = self.engine.render_to_string(
"cut05", {"a": "x&y", "b": mark_safe("x&y")}
)
self.assertEqual(output, "x&y x&y")
@setup({"cut06": '{{ a|cut:";" }} {{ b|cut:";" }}'})
def test_cut06(self):
output = self.engine.render_to_string(
"cut06", {"a": "x&y", "b": mark_safe("x&y")}
)
self.assertEqual(output, "x&y x&ampy")
class FunctionTests(SimpleTestCase):
def test_character(self):
self.assertEqual(cut("a string to be mangled", "a"), " string to be mngled")
def test_characters(self):
self.assertEqual(cut("a string to be mangled", "ng"), "a stri to be maled")
def test_non_matching_string(self):
self.assertEqual(
cut("a string to be mangled", "strings"), "a string to be mangled"
)
def test_non_string_input(self):
self.assertEqual(cut(123, "2"), "13")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_chaining.py | tests/template_tests/filter_tests/test_chaining.py | from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class ChainingTests(SimpleTestCase):
"""
Chaining safeness-preserving filters should not alter the safe status.
"""
@setup({"chaining01": '{{ a|capfirst|center:"7" }}.{{ b|capfirst|center:"7" }}'})
def test_chaining01(self):
output = self.engine.render_to_string(
"chaining01", {"a": "a < b", "b": mark_safe("a < b")}
)
self.assertEqual(output, " A < b . A < b ")
@setup(
{
"chaining02": (
'{% autoescape off %}{{ a|capfirst|center:"7" }}.'
'{{ b|capfirst|center:"7" }}{% endautoescape %}'
)
}
)
def test_chaining02(self):
output = self.engine.render_to_string(
"chaining02", {"a": "a < b", "b": mark_safe("a < b")}
)
self.assertEqual(output, " A < b . A < b ")
# Using a filter that forces a string back to unsafe:
@setup({"chaining03": '{{ a|cut:"b"|capfirst }}.{{ b|cut:"b"|capfirst }}'})
def test_chaining03(self):
output = self.engine.render_to_string(
"chaining03", {"a": "a < b", "b": mark_safe("a < b")}
)
self.assertEqual(output, "A < .A < ")
@setup(
{
"chaining04": (
'{% autoescape off %}{{ a|cut:"b"|capfirst }}.{{ b|cut:"b"|capfirst }}'
"{% endautoescape %}"
)
}
)
def test_chaining04(self):
output = self.engine.render_to_string(
"chaining04", {"a": "a < b", "b": mark_safe("a < b")}
)
self.assertEqual(output, "A < .A < ")
# Using a filter that forces safeness does not lead to double-escaping
@setup({"chaining05": "{{ a|escape|capfirst }}"})
def test_chaining05(self):
output = self.engine.render_to_string("chaining05", {"a": "a < b"})
self.assertEqual(output, "A < b")
@setup(
{"chaining06": "{% autoescape off %}{{ a|escape|capfirst }}{% endautoescape %}"}
)
def test_chaining06(self):
output = self.engine.render_to_string("chaining06", {"a": "a < b"})
self.assertEqual(output, "A < b")
# Force to safe, then back (also showing why using force_escape too
# early in a chain can lead to unexpected results).
@setup({"chaining07": '{{ a|force_escape|cut:";" }}'})
def test_chaining07(self):
output = self.engine.render_to_string("chaining07", {"a": "a < b"})
self.assertEqual(output, "a &lt b")
@setup(
{
"chaining08": (
'{% autoescape off %}{{ a|force_escape|cut:";" }}{% endautoescape %}'
)
}
)
def test_chaining08(self):
output = self.engine.render_to_string("chaining08", {"a": "a < b"})
self.assertEqual(output, "a < b")
@setup({"chaining09": '{{ a|cut:";"|force_escape }}'})
def test_chaining09(self):
output = self.engine.render_to_string("chaining09", {"a": "a < b"})
self.assertEqual(output, "a < b")
@setup(
{
"chaining10": (
'{% autoescape off %}{{ a|cut:";"|force_escape }}{% endautoescape %}'
)
}
)
def test_chaining10(self):
output = self.engine.render_to_string("chaining10", {"a": "a < b"})
self.assertEqual(output, "a < b")
@setup({"chaining11": '{{ a|cut:"b"|safe }}'})
def test_chaining11(self):
output = self.engine.render_to_string("chaining11", {"a": "a < b"})
self.assertEqual(output, "a < ")
@setup(
{"chaining12": '{% autoescape off %}{{ a|cut:"b"|safe }}{% endautoescape %}'}
)
def test_chaining12(self):
output = self.engine.render_to_string("chaining12", {"a": "a < b"})
self.assertEqual(output, "a < ")
@setup({"chaining13": "{{ a|safe|force_escape }}"})
def test_chaining13(self):
output = self.engine.render_to_string("chaining13", {"a": "a < b"})
self.assertEqual(output, "a < b")
@setup(
{
"chaining14": (
"{% autoescape off %}{{ a|safe|force_escape }}{% endautoescape %}"
)
}
)
def test_chaining14(self):
output = self.engine.render_to_string("chaining14", {"a": "a < b"})
self.assertEqual(output, "a < b")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_wordwrap.py | tests/template_tests/filter_tests/test_wordwrap.py | from django.template.defaultfilters import wordwrap
from django.test import SimpleTestCase
from django.utils.functional import lazystr
from django.utils.safestring import mark_safe
from ..utils import setup
class WordwrapTests(SimpleTestCase):
@setup(
{
"wordwrap01": (
'{% autoescape off %}{{ a|wordwrap:"3" }} {{ b|wordwrap:"3" }}'
"{% endautoescape %}"
)
}
)
def test_wordwrap01(self):
output = self.engine.render_to_string(
"wordwrap01", {"a": "a & b", "b": mark_safe("a & b")}
)
self.assertEqual(output, "a &\nb a &\nb")
@setup({"wordwrap02": '{{ a|wordwrap:"3" }} {{ b|wordwrap:"3" }}'})
def test_wordwrap02(self):
output = self.engine.render_to_string(
"wordwrap02", {"a": "a & b", "b": mark_safe("a & b")}
)
self.assertEqual(output, "a &\nb a &\nb")
class FunctionTests(SimpleTestCase):
def test_wrap(self):
self.assertEqual(
wordwrap(
"this is a long paragraph of text that really needs to be wrapped I'm "
"afraid",
14,
),
"this is a long\nparagraph of\ntext that\nreally needs\nto be wrapped\n"
"I'm afraid",
)
def test_indent(self):
self.assertEqual(
wordwrap(
"this is a short paragraph of text.\n But this line should be "
"indented",
14,
),
"this is a\nshort\nparagraph of\ntext.\n But this\nline should be\n"
"indented",
)
def test_indent2(self):
self.assertEqual(
wordwrap(
"this is a short paragraph of text.\n But this line should be "
"indented",
15,
),
"this is a short\nparagraph of\ntext.\n But this line\nshould be\n"
"indented",
)
def test_non_string_input(self):
self.assertEqual(wordwrap(123, 2), "123")
def test_wrap_lazy_string(self):
self.assertEqual(
wordwrap(
lazystr(
"this is a long paragraph of text that really needs to be wrapped "
"I'm afraid"
),
14,
),
"this is a long\nparagraph of\ntext that\nreally needs\nto be wrapped\n"
"I'm afraid",
)
def test_wrap_long_text(self):
long_text = (
"this is a long paragraph of text that really needs"
" to be wrapped I'm afraid " * 20_000
)
self.assertIn(
"this is a\nlong\nparagraph\nof text\nthat\nreally\nneeds to\nbe wrapped\n"
"I'm afraid",
wordwrap(long_text, 10),
)
def test_wrap_preserve_newlines(self):
cases = [
(
"this is a long paragraph of text that really needs to be wrapped\n\n"
"that is followed by another paragraph separated by an empty line\n",
"this is a long paragraph of\ntext that really needs to be\nwrapped\n\n"
"that is followed by another\nparagraph separated by an\nempty line\n",
30,
),
("\n\n\n", "\n\n\n", 5),
("\n\n\n\n\n\n", "\n\n\n\n\n\n", 5),
]
for text, expected, width in cases:
with self.subTest(text=text):
self.assertEqual(wordwrap(text, width), expected)
def test_wrap_preserve_whitespace(self):
width = 5
width_spaces = " " * width
cases = [
(
f"first line\n{width_spaces}\nsecond line",
f"first\nline\n{width_spaces}\nsecond\nline",
),
(
"first line\n \t\t\t \nsecond line",
"first\nline\n \t\t\t \nsecond\nline",
),
(
f"first line\n{width_spaces}\nsecond line\n\nthird{width_spaces}\n",
f"first\nline\n{width_spaces}\nsecond\nline\n\nthird\n",
),
(
f"first line\n{width_spaces}{width_spaces}\nsecond line",
f"first\nline\n{width_spaces}{width_spaces}\nsecond\nline",
),
]
for text, expected in cases:
with self.subTest(text=text):
self.assertEqual(wordwrap(text, width), expected)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_linenumbers.py | tests/template_tests/filter_tests/test_linenumbers.py | from django.template.defaultfilters import linenumbers
from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class LinenumbersTests(SimpleTestCase):
"""
The contents of "linenumbers" is escaped according to the current
autoescape setting.
"""
@setup({"linenumbers01": "{{ a|linenumbers }} {{ b|linenumbers }}"})
def test_linenumbers01(self):
output = self.engine.render_to_string(
"linenumbers01",
{"a": "one\n<two>\nthree", "b": mark_safe("one\n<two>\nthree")},
)
self.assertEqual(
output, "1. one\n2. <two>\n3. three 1. one\n2. <two>\n3. three"
)
@setup(
{
"linenumbers02": (
"{% autoescape off %}{{ a|linenumbers }} {{ b|linenumbers }}"
"{% endautoescape %}"
)
}
)
def test_linenumbers02(self):
output = self.engine.render_to_string(
"linenumbers02",
{"a": "one\n<two>\nthree", "b": mark_safe("one\n<two>\nthree")},
)
self.assertEqual(
output, "1. one\n2. <two>\n3. three 1. one\n2. <two>\n3. three"
)
class FunctionTests(SimpleTestCase):
def test_linenumbers(self):
self.assertEqual(linenumbers("line 1\nline 2"), "1. line 1\n2. line 2")
def test_linenumbers2(self):
self.assertEqual(
linenumbers("\n".join(["x"] * 10)),
"01. x\n02. x\n03. x\n04. x\n05. x\n06. x\n07. x\n08. x\n09. x\n10. x",
)
def test_non_string_input(self):
self.assertEqual(linenumbers(123), "1. 123")
def test_autoescape(self):
self.assertEqual(
linenumbers("foo\n<a>bar</a>\nbuz"),
"1. foo\n2. <a>bar</a>\n3. buz",
)
def test_autoescape_off(self):
self.assertEqual(
linenumbers("foo\n<a>bar</a>\nbuz", autoescape=False),
"1. foo\n2. <a>bar</a>\n3. buz",
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_phone2numeric.py | tests/template_tests/filter_tests/test_phone2numeric.py | from django.template.defaultfilters import phone2numeric_filter
from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class Phone2numericTests(SimpleTestCase):
@setup({"phone2numeric01": "{{ a|phone2numeric }} {{ b|phone2numeric }}"})
def test_phone2numeric01(self):
output = self.engine.render_to_string(
"phone2numeric01",
{"a": "<1-800-call-me>", "b": mark_safe("<1-800-call-me>")},
)
self.assertEqual(output, "<1-800-2255-63> <1-800-2255-63>")
@setup(
{
"phone2numeric02": (
"{% autoescape off %}{{ a|phone2numeric }} {{ b|phone2numeric }}"
"{% endautoescape %}"
)
}
)
def test_phone2numeric02(self):
output = self.engine.render_to_string(
"phone2numeric02",
{"a": "<1-800-call-me>", "b": mark_safe("<1-800-call-me>")},
)
self.assertEqual(output, "<1-800-2255-63> <1-800-2255-63>")
@setup({"phone2numeric03": "{{ a|phone2numeric }}"})
def test_phone2numeric03(self):
output = self.engine.render_to_string(
"phone2numeric03",
{"a": "How razorback-jumping frogs can level six piqued gymnasts!"},
)
self.assertEqual(
output, "469 729672225-5867464 37647 226 53835 749 747833 49662787!"
)
class FunctionTests(SimpleTestCase):
def test_phone2numeric(self):
self.assertEqual(phone2numeric_filter("0800 flowers"), "0800 3569377")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_capfirst.py | tests/template_tests/filter_tests/test_capfirst.py | from django.template.defaultfilters import capfirst
from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class CapfirstTests(SimpleTestCase):
@setup(
{
"capfirst01": (
"{% autoescape off %}{{ a|capfirst }} {{ b|capfirst }}"
"{% endautoescape %}"
)
}
)
def test_capfirst01(self):
output = self.engine.render_to_string(
"capfirst01", {"a": "fred>", "b": mark_safe("fred>")}
)
self.assertEqual(output, "Fred> Fred>")
@setup({"capfirst02": "{{ a|capfirst }} {{ b|capfirst }}"})
def test_capfirst02(self):
output = self.engine.render_to_string(
"capfirst02", {"a": "fred>", "b": mark_safe("fred>")}
)
self.assertEqual(output, "Fred> Fred>")
class FunctionTests(SimpleTestCase):
def test_capfirst(self):
self.assertEqual(capfirst("hello world"), "Hello world")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_ljust.py | tests/template_tests/filter_tests/test_ljust.py | from django.template.defaultfilters import ljust
from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class LjustTests(SimpleTestCase):
@setup(
{
"ljust01": (
'{% autoescape off %}.{{ a|ljust:"5" }}. .{{ b|ljust:"5" }}.'
"{% endautoescape %}"
)
}
)
def test_ljust01(self):
output = self.engine.render_to_string(
"ljust01", {"a": "a&b", "b": mark_safe("a&b")}
)
self.assertEqual(output, ".a&b . .a&b .")
@setup({"ljust02": '.{{ a|ljust:"5" }}. .{{ b|ljust:"5" }}.'})
def test_ljust02(self):
output = self.engine.render_to_string(
"ljust02", {"a": "a&b", "b": mark_safe("a&b")}
)
self.assertEqual(output, ".a&b . .a&b .")
class FunctionTests(SimpleTestCase):
def test_ljust(self):
self.assertEqual(ljust("test", 10), "test ")
self.assertEqual(ljust("test", 3), "test")
def test_less_than_string_length(self):
self.assertEqual(ljust("test", 3), "test")
def test_non_string_input(self):
self.assertEqual(ljust(123, 4), "123 ")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_truncatewords_html.py | tests/template_tests/filter_tests/test_truncatewords_html.py | from django.template.defaultfilters import truncatewords_html
from django.test import SimpleTestCase
class FunctionTests(SimpleTestCase):
def test_truncate_zero(self):
self.assertEqual(
truncatewords_html(
'<p>one <a href="#">two - three <br>four</a> five</p>', 0
),
"",
)
def test_truncate(self):
self.assertEqual(
truncatewords_html(
'<p>one <a href="#">two - three <br>four</a> five</p>', 2
),
'<p>one <a href="#">two …</a></p>',
)
def test_truncate2(self):
self.assertEqual(
truncatewords_html(
'<p>one <a href="#">two - three <br>four</a> five</p>', 4
),
'<p>one <a href="#">two - three <br> …</a></p>',
)
def test_truncate3(self):
self.assertEqual(
truncatewords_html(
'<p>one <a href="#">two - three <br>four</a> five</p>', 5
),
'<p>one <a href="#">two - three <br>four</a> …</p>',
)
def test_truncate4(self):
self.assertEqual(
truncatewords_html(
'<p>one <a href="#">two - three <br>four</a> five</p>', 100
),
'<p>one <a href="#">two - three <br>four</a> five</p>',
)
def test_truncate_unicode(self):
self.assertEqual(
truncatewords_html("\xc5ngstr\xf6m was here", 1), "\xc5ngstr\xf6m …"
)
def test_truncate_complex(self):
self.assertEqual(
truncatewords_html(
"<i>Buenos días! ¿Cómo está?</i>", 3
),
"<i>Buenos días! ¿Cómo …</i>",
)
def test_invalid_arg(self):
self.assertEqual(truncatewords_html("<p>string</p>", "a"), "<p>string</p>")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_escapeseq.py | tests/template_tests/filter_tests/test_escapeseq.py | from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class EscapeseqTests(SimpleTestCase):
"""
The "escapeseq" filter works the same whether autoescape is on or off,
and has no effect on strings already marked as safe.
"""
@setup(
{
"escapeseq_basic": (
'{{ a|escapeseq|join:", " }} -- {{ b|escapeseq|join:", " }}'
),
}
)
def test_basic(self):
output = self.engine.render_to_string(
"escapeseq_basic",
{"a": ["x&y", "<p>"], "b": [mark_safe("x&y"), mark_safe("<p>")]},
)
self.assertEqual(output, "x&y, <p> -- x&y, <p>")
@setup(
{
"escapeseq_autoescape_off": (
'{% autoescape off %}{{ a|escapeseq|join:", " }}'
" -- "
'{{ b|escapeseq|join:", "}}{% endautoescape %}'
)
}
)
def test_autoescape_off(self):
output = self.engine.render_to_string(
"escapeseq_autoescape_off",
{"a": ["x&y", "<p>"], "b": [mark_safe("x&y"), mark_safe("<p>")]},
)
self.assertEqual(output, "x&y, <p> -- x&y, <p>")
@setup({"escapeseq_join": '{{ a|escapeseq|join:"<br/>" }}'})
def test_chain_join(self):
output = self.engine.render_to_string("escapeseq_join", {"a": ["x&y", "<p>"]})
self.assertEqual(output, "x&y<br/><p>")
@setup(
{
"escapeseq_join_autoescape_off": (
'{% autoescape off %}{{ a|escapeseq|join:"<br/>" }}{% endautoescape %}'
),
}
)
def test_chain_join_autoescape_off(self):
output = self.engine.render_to_string(
"escapeseq_join_autoescape_off", {"a": ["x&y", "<p>"]}
)
self.assertEqual(output, "x&y<br/><p>")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_stringformat.py | tests/template_tests/filter_tests/test_stringformat.py | from django.template.defaultfilters import stringformat
from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class StringformatTests(SimpleTestCase):
"""
Notice that escaping is applied *after* any filters, so the string
formatting here only needs to deal with pre-escaped characters.
"""
@setup(
{
"stringformat01": (
'{% autoescape off %}.{{ a|stringformat:"5s" }}. .'
'{{ b|stringformat:"5s" }}.{% endautoescape %}'
)
}
)
def test_stringformat01(self):
output = self.engine.render_to_string(
"stringformat01", {"a": "a<b", "b": mark_safe("a<b")}
)
self.assertEqual(output, ". a<b. . a<b.")
@setup(
{"stringformat02": '.{{ a|stringformat:"5s" }}. .{{ b|stringformat:"5s" }}.'}
)
def test_stringformat02(self):
output = self.engine.render_to_string(
"stringformat02", {"a": "a<b", "b": mark_safe("a<b")}
)
self.assertEqual(output, ". a<b. . a<b.")
class FunctionTests(SimpleTestCase):
def test_format(self):
self.assertEqual(stringformat(1, "03d"), "001")
self.assertEqual(stringformat([1, None], "s"), "[1, None]")
self.assertEqual(stringformat((1, 2, 3), "s"), "(1, 2, 3)")
self.assertEqual(stringformat((1,), "s"), "(1,)")
self.assertEqual(stringformat({1, 2}, "s"), "{1, 2}")
self.assertEqual(stringformat({1: 2, 2: 3}, "s"), "{1: 2, 2: 3}")
def test_invalid(self):
self.assertEqual(stringformat(1, "z"), "")
self.assertEqual(stringformat(object(), "d"), "")
self.assertEqual(stringformat(None, "d"), "")
self.assertEqual(stringformat((1, 2, 3), "d"), "")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_addslashes.py | tests/template_tests/filter_tests/test_addslashes.py | from django.template.defaultfilters import addslashes
from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class AddslashesTests(SimpleTestCase):
@setup(
{
"addslashes01": (
"{% autoescape off %}{{ a|addslashes }} {{ b|addslashes }}"
"{% endautoescape %}"
)
}
)
def test_addslashes01(self):
output = self.engine.render_to_string(
"addslashes01", {"a": "<a>'", "b": mark_safe("<a>'")}
)
self.assertEqual(output, r"<a>\' <a>\'")
@setup({"addslashes02": "{{ a|addslashes }} {{ b|addslashes }}"})
def test_addslashes02(self):
output = self.engine.render_to_string(
"addslashes02", {"a": "<a>'", "b": mark_safe("<a>'")}
)
self.assertEqual(output, r"<a>\' <a>\'")
class FunctionTests(SimpleTestCase):
def test_quotes(self):
self.assertEqual(
addslashes("\"double quotes\" and 'single quotes'"),
"\\\"double quotes\\\" and \\'single quotes\\'",
)
def test_backslashes(self):
self.assertEqual(addslashes(r"\ : backslashes, too"), "\\\\ : backslashes, too")
def test_non_string_input(self):
self.assertEqual(addslashes(123), "123")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_safeseq.py | tests/template_tests/filter_tests/test_safeseq.py | from django.test import SimpleTestCase
from ..utils import setup
class SafeseqTests(SimpleTestCase):
@setup({"safeseq01": '{{ a|join:", " }} -- {{ a|safeseq|join:", " }}'})
def test_safeseq01(self):
output = self.engine.render_to_string("safeseq01", {"a": ["&", "<"]})
self.assertEqual(output, "&, < -- &, <")
@setup(
{
"safeseq02": (
'{% autoescape off %}{{ a|join:", " }} -- {{ a|safeseq|join:", " }}'
"{% endautoescape %}"
)
}
)
def test_safeseq02(self):
output = self.engine.render_to_string("safeseq02", {"a": ["&", "<"]})
self.assertEqual(output, "&, < -- &, <")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_timeuntil.py | tests/template_tests/filter_tests/test_timeuntil.py | from datetime import datetime, timedelta
from django.template.defaultfilters import timeuntil_filter
from django.test import SimpleTestCase
from django.test.utils import requires_tz_support
from ..utils import setup
from .timezone_utils import TimezoneTestCase
class TimeuntilTests(TimezoneTestCase):
# Default compare with datetime.now()
@setup({"timeuntil01": "{{ a|timeuntil }}"})
def test_timeuntil01(self):
output = self.engine.render_to_string(
"timeuntil01", {"a": datetime.now() + timedelta(minutes=2, seconds=10)}
)
self.assertEqual(output, "2\xa0minutes")
@setup({"timeuntil02": "{{ a|timeuntil }}"})
def test_timeuntil02(self):
output = self.engine.render_to_string(
"timeuntil02", {"a": (datetime.now() + timedelta(days=1, seconds=10))}
)
self.assertEqual(output, "1\xa0day")
@setup({"timeuntil03": "{{ a|timeuntil }}"})
def test_timeuntil03(self):
output = self.engine.render_to_string(
"timeuntil03",
{"a": (datetime.now() + timedelta(hours=8, minutes=10, seconds=10))},
)
self.assertEqual(output, "8\xa0hours, 10\xa0minutes")
# Compare to a given parameter
@setup({"timeuntil04": "{{ a|timeuntil:b }}"})
def test_timeuntil04(self):
output = self.engine.render_to_string(
"timeuntil04",
{"a": self.now - timedelta(days=1), "b": self.now - timedelta(days=2)},
)
self.assertEqual(output, "1\xa0day")
@setup({"timeuntil05": "{{ a|timeuntil:b }}"})
def test_timeuntil05(self):
output = self.engine.render_to_string(
"timeuntil05",
{
"a": self.now - timedelta(days=2),
"b": self.now - timedelta(days=2, minutes=1),
},
)
self.assertEqual(output, "1\xa0minute")
# Regression for #7443
@setup({"timeuntil06": "{{ earlier|timeuntil }}"})
def test_timeuntil06(self):
output = self.engine.render_to_string(
"timeuntil06", {"earlier": self.now - timedelta(days=7)}
)
self.assertEqual(output, "0\xa0minutes")
@setup({"timeuntil07": "{{ earlier|timeuntil:now }}"})
def test_timeuntil07(self):
output = self.engine.render_to_string(
"timeuntil07", {"now": self.now, "earlier": self.now - timedelta(days=7)}
)
self.assertEqual(output, "0\xa0minutes")
@setup({"timeuntil08": "{{ later|timeuntil }}"})
def test_timeuntil08(self):
output = self.engine.render_to_string(
"timeuntil08", {"later": self.now + timedelta(days=7, hours=1)}
)
self.assertEqual(output, "1\xa0week")
@setup({"timeuntil09": "{{ later|timeuntil:now }}"})
def test_timeuntil09(self):
output = self.engine.render_to_string(
"timeuntil09", {"now": self.now, "later": self.now + timedelta(days=7)}
)
self.assertEqual(output, "1\xa0week")
# Differing timezones are calculated correctly.
@requires_tz_support
@setup({"timeuntil10": "{{ a|timeuntil }}"})
def test_timeuntil10(self):
output = self.engine.render_to_string("timeuntil10", {"a": self.now_tz})
self.assertEqual(output, "0\xa0minutes")
@requires_tz_support
@setup({"timeuntil11": "{{ a|timeuntil }}"})
def test_timeuntil11(self):
output = self.engine.render_to_string("timeuntil11", {"a": self.now_tz_i})
self.assertEqual(output, "0\xa0minutes")
@setup({"timeuntil12": "{{ a|timeuntil:b }}"})
def test_timeuntil12(self):
output = self.engine.render_to_string(
"timeuntil12", {"a": self.now_tz_i, "b": self.now_tz}
)
self.assertEqual(output, "0\xa0minutes")
# Regression for #9065 (two date objects).
@setup({"timeuntil13": "{{ a|timeuntil:b }}"})
def test_timeuntil13(self):
output = self.engine.render_to_string(
"timeuntil13", {"a": self.today, "b": self.today}
)
self.assertEqual(output, "0\xa0minutes")
@setup({"timeuntil14": "{{ a|timeuntil:b }}"})
def test_timeuntil14(self):
output = self.engine.render_to_string(
"timeuntil14", {"a": self.today, "b": self.today - timedelta(hours=24)}
)
self.assertEqual(output, "1\xa0day")
@setup({"timeuntil15": "{{ a|timeuntil:b }}"})
def test_naive_aware_type_error(self):
output = self.engine.render_to_string(
"timeuntil15", {"a": self.now, "b": self.now_tz_i}
)
self.assertEqual(output, "")
@setup({"timeuntil16": "{{ a|timeuntil:b }}"})
def test_aware_naive_type_error(self):
output = self.engine.render_to_string(
"timeuntil16", {"a": self.now_tz_i, "b": self.now}
)
self.assertEqual(output, "")
class FunctionTests(SimpleTestCase):
def test_until_now(self):
self.assertEqual(timeuntil_filter(datetime.now() + timedelta(1, 1)), "1\xa0day")
def test_no_args(self):
self.assertEqual(timeuntil_filter(None), "")
def test_explicit_date(self):
self.assertEqual(
timeuntil_filter(datetime(2005, 12, 30), datetime(2005, 12, 29)), "1\xa0day"
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_escape.py | tests/template_tests/filter_tests/test_escape.py | from django.template.defaultfilters import escape
from django.test import SimpleTestCase
from django.utils.functional import Promise, lazy
from django.utils.safestring import mark_safe
from ..utils import setup
class EscapeTests(SimpleTestCase):
"""
The "escape" filter works the same whether autoescape is on or off,
but it has no effect on strings already marked as safe.
"""
@setup({"escape01": "{{ a|escape }} {{ b|escape }}"})
def test_escape01(self):
output = self.engine.render_to_string(
"escape01", {"a": "x&y", "b": mark_safe("x&y")}
)
self.assertEqual(output, "x&y x&y")
@setup(
{
"escape02": (
"{% autoescape off %}{{ a|escape }} {{ b|escape }}{% endautoescape %}"
)
}
)
def test_escape02(self):
output = self.engine.render_to_string(
"escape02", {"a": "x&y", "b": mark_safe("x&y")}
)
self.assertEqual(output, "x&y x&y")
@setup({"escape03": "{% autoescape off %}{{ a|escape|escape }}{% endautoescape %}"})
def test_escape03(self):
output = self.engine.render_to_string("escape03", {"a": "x&y"})
self.assertEqual(output, "x&y")
@setup({"escape04": "{{ a|escape|escape }}"})
def test_escape04(self):
output = self.engine.render_to_string("escape04", {"a": "x&y"})
self.assertEqual(output, "x&y")
def test_escape_lazy_string(self):
add_html = lazy(lambda string: string + "special characters > here", str)
escaped = escape(add_html("<some html & "))
self.assertIsInstance(escaped, Promise)
self.assertEqual(escaped, "<some html & special characters > here")
class FunctionTests(SimpleTestCase):
def test_non_string_input(self):
self.assertEqual(escape(123), "123")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_timesince.py | tests/template_tests/filter_tests/test_timesince.py | from datetime import datetime, timedelta
from django.template.defaultfilters import timesince_filter
from django.test import SimpleTestCase
from django.test.utils import requires_tz_support
from ..utils import setup
from .timezone_utils import TimezoneTestCase
class TimesinceTests(TimezoneTestCase):
"""
#20246 - \xa0 in output avoids line-breaks between value and unit
"""
# Default compare with datetime.now()
@setup({"timesince01": "{{ a|timesince }}"})
def test_timesince01(self):
output = self.engine.render_to_string(
"timesince01", {"a": datetime.now() + timedelta(minutes=-1, seconds=-10)}
)
self.assertEqual(output, "1\xa0minute")
@setup({"timesince02": "{{ a|timesince }}"})
def test_timesince02(self):
output = self.engine.render_to_string(
"timesince02", {"a": datetime.now() - timedelta(days=1, minutes=1)}
)
self.assertEqual(output, "1\xa0day")
@setup({"timesince03": "{{ a|timesince }}"})
def test_timesince03(self):
output = self.engine.render_to_string(
"timesince03",
{"a": datetime.now() - timedelta(hours=1, minutes=25, seconds=10)},
)
self.assertEqual(output, "1\xa0hour, 25\xa0minutes")
# Compare to a given parameter
@setup({"timesince04": "{{ a|timesince:b }}"})
def test_timesince04(self):
output = self.engine.render_to_string(
"timesince04",
{"a": self.now - timedelta(days=2), "b": self.now - timedelta(days=1)},
)
self.assertEqual(output, "1\xa0day")
@setup({"timesince05": "{{ a|timesince:b }}"})
def test_timesince05(self):
output = self.engine.render_to_string(
"timesince05",
{
"a": self.now - timedelta(days=2, minutes=1),
"b": self.now - timedelta(days=2),
},
)
self.assertEqual(output, "1\xa0minute")
# Timezone is respected
@setup({"timesince06": "{{ a|timesince:b }}"})
def test_timesince06(self):
output = self.engine.render_to_string(
"timesince06", {"a": self.now_tz - timedelta(hours=8), "b": self.now_tz}
)
self.assertEqual(output, "8\xa0hours")
# Tests for #7443
@setup({"timesince07": "{{ earlier|timesince }}"})
def test_timesince07(self):
output = self.engine.render_to_string(
"timesince07", {"earlier": self.now - timedelta(days=7)}
)
self.assertEqual(output, "1\xa0week")
@setup({"timesince08": "{{ earlier|timesince:now }}"})
def test_timesince08(self):
output = self.engine.render_to_string(
"timesince08", {"now": self.now, "earlier": self.now - timedelta(days=7)}
)
self.assertEqual(output, "1\xa0week")
@setup({"timesince09": "{{ later|timesince }}"})
def test_timesince09(self):
output = self.engine.render_to_string(
"timesince09", {"later": self.now + timedelta(days=7)}
)
self.assertEqual(output, "0\xa0minutes")
@setup({"timesince10": "{{ later|timesince:now }}"})
def test_timesince10(self):
output = self.engine.render_to_string(
"timesince10", {"now": self.now, "later": self.now + timedelta(days=7)}
)
self.assertEqual(output, "0\xa0minutes")
# Differing timezones are calculated correctly.
@setup({"timesince11": "{{ a|timesince }}"})
def test_timesince11(self):
output = self.engine.render_to_string("timesince11", {"a": self.now})
self.assertEqual(output, "0\xa0minutes")
@requires_tz_support
@setup({"timesince12": "{{ a|timesince }}"})
def test_timesince12(self):
output = self.engine.render_to_string("timesince12", {"a": self.now_tz})
self.assertEqual(output, "0\xa0minutes")
@requires_tz_support
@setup({"timesince13": "{{ a|timesince }}"})
def test_timesince13(self):
output = self.engine.render_to_string("timesince13", {"a": self.now_tz_i})
self.assertEqual(output, "0\xa0minutes")
@setup({"timesince14": "{{ a|timesince:b }}"})
def test_timesince14(self):
output = self.engine.render_to_string(
"timesince14", {"a": self.now_tz, "b": self.now_tz_i}
)
self.assertEqual(output, "0\xa0minutes")
@setup({"timesince15": "{{ a|timesince:b }}"})
def test_timesince15(self):
output = self.engine.render_to_string(
"timesince15", {"a": self.now, "b": self.now_tz_i}
)
self.assertEqual(output, "")
@setup({"timesince16": "{{ a|timesince:b }}"})
def test_timesince16(self):
output = self.engine.render_to_string(
"timesince16", {"a": self.now_tz_i, "b": self.now}
)
self.assertEqual(output, "")
# Tests for #9065 (two date objects).
@setup({"timesince17": "{{ a|timesince:b }}"})
def test_timesince17(self):
output = self.engine.render_to_string(
"timesince17", {"a": self.today, "b": self.today}
)
self.assertEqual(output, "0\xa0minutes")
@setup({"timesince18": "{{ a|timesince:b }}"})
def test_timesince18(self):
output = self.engine.render_to_string(
"timesince18", {"a": self.today, "b": self.today + timedelta(hours=24)}
)
self.assertEqual(output, "1\xa0day")
# Tests for #33879 (wrong results for 11 months + several weeks).
@setup({"timesince19": "{{ earlier|timesince }}"})
def test_timesince19(self):
output = self.engine.render_to_string(
"timesince19", {"earlier": self.today - timedelta(days=358)}
)
self.assertEqual(output, "11\xa0months, 3\xa0weeks")
@setup({"timesince20": "{{ a|timesince:b }}"})
def test_timesince20(self):
now = datetime(2018, 5, 9)
output = self.engine.render_to_string(
"timesince20",
{"a": now, "b": now + timedelta(days=365) + timedelta(days=364)},
)
self.assertEqual(output, "1\xa0year, 11\xa0months")
class FunctionTests(SimpleTestCase):
def test_since_now(self):
self.assertEqual(timesince_filter(datetime.now() - timedelta(1)), "1\xa0day")
def test_no_args(self):
self.assertEqual(timesince_filter(None), "")
def test_explicit_date(self):
self.assertEqual(
timesince_filter(datetime(2005, 12, 29), datetime(2005, 12, 30)), "1\xa0day"
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_floatformat.py | tests/template_tests/filter_tests/test_floatformat.py | from decimal import Decimal, localcontext
from django.template.defaultfilters import floatformat
from django.test import SimpleTestCase
from django.utils import translation
from django.utils.safestring import mark_safe
from django.utils.version import PYPY
from ..utils import setup
class FloatformatTests(SimpleTestCase):
@setup(
{
"floatformat01": (
"{% autoescape off %}{{ a|floatformat }} {{ b|floatformat }}"
"{% endautoescape %}"
)
}
)
def test_floatformat01(self):
output = self.engine.render_to_string(
"floatformat01", {"a": "1.42", "b": mark_safe("1.42")}
)
self.assertEqual(output, "1.4 1.4")
@setup({"floatformat02": "{{ a|floatformat }} {{ b|floatformat }}"})
def test_floatformat02(self):
output = self.engine.render_to_string(
"floatformat02", {"a": "1.42", "b": mark_safe("1.42")}
)
self.assertEqual(output, "1.4 1.4")
class FunctionTests(SimpleTestCase):
def test_inputs(self):
self.assertEqual(floatformat(7.7), "7.7")
self.assertEqual(floatformat(7.0), "7")
self.assertEqual(floatformat(0.7), "0.7")
self.assertEqual(floatformat(-0.7), "-0.7")
self.assertEqual(floatformat(0.07), "0.1")
self.assertEqual(floatformat(-0.07), "-0.1")
self.assertEqual(floatformat(0.007), "0.0")
self.assertEqual(floatformat(0.0), "0")
self.assertEqual(floatformat(7.7, 0), "8")
self.assertEqual(floatformat(7.7, 3), "7.700")
self.assertEqual(floatformat(6.000000, 3), "6.000")
self.assertEqual(floatformat(6.200000, 3), "6.200")
self.assertEqual(floatformat(6.200000, -3), "6.200")
self.assertEqual(floatformat(13.1031, -3), "13.103")
self.assertEqual(floatformat(11.1197, -2), "11.12")
self.assertEqual(floatformat(11.0000, -2), "11")
self.assertEqual(floatformat(11.000001, -2), "11.00")
self.assertEqual(floatformat(8.2798, 3), "8.280")
self.assertEqual(floatformat(5555.555, 2), "5555.56")
self.assertEqual(floatformat(001.3000, 2), "1.30")
self.assertEqual(floatformat(0.12345, 2), "0.12")
self.assertEqual(floatformat(Decimal("555.555"), 2), "555.56")
self.assertEqual(floatformat(Decimal("09.000")), "9")
self.assertEqual(
floatformat(Decimal("123456.123456789012345678901"), 21),
"123456.123456789012345678901",
)
self.assertEqual(floatformat(13.1031, "bar"), "13.1031")
self.assertEqual(floatformat(18.125, 2), "18.13")
self.assertEqual(
floatformat(-1.323297138040798e35, 2),
"-132329713804079800000000000000000000.00",
)
self.assertEqual(
floatformat(-1.323297138040798e35, -2),
"-132329713804079800000000000000000000",
)
self.assertEqual(floatformat(1.5e-15, 20), "0.00000000000000150000")
self.assertEqual(floatformat(1.5e-15, -20), "0.00000000000000150000")
self.assertEqual(floatformat(1.00000000000000015, 16), "1.0000000000000002")
self.assertEqual(floatformat("1e199"), "1" + "0" * 199)
def test_invalid_inputs(self):
cases = [
# Non-numeric strings.
None,
[],
{},
object(),
"abc123",
"123abc",
"foo",
"error",
"¿Cómo esta usted?",
# Scientific notation - missing exponent value.
"1e",
"1e+",
"1e-",
# Scientific notation - missing base number.
"e400",
"e+400",
"e-400",
# Scientific notation - invalid exponent value.
"1e^2",
"1e2e3",
"1e2a",
"1e2.0",
"1e2,0",
# Scientific notation - misplaced decimal point.
"1e.2",
"1e2.",
# Scientific notation - misplaced '+' sign.
"1+e2",
"1e2+",
]
for value in cases:
with self.subTest(value=value):
self.assertEqual(floatformat(value), "")
with self.subTest(value=value, arg="bar"):
self.assertEqual(floatformat(value, "bar"), "")
def test_force_grouping(self):
with translation.override("en"):
self.assertEqual(floatformat(10000, "g"), "10,000")
self.assertEqual(floatformat(66666.666, "1g"), "66,666.7")
# Invalid suffix.
self.assertEqual(floatformat(10000, "g2"), "10000")
with translation.override("de", deactivate=True):
self.assertEqual(floatformat(10000, "g"), "10.000")
self.assertEqual(floatformat(66666.666, "1g"), "66.666,7")
# Invalid suffix.
self.assertEqual(floatformat(10000, "g2"), "10000")
def test_unlocalize(self):
with translation.override("de", deactivate=True):
self.assertEqual(floatformat(66666.666, "2"), "66666,67")
self.assertEqual(floatformat(66666.666, "2u"), "66666.67")
with self.settings(
USE_THOUSAND_SEPARATOR=True,
NUMBER_GROUPING=3,
THOUSAND_SEPARATOR="!",
):
self.assertEqual(floatformat(66666.666, "2gu"), "66!666.67")
self.assertEqual(floatformat(66666.666, "2ug"), "66!666.67")
# Invalid suffix.
self.assertEqual(floatformat(66666.666, "u2"), "66666.666")
def test_zero_values(self):
self.assertEqual(floatformat(0, 6), "0.000000")
self.assertEqual(floatformat(0, 7), "0.0000000")
self.assertEqual(floatformat(0, 10), "0.0000000000")
self.assertEqual(
floatformat(0.000000000000000000015, 20), "0.00000000000000000002"
)
self.assertEqual(floatformat("0.00", 0), "0")
self.assertEqual(floatformat(Decimal("0.00"), 0), "0")
self.assertEqual(floatformat("0.0000", 2), "0.00")
self.assertEqual(floatformat(Decimal("0.0000"), 2), "0.00")
self.assertEqual(floatformat("0.000000", 4), "0.0000")
self.assertEqual(floatformat(Decimal("0.000000"), 4), "0.0000")
def test_negative_zero_values(self):
tests = [
(-0.01, -1, "0.0"),
(-0.001, 2, "0.00"),
(-0.499, 0, "0"),
]
for num, decimal_places, expected in tests:
with self.subTest(num=num, decimal_places=decimal_places):
self.assertEqual(floatformat(num, decimal_places), expected)
def test_infinity(self):
pos_inf = float(1e30000)
neg_inf = float(-1e30000)
self.assertEqual(floatformat(pos_inf), "inf")
self.assertEqual(floatformat(neg_inf), "-inf")
self.assertEqual(floatformat(pos_inf / pos_inf), "nan")
self.assertEqual(floatformat("inf"), "inf")
self.assertEqual(floatformat("NaN"), "NaN")
def test_too_many_digits_to_render(self):
cases = [
"1e200",
"1E200",
"1E10000000000000000",
"-1E10000000000000000",
"1e10000000000000000",
"-1e10000000000000000",
]
for value in cases:
with self.subTest(value=value):
self.assertEqual(floatformat(value), value)
def test_too_many_digits_to_render_very_long(self):
value = "1" + "0" * 1_000_000
if PYPY:
# PyPy casts decimal parts to int, which reaches the integer string
# conversion length limit (default 4300 digits, CVE-2020-10735).
with self.assertRaises(ValueError):
floatformat(value)
else:
self.assertEqual(floatformat(value), value)
def test_float_dunder_method(self):
class FloatWrapper:
def __init__(self, value):
self.value = value
def __float__(self):
return self.value
self.assertEqual(floatformat(FloatWrapper(11.000001), -2), "11.00")
def test_low_decimal_precision(self):
"""
#15789
"""
with localcontext() as ctx:
ctx.prec = 2
self.assertEqual(floatformat(1.2345, 2), "1.23")
self.assertEqual(floatformat(15.2042, -3), "15.204")
self.assertEqual(floatformat(1.2345, "2"), "1.23")
self.assertEqual(floatformat(15.2042, "-3"), "15.204")
self.assertEqual(floatformat(Decimal("1.2345"), 2), "1.23")
self.assertEqual(floatformat(Decimal("15.2042"), -3), "15.204")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_urlizetrunc.py | tests/template_tests/filter_tests/test_urlizetrunc.py | from django.template.defaultfilters import urlizetrunc
from django.test import SimpleTestCase
from django.test.utils import override_settings
from django.utils.safestring import mark_safe
from ..utils import setup
class UrlizetruncTests(SimpleTestCase):
@setup(
{
"urlizetrunc01": (
'{% autoescape off %}{{ a|urlizetrunc:"8" }} {{ b|urlizetrunc:"8" }}'
"{% endautoescape %}"
)
}
)
def test_urlizetrunc01(self):
output = self.engine.render_to_string(
"urlizetrunc01",
{
"a": '"Unsafe" http://example.com/x=&y=',
"b": mark_safe(""Safe" http://example.com?x=&y="),
},
)
self.assertEqual(
output,
'"Unsafe" '
'<a href="http://example.com/x=&y=" rel="nofollow">http://…</a> '
""Safe" "
'<a href="http://example.com?x=&y=" rel="nofollow">http://…</a>',
)
@setup({"urlizetrunc02": '{{ a|urlizetrunc:"8" }} {{ b|urlizetrunc:"8" }}'})
def test_urlizetrunc02(self):
output = self.engine.render_to_string(
"urlizetrunc02",
{
"a": '"Unsafe" http://example.com/x=&y=',
"b": mark_safe(""Safe" http://example.com?x=&y="),
},
)
self.assertEqual(
output,
'"Unsafe" <a href="http://example.com/x=&y=" rel="nofollow">'
"http://…</a> "
'"Safe" <a href="http://example.com?x=&y=" rel="nofollow">'
"http://…</a>",
)
@override_settings(URLIZE_ASSUME_HTTPS=True)
class FunctionTests(SimpleTestCase):
def test_truncate(self):
uri = "http://31characteruri.com/test/"
self.assertEqual(len(uri), 31)
self.assertEqual(
urlizetrunc(uri, 31),
'<a href="http://31characteruri.com/test/" rel="nofollow">'
"http://31characteruri.com/test/</a>",
)
self.assertEqual(
urlizetrunc(uri, 30),
'<a href="http://31characteruri.com/test/" rel="nofollow">'
"http://31characteruri.com/tes…</a>",
)
self.assertEqual(
urlizetrunc(uri, 1),
'<a href="http://31characteruri.com/test/" rel="nofollow">…</a>',
)
def test_overtruncate(self):
self.assertEqual(
urlizetrunc("http://short.com/", 20),
'<a href="http://short.com/" rel="nofollow">http://short.com/</a>',
)
def test_query_string(self):
self.assertEqual(
urlizetrunc(
"http://www.google.co.uk/search?hl=en&q=some+long+url&btnG=Search"
"&meta=",
20,
),
'<a href="http://www.google.co.uk/search?hl=en&q=some+long+url&'
'btnG=Search&meta=" rel="nofollow">http://www.google.c…</a>',
)
def test_non_string_input(self):
self.assertEqual(urlizetrunc(123, 1), "123")
def test_autoescape(self):
self.assertEqual(
urlizetrunc('foo<a href=" google.com ">bar</a>buz', 10),
'foo<a href=" <a href="https://google.com" rel="nofollow">'
"google.com</a> ">bar</a>buz",
)
def test_autoescape_off(self):
self.assertEqual(
urlizetrunc('foo<a href=" google.com ">bar</a>buz', 9, autoescape=False),
'foo<a href=" <a href="https://google.com" rel="nofollow">google.c…</a> ">'
"bar</a>buz",
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_date.py | tests/template_tests/filter_tests/test_date.py | from datetime import datetime, time
from django.template.defaultfilters import date
from django.test import SimpleTestCase
from django.utils import timezone, translation
from ..utils import setup
from .timezone_utils import TimezoneTestCase
class DateTests(TimezoneTestCase):
@setup({"date01": '{{ d|date:"m" }}'})
def test_date01(self):
output = self.engine.render_to_string("date01", {"d": datetime(2008, 1, 1)})
self.assertEqual(output, "01")
@setup({"date02": "{{ d|date }}"})
def test_date02(self):
output = self.engine.render_to_string("date02", {"d": datetime(2008, 1, 1)})
self.assertEqual(output, "Jan. 1, 2008")
@setup({"date02_l10n": "{{ d|date }}"})
def test_date02_l10n(self):
"""Without arg, the active language's DATE_FORMAT is used."""
with translation.override("fr"):
output = self.engine.render_to_string(
"date02_l10n", {"d": datetime(2008, 1, 1)}
)
self.assertEqual(output, "1 janvier 2008")
@setup({"date03": '{{ d|date:"m" }}'})
def test_date03(self):
"""
#9520: Make sure |date doesn't blow up on non-dates
"""
output = self.engine.render_to_string("date03", {"d": "fail_string"})
self.assertEqual(output, "")
# ISO date formats
@setup({"date04": '{{ d|date:"o" }}'})
def test_date04(self):
output = self.engine.render_to_string("date04", {"d": datetime(2008, 12, 29)})
self.assertEqual(output, "2009")
@setup({"date05": '{{ d|date:"o" }}'})
def test_date05(self):
output = self.engine.render_to_string("date05", {"d": datetime(2010, 1, 3)})
self.assertEqual(output, "2009")
# Timezone name
@setup({"date06": '{{ d|date:"e" }}'})
def test_date06(self):
output = self.engine.render_to_string(
"date06",
{"d": datetime(2009, 3, 12, tzinfo=timezone.get_fixed_timezone(30))},
)
self.assertEqual(output, "+0030")
@setup({"date07": '{{ d|date:"e" }}'})
def test_date07(self):
output = self.engine.render_to_string("date07", {"d": datetime(2009, 3, 12)})
self.assertEqual(output, "")
# #19370: Make sure |date doesn't blow up on a midnight time object
@setup({"date08": '{{ t|date:"H:i" }}'})
def test_date08(self):
output = self.engine.render_to_string("date08", {"t": time(0, 1)})
self.assertEqual(output, "00:01")
@setup({"date09": '{{ t|date:"H:i" }}'})
def test_date09(self):
output = self.engine.render_to_string("date09", {"t": time(0, 0)})
self.assertEqual(output, "00:00")
@setup({"datelazy": '{{ t|date:_("H:i") }}'})
def test_date_lazy(self):
output = self.engine.render_to_string("datelazy", {"t": time(0, 0)})
self.assertEqual(output, "00:00")
class FunctionTests(SimpleTestCase):
def test_date(self):
self.assertEqual(date(datetime(2005, 12, 29), "d F Y"), "29 December 2005")
def test_no_args(self):
self.assertEqual(date(""), "")
self.assertEqual(date(None), "")
def test_escape_characters(self):
self.assertEqual(date(datetime(2005, 12, 29), r"jS \o\f F"), "29th of December")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_autoescape.py | tests/template_tests/filter_tests/test_autoescape.py | from django.test import SimpleTestCase
from ..utils import SafeClass, UnsafeClass, setup
class AutoescapeStringfilterTests(SimpleTestCase):
"""
Filters decorated with stringfilter still respect is_safe.
"""
@setup({"autoescape-stringfilter01": "{{ unsafe|capfirst }}"})
def test_autoescape_stringfilter01(self):
output = self.engine.render_to_string(
"autoescape-stringfilter01", {"unsafe": UnsafeClass()}
)
self.assertEqual(output, "You & me")
@setup(
{
"autoescape-stringfilter02": (
"{% autoescape off %}{{ unsafe|capfirst }}{% endautoescape %}"
)
}
)
def test_autoescape_stringfilter02(self):
output = self.engine.render_to_string(
"autoescape-stringfilter02", {"unsafe": UnsafeClass()}
)
self.assertEqual(output, "You & me")
@setup({"autoescape-stringfilter03": "{{ safe|capfirst }}"})
def test_autoescape_stringfilter03(self):
output = self.engine.render_to_string(
"autoescape-stringfilter03", {"safe": SafeClass()}
)
self.assertEqual(output, "You > me")
@setup(
{
"autoescape-stringfilter04": (
"{% autoescape off %}{{ safe|capfirst }}{% endautoescape %}"
)
}
)
def test_autoescape_stringfilter04(self):
output = self.engine.render_to_string(
"autoescape-stringfilter04", {"safe": SafeClass()}
)
self.assertEqual(output, "You > me")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_default.py | tests/template_tests/filter_tests/test_default.py | from django.template.defaultfilters import default
from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class DefaultTests(SimpleTestCase):
"""
Literal string arguments to the default filter are always treated as
safe strings, regardless of the auto-escaping state.
Note: we have to use {"a": ""} here, otherwise the invalid template
variable string interferes with the test result.
"""
@setup({"default01": '{{ a|default:"x<" }}'})
def test_default01(self):
output = self.engine.render_to_string("default01", {"a": ""})
self.assertEqual(output, "x<")
@setup({"default02": '{% autoescape off %}{{ a|default:"x<" }}{% endautoescape %}'})
def test_default02(self):
output = self.engine.render_to_string("default02", {"a": ""})
self.assertEqual(output, "x<")
@setup({"default03": '{{ a|default:"x<" }}'})
def test_default03(self):
output = self.engine.render_to_string("default03", {"a": mark_safe("x>")})
self.assertEqual(output, "x>")
@setup({"default04": '{% autoescape off %}{{ a|default:"x<" }}{% endautoescape %}'})
def test_default04(self):
output = self.engine.render_to_string("default04", {"a": mark_safe("x>")})
self.assertEqual(output, "x>")
class DefaultIfNoneTests(SimpleTestCase):
@setup({"default_if_none01": '{{ a|default:"x<" }}'})
def test_default_if_none01(self):
output = self.engine.render_to_string("default_if_none01", {"a": None})
self.assertEqual(output, "x<")
@setup(
{
"default_if_none02": (
'{% autoescape off %}{{ a|default:"x<" }}{% endautoescape %}'
)
}
)
def test_default_if_none02(self):
output = self.engine.render_to_string("default_if_none02", {"a": None})
self.assertEqual(output, "x<")
class FunctionTests(SimpleTestCase):
def test_value(self):
self.assertEqual(default("val", "default"), "val")
def test_none(self):
self.assertEqual(default(None, "default"), "default")
def test_empty_string(self):
self.assertEqual(default("", "default"), "default")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/__init__.py | tests/template_tests/filter_tests/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_dictsortreversed.py | tests/template_tests/filter_tests/test_dictsortreversed.py | from django.template.defaultfilters import dictsortreversed
from django.test import SimpleTestCase
class FunctionTests(SimpleTestCase):
def test_sort(self):
sorted_dicts = dictsortreversed(
[
{"age": 23, "name": "Barbara-Ann"},
{"age": 63, "name": "Ra Ra Rasputin"},
{"name": "Jonny B Goode", "age": 18},
],
"age",
)
self.assertEqual(
[sorted(dict.items()) for dict in sorted_dicts],
[
[("age", 63), ("name", "Ra Ra Rasputin")],
[("age", 23), ("name", "Barbara-Ann")],
[("age", 18), ("name", "Jonny B Goode")],
],
)
def test_sort_list_of_tuples(self):
data = [("a", "42"), ("c", "string"), ("b", "foo")]
expected = [("c", "string"), ("b", "foo"), ("a", "42")]
self.assertEqual(dictsortreversed(data, 0), expected)
def test_sort_list_of_tuple_like_dicts(self):
data = [
{"0": "a", "1": "42"},
{"0": "c", "1": "string"},
{"0": "b", "1": "foo"},
]
expected = [
{"0": "c", "1": "string"},
{"0": "b", "1": "foo"},
{"0": "a", "1": "42"},
]
self.assertEqual(dictsortreversed(data, "0"), expected)
def test_invalid_values(self):
"""
If dictsortreversed is passed something other than a list of
dictionaries, fail silently.
"""
self.assertEqual(dictsortreversed([1, 2, 3], "age"), "")
self.assertEqual(dictsortreversed("Hello!", "age"), "")
self.assertEqual(dictsortreversed({"a": 1}, "age"), "")
self.assertEqual(dictsortreversed(1, "age"), "")
def test_invalid_args(self):
"""Fail silently if invalid lookups are passed."""
self.assertEqual(dictsortreversed([{}], "._private"), "")
self.assertEqual(dictsortreversed([{"_private": "test"}], "_private"), "")
self.assertEqual(
dictsortreversed([{"nested": {"_private": "test"}}], "nested._private"), ""
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_dictsort.py | tests/template_tests/filter_tests/test_dictsort.py | from django.template.defaultfilters import _property_resolver, dictsort
from django.test import SimpleTestCase
class User:
password = "abc"
_private = "private"
@property
def test_property(self):
return "cde"
def test_method(self):
"""This is just a test method."""
class FunctionTests(SimpleTestCase):
def test_property_resolver(self):
user = User()
dict_data = {
"a": {
"b1": {"c": "result1"},
"b2": user,
"b3": {"0": "result2"},
"b4": [0, 1, 2],
}
}
list_data = ["a", "b", "c"]
tests = [
("a.b1.c", dict_data, "result1"),
("a.b2.password", dict_data, "abc"),
("a.b2.test_property", dict_data, "cde"),
# The method should not get called.
("a.b2.test_method", dict_data, user.test_method),
("a.b3.0", dict_data, "result2"),
(0, list_data, "a"),
]
for arg, data, expected_value in tests:
with self.subTest(arg=arg):
self.assertEqual(_property_resolver(arg)(data), expected_value)
# Invalid lookups.
fail_tests = [
("a.b1.d", dict_data, AttributeError),
("a.b2.password.0", dict_data, AttributeError),
("a.b2._private", dict_data, AttributeError),
("a.b4.0", dict_data, AttributeError),
("a", list_data, AttributeError),
("0", list_data, TypeError),
(4, list_data, IndexError),
]
for arg, data, expected_exception in fail_tests:
with self.subTest(arg=arg):
with self.assertRaises(expected_exception):
_property_resolver(arg)(data)
def test_sort(self):
sorted_dicts = dictsort(
[
{"age": 23, "name": "Barbara-Ann"},
{"age": 63, "name": "Ra Ra Rasputin"},
{"name": "Jonny B Goode", "age": 18},
],
"age",
)
self.assertEqual(
[sorted(dict.items()) for dict in sorted_dicts],
[
[("age", 18), ("name", "Jonny B Goode")],
[("age", 23), ("name", "Barbara-Ann")],
[("age", 63), ("name", "Ra Ra Rasputin")],
],
)
def test_dictsort_complex_sorting_key(self):
"""
Since dictsort uses dict.get()/getattr() under the hood, it can sort
on keys like 'foo.bar'.
"""
data = [
{"foo": {"bar": 1, "baz": "c"}},
{"foo": {"bar": 2, "baz": "b"}},
{"foo": {"bar": 3, "baz": "a"}},
]
sorted_data = dictsort(data, "foo.baz")
self.assertEqual([d["foo"]["bar"] for d in sorted_data], [3, 2, 1])
def test_sort_list_of_tuples(self):
data = [("a", "42"), ("c", "string"), ("b", "foo")]
expected = [("a", "42"), ("b", "foo"), ("c", "string")]
self.assertEqual(dictsort(data, 0), expected)
def test_sort_list_of_tuple_like_dicts(self):
data = [
{"0": "a", "1": "42"},
{"0": "c", "1": "string"},
{"0": "b", "1": "foo"},
]
expected = [
{"0": "a", "1": "42"},
{"0": "b", "1": "foo"},
{"0": "c", "1": "string"},
]
self.assertEqual(dictsort(data, "0"), expected)
def test_invalid_values(self):
"""
If dictsort is passed something other than a list of dictionaries,
fail silently.
"""
self.assertEqual(dictsort([1, 2, 3], "age"), "")
self.assertEqual(dictsort("Hello!", "age"), "")
self.assertEqual(dictsort({"a": 1}, "age"), "")
self.assertEqual(dictsort(1, "age"), "")
def test_invalid_args(self):
"""Fail silently if invalid lookups are passed."""
self.assertEqual(dictsort([{}], "._private"), "")
self.assertEqual(dictsort([{"_private": "test"}], "_private"), "")
self.assertEqual(
dictsort([{"nested": {"_private": "test"}}], "nested._private"), ""
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_pluralize.py | tests/template_tests/filter_tests/test_pluralize.py | from decimal import Decimal
from django.template.defaultfilters import pluralize
from django.test import SimpleTestCase
from ..utils import setup
class PluralizeTests(SimpleTestCase):
def check_values(self, *tests):
for value, expected in tests:
with self.subTest(value=value):
output = self.engine.render_to_string("t", {"value": value})
self.assertEqual(output, expected)
@setup({"t": "vote{{ value|pluralize }}"})
def test_no_arguments(self):
self.check_values(("0", "votes"), ("1", "vote"), ("2", "votes"))
@setup({"t": 'class{{ value|pluralize:"es" }}'})
def test_suffix(self):
self.check_values(("0", "classes"), ("1", "class"), ("2", "classes"))
@setup({"t": 'cand{{ value|pluralize:"y,ies" }}'})
def test_singular_and_plural_suffix(self):
self.check_values(("0", "candies"), ("1", "candy"), ("2", "candies"))
class FunctionTests(SimpleTestCase):
def test_integers(self):
self.assertEqual(pluralize(1), "")
self.assertEqual(pluralize(0), "s")
self.assertEqual(pluralize(2), "s")
def test_floats(self):
self.assertEqual(pluralize(0.5), "s")
self.assertEqual(pluralize(1.5), "s")
def test_decimals(self):
self.assertEqual(pluralize(Decimal(1)), "")
self.assertEqual(pluralize(Decimal(0)), "s")
self.assertEqual(pluralize(Decimal(2)), "s")
def test_lists(self):
self.assertEqual(pluralize([1]), "")
self.assertEqual(pluralize([]), "s")
self.assertEqual(pluralize([1, 2, 3]), "s")
def test_suffixes(self):
self.assertEqual(pluralize(1, "es"), "")
self.assertEqual(pluralize(0, "es"), "es")
self.assertEqual(pluralize(2, "es"), "es")
self.assertEqual(pluralize(1, "y,ies"), "y")
self.assertEqual(pluralize(0, "y,ies"), "ies")
self.assertEqual(pluralize(2, "y,ies"), "ies")
self.assertEqual(pluralize(0, "y,ies,error"), "")
def test_no_len_type(self):
self.assertEqual(pluralize(object(), "y,es"), "")
self.assertEqual(pluralize(object(), "es"), "")
def test_value_error(self):
self.assertEqual(pluralize("", "y,es"), "")
self.assertEqual(pluralize("", "es"), "")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/timezone_utils.py | tests/template_tests/filter_tests/timezone_utils.py | from datetime import date, datetime
from django.test import SimpleTestCase
from django.utils import timezone
class TimezoneTestCase(SimpleTestCase):
def setUp(self):
self.now = datetime.now()
self.now_tz = timezone.make_aware(
self.now,
timezone.get_default_timezone(),
)
self.now_tz_i = timezone.localtime(
self.now_tz,
timezone.get_fixed_timezone(195),
)
self.today = date.today()
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_urlencode.py | tests/template_tests/filter_tests/test_urlencode.py | from django.template.defaultfilters import urlencode
from django.test import SimpleTestCase
from ..utils import setup
class UrlencodeTests(SimpleTestCase):
@setup({"urlencode01": "{{ url|urlencode }}"})
def test_urlencode01(self):
output = self.engine.render_to_string("urlencode01", {"url": '/test&"/me?/'})
self.assertEqual(output, "/test%26%22/me%3F/")
@setup({"urlencode02": '/test/{{ urlbit|urlencode:"" }}/'})
def test_urlencode02(self):
output = self.engine.render_to_string("urlencode02", {"urlbit": "escape/slash"})
self.assertEqual(output, "/test/escape%2Fslash/")
class FunctionTests(SimpleTestCase):
def test_urlencode(self):
self.assertEqual(urlencode("fran\xe7ois & jill"), "fran%C3%A7ois%20%26%20jill")
def test_non_string_input(self):
self.assertEqual(urlencode(1), "1")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_safe.py | tests/template_tests/filter_tests/test_safe.py | from django.test import SimpleTestCase
from ..utils import setup
class SafeTests(SimpleTestCase):
@setup({"safe01": "{{ a }} -- {{ a|safe }}"})
def test_safe01(self):
output = self.engine.render_to_string("safe01", {"a": "<b>hello</b>"})
self.assertEqual(output, "<b>hello</b> -- <b>hello</b>")
@setup({"safe02": "{% autoescape off %}{{ a }} -- {{ a|safe }}{% endautoescape %}"})
def test_safe02(self):
output = self.engine.render_to_string("safe02", {"a": "<b>hello</b>"})
self.assertEqual(output, "<b>hello</b> -- <b>hello</b>")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_truncatechars.py | tests/template_tests/filter_tests/test_truncatechars.py | from django.test import SimpleTestCase
from ..utils import setup
class TruncatecharsTests(SimpleTestCase):
@setup({"truncatechars01": "{{ a|truncatechars:3 }}"})
def test_truncatechars01(self):
output = self.engine.render_to_string(
"truncatechars01", {"a": "Testing, testing"}
)
self.assertEqual(output, "Te…")
@setup({"truncatechars02": "{{ a|truncatechars:7 }}"})
def test_truncatechars02(self):
output = self.engine.render_to_string("truncatechars02", {"a": "Testing"})
self.assertEqual(output, "Testing")
@setup({"truncatechars03": "{{ a|truncatechars:'e' }}"})
def test_fail_silently_incorrect_arg(self):
output = self.engine.render_to_string(
"truncatechars03", {"a": "Testing, testing"}
)
self.assertEqual(output, "Testing, testing")
@setup({"truncatechars04": "{{ a|truncatechars:3 }}"})
def test_truncatechars04(self):
output = self.engine.render_to_string("truncatechars04", {"a": "abc"})
self.assertEqual(output, "abc")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_linebreaksbr.py | tests/template_tests/filter_tests/test_linebreaksbr.py | from django.template.defaultfilters import linebreaksbr
from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class LinebreaksbrTests(SimpleTestCase):
"""
The contents in "linebreaksbr" are escaped according to the current
autoescape setting.
"""
@setup({"linebreaksbr01": "{{ a|linebreaksbr }} {{ b|linebreaksbr }}"})
def test_linebreaksbr01(self):
output = self.engine.render_to_string(
"linebreaksbr01", {"a": "x&\ny", "b": mark_safe("x&\ny")}
)
self.assertEqual(output, "x&<br>y x&<br>y")
@setup(
{
"linebreaksbr02": (
"{% autoescape off %}{{ a|linebreaksbr }} {{ b|linebreaksbr }}"
"{% endautoescape %}"
)
}
)
def test_linebreaksbr02(self):
output = self.engine.render_to_string(
"linebreaksbr02", {"a": "x&\ny", "b": mark_safe("x&\ny")}
)
self.assertEqual(output, "x&<br>y x&<br>y")
class FunctionTests(SimpleTestCase):
def test_newline(self):
self.assertEqual(linebreaksbr("line 1\nline 2"), "line 1<br>line 2")
def test_carriage(self):
self.assertEqual(linebreaksbr("line 1\rline 2"), "line 1<br>line 2")
def test_carriage_newline(self):
self.assertEqual(linebreaksbr("line 1\r\nline 2"), "line 1<br>line 2")
def test_non_string_input(self):
self.assertEqual(linebreaksbr(123), "123")
def test_autoescape(self):
self.assertEqual(
linebreaksbr("foo\n<a>bar</a>\nbuz"),
"foo<br><a>bar</a><br>buz",
)
def test_autoescape_off(self):
self.assertEqual(
linebreaksbr("foo\n<a>bar</a>\nbuz", autoescape=False),
"foo<br><a>bar</a><br>buz",
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_striptags.py | tests/template_tests/filter_tests/test_striptags.py | from django.template.defaultfilters import striptags
from django.test import SimpleTestCase
from django.utils.functional import lazystr
from django.utils.safestring import mark_safe
from ..utils import setup
class StriptagsTests(SimpleTestCase):
@setup({"striptags01": "{{ a|striptags }} {{ b|striptags }}"})
def test_striptags01(self):
output = self.engine.render_to_string(
"striptags01",
{
"a": "<a>x</a> <p><b>y</b></p>",
"b": mark_safe("<a>x</a> <p><b>y</b></p>"),
},
)
self.assertEqual(output, "x y x y")
@setup(
{
"striptags02": (
"{% autoescape off %}{{ a|striptags }} {{ b|striptags }}"
"{% endautoescape %}"
)
}
)
def test_striptags02(self):
output = self.engine.render_to_string(
"striptags02",
{
"a": "<a>x</a> <p><b>y</b></p>",
"b": mark_safe("<a>x</a> <p><b>y</b></p>"),
},
)
self.assertEqual(output, "x y x y")
class FunctionTests(SimpleTestCase):
def test_strip(self):
self.assertEqual(
striptags(
'some <b>html</b> with <script>alert("You smell")</script> disallowed '
"<img /> tags"
),
'some html with alert("You smell") disallowed tags',
)
def test_non_string_input(self):
self.assertEqual(striptags(123), "123")
def test_strip_lazy_string(self):
self.assertEqual(
striptags(
lazystr(
'some <b>html</b> with <script>alert("Hello")</script> disallowed '
"<img /> tags"
)
),
'some html with alert("Hello") disallowed tags',
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_make_list.py | tests/template_tests/filter_tests/test_make_list.py | from django.template.defaultfilters import make_list
from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class MakeListTests(SimpleTestCase):
"""
The make_list filter can destroy existing escaping, so the results are
escaped.
"""
@setup({"make_list01": "{% autoescape off %}{{ a|make_list }}{% endautoescape %}"})
def test_make_list01(self):
output = self.engine.render_to_string("make_list01", {"a": mark_safe("&")})
self.assertEqual(output, "['&']")
@setup({"make_list02": "{{ a|make_list }}"})
def test_make_list02(self):
output = self.engine.render_to_string("make_list02", {"a": mark_safe("&")})
self.assertEqual(output, "['&']")
@setup(
{
"make_list03": (
'{% autoescape off %}{{ a|make_list|stringformat:"s"|safe }}'
"{% endautoescape %}"
)
}
)
def test_make_list03(self):
output = self.engine.render_to_string("make_list03", {"a": mark_safe("&")})
self.assertEqual(output, "['&']")
@setup({"make_list04": '{{ a|make_list|stringformat:"s"|safe }}'})
def test_make_list04(self):
output = self.engine.render_to_string("make_list04", {"a": mark_safe("&")})
self.assertEqual(output, "['&']")
class FunctionTests(SimpleTestCase):
def test_string(self):
self.assertEqual(make_list("abc"), ["a", "b", "c"])
def test_integer(self):
self.assertEqual(make_list(1234), ["1", "2", "3", "4"])
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_wordcount.py | tests/template_tests/filter_tests/test_wordcount.py | from django.template.defaultfilters import wordcount
from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import setup
class WordcountTests(SimpleTestCase):
@setup(
{
"wordcount01": (
"{% autoescape off %}{{ a|wordcount }} {{ b|wordcount }}"
"{% endautoescape %}"
)
}
)
def test_wordcount01(self):
output = self.engine.render_to_string(
"wordcount01", {"a": "a & b", "b": mark_safe("a & b")}
)
self.assertEqual(output, "3 3")
@setup({"wordcount02": "{{ a|wordcount }} {{ b|wordcount }}"})
def test_wordcount02(self):
output = self.engine.render_to_string(
"wordcount02", {"a": "a & b", "b": mark_safe("a & b")}
)
self.assertEqual(output, "3 3")
class FunctionTests(SimpleTestCase):
def test_empty_string(self):
self.assertEqual(wordcount(""), 0)
def test_count_one(self):
self.assertEqual(wordcount("oneword"), 1)
def test_count_multiple(self):
self.assertEqual(wordcount("lots of words"), 3)
def test_non_string_input(self):
self.assertEqual(wordcount(123), 1)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_default_if_none.py | tests/template_tests/filter_tests/test_default_if_none.py | from django.template.defaultfilters import default_if_none
from django.test import SimpleTestCase
class FunctionTests(SimpleTestCase):
def test_value(self):
self.assertEqual(default_if_none("val", "default"), "val")
def test_none(self):
self.assertEqual(default_if_none(None, "default"), "default")
def test_empty_string(self):
self.assertEqual(default_if_none("", "default"), "")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_json_script.py | tests/template_tests/filter_tests/test_json_script.py | from django.test import SimpleTestCase
from ..utils import setup
class JsonScriptTests(SimpleTestCase):
@setup({"json-tag01": '{{ value|json_script:"test_id" }}'})
def test_basic(self):
output = self.engine.render_to_string(
"json-tag01", {"value": {"a": "testing\r\njson 'string\" <b>escaping</b>"}}
)
self.assertEqual(
output,
'<script id="test_id" type="application/json">'
'{"a": "testing\\r\\njson \'string\\" '
'\\u003Cb\\u003Eescaping\\u003C/b\\u003E"}'
"</script>",
)
@setup({"json-tag02": "{{ value|json_script }}"})
def test_without_id(self):
output = self.engine.render_to_string("json-tag02", {"value": {}})
self.assertEqual(output, '<script type="application/json">{}</script>')
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_get_digit.py | tests/template_tests/filter_tests/test_get_digit.py | from django.template.defaultfilters import get_digit
from django.test import SimpleTestCase
class FunctionTests(SimpleTestCase):
def test_values(self):
self.assertEqual(get_digit(123, 1), 3)
self.assertEqual(get_digit(123, 2), 2)
self.assertEqual(get_digit(123, 3), 1)
self.assertEqual(get_digit(123, 4), 0)
self.assertEqual(get_digit(123, 0), 123)
def test_string(self):
self.assertEqual(get_digit("xyz", 0), "xyz")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_title.py | tests/template_tests/filter_tests/test_title.py | from django.template.defaultfilters import title
from django.test import SimpleTestCase
from ..utils import setup
class TitleTests(SimpleTestCase):
@setup({"title1": "{{ a|title }}"})
def test_title1(self):
output = self.engine.render_to_string("title1", {"a": "JOE'S CRAB SHACK"})
self.assertEqual(output, "Joe's Crab Shack")
@setup({"title2": "{{ a|title }}"})
def test_title2(self):
output = self.engine.render_to_string("title2", {"a": "555 WEST 53RD STREET"})
self.assertEqual(output, "555 West 53rd Street")
class FunctionTests(SimpleTestCase):
def test_title(self):
self.assertEqual(title("a nice title, isn't it?"), "A Nice Title, Isn't It?")
def test_unicode(self):
self.assertEqual(title("discoth\xe8que"), "Discoth\xe8que")
def test_non_string_input(self):
self.assertEqual(title(123), "123")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/filter_tests/test_slugify.py | tests/template_tests/filter_tests/test_slugify.py | from django.template.defaultfilters import slugify
from django.test import SimpleTestCase
from django.utils.functional import lazy
from django.utils.safestring import mark_safe
from ..utils import setup
class SlugifyTests(SimpleTestCase):
"""
Running slugify on a pre-escaped string leads to odd behavior,
but the result is still safe.
"""
@setup(
{
"slugify01": (
"{% autoescape off %}{{ a|slugify }} {{ b|slugify }}{% endautoescape %}"
)
}
)
def test_slugify01(self):
output = self.engine.render_to_string(
"slugify01", {"a": "a & b", "b": mark_safe("a & b")}
)
self.assertEqual(output, "a-b a-amp-b")
@setup({"slugify02": "{{ a|slugify }} {{ b|slugify }}"})
def test_slugify02(self):
output = self.engine.render_to_string(
"slugify02", {"a": "a & b", "b": mark_safe("a & b")}
)
self.assertEqual(output, "a-b a-amp-b")
class FunctionTests(SimpleTestCase):
def test_slugify(self):
self.assertEqual(
slugify(
" Jack & Jill like numbers 1,2,3 and 4 and silly characters ?%.$!/"
),
"jack-jill-like-numbers-123-and-4-and-silly-characters",
)
def test_unicode(self):
self.assertEqual(
slugify("Un \xe9l\xe9phant \xe0 l'or\xe9e du bois"),
"un-elephant-a-loree-du-bois",
)
def test_non_string_input(self):
self.assertEqual(slugify(123), "123")
def test_slugify_lazy_string(self):
lazy_str = lazy(lambda string: string, str)
self.assertEqual(
slugify(
lazy_str(
" Jack & Jill like numbers 1,2,3 and 4 and silly characters ?%.$!/"
)
),
"jack-jill-like-numbers-123-and-4-and-silly-characters",
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_now.py | tests/template_tests/syntax_tests/test_now.py | from datetime import datetime
from django.template import TemplateSyntaxError
from django.test import SimpleTestCase
from django.utils.formats import date_format
from ..utils import setup
class NowTagTests(SimpleTestCase):
@setup({"now01": '{% now "j n Y" %}'})
def test_now01(self):
"""
Simple case
"""
output = self.engine.render_to_string("now01")
self.assertEqual(
output,
"%d %d %d"
% (
datetime.now().day,
datetime.now().month,
datetime.now().year,
),
)
# Check parsing of locale strings
@setup({"now02": '{% now "DATE_FORMAT" %}'})
def test_now02(self):
output = self.engine.render_to_string("now02")
self.assertEqual(output, date_format(datetime.now()))
@setup({"now03": "{% now 'j n Y' %}"})
def test_now03(self):
"""
#15092 - Also accept simple quotes
"""
output = self.engine.render_to_string("now03")
self.assertEqual(
output,
"%d %d %d"
% (
datetime.now().day,
datetime.now().month,
datetime.now().year,
),
)
@setup({"now04": "{% now 'DATE_FORMAT' %}"})
def test_now04(self):
output = self.engine.render_to_string("now04")
self.assertEqual(output, date_format(datetime.now()))
@setup({"now05": "{% now 'j \"n\" Y'%}"})
def test_now05(self):
output = self.engine.render_to_string("now05")
self.assertEqual(
output,
'%d "%d" %d'
% (
datetime.now().day,
datetime.now().month,
datetime.now().year,
),
)
@setup({"now06": "{% now \"j 'n' Y\"%}"})
def test_now06(self):
output = self.engine.render_to_string("now06")
self.assertEqual(
output,
"%d '%d' %d"
% (
datetime.now().day,
datetime.now().month,
datetime.now().year,
),
)
@setup({"now07": '{% now "j n Y" as N %}-{{N}}-'})
def test_now07(self):
output = self.engine.render_to_string("now07")
self.assertEqual(
output,
"-%d %d %d-"
% (
datetime.now().day,
datetime.now().month,
datetime.now().year,
),
)
@setup({"no_args": "{% now %}"})
def test_now_args(self):
with self.assertRaisesMessage(
TemplateSyntaxError, "'now' statement takes one argument"
):
self.engine.render_to_string("no_args")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_named_endblock.py | tests/template_tests/syntax_tests/test_named_endblock.py | from django.template import TemplateSyntaxError
from django.test import SimpleTestCase
from ..utils import setup
class NamedEndblockTests(SimpleTestCase):
@setup(
{
"namedendblocks01": "1{% block first %}_{% block second %}"
"2{% endblock second %}_{% endblock first %}3"
}
)
def test_namedendblocks01(self):
output = self.engine.render_to_string("namedendblocks01")
self.assertEqual(output, "1_2_3")
# Unbalanced blocks
@setup(
{
"namedendblocks02": "1{% block first %}_{% block second %}"
"2{% endblock first %}_{% endblock second %}3"
}
)
def test_namedendblocks02(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("namedendblocks02")
@setup(
{
"namedendblocks03": "1{% block first %}_{% block second %}"
"2{% endblock %}_{% endblock second %}3"
}
)
def test_namedendblocks03(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("namedendblocks03")
@setup(
{
"namedendblocks04": "1{% block first %}_{% block second %}"
"2{% endblock second %}_{% endblock third %}3"
}
)
def test_namedendblocks04(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("namedendblocks04")
@setup(
{
"namedendblocks05": (
"1{% block first %}_{% block second %}2{% endblock first %}"
)
}
)
def test_namedendblocks05(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("namedendblocks05")
# Mixed named and unnamed endblocks
@setup(
{
"namedendblocks06": "1{% block first %}_{% block second %}"
"2{% endblock %}_{% endblock first %}3"
}
)
def test_namedendblocks06(self):
"""
Mixed named and unnamed endblocks
"""
output = self.engine.render_to_string("namedendblocks06")
self.assertEqual(output, "1_2_3")
@setup(
{
"namedendblocks07": "1{% block first %}_{% block second %}"
"2{% endblock second %}_{% endblock %}3"
}
)
def test_namedendblocks07(self):
output = self.engine.render_to_string("namedendblocks07")
self.assertEqual(output, "1_2_3")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_invalid_string.py | tests/template_tests/syntax_tests/test_invalid_string.py | from django.test import SimpleTestCase
from ..utils import setup
class InvalidStringTests(SimpleTestCase):
libraries = {"i18n": "django.templatetags.i18n"}
@setup({"invalidstr01": '{{ var|default:"Foo" }}'})
def test_invalidstr01(self):
output = self.engine.render_to_string("invalidstr01")
if self.engine.string_if_invalid:
self.assertEqual(output, "INVALID")
else:
self.assertEqual(output, "Foo")
@setup({"invalidstr02": '{{ var|default_if_none:"Foo" }}'})
def test_invalidstr02(self):
output = self.engine.render_to_string("invalidstr02")
if self.engine.string_if_invalid:
self.assertEqual(output, "INVALID")
else:
self.assertEqual(output, "")
@setup({"invalidstr03": "{% for v in var %}({{ v }}){% endfor %}"})
def test_invalidstr03(self):
output = self.engine.render_to_string("invalidstr03")
self.assertEqual(output, "")
@setup({"invalidstr04": "{% if var %}Yes{% else %}No{% endif %}"})
def test_invalidstr04(self):
output = self.engine.render_to_string("invalidstr04")
self.assertEqual(output, "No")
@setup({"invalidstr04_2": '{% if var|default:"Foo" %}Yes{% else %}No{% endif %}'})
def test_invalidstr04_2(self):
output = self.engine.render_to_string("invalidstr04_2")
self.assertEqual(output, "Yes")
@setup({"invalidstr05": "{{ var }}"})
def test_invalidstr05(self):
output = self.engine.render_to_string("invalidstr05")
if self.engine.string_if_invalid:
self.assertEqual(output, "INVALID")
else:
self.assertEqual(output, "")
@setup({"invalidstr06": "{{ var.prop }}"})
def test_invalidstr06(self):
output = self.engine.render_to_string("invalidstr06")
if self.engine.string_if_invalid:
self.assertEqual(output, "INVALID")
else:
self.assertEqual(output, "")
@setup(
{
"invalidstr07": (
"{% load i18n %}{% blocktranslate %}{{ var }}{% endblocktranslate %}"
)
}
)
def test_invalidstr07(self):
output = self.engine.render_to_string("invalidstr07")
if self.engine.string_if_invalid:
self.assertEqual(output, "INVALID")
else:
self.assertEqual(output, "")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_multiline.py | tests/template_tests/syntax_tests/test_multiline.py | from django.test import SimpleTestCase
from ..utils import setup
multiline_string = """
Hello,
boys.
How
are
you
gentlemen.
"""
class MultilineTests(SimpleTestCase):
@setup({"multiline01": multiline_string})
def test_multiline01(self):
output = self.engine.render_to_string("multiline01")
self.assertEqual(output, multiline_string)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_load.py | tests/template_tests/syntax_tests/test_load.py | from django.template import TemplateSyntaxError
from django.test import SimpleTestCase
from ..utils import setup
class LoadTagTests(SimpleTestCase):
libraries = {
"subpackage.echo": "template_tests.templatetags.subpackage.echo",
"testtags": "template_tests.templatetags.testtags",
}
@setup(
{
"load01": (
'{% load testtags subpackage.echo %}{% echo test %} {% echo2 "test" %}'
)
}
)
def test_load01(self):
output = self.engine.render_to_string("load01")
self.assertEqual(output, "test test")
@setup({"load02": '{% load subpackage.echo %}{% echo2 "test" %}'})
def test_load02(self):
output = self.engine.render_to_string("load02")
self.assertEqual(output, "test")
# {% load %} tag, importing individual tags
@setup({"load03": "{% load echo from testtags %}{% echo this that theother %}"})
def test_load03(self):
output = self.engine.render_to_string("load03")
self.assertEqual(output, "this that theother")
@setup(
{
"load04": "{% load echo other_echo from testtags %}"
"{% echo this that theother %} {% other_echo and another thing %}"
}
)
def test_load04(self):
output = self.engine.render_to_string("load04")
self.assertEqual(output, "this that theother and another thing")
@setup(
{
"load05": "{% load echo upper from testtags %}"
"{% echo this that theother %} {{ statement|upper }}"
}
)
def test_load05(self):
output = self.engine.render_to_string("load05", {"statement": "not shouting"})
self.assertEqual(output, "this that theother NOT SHOUTING")
@setup({"load06": '{% load echo2 from subpackage.echo %}{% echo2 "test" %}'})
def test_load06(self):
output = self.engine.render_to_string("load06")
self.assertEqual(output, "test")
# {% load %} tag errors
@setup({"load07": "{% load echo other_echo bad_tag from testtags %}"})
def test_load07(self):
msg = "'bad_tag' is not a valid tag or filter in tag library 'testtags'"
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.get_template("load07")
@setup({"load08": "{% load echo other_echo bad_tag from %}"})
def test_load08(self):
msg = (
"'echo' is not a registered tag library. Must be one of:\n"
"subpackage.echo\ntesttags"
)
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.get_template("load08")
@setup({"load09": "{% load from testtags %}"})
def test_load09(self):
msg = (
"'from' is not a registered tag library. Must be one of:\n"
"subpackage.echo\ntesttags"
)
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.get_template("load09")
@setup({"load10": "{% load echo from bad_library %}"})
def test_load10(self):
msg = (
"'bad_library' is not a registered tag library. Must be one of:\n"
"subpackage.echo\ntesttags"
)
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.get_template("load10")
@setup({"load12": "{% load subpackage.missing %}"})
def test_load12(self):
msg = (
"'subpackage.missing' is not a registered tag library. Must be one of:\n"
"subpackage.echo\ntesttags"
)
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.get_template("load12")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_lorem.py | tests/template_tests/syntax_tests/test_lorem.py | from django.template.base import TemplateSyntaxError
from django.test import SimpleTestCase
from django.utils.lorem_ipsum import COMMON_P, WORDS
from ..utils import setup
class LoremTagTests(SimpleTestCase):
@setup({"lorem1": "{% lorem 3 w %}"})
def test_lorem1(self):
output = self.engine.render_to_string("lorem1")
self.assertEqual(output, "lorem ipsum dolor")
@setup({"lorem_random": "{% lorem 3 w random %}"})
def test_lorem_random(self):
output = self.engine.render_to_string("lorem_random")
words = output.split(" ")
self.assertEqual(len(words), 3)
for word in words:
self.assertIn(word, WORDS)
@setup({"lorem_default": "{% lorem %}"})
def test_lorem_default(self):
output = self.engine.render_to_string("lorem_default")
self.assertEqual(output, COMMON_P)
@setup({"lorem_syntax_error": "{% lorem 1 2 3 4 %}"})
def test_lorem_syntax(self):
msg = "Incorrect format for 'lorem' tag"
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.render_to_string("lorem_syntax_error")
@setup({"lorem_multiple_paragraphs": "{% lorem 2 p %}"})
def test_lorem_multiple_paragraphs(self):
output = self.engine.render_to_string("lorem_multiple_paragraphs")
self.assertEqual(output.count("<p>"), 2)
@setup({"lorem_incorrect_count": "{% lorem two p %}"})
def test_lorem_incorrect_count(self):
output = self.engine.render_to_string("lorem_incorrect_count")
self.assertEqual(output.count("<p>"), 1)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_verbatim.py | tests/template_tests/syntax_tests/test_verbatim.py | from django.template import TemplateSyntaxError
from django.test import SimpleTestCase
from ..utils import setup
class VerbatimTagTests(SimpleTestCase):
@setup({"verbatim-tag01": "{% verbatim %}{{bare }}{% endverbatim %}"})
def test_verbatim_tag01(self):
output = self.engine.render_to_string("verbatim-tag01")
self.assertEqual(output, "{{bare }}")
@setup({"verbatim-tag02": "{% verbatim %}{% endif %}{% endverbatim %}"})
def test_verbatim_tag02(self):
output = self.engine.render_to_string("verbatim-tag02")
self.assertEqual(output, "{% endif %}")
@setup(
{"verbatim-tag03": "{% verbatim %}It's the {% verbatim %} tag{% endverbatim %}"}
)
def test_verbatim_tag03(self):
output = self.engine.render_to_string("verbatim-tag03")
self.assertEqual(output, "It's the {% verbatim %} tag")
@setup(
{
"verbatim-tag04": (
"{% verbatim %}{% verbatim %}{% endverbatim %}{% endverbatim %}"
)
}
)
def test_verbatim_tag04(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("verbatim-tag04")
@setup(
{
"verbatim-tag05": (
"{% verbatim %}{% endverbatim %}{% verbatim %}{% endverbatim %}"
)
}
)
def test_verbatim_tag05(self):
output = self.engine.render_to_string("verbatim-tag05")
self.assertEqual(output, "")
@setup(
{
"verbatim-tag06": "{% verbatim special %}"
"Don't {% endverbatim %} just yet{% endverbatim special %}"
}
)
def test_verbatim_tag06(self):
output = self.engine.render_to_string("verbatim-tag06")
self.assertEqual(output, "Don't {% endverbatim %} just yet")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_width_ratio.py | tests/template_tests/syntax_tests/test_width_ratio.py | from django.template import TemplateSyntaxError
from django.test import SimpleTestCase
from ..utils import setup
class WidthRatioTagTests(SimpleTestCase):
libraries = {"custom": "template_tests.templatetags.custom"}
@setup({"widthratio01": "{% widthratio a b 0 %}"})
def test_widthratio01(self):
output = self.engine.render_to_string("widthratio01", {"a": 50, "b": 100})
self.assertEqual(output, "0")
@setup({"widthratio02": "{% widthratio a b 100 %}"})
def test_widthratio02(self):
output = self.engine.render_to_string("widthratio02", {"a": 0, "b": 0})
self.assertEqual(output, "0")
@setup({"widthratio03": "{% widthratio a b 100 %}"})
def test_widthratio03(self):
output = self.engine.render_to_string("widthratio03", {"a": 0, "b": 100})
self.assertEqual(output, "0")
@setup({"widthratio04": "{% widthratio a b 100 %}"})
def test_widthratio04(self):
output = self.engine.render_to_string("widthratio04", {"a": 50, "b": 100})
self.assertEqual(output, "50")
@setup({"widthratio05": "{% widthratio a b 100 %}"})
def test_widthratio05(self):
output = self.engine.render_to_string("widthratio05", {"a": 100, "b": 100})
self.assertEqual(output, "100")
@setup({"widthratio06": "{% widthratio a b 100 %}"})
def test_widthratio06(self):
"""
62.5 should round to 62
"""
output = self.engine.render_to_string("widthratio06", {"a": 50, "b": 80})
self.assertEqual(output, "62")
@setup({"widthratio07": "{% widthratio a b 100 %}"})
def test_widthratio07(self):
"""
71.4 should round to 71
"""
output = self.engine.render_to_string("widthratio07", {"a": 50, "b": 70})
self.assertEqual(output, "71")
# Raise exception if we don't have 3 args, last one an integer
@setup({"widthratio08": "{% widthratio %}"})
def test_widthratio08(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("widthratio08")
@setup({"widthratio09": "{% widthratio a b %}"})
def test_widthratio09(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.render_to_string("widthratio09", {"a": 50, "b": 100})
@setup({"widthratio10": "{% widthratio a b 100.0 %}"})
def test_widthratio10(self):
output = self.engine.render_to_string("widthratio10", {"a": 50, "b": 100})
self.assertEqual(output, "50")
@setup({"widthratio11": "{% widthratio a b c %}"})
def test_widthratio11(self):
"""
#10043: widthratio should allow max_width to be a variable
"""
output = self.engine.render_to_string(
"widthratio11", {"a": 50, "c": 100, "b": 100}
)
self.assertEqual(output, "50")
# #18739: widthratio should handle None args consistently with
# non-numerics
@setup({"widthratio12a": "{% widthratio a b c %}"})
def test_widthratio12a(self):
output = self.engine.render_to_string(
"widthratio12a", {"a": "a", "c": 100, "b": 100}
)
self.assertEqual(output, "")
@setup({"widthratio12b": "{% widthratio a b c %}"})
def test_widthratio12b(self):
output = self.engine.render_to_string(
"widthratio12b", {"a": None, "c": 100, "b": 100}
)
self.assertEqual(output, "")
@setup({"widthratio13a": "{% widthratio a b c %}"})
def test_widthratio13a(self):
output = self.engine.render_to_string(
"widthratio13a", {"a": 0, "c": 100, "b": "b"}
)
self.assertEqual(output, "")
@setup({"widthratio13b": "{% widthratio a b c %}"})
def test_widthratio13b(self):
output = self.engine.render_to_string(
"widthratio13b", {"a": 0, "c": 100, "b": None}
)
self.assertEqual(output, "")
@setup({"widthratio14a": "{% widthratio a b c %}"})
def test_widthratio14a(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.render_to_string("widthratio14a", {"a": 0, "c": "c", "b": 100})
@setup({"widthratio14b": "{% widthratio a b c %}"})
def test_widthratio14b(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.render_to_string("widthratio14b", {"a": 0, "c": None, "b": 100})
@setup({"widthratio15": '{% load custom %}{% widthratio a|noop:"x y" b 0 %}'})
def test_widthratio15(self):
"""
Test whitespace in filter argument
"""
output = self.engine.render_to_string("widthratio15", {"a": 50, "b": 100})
self.assertEqual(output, "0")
# Widthratio with variable assignment
@setup({"widthratio16": "{% widthratio a b 100 as variable %}-{{ variable }}-"})
def test_widthratio16(self):
output = self.engine.render_to_string("widthratio16", {"a": 50, "b": 100})
self.assertEqual(output, "-50-")
@setup({"widthratio17": "{% widthratio a b 100 as variable %}-{{ variable }}-"})
def test_widthratio17(self):
output = self.engine.render_to_string("widthratio17", {"a": 100, "b": 100})
self.assertEqual(output, "-100-")
@setup({"widthratio18": "{% widthratio a b 100 as %}"})
def test_widthratio18(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("widthratio18")
@setup({"widthratio19": "{% widthratio a b 100 not_as variable %}"})
def test_widthratio19(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("widthratio19")
@setup({"widthratio20": "{% widthratio a b 100 %}"})
def test_widthratio20(self):
output = self.engine.render_to_string(
"widthratio20", {"a": float("inf"), "b": float("inf")}
)
self.assertEqual(output, "")
@setup({"widthratio21": "{% widthratio a b 100 %}"})
def test_widthratio21(self):
output = self.engine.render_to_string(
"widthratio21", {"a": float("inf"), "b": 2}
)
self.assertEqual(output, "")
@setup({"t": "{% widthratio a b 100 as variable %}-{{ variable }}-"})
def test_zerodivisionerror_as_var(self):
output = self.engine.render_to_string("t", {"a": 0, "b": 0})
self.assertEqual(output, "-0-")
@setup({"t": "{% widthratio a b c as variable %}-{{ variable }}-"})
def test_typeerror_as_var(self):
output = self.engine.render_to_string("t", {"a": "a", "c": 100, "b": 100})
self.assertEqual(output, "--")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_include.py | tests/template_tests/syntax_tests/test_include.py | 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": []}]},
],
}
]
with self.subTest(template="recursive_include.html"):
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(),
)
with self.subTest(template="recursive_relative_include.html"):
engine = Engine(app_dirs=True)
t = engine.get_template("recursive_relative_include.html")
self.assertEqual(
"Recursion! A1 Recursion! B1 B2 B3 Recursion! C1",
t.render(Context({"comments": comments}))
.replace(" ", "")
.replace("\n", " ")
.strip(),
)
with self.subTest(template="tmpl"):
engine = Engine()
template = """
Recursion!
{% for c in comments %}
{{ c.comment }}
{% if c.children %}{% include tmpl with comments=c.children %}{% endif %}
{% endfor %}
"""
outer_tmpl = engine.from_string("{% include tmpl %}")
output = outer_tmpl.render(
Context({"tmpl": engine.from_string(template), "comments": comments})
)
self.assertEqual(
"Recursion! A1 Recursion! B1 B2 B3 Recursion! C1",
output.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'>",
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_list_index.py | tests/template_tests/syntax_tests/test_list_index.py | from django.test import SimpleTestCase
from ..utils import setup
class ListIndexTests(SimpleTestCase):
@setup({"list-index01": "{{ var.1 }}"})
def test_list_index01(self):
"""
List-index syntax allows a template to access a certain item of a
subscriptable object.
"""
output = self.engine.render_to_string(
"list-index01", {"var": ["first item", "second item"]}
)
self.assertEqual(output, "second item")
@setup({"list-index02": "{{ var.5 }}"})
def test_list_index02(self):
"""
Fail silently when the list index is out of range.
"""
output = self.engine.render_to_string(
"list-index02", {"var": ["first item", "second item"]}
)
if self.engine.string_if_invalid:
self.assertEqual(output, "INVALID")
else:
self.assertEqual(output, "")
@setup({"list-index03": "{{ var.1 }}"})
def test_list_index03(self):
"""
Fail silently when the list index is out of range.
"""
output = self.engine.render_to_string("list-index03", {"var": None})
if self.engine.string_if_invalid:
self.assertEqual(output, "INVALID")
else:
self.assertEqual(output, "")
@setup({"list-index04": "{{ var.1 }}"})
def test_list_index04(self):
"""
Fail silently when variable is a dict without the specified key.
"""
output = self.engine.render_to_string("list-index04", {"var": {}})
if self.engine.string_if_invalid:
self.assertEqual(output, "INVALID")
else:
self.assertEqual(output, "")
@setup({"list-index05": "{{ var.1 }}"})
def test_list_index05(self):
"""
Dictionary lookup wins out when dict's key is a string.
"""
output = self.engine.render_to_string("list-index05", {"var": {"1": "hello"}})
self.assertEqual(output, "hello")
@setup({"list-index06": "{{ var.1 }}"})
def test_list_index06(self):
"""
But list-index lookup wins out when dict's key is an int, which
behind the scenes is really a dictionary lookup (for a dict)
after converting the key to an int.
"""
output = self.engine.render_to_string("list-index06", {"var": {1: "hello"}})
self.assertEqual(output, "hello")
@setup({"list-index07": "{{ var.1 }}"})
def test_list_index07(self):
"""
Dictionary lookup wins out when there is a string and int version
of the key.
"""
output = self.engine.render_to_string(
"list-index07", {"var": {"1": "hello", 1: "world"}}
)
self.assertEqual(output, "hello")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_extends.py | tests/template_tests/syntax_tests/test_extends.py | from django.template import NodeList, TemplateSyntaxError
from django.template.base import Node
from django.template.loader_tags import ExtendsNode
from django.test import SimpleTestCase
from ..utils import setup
inheritance_templates = {
"inheritance01": (
"1{% block first %}&{% endblock %}3{% block second %}_{% endblock %}"
),
"inheritance02": "{% extends 'inheritance01' %}"
"{% block first %}2{% endblock %}{% block second %}4{% endblock %}",
"inheritance03": "{% extends 'inheritance02' %}",
"inheritance04": "{% extends 'inheritance01' %}",
"inheritance05": "{% extends 'inheritance02' %}",
"inheritance06": "{% extends foo %}",
"inheritance07": "{% extends 'inheritance01' %}{% block second %}5{% endblock %}",
"inheritance08": "{% extends 'inheritance02' %}{% block second %}5{% endblock %}",
"inheritance09": "{% extends 'inheritance04' %}",
"inheritance10": "{% extends 'inheritance04' %} ",
"inheritance11": "{% extends 'inheritance04' %}"
"{% block first %}2{% endblock %}{% block second %}4{% endblock %}",
"inheritance12": "{% extends 'inheritance07' %}{% block first %}2{% endblock %}",
"inheritance13": "{% extends 'inheritance02' %}"
"{% block first %}a{% endblock %}{% block second %}b{% endblock %}",
"inheritance14": (
"{% extends 'inheritance01' %}{% block newblock %}NO DISPLAY{% endblock %}"
),
"inheritance15": "{% extends 'inheritance01' %}"
"{% block first %}2{% block inner %}inner{% endblock %}{% endblock %}",
"inheritance16": "{% extends 'inheritance15' %}{% block inner %}out{% endblock %}",
"inheritance17": "{% load testtags %}{% block first %}1234{% endblock %}",
"inheritance18": "{% load testtags %}{% echo this that theother %}5678",
"inheritance19": "{% extends 'inheritance01' %}"
"{% block first %}{% load testtags %}{% echo 400 %}5678{% endblock %}",
"inheritance20": (
"{% extends 'inheritance01' %}{% block first %}{{ block.super }}a{% endblock %}"
),
"inheritance21": (
"{% extends 'inheritance02' %}{% block first %}{{ block.super }}a{% endblock %}"
),
"inheritance22": (
"{% extends 'inheritance04' %}{% block first %}{{ block.super }}a{% endblock %}"
),
"inheritance23": (
"{% extends 'inheritance20' %}{% block first %}{{ block.super }}b{% endblock %}"
),
"inheritance24": "{% extends context_template %}"
"{% block first %}2{% endblock %}{% block second %}4{% endblock %}",
"inheritance25": "{% extends context_template.1 %}"
"{% block first %}2{% endblock %}{% block second %}4{% endblock %}",
"inheritance26": "no tags",
"inheritance27": "{% extends 'inheritance26' %}",
"inheritance 28": "{% block first %}!{% endblock %}",
"inheritance29": "{% extends 'inheritance 28' %}",
"inheritance30": "1{% if optional %}{% block opt %}2{% endblock %}{% endif %}3",
"inheritance31": "{% extends 'inheritance30' %}{% block opt %}two{% endblock %}",
"inheritance32": "{% extends 'inheritance30' %}{% block opt %}two{% endblock %}",
"inheritance33": (
"1{% if optional == 1 %}{% block opt %}2{% endblock %}{% endif %}3"
),
"inheritance34": "{% extends 'inheritance33' %}{% block opt %}two{% endblock %}",
"inheritance35": "{% extends 'inheritance33' %}{% block opt %}two{% endblock %}",
"inheritance36": (
"{% for n in numbers %}_{% block opt %}{{ n }}{% endblock %}{% endfor %}_"
),
"inheritance37": "{% extends 'inheritance36' %}{% block opt %}X{% endblock %}",
"inheritance38": "{% extends 'inheritance36' %}{% block opt %}X{% endblock %}",
"inheritance39": (
"{% extends 'inheritance30' %}{% block opt %}new{{ block.super }}{% endblock %}"
),
"inheritance40": (
"{% extends 'inheritance33' %}{% block opt %}new{{ block.super }}{% endblock %}"
),
"inheritance41": (
"{% extends 'inheritance36' %}{% block opt %}new{{ block.super }}{% endblock %}"
),
"inheritance42": "{% extends 'inheritance02'|cut:' ' %}",
"inheritance_empty": "{% extends %}",
"extends_duplicate": "{% extends 'base.html' %}{% extends 'base.html' %}",
"duplicate_block": (
"{% extends 'base.html' %}{% block content %}2{% endblock %}{% block content %}"
"4{% endblock %}"
),
}
class InheritanceTests(SimpleTestCase):
libraries = {"testtags": "template_tests.templatetags.testtags"}
@setup(inheritance_templates)
def test_inheritance01(self):
"""
Standard template with no inheritance
"""
output = self.engine.render_to_string("inheritance01")
self.assertEqual(output, "1&3_")
@setup(inheritance_templates)
def test_inheritance02(self):
"""
Standard two-level inheritance
"""
output = self.engine.render_to_string("inheritance02")
self.assertEqual(output, "1234")
@setup(inheritance_templates)
def test_inheritance03(self):
"""
Three-level with no redefinitions on third level
"""
output = self.engine.render_to_string("inheritance03")
self.assertEqual(output, "1234")
@setup(inheritance_templates)
def test_inheritance04(self):
"""
Two-level with no redefinitions on second level
"""
output = self.engine.render_to_string("inheritance04")
self.assertEqual(output, "1&3_")
@setup(inheritance_templates)
def test_inheritance05(self):
"""
Two-level with double quotes instead of single quotes
"""
output = self.engine.render_to_string("inheritance05")
self.assertEqual(output, "1234")
@setup(inheritance_templates)
def test_inheritance06(self):
"""
Three-level with variable parent-template name
"""
output = self.engine.render_to_string("inheritance06", {"foo": "inheritance02"})
self.assertEqual(output, "1234")
@setup(inheritance_templates)
def test_inheritance07(self):
"""
Two-level with one block defined, one block not defined
"""
output = self.engine.render_to_string("inheritance07")
self.assertEqual(output, "1&35")
@setup(inheritance_templates)
def test_inheritance08(self):
"""
Three-level with one block defined on this level, two blocks
defined next level
"""
output = self.engine.render_to_string("inheritance08")
self.assertEqual(output, "1235")
@setup(inheritance_templates)
def test_inheritance09(self):
"""
Three-level with second and third levels blank
"""
output = self.engine.render_to_string("inheritance09")
self.assertEqual(output, "1&3_")
@setup(inheritance_templates)
def test_inheritance10(self):
"""
Three-level with space NOT in a block -- should be ignored
"""
output = self.engine.render_to_string("inheritance10")
self.assertEqual(output, "1&3_")
@setup(inheritance_templates)
def test_inheritance11(self):
"""
Three-level with both blocks defined on this level, but none on
second level
"""
output = self.engine.render_to_string("inheritance11")
self.assertEqual(output, "1234")
@setup(inheritance_templates)
def test_inheritance12(self):
"""
Three-level with this level providing one and second level
providing the other
"""
output = self.engine.render_to_string("inheritance12")
self.assertEqual(output, "1235")
@setup(inheritance_templates)
def test_inheritance13(self):
"""
Three-level with this level overriding second level
"""
output = self.engine.render_to_string("inheritance13")
self.assertEqual(output, "1a3b")
@setup(inheritance_templates)
def test_inheritance14(self):
"""
A block defined only in a child template shouldn't be displayed
"""
output = self.engine.render_to_string("inheritance14")
self.assertEqual(output, "1&3_")
@setup(inheritance_templates)
def test_inheritance15(self):
"""
A block within another block
"""
output = self.engine.render_to_string("inheritance15")
self.assertEqual(output, "12inner3_")
@setup(inheritance_templates)
def test_inheritance16(self):
"""
A block within another block (level 2)
"""
output = self.engine.render_to_string("inheritance16")
self.assertEqual(output, "12out3_")
@setup(inheritance_templates)
def test_inheritance17(self):
"""
{% load %} tag (parent -- setup for exception04)
"""
output = self.engine.render_to_string("inheritance17")
self.assertEqual(output, "1234")
@setup(inheritance_templates)
def test_inheritance18(self):
"""
{% load %} tag (standard usage, without inheritance)
"""
output = self.engine.render_to_string("inheritance18")
self.assertEqual(output, "this that theother5678")
@setup(inheritance_templates)
def test_inheritance19(self):
"""
{% load %} tag (within a child template)
"""
output = self.engine.render_to_string("inheritance19")
self.assertEqual(output, "140056783_")
@setup(inheritance_templates)
def test_inheritance20(self):
"""
Two-level inheritance with {{ block.super }}
"""
output = self.engine.render_to_string("inheritance20")
self.assertEqual(output, "1&a3_")
@setup(inheritance_templates)
def test_inheritance21(self):
"""
Three-level inheritance with {{ block.super }} from parent
"""
output = self.engine.render_to_string("inheritance21")
self.assertEqual(output, "12a34")
@setup(inheritance_templates)
def test_inheritance22(self):
"""
Three-level inheritance with {{ block.super }} from grandparent
"""
output = self.engine.render_to_string("inheritance22")
self.assertEqual(output, "1&a3_")
@setup(inheritance_templates)
def test_inheritance23(self):
"""
Three-level inheritance with {{ block.super }} from parent and
grandparent
"""
output = self.engine.render_to_string("inheritance23")
self.assertEqual(output, "1&ab3_")
@setup(inheritance_templates)
def test_inheritance24(self):
"""
Inheritance from local context without use of template loader
"""
context_template = self.engine.from_string(
"1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"
)
output = self.engine.render_to_string(
"inheritance24", {"context_template": context_template}
)
self.assertEqual(output, "1234")
@setup(inheritance_templates)
def test_inheritance25(self):
"""
Inheritance from local context with variable parent template
"""
context_template = [
self.engine.from_string("Wrong"),
self.engine.from_string(
"1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"
),
]
output = self.engine.render_to_string(
"inheritance25", {"context_template": context_template}
)
self.assertEqual(output, "1234")
@setup(inheritance_templates)
def test_inheritance26(self):
"""
Set up a base template to extend
"""
output = self.engine.render_to_string("inheritance26")
self.assertEqual(output, "no tags")
@setup(inheritance_templates)
def test_inheritance27(self):
"""
Inheritance from a template that doesn't have any blocks
"""
output = self.engine.render_to_string("inheritance27")
self.assertEqual(output, "no tags")
@setup(inheritance_templates)
def test_inheritance_28(self):
"""
Set up a base template with a space in it.
"""
output = self.engine.render_to_string("inheritance 28")
self.assertEqual(output, "!")
@setup(inheritance_templates)
def test_inheritance29(self):
"""
Inheritance from a template with a space in its name should work.
"""
output = self.engine.render_to_string("inheritance29")
self.assertEqual(output, "!")
@setup(inheritance_templates)
def test_inheritance30(self):
"""
Base template, putting block in a conditional {% if %} tag
"""
output = self.engine.render_to_string("inheritance30", {"optional": True})
self.assertEqual(output, "123")
# Inherit from a template with block wrapped in an {% if %} tag
# (in parent), still gets overridden
@setup(inheritance_templates)
def test_inheritance31(self):
output = self.engine.render_to_string("inheritance31", {"optional": True})
self.assertEqual(output, "1two3")
@setup(inheritance_templates)
def test_inheritance32(self):
output = self.engine.render_to_string("inheritance32")
self.assertEqual(output, "13")
@setup(inheritance_templates)
def test_inheritance33(self):
"""
Base template, putting block in a conditional {% if %} tag
"""
output = self.engine.render_to_string("inheritance33", {"optional": 1})
self.assertEqual(output, "123")
@setup(inheritance_templates)
def test_inheritance34(self):
"""
Inherit from a template with block wrapped in an {% if %} tag
(in parent), still gets overridden
"""
output = self.engine.render_to_string("inheritance34", {"optional": 1})
self.assertEqual(output, "1two3")
@setup(inheritance_templates)
def test_inheritance35(self):
"""
Inherit from a template with block wrapped in an {% if %} tag
(in parent), still gets overridden
"""
output = self.engine.render_to_string("inheritance35", {"optional": 2})
self.assertEqual(output, "13")
@setup(inheritance_templates)
def test_inheritance36(self):
"""
Base template, putting block in a {% for %} tag
"""
output = self.engine.render_to_string("inheritance36", {"numbers": "123"})
self.assertEqual(output, "_1_2_3_")
@setup(inheritance_templates)
def test_inheritance37(self):
"""
Inherit from a template with block wrapped in an {% for %} tag
(in parent), still gets overridden
"""
output = self.engine.render_to_string("inheritance37", {"numbers": "123"})
self.assertEqual(output, "_X_X_X_")
@setup(inheritance_templates)
def test_inheritance38(self):
"""
Inherit from a template with block wrapped in an {% for %} tag
(in parent), still gets overridden
"""
output = self.engine.render_to_string("inheritance38")
self.assertEqual(output, "_")
# The super block will still be found.
@setup(inheritance_templates)
def test_inheritance39(self):
output = self.engine.render_to_string("inheritance39", {"optional": True})
self.assertEqual(output, "1new23")
@setup(inheritance_templates)
def test_inheritance40(self):
output = self.engine.render_to_string("inheritance40", {"optional": 1})
self.assertEqual(output, "1new23")
@setup(inheritance_templates)
def test_inheritance41(self):
output = self.engine.render_to_string("inheritance41", {"numbers": "123"})
self.assertEqual(output, "_new1_new2_new3_")
@setup(inheritance_templates)
def test_inheritance42(self):
"""
Expression starting and ending with a quote
"""
output = self.engine.render_to_string("inheritance42")
self.assertEqual(output, "1234")
@setup(inheritance_templates)
def test_inheritance_empty(self):
with self.assertRaisesMessage(
TemplateSyntaxError, "'extends' takes one argument"
):
self.engine.render_to_string("inheritance_empty")
@setup(inheritance_templates)
def test_extends_duplicate(self):
msg = "'extends' cannot appear more than once in the same template"
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.render_to_string("extends_duplicate")
@setup(inheritance_templates)
def test_duplicate_block(self):
msg = "'block' tag with name 'content' appears more than once"
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.render_to_string("duplicate_block")
class ExtendsNodeTests(SimpleTestCase):
def test_extends_node_repr(self):
extends_node = ExtendsNode(
nodelist=NodeList([]),
parent_name=Node(),
template_dirs=[],
)
self.assertEqual(repr(extends_node), "<ExtendsNode: extends None>")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_regroup.py | tests/template_tests/syntax_tests/test_regroup.py | from datetime import date
from django.template import TemplateSyntaxError
from django.test import SimpleTestCase
from ..utils import setup
class RegroupTagTests(SimpleTestCase):
@setup(
{
"regroup01": ""
"{% regroup data by bar as grouped %}"
"{% for group in grouped %}"
"{{ group.grouper }}:"
"{% for item in group.list %}"
"{{ item.foo }}"
"{% endfor %},"
"{% endfor %}"
}
)
def test_regroup01(self):
output = self.engine.render_to_string(
"regroup01",
{
"data": [
{"foo": "c", "bar": 1},
{"foo": "d", "bar": 1},
{"foo": "a", "bar": 2},
{"foo": "b", "bar": 2},
{"foo": "x", "bar": 3},
],
},
)
self.assertEqual(output, "1:cd,2:ab,3:x,")
@setup(
{
"regroup02": ""
"{% regroup data by bar as grouped %}"
"{% for group in grouped %}"
"{{ group.grouper }}:"
"{% for item in group.list %}"
"{{ item.foo }}"
"{% endfor %}"
"{% endfor %}"
}
)
def test_regroup02(self):
"""
Test for silent failure when target variable isn't found
"""
output = self.engine.render_to_string("regroup02", {})
self.assertEqual(output, "")
@setup(
{
"regroup03": ""
'{% regroup data by at|date:"m" as grouped %}'
"{% for group in grouped %}"
"{{ group.grouper }}:"
"{% for item in group.list %}"
'{{ item.at|date:"d" }}'
"{% endfor %},"
"{% endfor %}"
}
)
def test_regroup03(self):
"""
Regression tests for #17675
The date template filter has expects_localtime = True
"""
output = self.engine.render_to_string(
"regroup03",
{
"data": [
{"at": date(2012, 2, 14)},
{"at": date(2012, 2, 28)},
{"at": date(2012, 7, 4)},
],
},
)
self.assertEqual(output, "02:1428,07:04,")
@setup(
{
"regroup04": ""
'{% regroup data by bar|join:"" as grouped %}'
"{% for group in grouped %}"
"{{ group.grouper }}:"
"{% for item in group.list %}"
"{{ item.foo|first }}"
"{% endfor %},"
"{% endfor %}"
}
)
def test_regroup04(self):
"""
The join template filter has needs_autoescape = True
"""
output = self.engine.render_to_string(
"regroup04",
{
"data": [
{"foo": "x", "bar": ["ab", "c"]},
{"foo": "y", "bar": ["a", "bc"]},
{"foo": "z", "bar": ["a", "d"]},
],
},
)
self.assertEqual(output, "abc:xy,ad:z,")
# Test syntax errors
@setup({"regroup05": "{% regroup data by bar as %}"})
def test_regroup05(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("regroup05")
@setup({"regroup06": "{% regroup data by bar thisaintright grouped %}"})
def test_regroup06(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("regroup06")
@setup({"regroup07": "{% regroup data thisaintright bar as grouped %}"})
def test_regroup07(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("regroup07")
@setup({"regroup08": "{% regroup data by bar as grouped toomanyargs %}"})
def test_regroup08(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("regroup08")
@setup(
{
"regroup_unpack": "{% regroup data by bar as grouped %}"
"{% for grouper, group in grouped %}"
"{{ grouper }}:"
"{% for item in group %}"
"{{ item.foo }}"
"{% endfor %},"
"{% endfor %}"
}
)
def test_regroup_unpack(self):
output = self.engine.render_to_string(
"regroup_unpack",
{
"data": [
{"foo": "c", "bar": 1},
{"foo": "d", "bar": 1},
{"foo": "a", "bar": 2},
{"foo": "b", "bar": 2},
{"foo": "x", "bar": 3},
],
},
)
self.assertEqual(output, "1:cd,2:ab,3:x,")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_if_changed.py | tests/template_tests/syntax_tests/test_if_changed.py | from django.template import Context, Engine
from django.test import SimpleTestCase
from ..utils import setup
class IfChangedTagTests(SimpleTestCase):
libraries = {"custom": "template_tests.templatetags.custom"}
@setup(
{
"ifchanged01": (
"{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}"
)
}
)
def test_ifchanged01(self):
output = self.engine.render_to_string("ifchanged01", {"num": (1, 2, 3)})
self.assertEqual(output, "123")
@setup(
{
"ifchanged02": (
"{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}"
)
}
)
def test_ifchanged02(self):
output = self.engine.render_to_string("ifchanged02", {"num": (1, 1, 3)})
self.assertEqual(output, "13")
@setup(
{
"ifchanged03": (
"{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}"
)
}
)
def test_ifchanged03(self):
output = self.engine.render_to_string("ifchanged03", {"num": (1, 1, 1)})
self.assertEqual(output, "1")
@setup(
{
"ifchanged04": "{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}"
"{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}"
"{% endfor %}{% endfor %}"
}
)
def test_ifchanged04(self):
output = self.engine.render_to_string(
"ifchanged04", {"num": (1, 2, 3), "numx": (2, 2, 2)}
)
self.assertEqual(output, "122232")
@setup(
{
"ifchanged05": "{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}"
"{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}"
"{% endfor %}{% endfor %}"
}
)
def test_ifchanged05(self):
output = self.engine.render_to_string(
"ifchanged05", {"num": (1, 1, 1), "numx": (1, 2, 3)}
)
self.assertEqual(output, "1123123123")
@setup(
{
"ifchanged06": "{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}"
"{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}"
"{% endfor %}{% endfor %}"
}
)
def test_ifchanged06(self):
output = self.engine.render_to_string(
"ifchanged06", {"num": (1, 1, 1), "numx": (2, 2, 2)}
)
self.assertEqual(output, "1222")
@setup(
{
"ifchanged07": "{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}"
"{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}"
"{% for y in numy %}{% ifchanged %}{{ y }}{% endifchanged %}"
"{% endfor %}{% endfor %}{% endfor %}"
}
)
def test_ifchanged07(self):
output = self.engine.render_to_string(
"ifchanged07", {"num": (1, 1, 1), "numx": (2, 2, 2), "numy": (3, 3, 3)}
)
self.assertEqual(output, "1233323332333")
@setup(
{
"ifchanged08": "{% for data in datalist %}{% for c,d in data %}"
"{% if c %}{% ifchanged %}{{ d }}{% endifchanged %}"
"{% endif %}{% endfor %}{% endfor %}"
}
)
def test_ifchanged08(self):
output = self.engine.render_to_string(
"ifchanged08",
{
"datalist": [
[(1, "a"), (1, "a"), (0, "b"), (1, "c")],
[(0, "a"), (1, "c"), (1, "d"), (1, "d"), (0, "e")],
]
},
)
self.assertEqual(output, "accd")
@setup(
{
"ifchanged-param01": (
"{% for n in num %}{% ifchanged n %}..{% endifchanged %}"
"{{ n }}{% endfor %}"
)
}
)
def test_ifchanged_param01(self):
"""
Test one parameter given to ifchanged.
"""
output = self.engine.render_to_string("ifchanged-param01", {"num": (1, 2, 3)})
self.assertEqual(output, "..1..2..3")
@setup(
{
"ifchanged-param02": (
"{% for n in num %}{% for x in numx %}"
"{% ifchanged n %}..{% endifchanged %}{{ x }}"
"{% endfor %}{% endfor %}"
)
}
)
def test_ifchanged_param02(self):
output = self.engine.render_to_string(
"ifchanged-param02", {"num": (1, 2, 3), "numx": (5, 6, 7)}
)
self.assertEqual(output, "..567..567..567")
@setup(
{
"ifchanged-param03": "{% for n in num %}{{ n }}{% for x in numx %}"
"{% ifchanged x n %}{{ x }}{% endifchanged %}"
"{% endfor %}{% endfor %}"
}
)
def test_ifchanged_param03(self):
"""
Test multiple parameters to ifchanged.
"""
output = self.engine.render_to_string(
"ifchanged-param03", {"num": (1, 1, 2), "numx": (5, 6, 6)}
)
self.assertEqual(output, "156156256")
@setup(
{
"ifchanged-param04": (
"{% for d in days %}{% ifchanged %}{{ d.day }}{% endifchanged %}"
"{% for h in d.hours %}{% ifchanged d h %}{{ h }}{% endifchanged %}"
"{% endfor %}{% endfor %}"
)
}
)
def test_ifchanged_param04(self):
"""
Test a date+hour like construct, where the hour of the last day is
the same but the date had changed, so print the hour anyway.
"""
output = self.engine.render_to_string(
"ifchanged-param04",
{"days": [{"hours": [1, 2, 3], "day": 1}, {"hours": [3], "day": 2}]},
)
self.assertEqual(output, "112323")
@setup(
{
"ifchanged-param05": (
"{% for d in days %}{% ifchanged d.day %}{{ d.day }}{% endifchanged %}"
"{% for h in d.hours %}{% ifchanged d.day h %}{{ h }}{% endifchanged %}"
"{% endfor %}{% endfor %}"
)
}
)
def test_ifchanged_param05(self):
"""
Logically the same as above, just written with explicit ifchanged
for the day.
"""
output = self.engine.render_to_string(
"ifchanged-param05",
{"days": [{"hours": [1, 2, 3], "day": 1}, {"hours": [3], "day": 2}]},
)
self.assertEqual(output, "112323")
@setup(
{
"ifchanged-else01": "{% for id in ids %}{{ id }}"
"{% ifchanged id %}-first{% else %}-other{% endifchanged %}"
",{% endfor %}"
}
)
def test_ifchanged_else01(self):
"""
Test the else clause of ifchanged.
"""
output = self.engine.render_to_string(
"ifchanged-else01", {"ids": [1, 1, 2, 2, 2, 3]}
)
self.assertEqual(output, "1-first,1-other,2-first,2-other,2-other,3-first,")
@setup(
{
"ifchanged-else02": "{% for id in ids %}{{ id }}-"
'{% ifchanged id %}{% cycle "red" "blue" %}{% else %}gray{% endifchanged %}'
",{% endfor %}"
}
)
def test_ifchanged_else02(self):
output = self.engine.render_to_string(
"ifchanged-else02", {"ids": [1, 1, 2, 2, 2, 3]}
)
self.assertEqual(output, "1-red,1-gray,2-blue,2-gray,2-gray,3-red,")
@setup(
{
"ifchanged-else03": "{% for id in ids %}{{ id }}"
'{% ifchanged id %}-{% cycle "red" "blue" %}{% else %}{% endifchanged %}'
",{% endfor %}"
}
)
def test_ifchanged_else03(self):
output = self.engine.render_to_string(
"ifchanged-else03", {"ids": [1, 1, 2, 2, 2, 3]}
)
self.assertEqual(output, "1-red,1,2-blue,2,2,3-red,")
@setup(
{
"ifchanged-else04": "{% for id in ids %}"
"{% ifchanged %}***{{ id }}*{% else %}...{% endifchanged %}"
"{{ forloop.counter }}{% endfor %}"
}
)
def test_ifchanged_else04(self):
output = self.engine.render_to_string(
"ifchanged-else04", {"ids": [1, 1, 2, 2, 2, 3, 4]}
)
self.assertEqual(output, "***1*1...2***2*3...4...5***3*6***4*7")
@setup(
{
"ifchanged-filter-ws": "{% load custom %}{% for n in num %}"
'{% ifchanged n|noop:"x y" %}..{% endifchanged %}{{ n }}'
"{% endfor %}"
}
)
def test_ifchanged_filter_ws(self):
"""
Test whitespace in filter arguments
"""
output = self.engine.render_to_string("ifchanged-filter-ws", {"num": (1, 2, 3)})
self.assertEqual(output, "..1..2..3")
class IfChangedTests(SimpleTestCase):
@classmethod
def setUpClass(cls):
cls.engine = Engine()
super().setUpClass()
def test_ifchanged_concurrency(self):
"""
#15849 -- ifchanged should be thread-safe.
"""
template = self.engine.from_string(
"[0{% for x in foo %},{% with var=get_value %}{% ifchanged %}"
"{{ var }}{% endifchanged %}{% endwith %}{% endfor %}]"
)
# Using generator to mimic concurrency.
# The generator is not passed to the 'for' loop, because it does a
# list(values) instead, call gen.next() in the template to control the
# generator.
def gen():
yield 1
yield 2
# Simulate that another thread is now rendering.
# When the IfChangeNode stores state at 'self' it stays at '3' and
# skip the last yielded value below.
iter2 = iter([1, 2, 3])
output2 = template.render(
Context({"foo": range(3), "get_value": lambda: next(iter2)})
)
self.assertEqual(
output2,
"[0,1,2,3]",
"Expected [0,1,2,3] in second parallel template, got {}".format(
output2
),
)
yield 3
gen1 = gen()
output1 = template.render(
Context({"foo": range(3), "get_value": lambda: next(gen1)})
)
self.assertEqual(
output1,
"[0,1,2,3]",
"Expected [0,1,2,3] in first template, got {}".format(output1),
)
def test_ifchanged_render_once(self):
"""
#19890. The content of ifchanged template tag was rendered twice.
"""
template = self.engine.from_string(
'{% ifchanged %}{% cycle "1st time" "2nd time" %}{% endifchanged %}'
)
output = template.render(Context({}))
self.assertEqual(output, "1st time")
def test_include(self):
"""
#23516 -- This works as a regression test only if the cached loader
isn't used. Hence we don't use the @setup decorator.
"""
engine = Engine(
loaders=[
(
"django.template.loaders.locmem.Loader",
{
"template": (
'{% for x in vars %}{% include "include" %}{% endfor %}'
),
"include": "{% ifchanged %}{{ x }}{% endifchanged %}",
},
),
]
)
output = engine.render_to_string("template", {"vars": [1, 1, 2, 2, 3, 3]})
self.assertEqual(output, "123")
def test_include_state(self):
"""Tests the node state for different IncludeNodes (#27974)."""
engine = Engine(
loaders=[
(
"django.template.loaders.locmem.Loader",
{
"template": (
'{% for x in vars %}{% include "include" %}'
'{% include "include" %}{% endfor %}'
),
"include": "{% ifchanged %}{{ x }}{% endifchanged %}",
},
),
]
)
output = engine.render_to_string("template", {"vars": [1, 1, 2, 2, 3, 3]})
self.assertEqual(output, "112233")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_if.py | tests/template_tests/syntax_tests/test_if.py | from django.template import TemplateSyntaxError
from django.template.defaulttags import IfNode
from django.test import SimpleTestCase
from ..utils import TestObj, setup
class IfTagTests(SimpleTestCase):
@setup({"if-tag01": "{% if foo %}yes{% else %}no{% endif %}"})
def test_if_tag01(self):
output = self.engine.render_to_string("if-tag01", {"foo": True})
self.assertEqual(output, "yes")
@setup({"if-tag02": "{% if foo %}yes{% else %}no{% endif %}"})
def test_if_tag02(self):
output = self.engine.render_to_string("if-tag02", {"foo": False})
self.assertEqual(output, "no")
@setup({"if-tag03": "{% if foo %}yes{% else %}no{% endif %}"})
def test_if_tag03(self):
output = self.engine.render_to_string("if-tag03")
self.assertEqual(output, "no")
@setup({"if-tag04": "{% if foo %}foo{% elif bar %}bar{% endif %}"})
def test_if_tag04(self):
output = self.engine.render_to_string("if-tag04", {"foo": True})
self.assertEqual(output, "foo")
@setup({"if-tag05": "{% if foo %}foo{% elif bar %}bar{% endif %}"})
def test_if_tag05(self):
output = self.engine.render_to_string("if-tag05", {"bar": True})
self.assertEqual(output, "bar")
@setup({"if-tag06": "{% if foo %}foo{% elif bar %}bar{% endif %}"})
def test_if_tag06(self):
output = self.engine.render_to_string("if-tag06")
self.assertEqual(output, "")
@setup({"if-tag07": "{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"})
def test_if_tag07(self):
output = self.engine.render_to_string("if-tag07", {"foo": True})
self.assertEqual(output, "foo")
@setup({"if-tag08": "{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"})
def test_if_tag08(self):
output = self.engine.render_to_string("if-tag08", {"bar": True})
self.assertEqual(output, "bar")
@setup({"if-tag09": "{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"})
def test_if_tag09(self):
output = self.engine.render_to_string("if-tag09")
self.assertEqual(output, "nothing")
@setup(
{
"if-tag10": (
"{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing"
"{% endif %}"
)
}
)
def test_if_tag10(self):
output = self.engine.render_to_string("if-tag10", {"foo": True})
self.assertEqual(output, "foo")
@setup(
{
"if-tag11": (
"{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing"
"{% endif %}"
)
}
)
def test_if_tag11(self):
output = self.engine.render_to_string("if-tag11", {"bar": True})
self.assertEqual(output, "bar")
@setup(
{
"if-tag12": (
"{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing"
"{% endif %}"
)
}
)
def test_if_tag12(self):
output = self.engine.render_to_string("if-tag12", {"baz": True})
self.assertEqual(output, "baz")
@setup(
{
"if-tag13": (
"{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing"
"{% endif %}"
)
}
)
def test_if_tag13(self):
output = self.engine.render_to_string("if-tag13")
self.assertEqual(output, "nothing")
# Filters
@setup({"if-tag-filter01": "{% if foo|length == 5 %}yes{% else %}no{% endif %}"})
def test_if_tag_filter01(self):
output = self.engine.render_to_string("if-tag-filter01", {"foo": "abcde"})
self.assertEqual(output, "yes")
@setup({"if-tag-filter02": "{% if foo|upper == 'ABC' %}yes{% else %}no{% endif %}"})
def test_if_tag_filter02(self):
output = self.engine.render_to_string("if-tag-filter02")
self.assertEqual(output, "no")
# Equality
@setup({"if-tag-eq01": "{% if foo == bar %}yes{% else %}no{% endif %}"})
def test_if_tag_eq01(self):
output = self.engine.render_to_string("if-tag-eq01")
self.assertEqual(output, "yes")
@setup({"if-tag-eq02": "{% if foo == bar %}yes{% else %}no{% endif %}"})
def test_if_tag_eq02(self):
output = self.engine.render_to_string("if-tag-eq02", {"foo": 1})
self.assertEqual(output, "no")
@setup({"if-tag-eq03": "{% if foo == bar %}yes{% else %}no{% endif %}"})
def test_if_tag_eq03(self):
output = self.engine.render_to_string("if-tag-eq03", {"foo": 1, "bar": 1})
self.assertEqual(output, "yes")
@setup({"if-tag-eq04": "{% if foo == bar %}yes{% else %}no{% endif %}"})
def test_if_tag_eq04(self):
output = self.engine.render_to_string("if-tag-eq04", {"foo": 1, "bar": 2})
self.assertEqual(output, "no")
@setup({"if-tag-eq05": "{% if foo == '' %}yes{% else %}no{% endif %}"})
def test_if_tag_eq05(self):
output = self.engine.render_to_string("if-tag-eq05")
self.assertEqual(output, "no")
# Inequality
@setup({"if-tag-noteq01": "{% if foo != bar %}yes{% else %}no{% endif %}"})
def test_if_tag_noteq01(self):
output = self.engine.render_to_string("if-tag-noteq01")
self.assertEqual(output, "no")
@setup({"if-tag-noteq02": "{% if foo != bar %}yes{% else %}no{% endif %}"})
def test_if_tag_noteq02(self):
output = self.engine.render_to_string("if-tag-noteq02", {"foo": 1})
self.assertEqual(output, "yes")
@setup({"if-tag-noteq03": "{% if foo != bar %}yes{% else %}no{% endif %}"})
def test_if_tag_noteq03(self):
output = self.engine.render_to_string("if-tag-noteq03", {"foo": 1, "bar": 1})
self.assertEqual(output, "no")
@setup({"if-tag-noteq04": "{% if foo != bar %}yes{% else %}no{% endif %}"})
def test_if_tag_noteq04(self):
output = self.engine.render_to_string("if-tag-noteq04", {"foo": 1, "bar": 2})
self.assertEqual(output, "yes")
@setup({"if-tag-noteq05": '{% if foo != "" %}yes{% else %}no{% endif %}'})
def test_if_tag_noteq05(self):
output = self.engine.render_to_string("if-tag-noteq05")
self.assertEqual(output, "yes")
# Comparison
@setup({"if-tag-gt-01": "{% if 2 > 1 %}yes{% else %}no{% endif %}"})
def test_if_tag_gt_01(self):
output = self.engine.render_to_string("if-tag-gt-01")
self.assertEqual(output, "yes")
@setup({"if-tag-gt-02": "{% if 1 > 1 %}yes{% else %}no{% endif %}"})
def test_if_tag_gt_02(self):
output = self.engine.render_to_string("if-tag-gt-02")
self.assertEqual(output, "no")
@setup({"if-tag-gte-01": "{% if 1 >= 1 %}yes{% else %}no{% endif %}"})
def test_if_tag_gte_01(self):
output = self.engine.render_to_string("if-tag-gte-01")
self.assertEqual(output, "yes")
@setup({"if-tag-gte-02": "{% if 1 >= 2 %}yes{% else %}no{% endif %}"})
def test_if_tag_gte_02(self):
output = self.engine.render_to_string("if-tag-gte-02")
self.assertEqual(output, "no")
@setup({"if-tag-lt-01": "{% if 1 < 2 %}yes{% else %}no{% endif %}"})
def test_if_tag_lt_01(self):
output = self.engine.render_to_string("if-tag-lt-01")
self.assertEqual(output, "yes")
@setup({"if-tag-lt-02": "{% if 1 < 1 %}yes{% else %}no{% endif %}"})
def test_if_tag_lt_02(self):
output = self.engine.render_to_string("if-tag-lt-02")
self.assertEqual(output, "no")
@setup({"if-tag-lte-01": "{% if 1 <= 1 %}yes{% else %}no{% endif %}"})
def test_if_tag_lte_01(self):
output = self.engine.render_to_string("if-tag-lte-01")
self.assertEqual(output, "yes")
@setup({"if-tag-lte-02": "{% if 2 <= 1 %}yes{% else %}no{% endif %}"})
def test_if_tag_lte_02(self):
output = self.engine.render_to_string("if-tag-lte-02")
self.assertEqual(output, "no")
# Contains
@setup({"if-tag-in-01": "{% if 1 in x %}yes{% else %}no{% endif %}"})
def test_if_tag_in_01(self):
output = self.engine.render_to_string("if-tag-in-01", {"x": [1]})
self.assertEqual(output, "yes")
@setup({"if-tag-in-02": "{% if 2 in x %}yes{% else %}no{% endif %}"})
def test_if_tag_in_02(self):
output = self.engine.render_to_string("if-tag-in-02", {"x": [1]})
self.assertEqual(output, "no")
@setup({"if-tag-not-in-01": "{% if 1 not in x %}yes{% else %}no{% endif %}"})
def test_if_tag_not_in_01(self):
output = self.engine.render_to_string("if-tag-not-in-01", {"x": [1]})
self.assertEqual(output, "no")
@setup({"if-tag-not-in-02": "{% if 2 not in x %}yes{% else %}no{% endif %}"})
def test_if_tag_not_in_02(self):
output = self.engine.render_to_string("if-tag-not-in-02", {"x": [1]})
self.assertEqual(output, "yes")
# AND
@setup({"if-tag-and01": "{% if foo and bar %}yes{% else %}no{% endif %}"})
def test_if_tag_and01(self):
output = self.engine.render_to_string(
"if-tag-and01", {"foo": True, "bar": True}
)
self.assertEqual(output, "yes")
@setup({"if-tag-and02": "{% if foo and bar %}yes{% else %}no{% endif %}"})
def test_if_tag_and02(self):
output = self.engine.render_to_string(
"if-tag-and02", {"foo": True, "bar": False}
)
self.assertEqual(output, "no")
@setup({"if-tag-and03": "{% if foo and bar %}yes{% else %}no{% endif %}"})
def test_if_tag_and03(self):
output = self.engine.render_to_string(
"if-tag-and03", {"foo": False, "bar": True}
)
self.assertEqual(output, "no")
@setup({"if-tag-and04": "{% if foo and bar %}yes{% else %}no{% endif %}"})
def test_if_tag_and04(self):
output = self.engine.render_to_string(
"if-tag-and04", {"foo": False, "bar": False}
)
self.assertEqual(output, "no")
@setup({"if-tag-and05": "{% if foo and bar %}yes{% else %}no{% endif %}"})
def test_if_tag_and05(self):
output = self.engine.render_to_string("if-tag-and05", {"foo": False})
self.assertEqual(output, "no")
@setup({"if-tag-and06": "{% if foo and bar %}yes{% else %}no{% endif %}"})
def test_if_tag_and06(self):
output = self.engine.render_to_string("if-tag-and06", {"bar": False})
self.assertEqual(output, "no")
@setup({"if-tag-and07": "{% if foo and bar %}yes{% else %}no{% endif %}"})
def test_if_tag_and07(self):
output = self.engine.render_to_string("if-tag-and07", {"foo": True})
self.assertEqual(output, "no")
@setup({"if-tag-and08": "{% if foo and bar %}yes{% else %}no{% endif %}"})
def test_if_tag_and08(self):
output = self.engine.render_to_string("if-tag-and08", {"bar": True})
self.assertEqual(output, "no")
# OR
@setup({"if-tag-or01": "{% if foo or bar %}yes{% else %}no{% endif %}"})
def test_if_tag_or01(self):
output = self.engine.render_to_string("if-tag-or01", {"foo": True, "bar": True})
self.assertEqual(output, "yes")
@setup({"if-tag-or02": "{% if foo or bar %}yes{% else %}no{% endif %}"})
def test_if_tag_or02(self):
output = self.engine.render_to_string(
"if-tag-or02", {"foo": True, "bar": False}
)
self.assertEqual(output, "yes")
@setup({"if-tag-or03": "{% if foo or bar %}yes{% else %}no{% endif %}"})
def test_if_tag_or03(self):
output = self.engine.render_to_string(
"if-tag-or03", {"foo": False, "bar": True}
)
self.assertEqual(output, "yes")
@setup({"if-tag-or04": "{% if foo or bar %}yes{% else %}no{% endif %}"})
def test_if_tag_or04(self):
output = self.engine.render_to_string(
"if-tag-or04", {"foo": False, "bar": False}
)
self.assertEqual(output, "no")
@setup({"if-tag-or05": "{% if foo or bar %}yes{% else %}no{% endif %}"})
def test_if_tag_or05(self):
output = self.engine.render_to_string("if-tag-or05", {"foo": False})
self.assertEqual(output, "no")
@setup({"if-tag-or06": "{% if foo or bar %}yes{% else %}no{% endif %}"})
def test_if_tag_or06(self):
output = self.engine.render_to_string("if-tag-or06", {"bar": False})
self.assertEqual(output, "no")
@setup({"if-tag-or07": "{% if foo or bar %}yes{% else %}no{% endif %}"})
def test_if_tag_or07(self):
output = self.engine.render_to_string("if-tag-or07", {"foo": True})
self.assertEqual(output, "yes")
@setup({"if-tag-or08": "{% if foo or bar %}yes{% else %}no{% endif %}"})
def test_if_tag_or08(self):
output = self.engine.render_to_string("if-tag-or08", {"bar": True})
self.assertEqual(output, "yes")
@setup({"if-tag-or09": "{% if foo or bar or baz %}yes{% else %}no{% endif %}"})
def test_if_tag_or09(self):
"""
multiple ORs
"""
output = self.engine.render_to_string("if-tag-or09", {"baz": True})
self.assertEqual(output, "yes")
# NOT
@setup({"if-tag-not01": "{% if not foo %}no{% else %}yes{% endif %}"})
def test_if_tag_not01(self):
output = self.engine.render_to_string("if-tag-not01", {"foo": True})
self.assertEqual(output, "yes")
@setup({"if-tag-not02": "{% if not not foo %}no{% else %}yes{% endif %}"})
def test_if_tag_not02(self):
output = self.engine.render_to_string("if-tag-not02", {"foo": True})
self.assertEqual(output, "no")
@setup({"if-tag-not06": "{% if foo and not bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not06(self):
output = self.engine.render_to_string("if-tag-not06")
self.assertEqual(output, "no")
@setup({"if-tag-not07": "{% if foo and not bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not07(self):
output = self.engine.render_to_string(
"if-tag-not07", {"foo": True, "bar": True}
)
self.assertEqual(output, "no")
@setup({"if-tag-not08": "{% if foo and not bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not08(self):
output = self.engine.render_to_string(
"if-tag-not08", {"foo": True, "bar": False}
)
self.assertEqual(output, "yes")
@setup({"if-tag-not09": "{% if foo and not bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not09(self):
output = self.engine.render_to_string(
"if-tag-not09", {"foo": False, "bar": True}
)
self.assertEqual(output, "no")
@setup({"if-tag-not10": "{% if foo and not bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not10(self):
output = self.engine.render_to_string(
"if-tag-not10", {"foo": False, "bar": False}
)
self.assertEqual(output, "no")
@setup({"if-tag-not11": "{% if not foo and bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not11(self):
output = self.engine.render_to_string("if-tag-not11")
self.assertEqual(output, "no")
@setup({"if-tag-not12": "{% if not foo and bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not12(self):
output = self.engine.render_to_string(
"if-tag-not12", {"foo": True, "bar": True}
)
self.assertEqual(output, "no")
@setup({"if-tag-not13": "{% if not foo and bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not13(self):
output = self.engine.render_to_string(
"if-tag-not13", {"foo": True, "bar": False}
)
self.assertEqual(output, "no")
@setup({"if-tag-not14": "{% if not foo and bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not14(self):
output = self.engine.render_to_string(
"if-tag-not14", {"foo": False, "bar": True}
)
self.assertEqual(output, "yes")
@setup({"if-tag-not15": "{% if not foo and bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not15(self):
output = self.engine.render_to_string(
"if-tag-not15", {"foo": False, "bar": False}
)
self.assertEqual(output, "no")
@setup({"if-tag-not16": "{% if foo or not bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not16(self):
output = self.engine.render_to_string("if-tag-not16")
self.assertEqual(output, "yes")
@setup({"if-tag-not17": "{% if foo or not bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not17(self):
output = self.engine.render_to_string(
"if-tag-not17", {"foo": True, "bar": True}
)
self.assertEqual(output, "yes")
@setup({"if-tag-not18": "{% if foo or not bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not18(self):
output = self.engine.render_to_string(
"if-tag-not18", {"foo": True, "bar": False}
)
self.assertEqual(output, "yes")
@setup({"if-tag-not19": "{% if foo or not bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not19(self):
output = self.engine.render_to_string(
"if-tag-not19", {"foo": False, "bar": True}
)
self.assertEqual(output, "no")
@setup({"if-tag-not20": "{% if foo or not bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not20(self):
output = self.engine.render_to_string(
"if-tag-not20", {"foo": False, "bar": False}
)
self.assertEqual(output, "yes")
@setup({"if-tag-not21": "{% if not foo or bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not21(self):
output = self.engine.render_to_string("if-tag-not21")
self.assertEqual(output, "yes")
@setup({"if-tag-not22": "{% if not foo or bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not22(self):
output = self.engine.render_to_string(
"if-tag-not22", {"foo": True, "bar": True}
)
self.assertEqual(output, "yes")
@setup({"if-tag-not23": "{% if not foo or bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not23(self):
output = self.engine.render_to_string(
"if-tag-not23", {"foo": True, "bar": False}
)
self.assertEqual(output, "no")
@setup({"if-tag-not24": "{% if not foo or bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not24(self):
output = self.engine.render_to_string(
"if-tag-not24", {"foo": False, "bar": True}
)
self.assertEqual(output, "yes")
@setup({"if-tag-not25": "{% if not foo or bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not25(self):
output = self.engine.render_to_string(
"if-tag-not25", {"foo": False, "bar": False}
)
self.assertEqual(output, "yes")
@setup({"if-tag-not26": "{% if not foo and not bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not26(self):
output = self.engine.render_to_string("if-tag-not26")
self.assertEqual(output, "yes")
@setup({"if-tag-not27": "{% if not foo and not bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not27(self):
output = self.engine.render_to_string(
"if-tag-not27", {"foo": True, "bar": True}
)
self.assertEqual(output, "no")
@setup({"if-tag-not28": "{% if not foo and not bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not28(self):
output = self.engine.render_to_string(
"if-tag-not28", {"foo": True, "bar": False}
)
self.assertEqual(output, "no")
@setup({"if-tag-not29": "{% if not foo and not bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not29(self):
output = self.engine.render_to_string(
"if-tag-not29", {"foo": False, "bar": True}
)
self.assertEqual(output, "no")
@setup({"if-tag-not30": "{% if not foo and not bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not30(self):
output = self.engine.render_to_string(
"if-tag-not30", {"foo": False, "bar": False}
)
self.assertEqual(output, "yes")
@setup({"if-tag-not31": "{% if not foo or not bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not31(self):
output = self.engine.render_to_string("if-tag-not31")
self.assertEqual(output, "yes")
@setup({"if-tag-not32": "{% if not foo or not bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not32(self):
output = self.engine.render_to_string(
"if-tag-not32", {"foo": True, "bar": True}
)
self.assertEqual(output, "no")
@setup({"if-tag-not33": "{% if not foo or not bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not33(self):
output = self.engine.render_to_string(
"if-tag-not33", {"foo": True, "bar": False}
)
self.assertEqual(output, "yes")
@setup({"if-tag-not34": "{% if not foo or not bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not34(self):
output = self.engine.render_to_string(
"if-tag-not34", {"foo": False, "bar": True}
)
self.assertEqual(output, "yes")
@setup({"if-tag-not35": "{% if not foo or not bar %}yes{% else %}no{% endif %}"})
def test_if_tag_not35(self):
output = self.engine.render_to_string(
"if-tag-not35", {"foo": False, "bar": False}
)
self.assertEqual(output, "yes")
# Various syntax errors
@setup({"if-tag-error01": "{% if %}yes{% endif %}"})
def test_if_tag_error01(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("if-tag-error01")
@setup({"if-tag-error02": "{% if foo and %}yes{% else %}no{% endif %}"})
def test_if_tag_error02(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.render_to_string("if-tag-error02", {"foo": True})
@setup({"if-tag-error03": "{% if foo or %}yes{% else %}no{% endif %}"})
def test_if_tag_error03(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.render_to_string("if-tag-error03", {"foo": True})
@setup({"if-tag-error04": "{% if not foo and %}yes{% else %}no{% endif %}"})
def test_if_tag_error04(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.render_to_string("if-tag-error04", {"foo": True})
@setup({"if-tag-error05": "{% if not foo or %}yes{% else %}no{% endif %}"})
def test_if_tag_error05(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.render_to_string("if-tag-error05", {"foo": True})
@setup({"if-tag-error06": "{% if abc def %}yes{% endif %}"})
def test_if_tag_error06(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("if-tag-error06")
@setup({"if-tag-error07": "{% if not %}yes{% endif %}"})
def test_if_tag_error07(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("if-tag-error07")
@setup({"if-tag-error08": "{% if and %}yes{% endif %}"})
def test_if_tag_error08(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("if-tag-error08")
@setup({"if-tag-error09": "{% if or %}yes{% endif %}"})
def test_if_tag_error09(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("if-tag-error09")
@setup({"if-tag-error10": "{% if == %}yes{% endif %}"})
def test_if_tag_error10(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("if-tag-error10")
@setup({"if-tag-error11": "{% if 1 == %}yes{% endif %}"})
def test_if_tag_error11(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("if-tag-error11")
@setup({"if-tag-error12": "{% if a not b %}yes{% endif %}"})
def test_if_tag_error12(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("if-tag-error12")
@setup(
{
"else-if-tag-error01": (
"{% if foo is bar %} yes {% else if foo is not bar %} no {% endif %}"
)
}
)
def test_else_if_tag_error01(self):
error_message = 'Malformed template tag at line 1: "else if foo is not bar"'
with self.assertRaisesMessage(TemplateSyntaxError, error_message):
self.engine.get_template("else-if-tag-error01")
@setup(
{
"if-tag-shortcircuit01": (
"{% if x.is_true or x.is_bad %}yes{% else %}no{% endif %}"
)
}
)
def test_if_tag_shortcircuit01(self):
"""
If evaluations are shortcircuited where possible
"""
output = self.engine.render_to_string("if-tag-shortcircuit01", {"x": TestObj()})
self.assertEqual(output, "yes")
@setup(
{
"if-tag-shortcircuit02": (
"{% if x.is_false and x.is_bad %}yes{% else %}no{% endif %}"
)
}
)
def test_if_tag_shortcircuit02(self):
"""
The is_bad() function should not be evaluated. If it is, an
exception is raised.
"""
output = self.engine.render_to_string("if-tag-shortcircuit02", {"x": TestObj()})
self.assertEqual(output, "no")
@setup({"if-tag-badarg01": "{% if x|default_if_none:y %}yes{% endif %}"})
def test_if_tag_badarg01(self):
"""Nonexistent args"""
output = self.engine.render_to_string("if-tag-badarg01")
self.assertEqual(output, "")
@setup({"if-tag-badarg02": "{% if x|default_if_none:y %}yes{% endif %}"})
def test_if_tag_badarg02(self):
output = self.engine.render_to_string("if-tag-badarg02", {"y": 0})
self.assertEqual(output, "")
@setup({"if-tag-badarg03": "{% if x|default_if_none:y %}yes{% endif %}"})
def test_if_tag_badarg03(self):
output = self.engine.render_to_string("if-tag-badarg03", {"y": 1})
self.assertEqual(output, "yes")
@setup(
{"if-tag-badarg04": "{% if x|default_if_none:y %}yes{% else %}no{% endif %}"}
)
def test_if_tag_badarg04(self):
output = self.engine.render_to_string("if-tag-badarg04")
self.assertEqual(output, "no")
@setup({"if-tag-single-eq": "{% if foo = bar %}yes{% else %}no{% endif %}"})
def test_if_tag_single_eq(self):
# A single equals sign is a syntax error.
with self.assertRaises(TemplateSyntaxError):
self.engine.render_to_string("if-tag-single-eq", {"foo": 1})
@setup({"template": "{% if foo is True %}yes{% else %}no{% endif %}"})
def test_if_is_match(self):
output = self.engine.render_to_string("template", {"foo": True})
self.assertEqual(output, "yes")
@setup({"template": "{% if foo is True %}yes{% else %}no{% endif %}"})
def test_if_is_no_match(self):
output = self.engine.render_to_string("template", {"foo": 1})
self.assertEqual(output, "no")
@setup({"template": "{% if foo is bar %}yes{% else %}no{% endif %}"})
def test_if_is_variable_missing(self):
output = self.engine.render_to_string("template", {"foo": 1})
self.assertEqual(output, "no")
@setup({"template": "{% if foo is bar %}yes{% else %}no{% endif %}"})
def test_if_is_both_variables_missing(self):
output = self.engine.render_to_string("template", {})
self.assertEqual(output, "yes")
@setup({"template": "{% if foo is not None %}yes{% else %}no{% endif %}"})
def test_if_is_not_match(self):
# For this to act as a regression test, it's important not to use
# foo=True because True is (not None)
output = self.engine.render_to_string("template", {"foo": False})
self.assertEqual(output, "yes")
@setup({"template": "{% if foo is not None %}yes{% else %}no{% endif %}"})
def test_if_is_not_no_match(self):
output = self.engine.render_to_string("template", {"foo": None})
self.assertEqual(output, "no")
@setup({"template": "{% if foo is not bar %}yes{% else %}no{% endif %}"})
def test_if_is_not_variable_missing(self):
output = self.engine.render_to_string("template", {"foo": False})
self.assertEqual(output, "yes")
@setup({"template": "{% if foo is not bar %}yes{% else %}no{% endif %}"})
def test_if_is_not_both_variables_missing(self):
output = self.engine.render_to_string("template", {})
self.assertEqual(output, "no")
class IfNodeTests(SimpleTestCase):
def test_repr(self):
node = IfNode(conditions_nodelists=[])
self.assertEqual(repr(node), "<IfNode>")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_cache.py | tests/template_tests/syntax_tests/test_cache.py | from django.core.cache import cache
from django.template import Context, Engine, TemplateSyntaxError
from django.test import SimpleTestCase, override_settings
from ..utils import setup
class CacheTagTests(SimpleTestCase):
libraries = {
"cache": "django.templatetags.cache",
"custom": "template_tests.templatetags.custom",
}
def tearDown(self):
cache.clear()
@setup({"cache03": "{% load cache %}{% cache 2 test %}cache03{% endcache %}"})
def test_cache03(self):
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 %}",
}
)
def test_cache04(self):
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 %}"})
def test_cache05(self):
output = self.engine.render_to_string("cache05", {"foo": 1})
self.assertEqual(output, "cache05")
@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")
@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")
@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")
# Raise exception if we don't have at least 2 args, first one integer.
@setup({"cache11": "{% load cache %}{% cache %}{% endcache %}"})
def test_cache11(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("cache11")
@setup({"cache12": "{% load cache %}{% cache 1 %}{% endcache %}"})
def test_cache12(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("cache12")
@setup({"cache13": "{% load cache %}{% cache foo bar %}{% endcache %}"})
def test_cache13(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.render_to_string("cache13")
@setup({"cache14": "{% load cache %}{% cache foo bar %}{% endcache %}"})
def test_cache14(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.render_to_string("cache14", {"foo": "fail"})
@setup({"cache15": "{% load cache %}{% cache foo bar %}{% endcache %}"})
def test_cache15(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.render_to_string("cache15", {"foo": []})
@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, "")
@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",
{
"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")
@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")
@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")
class CacheTests(SimpleTestCase):
@classmethod
def setUpClass(cls):
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 %}"
)
cachenode = t.nodelist[1]
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",
},
}
)
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 %}'
)
ctx = Context()
o1 = t1.render(ctx)
o2 = t2.render(ctx)
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 %}'
)
ctx = Context()
with self.assertRaises(TemplateSyntaxError):
t.render(ctx)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_cycle.py | tests/template_tests/syntax_tests/test_cycle.py | from django.template import TemplateSyntaxError
from django.test import SimpleTestCase
from ..utils import setup
class CycleTagTests(SimpleTestCase):
@setup({"cycle01": "{% cycle a %}"})
def test_cycle01(self):
msg = "No named cycles in template. 'a' is not defined"
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.get_template("cycle01")
@setup({"cycle05": "{% cycle %}"})
def test_cycle05(self):
msg = "'cycle' tag requires at least two arguments"
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.get_template("cycle05")
@setup({"cycle07": "{% cycle a,b,c as foo %}{% cycle bar %}"})
def test_cycle07(self):
msg = "Could not parse the remainder: ',b,c' from 'a,b,c'"
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.get_template("cycle07")
@setup({"cycle10": "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}"})
def test_cycle10(self):
output = self.engine.render_to_string("cycle10")
self.assertEqual(output, "ab")
@setup({"cycle11": "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}"})
def test_cycle11(self):
output = self.engine.render_to_string("cycle11")
self.assertEqual(output, "abc")
@setup(
{
"cycle12": (
"{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}"
"{% cycle abc %}"
)
}
)
def test_cycle12(self):
output = self.engine.render_to_string("cycle12")
self.assertEqual(output, "abca")
@setup({"cycle13": "{% for i in test %}{% cycle 'a' 'b' %}{{ i }},{% endfor %}"})
def test_cycle13(self):
output = self.engine.render_to_string("cycle13", {"test": list(range(5))})
self.assertEqual(output, "a0,b1,a2,b3,a4,")
@setup({"cycle14": "{% cycle one two as foo %}{% cycle foo %}"})
def test_cycle14(self):
output = self.engine.render_to_string("cycle14", {"one": "1", "two": "2"})
self.assertEqual(output, "12")
@setup({"cycle15": "{% for i in test %}{% cycle aye bee %}{{ i }},{% endfor %}"})
def test_cycle15(self):
output = self.engine.render_to_string(
"cycle15", {"test": list(range(5)), "aye": "a", "bee": "b"}
)
self.assertEqual(output, "a0,b1,a2,b3,a4,")
@setup({"cycle16": "{% cycle one|lower two as foo %}{% cycle foo %}"})
def test_cycle16(self):
output = self.engine.render_to_string("cycle16", {"one": "A", "two": "2"})
self.assertEqual(output, "a2")
@setup(
{
"cycle17": "{% cycle 'a' 'b' 'c' as abc silent %}"
"{% cycle abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"
}
)
def test_cycle17(self):
output = self.engine.render_to_string("cycle17")
self.assertEqual(output, "")
@setup({"cycle18": "{% cycle 'a' 'b' 'c' as foo invalid_flag %}"})
def test_cycle18(self):
msg = "Only 'silent' flag is allowed after cycle's name, not 'invalid_flag'."
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.get_template("cycle18")
@setup({"cycle19": "{% cycle 'a' 'b' as silent %}{% cycle silent %}"})
def test_cycle19(self):
output = self.engine.render_to_string("cycle19")
self.assertEqual(output, "ab")
@setup({"cycle20": "{% cycle one two as foo %} & {% cycle foo %}"})
def test_cycle20(self):
output = self.engine.render_to_string(
"cycle20", {"two": "C & D", "one": "A & B"}
)
self.assertEqual(output, "A & B & C & D")
@setup(
{
"cycle21": "{% filter force_escape %}"
"{% cycle one two as foo %} & {% cycle foo %}{% endfilter %}"
}
)
def test_cycle21(self):
output = self.engine.render_to_string(
"cycle21", {"two": "C & D", "one": "A & B"}
)
self.assertEqual(output, "A &amp; B & C &amp; D")
@setup(
{
"cycle22": (
"{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ x }}"
"{% endfor %}"
)
}
)
def test_cycle22(self):
output = self.engine.render_to_string("cycle22", {"values": [1, 2, 3, 4]})
self.assertEqual(output, "1234")
@setup(
{
"cycle23": "{% for x in values %}"
"{% cycle 'a' 'b' 'c' as abc silent %}{{ abc }}{{ x }}{% endfor %}"
}
)
def test_cycle23(self):
output = self.engine.render_to_string("cycle23", {"values": [1, 2, 3, 4]})
self.assertEqual(output, "a1b2c3a4")
@setup(
{
"cycle24": (
"{% for x in values %}"
"{% cycle 'a' 'b' 'c' as abc silent %}{% include 'included-cycle' %}"
"{% endfor %}"
),
"included-cycle": "{{ abc }}",
}
)
def test_cycle24(self):
output = self.engine.render_to_string("cycle24", {"values": [1, 2, 3, 4]})
self.assertEqual(output, "abca")
@setup({"cycle25": "{% cycle a as abc %}"})
def test_cycle25(self):
output = self.engine.render_to_string("cycle25", {"a": "<"})
self.assertEqual(output, "<")
@setup({"cycle26": "{% cycle a b as ab %}{% cycle ab %}"})
def test_cycle26(self):
output = self.engine.render_to_string("cycle26", {"a": "<", "b": ">"})
self.assertEqual(output, "<>")
@setup(
{
"cycle27": (
"{% autoescape off %}{% cycle a b as ab %}{% cycle ab %}"
"{% endautoescape %}"
)
}
)
def test_cycle27(self):
output = self.engine.render_to_string("cycle27", {"a": "<", "b": ">"})
self.assertEqual(output, "<>")
@setup({"cycle28": "{% cycle a|safe b as ab %}{% cycle ab %}"})
def test_cycle28(self):
output = self.engine.render_to_string("cycle28", {"a": "<", "b": ">"})
self.assertEqual(output, "<>")
@setup(
{
"cycle29": "{% cycle 'a' 'b' 'c' as cycler silent %}"
"{% for x in values %}"
"{% ifchanged x %}"
"{% cycle cycler %}{{ cycler }}"
"{% else %}"
"{{ cycler }}"
"{% endifchanged %}"
"{% endfor %}"
}
)
def test_cycle29(self):
"""
A named {% cycle %} tag works inside an {% ifchanged %} block and a
{% for %} loop.
"""
output = self.engine.render_to_string(
"cycle29", {"values": [1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 9, 9]}
)
self.assertEqual(output, "bcabcabcccaa")
@setup(
{
"cycle30": "{% cycle 'a' 'b' 'c' as cycler silent %}"
"{% for x in values %}"
"{% with doesnothing=irrelevant %}"
"{% ifchanged x %}"
"{% cycle cycler %}{{ cycler }}"
"{% else %}"
"{{ cycler }}"
"{% endifchanged %}"
"{% endwith %}"
"{% endfor %}"
}
)
def test_cycle30(self):
"""
A {% with %} tag shouldn't reset the {% cycle %} variable.
"""
output = self.engine.render_to_string(
"cycle30", {"irrelevant": 1, "values": [1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 9, 9]}
)
self.assertEqual(output, "bcabcabcccaa")
@setup(
{
"undefined_cycle": "{% cycle 'a' 'b' 'c' as cycler silent %}"
"{% for x in values %}"
"{% cycle undefined %}{{ cycler }}"
"{% endfor %}"
}
)
def test_cycle_undefined(self):
with self.assertRaisesMessage(
TemplateSyntaxError, "Named cycle 'undefined' does not exist"
):
self.engine.render_to_string("undefined_cycle")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_filter_tag.py | tests/template_tests/syntax_tests/test_filter_tag.py | from django.template import TemplateSyntaxError
from django.test import SimpleTestCase
from ..utils import setup
class FilterTagTests(SimpleTestCase):
@setup({"filter01": "{% filter upper %}{% endfilter %}"})
def test_filter01(self):
output = self.engine.render_to_string("filter01")
self.assertEqual(output, "")
@setup({"filter02": "{% filter upper %}django{% endfilter %}"})
def test_filter02(self):
output = self.engine.render_to_string("filter02")
self.assertEqual(output, "DJANGO")
@setup({"filter03": "{% filter upper|lower %}django{% endfilter %}"})
def test_filter03(self):
output = self.engine.render_to_string("filter03")
self.assertEqual(output, "django")
@setup({"filter04": "{% filter cut:remove %}djangospam{% endfilter %}"})
def test_filter04(self):
output = self.engine.render_to_string("filter04", {"remove": "spam"})
self.assertEqual(output, "django")
@setup({"filter05": "{% filter safe %}fail{% endfilter %}"})
def test_filter05(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("filter05")
@setup({"filter05bis": "{% filter upper|safe %}fail{% endfilter %}"})
def test_filter05bis(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("filter05bis")
@setup({"filter06": "{% filter escape %}fail{% endfilter %}"})
def test_filter06(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("filter06")
@setup({"filter06bis": "{% filter upper|escape %}fail{% endfilter %}"})
def test_filter06bis(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("filter06bis")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_filter_syntax.py | tests/template_tests/syntax_tests/test_filter_syntax.py | from django.template import TemplateSyntaxError
from django.test import SimpleTestCase
from ..utils import SomeClass, SomeOtherException, UTF8Class, setup
class FilterSyntaxTests(SimpleTestCase):
@setup({"filter-syntax01": "{{ var|upper }}"})
def test_filter_syntax01(self):
"""
Basic filter usage
"""
output = self.engine.render_to_string(
"filter-syntax01", {"var": "Django is the greatest!"}
)
self.assertEqual(output, "DJANGO IS THE GREATEST!")
@setup({"filter-syntax02": "{{ var|upper|lower }}"})
def test_filter_syntax02(self):
"""
Chained filters
"""
output = self.engine.render_to_string(
"filter-syntax02", {"var": "Django is the greatest!"}
)
self.assertEqual(output, "django is the greatest!")
@setup({"filter-syntax03": "{{ var |upper }}"})
def test_filter_syntax03(self):
"""
Allow spaces before the filter pipe
"""
output = self.engine.render_to_string(
"filter-syntax03", {"var": "Django is the greatest!"}
)
self.assertEqual(output, "DJANGO IS THE GREATEST!")
@setup({"filter-syntax04": "{{ var| upper }}"})
def test_filter_syntax04(self):
"""
Allow spaces after the filter pipe
"""
output = self.engine.render_to_string(
"filter-syntax04", {"var": "Django is the greatest!"}
)
self.assertEqual(output, "DJANGO IS THE GREATEST!")
@setup({"filter-syntax05": "{{ var|does_not_exist }}"})
def test_filter_syntax05(self):
"""
Raise TemplateSyntaxError for a nonexistent filter
"""
msg = "Invalid filter: 'does_not_exist'"
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.get_template("filter-syntax05")
@setup({"filter-syntax06": "{{ var|fil(ter) }}"})
def test_filter_syntax06(self):
"""
Raise TemplateSyntaxError when trying to access a filter containing
an illegal character
"""
with self.assertRaisesMessage(TemplateSyntaxError, "Invalid filter: 'fil'"):
self.engine.get_template("filter-syntax06")
@setup({"filter-syntax07": "{% nothing_to_see_here %}"})
def test_filter_syntax07(self):
"""
Raise TemplateSyntaxError for invalid block tags
"""
msg = (
"Invalid block tag on line 1: 'nothing_to_see_here'. Did you "
"forget to register or load this tag?"
)
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.get_template("filter-syntax07")
@setup({"filter-syntax08": "{% %}"})
def test_filter_syntax08(self):
"""
Raise TemplateSyntaxError for empty block tags
"""
with self.assertRaisesMessage(TemplateSyntaxError, "Empty block tag on line 1"):
self.engine.get_template("filter-syntax08")
@setup(
{"filter-syntax08-multi-line": "line 1\nline 2\nline 3{% %}\nline 4\nline 5"}
)
def test_filter_syntax08_multi_line(self):
"""
Raise TemplateSyntaxError for empty block tags in templates with
multiple lines.
"""
with self.assertRaisesMessage(TemplateSyntaxError, "Empty block tag on line 3"):
self.engine.get_template("filter-syntax08-multi-line")
@setup({"filter-syntax09": '{{ var|cut:"o"|upper|lower }}'})
def test_filter_syntax09(self):
"""
Chained filters, with an argument to the first one
"""
output = self.engine.render_to_string("filter-syntax09", {"var": "Foo"})
self.assertEqual(output, "f")
@setup({"filter-syntax10": r'{{ var|default_if_none:" endquote\" hah" }}'})
def test_filter_syntax10(self):
"""
Literal string as argument is always "safe" from auto-escaping.
"""
output = self.engine.render_to_string("filter-syntax10", {"var": None})
self.assertEqual(output, ' endquote" hah')
@setup({"filter-syntax11": r"{{ var|default_if_none:var2 }}"})
def test_filter_syntax11(self):
"""
Variable as argument
"""
output = self.engine.render_to_string(
"filter-syntax11", {"var": None, "var2": "happy"}
)
self.assertEqual(output, "happy")
@setup({"filter-syntax13": r"1{{ var.method3 }}2"})
def test_filter_syntax13(self):
"""
Fail silently for methods that raise an exception with a
`silent_variable_failure` attribute
"""
output = self.engine.render_to_string("filter-syntax13", {"var": SomeClass()})
if self.engine.string_if_invalid:
self.assertEqual(output, "1INVALID2")
else:
self.assertEqual(output, "12")
@setup({"filter-syntax14": r"1{{ var.method4 }}2"})
def test_filter_syntax14(self):
"""
In methods that raise an exception without a
`silent_variable_attribute` set to True, the exception propagates
"""
with self.assertRaises(SomeOtherException):
self.engine.render_to_string("filter-syntax14", {"var": SomeClass()})
@setup({"filter-syntax15": r'{{ var|default_if_none:"foo\bar" }}'})
def test_filter_syntax15(self):
"""
Escaped backslash in argument
"""
output = self.engine.render_to_string("filter-syntax15", {"var": None})
self.assertEqual(output, r"foo\bar")
@setup({"filter-syntax16": r'{{ var|default_if_none:"foo\now" }}'})
def test_filter_syntax16(self):
"""
Escaped backslash using known escape char
"""
output = self.engine.render_to_string("filter-syntax16", {"var": None})
self.assertEqual(output, r"foo\now")
@setup({"filter-syntax17": r'{{ var|join:"" }}'})
def test_filter_syntax17(self):
"""
Empty strings can be passed as arguments to filters
"""
output = self.engine.render_to_string(
"filter-syntax17", {"var": ["a", "b", "c"]}
)
self.assertEqual(output, "abc")
@setup({"filter-syntax18": r"{{ var }}"})
def test_filter_syntax18(self):
"""
Strings are converted to bytestrings in the final output.
"""
output = self.engine.render_to_string("filter-syntax18", {"var": UTF8Class()})
self.assertEqual(output, "\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111")
@setup({"filter-syntax19": "{{ var|truncatewords:1 }}"})
def test_filter_syntax19(self):
"""
Numbers as filter arguments should work
"""
output = self.engine.render_to_string("filter-syntax19", {"var": "hello world"})
self.assertEqual(output, "hello …")
@setup({"filter-syntax20": '{{ ""|default_if_none:"was none" }}'})
def test_filter_syntax20(self):
"""
Filters should accept empty string constants
"""
output = self.engine.render_to_string("filter-syntax20")
self.assertEqual(output, "")
@setup({"filter-syntax21": r"1{{ var.silent_fail_key }}2"})
def test_filter_syntax21(self):
"""
Fail silently for non-callable attribute and dict lookups which
raise an exception with a "silent_variable_failure" attribute
"""
output = self.engine.render_to_string("filter-syntax21", {"var": SomeClass()})
if self.engine.string_if_invalid:
self.assertEqual(output, "1INVALID2")
else:
self.assertEqual(output, "12")
@setup({"filter-syntax22": r"1{{ var.silent_fail_attribute }}2"})
def test_filter_syntax22(self):
"""
Fail silently for non-callable attribute and dict lookups which
raise an exception with a `silent_variable_failure` attribute
"""
output = self.engine.render_to_string("filter-syntax22", {"var": SomeClass()})
if self.engine.string_if_invalid:
self.assertEqual(output, "1INVALID2")
else:
self.assertEqual(output, "12")
@setup({"filter-syntax23": r"1{{ var.noisy_fail_key }}2"})
def test_filter_syntax23(self):
"""
In attribute and dict lookups that raise an unexpected exception
without a `silent_variable_attribute` set to True, the exception
propagates
"""
with self.assertRaises(SomeOtherException):
self.engine.render_to_string("filter-syntax23", {"var": SomeClass()})
@setup({"filter-syntax24": r"1{{ var.noisy_fail_attribute }}2"})
def test_filter_syntax24(self):
"""
In attribute and dict lookups that raise an unexpected exception
without a `silent_variable_attribute` set to True, the exception
propagates
"""
with self.assertRaises(SomeOtherException):
self.engine.render_to_string("filter-syntax24", {"var": SomeClass()})
@setup({"filter-syntax25": "{{ var.attribute_error_attribute }}"})
def test_filter_syntax25(self):
"""
#16383 - Attribute errors from an @property value should be
reraised.
"""
with self.assertRaises(AttributeError):
self.engine.render_to_string("filter-syntax25", {"var": SomeClass()})
@setup({"template": "{{ var.type_error_attribute }}"})
def test_type_error_attribute(self):
with self.assertRaises(TypeError):
self.engine.render_to_string("template", {"var": SomeClass()})
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_url.py | tests/template_tests/syntax_tests/test_url.py | from django.template import RequestContext, TemplateSyntaxError
from django.template.defaulttags import URLNode
from django.test import RequestFactory, SimpleTestCase, override_settings
from django.urls import NoReverseMatch, resolve
from ..utils import setup
@override_settings(ROOT_URLCONF="template_tests.urls")
class UrlTagTests(SimpleTestCase):
request_factory = RequestFactory()
# Successes
@setup({"url01": '{% url "client" client.id %}'})
def test_url01(self):
output = self.engine.render_to_string("url01", {"client": {"id": 1}})
self.assertEqual(output, "/client/1/")
@setup({"url02": '{% url "client_action" id=client.id action="update" %}'})
def test_url02(self):
output = self.engine.render_to_string("url02", {"client": {"id": 1}})
self.assertEqual(output, "/client/1/update/")
@setup({"url02a": '{% url "client_action" client.id "update" %}'})
def test_url02a(self):
output = self.engine.render_to_string("url02a", {"client": {"id": 1}})
self.assertEqual(output, "/client/1/update/")
@setup({"url02b": "{% url 'client_action' id=client.id action='update' %}"})
def test_url02b(self):
output = self.engine.render_to_string("url02b", {"client": {"id": 1}})
self.assertEqual(output, "/client/1/update/")
@setup({"url02c": "{% url 'client_action' client.id 'update' %}"})
def test_url02c(self):
output = self.engine.render_to_string("url02c", {"client": {"id": 1}})
self.assertEqual(output, "/client/1/update/")
@setup({"url03": '{% url "index" %}'})
def test_url03(self):
output = self.engine.render_to_string("url03")
self.assertEqual(output, "/")
@setup({"url04": '{% url "named.client" client.id %}'})
def test_url04(self):
output = self.engine.render_to_string("url04", {"client": {"id": 1}})
self.assertEqual(output, "/named-client/1/")
@setup({"url05": '{% url "метка_оператора" v %}'})
def test_url05(self):
output = self.engine.render_to_string("url05", {"v": "Ω"})
self.assertEqual(output, "/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/")
@setup({"url06": '{% url "метка_оператора_2" tag=v %}'})
def test_url06(self):
output = self.engine.render_to_string("url06", {"v": "Ω"})
self.assertEqual(output, "/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/")
@setup({"url08": '{% url "метка_оператора" v %}'})
def test_url08(self):
output = self.engine.render_to_string("url08", {"v": "Ω"})
self.assertEqual(output, "/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/")
@setup({"url09": '{% url "метка_оператора_2" tag=v %}'})
def test_url09(self):
output = self.engine.render_to_string("url09", {"v": "Ω"})
self.assertEqual(output, "/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/")
@setup({"url10": '{% url "client_action" id=client.id action="two words" %}'})
def test_url10(self):
output = self.engine.render_to_string("url10", {"client": {"id": 1}})
self.assertEqual(output, "/client/1/two%20words/")
@setup({"url11": '{% url "client_action" id=client.id action="==" %}'})
def test_url11(self):
output = self.engine.render_to_string("url11", {"client": {"id": 1}})
self.assertEqual(output, "/client/1/==/")
@setup(
{"url12": '{% url "client_action" id=client.id action="!$&\'()*+,;=~:@," %}'}
)
def test_url12(self):
output = self.engine.render_to_string("url12", {"client": {"id": 1}})
self.assertEqual(output, "/client/1/!$&'()*+,;=~:@,/")
@setup({"url13": '{% url "client_action" id=client.id action=arg|join:"-" %}'})
def test_url13(self):
output = self.engine.render_to_string(
"url13", {"client": {"id": 1}, "arg": ["a", "b"]}
)
self.assertEqual(output, "/client/1/a-b/")
@setup({"url14": '{% url "client_action" client.id arg|join:"-" %}'})
def test_url14(self):
output = self.engine.render_to_string(
"url14", {"client": {"id": 1}, "arg": ["a", "b"]}
)
self.assertEqual(output, "/client/1/a-b/")
@setup({"url15": '{% url "client_action" 12 "test" %}'})
def test_url15(self):
output = self.engine.render_to_string("url15")
self.assertEqual(output, "/client/12/test/")
@setup({"url18": '{% url "client" "1,2" %}'})
def test_url18(self):
output = self.engine.render_to_string("url18")
self.assertEqual(output, "/client/1,2/")
@setup({"url19": "{% url named_url client.id %}"})
def test_url19(self):
output = self.engine.render_to_string(
"url19", {"client": {"id": 1}, "named_url": "client"}
)
self.assertEqual(output, "/client/1/")
@setup({"url20": "{% url url_name_in_var client.id %}"})
def test_url20(self):
output = self.engine.render_to_string(
"url20", {"client": {"id": 1}, "url_name_in_var": "named.client"}
)
self.assertEqual(output, "/named-client/1/")
@setup(
{
"url21": "{% autoescape off %}"
'{% url "client_action" id=client.id action="!$&\'()*+,;=~:@," %}'
"{% endautoescape %}"
}
)
def test_url21(self):
output = self.engine.render_to_string("url21", {"client": {"id": 1}})
self.assertEqual(output, "/client/1/!$&'()*+,;=~:@,/")
# Failures
@setup({"url-fail01": "{% url %}"})
def test_url_fail01(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("url-fail01")
@setup({"url-fail02": '{% url "no_such_view" %}'})
def test_url_fail02(self):
with self.assertRaises(NoReverseMatch):
self.engine.render_to_string("url-fail02")
@setup({"url-fail03": '{% url "client" %}'})
def test_url_fail03(self):
with self.assertRaises(NoReverseMatch):
self.engine.render_to_string("url-fail03")
@setup({"url-fail04": '{% url "view" id, %}'})
def test_url_fail04(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("url-fail04")
@setup({"url-fail05": '{% url "view" id= %}'})
def test_url_fail05(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("url-fail05")
@setup({"url-fail06": '{% url "view" a.id=id %}'})
def test_url_fail06(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("url-fail06")
@setup({"url-fail07": '{% url "view" a.id!id %}'})
def test_url_fail07(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("url-fail07")
@setup({"url-fail08": '{% url "view" id="unterminatedstring %}'})
def test_url_fail08(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("url-fail08")
@setup({"url-fail09": '{% url "view" id=", %}'})
def test_url_fail09(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("url-fail09")
@setup({"url-fail11": "{% url named_url %}"})
def test_url_fail11(self):
with self.assertRaises(NoReverseMatch):
self.engine.render_to_string("url-fail11")
@setup({"url-fail12": "{% url named_url %}"})
def test_url_fail12(self):
with self.assertRaises(NoReverseMatch):
self.engine.render_to_string("url-fail12", {"named_url": "no_such_view"})
@setup({"url-fail13": "{% url named_url %}"})
def test_url_fail13(self):
with self.assertRaises(NoReverseMatch):
self.engine.render_to_string(
"url-fail13", {"named_url": "template_tests.views.client"}
)
@setup({"url-fail14": "{% url named_url id, %}"})
def test_url_fail14(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.render_to_string("url-fail14", {"named_url": "view"})
@setup({"url-fail15": "{% url named_url id= %}"})
def test_url_fail15(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.render_to_string("url-fail15", {"named_url": "view"})
@setup({"url-fail16": "{% url named_url a.id=id %}"})
def test_url_fail16(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.render_to_string("url-fail16", {"named_url": "view"})
@setup({"url-fail17": "{% url named_url a.id!id %}"})
def test_url_fail17(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.render_to_string("url-fail17", {"named_url": "view"})
@setup({"url-fail18": '{% url named_url id="unterminatedstring %}'})
def test_url_fail18(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.render_to_string("url-fail18", {"named_url": "view"})
@setup({"url-fail19": '{% url named_url id=", %}'})
def test_url_fail19(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.render_to_string("url-fail19", {"named_url": "view"})
# {% url ... as var %}
@setup({"url-asvar01": '{% url "index" as url %}'})
def test_url_asvar01(self):
output = self.engine.render_to_string("url-asvar01")
self.assertEqual(output, "")
@setup({"url-asvar02": '{% url "index" as url %}{{ url }}'})
def test_url_asvar02(self):
output = self.engine.render_to_string("url-asvar02")
self.assertEqual(output, "/")
@setup({"url-asvar03": '{% url "no_such_view" as url %}{{ url }}'})
def test_url_asvar03(self):
output = self.engine.render_to_string("url-asvar03")
self.assertEqual(output, "")
@setup({"url-namespace01": '{% url "app:named.client" 42 %}'})
def test_url_namespace01(self):
request = self.request_factory.get("/")
request.resolver_match = resolve("/ns1/")
template = self.engine.get_template("url-namespace01")
context = RequestContext(request)
output = template.render(context)
self.assertEqual(output, "/ns1/named-client/42/")
@setup({"url-namespace02": '{% url "app:named.client" 42 %}'})
def test_url_namespace02(self):
request = self.request_factory.get("/")
request.resolver_match = resolve("/ns2/")
template = self.engine.get_template("url-namespace02")
context = RequestContext(request)
output = template.render(context)
self.assertEqual(output, "/ns2/named-client/42/")
@setup({"url-namespace03": '{% url "app:named.client" 42 %}'})
def test_url_namespace03(self):
request = self.request_factory.get("/")
template = self.engine.get_template("url-namespace03")
context = RequestContext(request)
output = template.render(context)
self.assertEqual(output, "/ns2/named-client/42/")
@setup({"url-namespace-no-current-app": '{% url "app:named.client" 42 %}'})
def test_url_namespace_no_current_app(self):
request = self.request_factory.get("/")
request.resolver_match = resolve("/ns1/")
request.current_app = None
template = self.engine.get_template("url-namespace-no-current-app")
context = RequestContext(request)
output = template.render(context)
self.assertEqual(output, "/ns2/named-client/42/")
@setup({"url-namespace-explicit-current-app": '{% url "app:named.client" 42 %}'})
def test_url_namespace_explicit_current_app(self):
request = self.request_factory.get("/")
request.resolver_match = resolve("/ns1/")
request.current_app = "app"
template = self.engine.get_template("url-namespace-explicit-current-app")
context = RequestContext(request)
output = template.render(context)
self.assertEqual(output, "/ns2/named-client/42/")
class URLNodeTest(SimpleTestCase):
def test_repr(self):
url_node = URLNode(view_name="named-view", args=[], kwargs={}, asvar=None)
self.assertEqual(
repr(url_node),
"<URLNode view_name='named-view' args=[] kwargs={} as=None>",
)
url_node = URLNode(
view_name="named-view",
args=[1, 2],
kwargs={"action": "update"},
asvar="my_url",
)
self.assertEqual(
repr(url_node),
"<URLNode view_name='named-view' args=[1, 2] "
"kwargs={'action': 'update'} as='my_url'>",
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_builtins.py | tests/template_tests/syntax_tests/test_builtins.py | from django.test import SimpleTestCase
from ..utils import setup
class BuiltinsTests(SimpleTestCase):
@setup({"builtins01": "{{ True }}"})
def test_builtins01(self):
output = self.engine.render_to_string("builtins01")
self.assertEqual(output, "True")
@setup({"builtins02": "{{ False }}"})
def test_builtins02(self):
output = self.engine.render_to_string("builtins02")
self.assertEqual(output, "False")
@setup({"builtins03": "{{ None }}"})
def test_builtins03(self):
output = self.engine.render_to_string("builtins03")
self.assertEqual(output, "None")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_numpy.py | tests/template_tests/syntax_tests/test_numpy.py | from unittest import skipIf
from django.test import SimpleTestCase
from ..utils import setup
try:
import numpy
except ImportError:
numpy = False
@skipIf(numpy is False, "Numpy must be installed to run these tests.")
class NumpyTests(SimpleTestCase):
@setup({"numpy-array-index01": "{{ var.1 }}"})
def test_numpy_array_index01(self):
"""
Numpy's array-index syntax allows a template to access a certain
item of a subscriptable object.
"""
output = self.engine.render_to_string(
"numpy-array-index01",
{"var": numpy.array(["first item", "second item"])},
)
self.assertEqual(output, "second item")
@setup({"numpy-array-index02": "{{ var.5 }}"})
def test_numpy_array_index02(self):
"""
Fail silently when the array index is out of range.
"""
output = self.engine.render_to_string(
"numpy-array-index02",
{"var": numpy.array(["first item", "second item"])},
)
if self.engine.string_if_invalid:
self.assertEqual(output, "INVALID")
else:
self.assertEqual(output, "")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_comment.py | tests/template_tests/syntax_tests/test_comment.py | from django.test import SimpleTestCase
from ..utils import setup
class CommentSyntaxTests(SimpleTestCase):
@setup({"comment-syntax01": "{# this is hidden #}hello"})
def test_comment_syntax01(self):
output = self.engine.render_to_string("comment-syntax01")
self.assertEqual(output, "hello")
@setup({"comment-syntax02": "{# this is hidden #}hello{# foo #}"})
def test_comment_syntax02(self):
output = self.engine.render_to_string("comment-syntax02")
self.assertEqual(output, "hello")
@setup({"comment-syntax03": "foo{# {% if %} #}"})
def test_comment_syntax03(self):
output = self.engine.render_to_string("comment-syntax03")
self.assertEqual(output, "foo")
@setup({"comment-syntax04": "foo{# {% endblock %} #}"})
def test_comment_syntax04(self):
output = self.engine.render_to_string("comment-syntax04")
self.assertEqual(output, "foo")
@setup({"comment-syntax05": "foo{# {% somerandomtag %} #}"})
def test_comment_syntax05(self):
output = self.engine.render_to_string("comment-syntax05")
self.assertEqual(output, "foo")
@setup({"comment-syntax06": "foo{# {% #}"})
def test_comment_syntax06(self):
output = self.engine.render_to_string("comment-syntax06")
self.assertEqual(output, "foo")
@setup({"comment-syntax07": "foo{# %} #}"})
def test_comment_syntax07(self):
output = self.engine.render_to_string("comment-syntax07")
self.assertEqual(output, "foo")
@setup({"comment-syntax08": "foo{# %} #}bar"})
def test_comment_syntax08(self):
output = self.engine.render_to_string("comment-syntax08")
self.assertEqual(output, "foobar")
@setup({"comment-syntax09": "foo{# {{ #}"})
def test_comment_syntax09(self):
output = self.engine.render_to_string("comment-syntax09")
self.assertEqual(output, "foo")
@setup({"comment-syntax10": "foo{# }} #}"})
def test_comment_syntax10(self):
output = self.engine.render_to_string("comment-syntax10")
self.assertEqual(output, "foo")
@setup({"comment-syntax11": "foo{# { #}"})
def test_comment_syntax11(self):
output = self.engine.render_to_string("comment-syntax11")
self.assertEqual(output, "foo")
@setup({"comment-syntax12": "foo{# } #}"})
def test_comment_syntax12(self):
output = self.engine.render_to_string("comment-syntax12")
self.assertEqual(output, "foo")
@setup({"comment-tag01": "{% comment %}this is hidden{% endcomment %}hello"})
def test_comment_tag01(self):
output = self.engine.render_to_string("comment-tag01")
self.assertEqual(output, "hello")
@setup(
{
"comment-tag02": "{% comment %}this is hidden{% endcomment %}"
"hello{% comment %}foo{% endcomment %}"
}
)
def test_comment_tag02(self):
output = self.engine.render_to_string("comment-tag02")
self.assertEqual(output, "hello")
@setup({"comment-tag03": "foo{% comment %} {% if %} {% endcomment %}"})
def test_comment_tag03(self):
output = self.engine.render_to_string("comment-tag03")
self.assertEqual(output, "foo")
@setup({"comment-tag04": "foo{% comment %} {% endblock %} {% endcomment %}"})
def test_comment_tag04(self):
output = self.engine.render_to_string("comment-tag04")
self.assertEqual(output, "foo")
@setup({"comment-tag05": "foo{% comment %} {% somerandomtag %} {% endcomment %}"})
def test_comment_tag05(self):
output = self.engine.render_to_string("comment-tag05")
self.assertEqual(output, "foo")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_autoescape.py | tests/template_tests/syntax_tests/test_autoescape.py | from django.template import TemplateSyntaxError
from django.test import SimpleTestCase
from django.utils.safestring import mark_safe
from ..utils import SafeClass, UnsafeClass, setup
class AutoescapeTagTests(SimpleTestCase):
@setup({"autoescape-tag01": "{% autoescape off %}hello{% endautoescape %}"})
def test_autoescape_tag01(self):
output = self.engine.render_to_string("autoescape-tag01")
self.assertEqual(output, "hello")
@setup({"autoescape-tag02": "{% autoescape off %}{{ first }}{% endautoescape %}"})
def test_autoescape_tag02(self):
output = self.engine.render_to_string(
"autoescape-tag02", {"first": "<b>hello</b>"}
)
self.assertEqual(output, "<b>hello</b>")
@setup({"autoescape-tag03": "{% autoescape on %}{{ first }}{% endautoescape %}"})
def test_autoescape_tag03(self):
output = self.engine.render_to_string(
"autoescape-tag03", {"first": "<b>hello</b>"}
)
self.assertEqual(output, "<b>hello</b>")
# Autoescape disabling and enabling nest in a predictable way.
@setup(
{
"autoescape-tag04": (
"{% autoescape off %}{{ first }} {% autoescape on %}{{ first }}"
"{% endautoescape %}{% endautoescape %}"
)
}
)
def test_autoescape_tag04(self):
output = self.engine.render_to_string("autoescape-tag04", {"first": "<a>"})
self.assertEqual(output, "<a> <a>")
@setup({"autoescape-tag05": "{% autoescape on %}{{ first }}{% endautoescape %}"})
def test_autoescape_tag05(self):
output = self.engine.render_to_string(
"autoescape-tag05", {"first": "<b>first</b>"}
)
self.assertEqual(output, "<b>first</b>")
# Strings (ASCII or Unicode) already marked as "safe" are not
# auto-escaped
@setup({"autoescape-tag06": "{{ first }}"})
def test_autoescape_tag06(self):
output = self.engine.render_to_string(
"autoescape-tag06", {"first": mark_safe("<b>first</b>")}
)
self.assertEqual(output, "<b>first</b>")
@setup({"autoescape-tag07": "{% autoescape on %}{{ first }}{% endautoescape %}"})
def test_autoescape_tag07(self):
output = self.engine.render_to_string(
"autoescape-tag07", {"first": mark_safe("<b>Apple</b>")}
)
self.assertEqual(output, "<b>Apple</b>")
@setup(
{
"autoescape-tag08": (
r'{% autoescape on %}{{ var|default_if_none:" endquote\" hah" }}'
r"{% endautoescape %}"
)
}
)
def test_autoescape_tag08(self):
"""
Literal string arguments to filters, if used in the result, are safe.
"""
output = self.engine.render_to_string("autoescape-tag08", {"var": None})
self.assertEqual(output, ' endquote" hah')
# Objects which return safe strings as their __str__ method
# won't get double-escaped.
@setup({"autoescape-tag09": r"{{ unsafe }}"})
def test_autoescape_tag09(self):
output = self.engine.render_to_string(
"autoescape-tag09", {"unsafe": UnsafeClass()}
)
self.assertEqual(output, "you & me")
@setup({"autoescape-tag10": r"{{ safe }}"})
def test_autoescape_tag10(self):
output = self.engine.render_to_string("autoescape-tag10", {"safe": SafeClass()})
self.assertEqual(output, "you > me")
@setup(
{
"autoescape-filtertag01": (
"{{ first }}{% filter safe %}{{ first }} x<y{% endfilter %}"
)
}
)
def test_autoescape_filtertag01(self):
"""
The "safe" and "escape" filters cannot work due to internal
implementation details (fortunately, the (no)autoescape block
tags can be used in those cases)
"""
with self.assertRaises(TemplateSyntaxError):
self.engine.render_to_string("autoescape-filtertag01", {"first": "<a>"})
# Arguments to filters are 'safe' and manipulate their input unescaped.
@setup({"autoescape-filters01": '{{ var|cut:"&" }}'})
def test_autoescape_filters01(self):
output = self.engine.render_to_string(
"autoescape-filters01", {"var": "this & that"}
)
self.assertEqual(output, "this that")
@setup({"autoescape-filters02": '{{ var|join:" & " }}'})
def test_autoescape_filters02(self):
output = self.engine.render_to_string(
"autoescape-filters02", {"var": ("Tom", "Dick", "Harry")}
)
self.assertEqual(output, "Tom & Dick & Harry")
@setup({"autoescape-literals01": '{{ "this & that" }}'})
def test_autoescape_literals01(self):
"""
Literal strings are safe.
"""
output = self.engine.render_to_string("autoescape-literals01")
self.assertEqual(output, "this & that")
@setup({"autoescape-stringiterations01": "{% for l in var %}{{ l }},{% endfor %}"})
def test_autoescape_stringiterations01(self):
"""
Iterating over strings outputs safe characters.
"""
output = self.engine.render_to_string(
"autoescape-stringiterations01", {"var": "K&R"}
)
self.assertEqual(output, "K,&,R,")
@setup({"autoescape-lookup01": "{{ var.key }}"})
def test_autoescape_lookup01(self):
"""
Escape requirement survives lookup.
"""
output = self.engine.render_to_string(
"autoescape-lookup01", {"var": {"key": "this & that"}}
)
self.assertEqual(output, "this & that")
@setup(
{
"autoescape-incorrect-arg": (
"{% autoescape true %}{{ var.key }}{% endautoescape %}"
)
}
)
def test_invalid_arg(self):
msg = "'autoescape' argument should be 'on' or 'off'"
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.render_to_string(
"autoescape-incorrect-arg", {"var": {"key": "this & that"}}
)
@setup(
{"autoescape-incorrect-arg": "{% autoescape %}{{ var.key }}{% endautoescape %}"}
)
def test_no_arg(self):
msg = "'autoescape' tag requires exactly one argument."
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.render_to_string(
"autoescape-incorrect-arg", {"var": {"key": "this & that"}}
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_static.py | tests/template_tests/syntax_tests/test_static.py | from urllib.parse import urljoin
from django.conf import settings
from django.template import TemplateSyntaxError
from django.templatetags.static import StaticNode
from django.test import SimpleTestCase, override_settings
from ..utils import setup
@override_settings(INSTALLED_APPS=[], MEDIA_URL="media/", STATIC_URL="static/")
class StaticTagTests(SimpleTestCase):
libraries = {"static": "django.templatetags.static"}
@setup({"static-prefixtag01": "{% load static %}{% get_static_prefix %}"})
def test_static_prefixtag01(self):
output = self.engine.render_to_string("static-prefixtag01")
self.assertEqual(output, settings.STATIC_URL)
@setup(
{
"static-prefixtag02": "{% load static %}"
"{% get_static_prefix as static_prefix %}{{ static_prefix }}"
}
)
def test_static_prefixtag02(self):
output = self.engine.render_to_string("static-prefixtag02")
self.assertEqual(output, settings.STATIC_URL)
@setup({"static-prefixtag03": "{% load static %}{% get_media_prefix %}"})
def test_static_prefixtag03(self):
output = self.engine.render_to_string("static-prefixtag03")
self.assertEqual(output, settings.MEDIA_URL)
@setup(
{
"static-prefixtag04": "{% load static %}"
"{% get_media_prefix as media_prefix %}{{ media_prefix }}"
}
)
def test_static_prefixtag04(self):
output = self.engine.render_to_string("static-prefixtag04")
self.assertEqual(output, settings.MEDIA_URL)
@setup(
{
"t": (
"{% load static %}{% get_media_prefix ad media_prefix %}"
"{{ media_prefix }}"
)
}
)
def test_static_prefixtag_without_as(self):
msg = "First argument in 'get_media_prefix' must be 'as'"
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.render_to_string("t")
@setup({"static-statictag01": '{% load static %}{% static "admin/base.css" %}'})
def test_static_statictag01(self):
output = self.engine.render_to_string("static-statictag01")
self.assertEqual(output, urljoin(settings.STATIC_URL, "admin/base.css"))
@setup({"static-statictag02": "{% load static %}{% static base_css %}"})
def test_static_statictag02(self):
output = self.engine.render_to_string(
"static-statictag02", {"base_css": "admin/base.css"}
)
self.assertEqual(output, urljoin(settings.STATIC_URL, "admin/base.css"))
@setup(
{
"static-statictag03": (
'{% load static %}{% static "admin/base.css" as foo %}{{ foo }}'
)
}
)
def test_static_statictag03(self):
output = self.engine.render_to_string("static-statictag03")
self.assertEqual(output, urljoin(settings.STATIC_URL, "admin/base.css"))
@setup(
{"static-statictag04": "{% load static %}{% static base_css as foo %}{{ foo }}"}
)
def test_static_statictag04(self):
output = self.engine.render_to_string(
"static-statictag04", {"base_css": "admin/base.css"}
)
self.assertEqual(output, urljoin(settings.STATIC_URL, "admin/base.css"))
@setup(
{
"static-statictag05": (
'{% load static %}{% static "special?chars"ed.html" %}'
)
}
)
def test_static_quotes_urls(self):
output = self.engine.render_to_string("static-statictag05")
self.assertEqual(
output,
urljoin(settings.STATIC_URL, "/static/special%3Fchars%26quoted.html"),
)
@setup({"t": "{% load static %}{% static %}"})
def test_static_statictag_without_path(self):
msg = "'static' takes at least one argument (path to file)"
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.render_to_string("t")
class StaticNodeTests(SimpleTestCase):
def test_repr(self):
static_node = StaticNode(varname="named-var", path="named-path")
self.assertEqual(
repr(static_node),
"StaticNode(varname='named-var', path='named-path')",
)
static_node = StaticNode(path="named-path")
self.assertEqual(
repr(static_node),
"StaticNode(varname=None, path='named-path')",
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_setup.py | tests/template_tests/syntax_tests/test_setup.py | from django.test import SimpleTestCase
from ..utils import setup
class SetupTests(SimpleTestCase):
def test_setup(self):
"""
Let's just make sure setup runs cases in the right order.
"""
cases = []
@setup({})
def method(self):
cases.append(
[
self.engine.string_if_invalid,
self.engine.debug,
]
)
method(self)
self.assertEqual(cases[0], ["", False])
self.assertEqual(cases[1], ["", False])
self.assertEqual(cases[2], ["INVALID", False])
self.assertEqual(cases[3], ["INVALID", False])
self.assertEqual(cases[4], ["", True])
self.assertEqual(cases[5], ["", True])
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/test_firstof.py | tests/template_tests/syntax_tests/test_firstof.py | from django.template import TemplateSyntaxError
from django.test import SimpleTestCase
from ..utils import setup
class FirstOfTagTests(SimpleTestCase):
@setup({"firstof01": "{% firstof a b c %}"})
def test_firstof01(self):
output = self.engine.render_to_string("firstof01", {"a": 0, "c": 0, "b": 0})
self.assertEqual(output, "")
@setup({"firstof02": "{% firstof a b c %}"})
def test_firstof02(self):
output = self.engine.render_to_string("firstof02", {"a": 1, "c": 0, "b": 0})
self.assertEqual(output, "1")
@setup({"firstof03": "{% firstof a b c %}"})
def test_firstof03(self):
output = self.engine.render_to_string("firstof03", {"a": 0, "c": 0, "b": 2})
self.assertEqual(output, "2")
@setup({"firstof04": "{% firstof a b c %}"})
def test_firstof04(self):
output = self.engine.render_to_string("firstof04", {"a": 0, "c": 3, "b": 0})
self.assertEqual(output, "3")
@setup({"firstof05": "{% firstof a b c %}"})
def test_firstof05(self):
output = self.engine.render_to_string("firstof05", {"a": 1, "c": 3, "b": 2})
self.assertEqual(output, "1")
@setup({"firstof06": "{% firstof a b c %}"})
def test_firstof06(self):
output = self.engine.render_to_string("firstof06", {"c": 3, "b": 0})
self.assertEqual(output, "3")
@setup({"firstof07": '{% firstof a b "c" %}'})
def test_firstof07(self):
output = self.engine.render_to_string("firstof07", {"a": 0})
self.assertEqual(output, "c")
@setup({"firstof08": '{% firstof a b "c and d" %}'})
def test_firstof08(self):
output = self.engine.render_to_string("firstof08", {"a": 0, "b": 0})
self.assertEqual(output, "c and d")
@setup({"firstof09": "{% firstof %}"})
def test_firstof09(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("firstof09")
@setup({"firstof10": "{% firstof a %}"})
def test_firstof10(self):
output = self.engine.render_to_string("firstof10", {"a": "<"})
self.assertEqual(output, "<")
@setup({"firstof11": "{% firstof a b %}"})
def test_firstof11(self):
output = self.engine.render_to_string("firstof11", {"a": "<", "b": ">"})
self.assertEqual(output, "<")
@setup({"firstof12": "{% firstof a b %}"})
def test_firstof12(self):
output = self.engine.render_to_string("firstof12", {"a": "", "b": ">"})
self.assertEqual(output, ">")
@setup({"firstof13": "{% autoescape off %}{% firstof a %}{% endautoescape %}"})
def test_firstof13(self):
output = self.engine.render_to_string("firstof13", {"a": "<"})
self.assertEqual(output, "<")
@setup({"firstof14": "{% firstof a|safe b %}"})
def test_firstof14(self):
output = self.engine.render_to_string("firstof14", {"a": "<"})
self.assertEqual(output, "<")
@setup({"firstof15": "{% firstof a b c as myvar %}"})
def test_firstof15(self):
ctx = {"a": 0, "b": 2, "c": 3}
output = self.engine.render_to_string("firstof15", ctx)
self.assertEqual(ctx["myvar"], "2")
self.assertEqual(output, "")
@setup({"firstof16": "{% firstof a b c as myvar %}"})
def test_all_false_arguments_asvar(self):
ctx = {"a": 0, "b": 0, "c": 0}
output = self.engine.render_to_string("firstof16", ctx)
self.assertEqual(ctx["myvar"], "")
self.assertEqual(output, "")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/syntax_tests/__init__.py | tests/template_tests/syntax_tests/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.