hash
stringlengths 64
64
| content
stringlengths 0
1.51M
|
|---|---|
01fc950e48c7f12ffa2e0e8ff1eface8b1870a7977052e0db77843010ce3b4ad | from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = []
operations = [
migrations.CreateModel(
"OtherAuthor",
[
("id", models.AutoField(primary_key=True)),
("name", models.CharField(max_length=255)),
("slug", models.SlugField(null=True)),
("age", models.IntegerField(default=0)),
("silly_field", models.BooleanField(default=False)),
],
),
]
|
26c7b35d5808f2655faf9f92353454a1fe7ae5afe3e8cd3f82066c7e2b21d06b | from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [("migrations", "0002_second")]
operations = [
migrations.CreateModel(
"OtherAuthor",
[
("id", models.AutoField(primary_key=True)),
("name", models.CharField(max_length=255)),
("slug", models.SlugField(null=True)),
("age", models.IntegerField(default=0)),
("silly_field", models.BooleanField(default=False)),
],
),
]
|
eda179ce9c029a06ae760571d529240073ec86e214f78b2cb72a8b22c7d94aae | 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")
|
73b0d22a98a89f431cf48ad627e1ccbd15b94f018bf32ed2dd6b4f8bf8d55a90 | 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>")
|
7b977d28f3d0ebf172ddb4de1e0e068cfa5eaece091ef837d21b3ab77ac88ddf | from django.template import (
Context,
Engine,
TemplateDoesNotExist,
TemplateSyntaxError,
loader,
)
from django.template.loader_tags import IncludeNode
from django.test import SimpleTestCase
from ..utils import setup
from .test_basic import basic_templates
include_fail_templates = {
"include-fail1": "{% load bad_tag %}{% badtag %}",
"include-fail2": "{% load broken_tag %}",
}
class IncludeTagTests(SimpleTestCase):
libraries = {"bad_tag": "template_tests.templatetags.bad_tag"}
@setup({"include01": '{% include "basic-syntax01" %}'}, basic_templates)
def test_include01(self):
output = self.engine.render_to_string("include01")
self.assertEqual(output, "something cool")
@setup({"include02": '{% include "basic-syntax02" %}'}, basic_templates)
def test_include02(self):
output = self.engine.render_to_string("include02", {"headline": "Included"})
self.assertEqual(output, "Included")
@setup({"include03": "{% include template_name %}"}, basic_templates)
def test_include03(self):
output = self.engine.render_to_string(
"include03",
{"template_name": "basic-syntax02", "headline": "Included"},
)
self.assertEqual(output, "Included")
@setup({"include04": 'a{% include "nonexistent" %}b'})
def test_include04(self):
template = self.engine.get_template("include04")
with self.assertRaises(TemplateDoesNotExist):
template.render(Context({}))
@setup(
{
"include 05": "template with a space",
"include06": '{% include "include 05"%}',
}
)
def test_include06(self):
output = self.engine.render_to_string("include06")
self.assertEqual(output, "template with a space")
@setup(
{"include07": '{% include "basic-syntax02" with headline="Inline" %}'},
basic_templates,
)
def test_include07(self):
output = self.engine.render_to_string("include07", {"headline": "Included"})
self.assertEqual(output, "Inline")
@setup(
{"include08": '{% include headline with headline="Dynamic" %}'}, basic_templates
)
def test_include08(self):
output = self.engine.render_to_string(
"include08", {"headline": "basic-syntax02"}
)
self.assertEqual(output, "Dynamic")
@setup(
{
"include09": (
"{{ first }}--"
'{% include "basic-syntax03" with '
"first=second|lower|upper second=first|upper %}"
"--{{ second }}"
)
},
basic_templates,
)
def test_include09(self):
output = self.engine.render_to_string(
"include09", {"first": "Ul", "second": "lU"}
)
self.assertEqual(output, "Ul--LU --- UL--lU")
@setup({"include10": '{% include "basic-syntax03" only %}'}, basic_templates)
def test_include10(self):
output = self.engine.render_to_string("include10", {"first": "1"})
if self.engine.string_if_invalid:
self.assertEqual(output, "INVALID --- INVALID")
else:
self.assertEqual(output, " --- ")
@setup(
{"include11": '{% include "basic-syntax03" only with second=2 %}'},
basic_templates,
)
def test_include11(self):
output = self.engine.render_to_string("include11", {"first": "1"})
if self.engine.string_if_invalid:
self.assertEqual(output, "INVALID --- 2")
else:
self.assertEqual(output, " --- 2")
@setup(
{"include12": '{% include "basic-syntax03" with first=1 only %}'},
basic_templates,
)
def test_include12(self):
output = self.engine.render_to_string("include12", {"second": "2"})
if self.engine.string_if_invalid:
self.assertEqual(output, "1 --- INVALID")
else:
self.assertEqual(output, "1 --- ")
@setup(
{
"include13": (
'{% autoescape off %}{% include "basic-syntax03" %}{% endautoescape %}'
)
},
basic_templates,
)
def test_include13(self):
output = self.engine.render_to_string("include13", {"first": "&"})
if self.engine.string_if_invalid:
self.assertEqual(output, "& --- INVALID")
else:
self.assertEqual(output, "& --- ")
@setup(
{
"include14": "{% autoescape off %}"
'{% include "basic-syntax03" with first=var1 only %}'
"{% endautoescape %}"
},
basic_templates,
)
def test_include14(self):
output = self.engine.render_to_string("include14", {"var1": "&"})
if self.engine.string_if_invalid:
self.assertEqual(output, "& --- INVALID")
else:
self.assertEqual(output, "& --- ")
# Include syntax errors
@setup({"include-error01": '{% include "basic-syntax01" with %}'})
def test_include_error01(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("include-error01")
@setup({"include-error02": '{% include "basic-syntax01" with "no key" %}'})
def test_include_error02(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("include-error02")
@setup(
{"include-error03": '{% include "basic-syntax01" with dotted.arg="error" %}'}
)
def test_include_error03(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("include-error03")
@setup({"include-error04": '{% include "basic-syntax01" something_random %}'})
def test_include_error04(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("include-error04")
@setup(
{"include-error05": '{% include "basic-syntax01" foo="duplicate" foo="key" %}'}
)
def test_include_error05(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("include-error05")
@setup({"include-error06": '{% include "basic-syntax01" only only %}'})
def test_include_error06(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("include-error06")
@setup(include_fail_templates)
def test_include_fail1(self):
with self.assertRaises(RuntimeError):
self.engine.get_template("include-fail1")
@setup(include_fail_templates)
def test_include_fail2(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("include-fail2")
@setup({"include-error07": '{% include "include-fail1" %}'}, include_fail_templates)
def test_include_error07(self):
template = self.engine.get_template("include-error07")
with self.assertRaises(RuntimeError):
template.render(Context())
@setup({"include-error08": '{% include "include-fail2" %}'}, include_fail_templates)
def test_include_error08(self):
template = self.engine.get_template("include-error08")
with self.assertRaises(TemplateSyntaxError):
template.render(Context())
@setup({"include-error09": "{% include failed_include %}"}, include_fail_templates)
def test_include_error09(self):
context = Context({"failed_include": "include-fail1"})
template = self.engine.get_template("include-error09")
with self.assertRaises(RuntimeError):
template.render(context)
@setup({"include-error10": "{% include failed_include %}"}, include_fail_templates)
def test_include_error10(self):
context = Context({"failed_include": "include-fail2"})
template = self.engine.get_template("include-error10")
with self.assertRaises(TemplateSyntaxError):
template.render(context)
@setup({"include_empty": "{% include %}"})
def test_include_empty(self):
msg = (
"'include' tag takes at least one argument: the name of the "
"template to be included."
)
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.get_template("include_empty")
class IncludeTests(SimpleTestCase):
def test_include_missing_template(self):
"""
The correct template is identified as not existing
when {% include %} specifies a template that does not exist.
"""
engine = Engine(app_dirs=True, debug=True)
template = engine.get_template("test_include_error.html")
with self.assertRaisesMessage(TemplateDoesNotExist, "missing.html"):
template.render(Context())
def test_extends_include_missing_baseloader(self):
"""
#12787 -- The correct template is identified as not existing
when {% extends %} specifies a template that does exist, but that
template has an {% include %} of something that does not exist.
"""
engine = Engine(app_dirs=True, debug=True)
template = engine.get_template("test_extends_error.html")
with self.assertRaisesMessage(TemplateDoesNotExist, "missing.html"):
template.render(Context())
def test_extends_include_missing_cachedloader(self):
engine = Engine(
debug=True,
loaders=[
(
"django.template.loaders.cached.Loader",
[
"django.template.loaders.app_directories.Loader",
],
),
],
)
template = engine.get_template("test_extends_error.html")
with self.assertRaisesMessage(TemplateDoesNotExist, "missing.html"):
template.render(Context())
# Repeat to ensure it still works when loading from the cache
template = engine.get_template("test_extends_error.html")
with self.assertRaisesMessage(TemplateDoesNotExist, "missing.html"):
template.render(Context())
def test_include_template_argument(self):
"""
Support any render() supporting object
"""
engine = Engine()
ctx = Context(
{
"tmpl": engine.from_string("This worked!"),
}
)
outer_tmpl = engine.from_string("{% include tmpl %}")
output = outer_tmpl.render(ctx)
self.assertEqual(output, "This worked!")
def test_include_template_iterable(self):
engine = Engine.get_default()
outer_temp = engine.from_string("{% include var %}")
tests = [
("admin/fail.html", "index.html"),
["admin/fail.html", "index.html"],
]
for template_names in tests:
with self.subTest(template_names):
output = outer_temp.render(Context({"var": template_names}))
self.assertEqual(output, "index\n")
def test_include_template_none(self):
engine = Engine.get_default()
outer_temp = engine.from_string("{% include var %}")
ctx = Context({"var": None})
msg = "No template names provided"
with self.assertRaisesMessage(TemplateDoesNotExist, msg):
outer_temp.render(ctx)
def test_include_from_loader_get_template(self):
tmpl = loader.get_template("include_tpl.html") # {% include tmpl %}
output = tmpl.render({"tmpl": loader.get_template("index.html")})
self.assertEqual(output, "index\n\n")
def test_include_immediate_missing(self):
"""
#16417 -- Include tags pointing to missing templates should not raise
an error at parsing time.
"""
Engine(debug=True).from_string('{% include "this_does_not_exist.html" %}')
def test_include_recursive(self):
comments = [
{
"comment": "A1",
"children": [
{"comment": "B1", "children": []},
{"comment": "B2", "children": []},
{"comment": "B3", "children": [{"comment": "C1", "children": []}]},
],
}
]
engine = Engine(app_dirs=True)
t = engine.get_template("recursive_include.html")
self.assertEqual(
"Recursion! A1 Recursion! B1 B2 B3 Recursion! C1",
t.render(Context({"comments": comments}))
.replace(" ", "")
.replace("\n", " ")
.strip(),
)
def test_include_cache(self):
"""
{% include %} keeps resolved templates constant (#27974). The
CounterNode object in the {% counter %} template tag is created once
if caching works properly. Each iteration increases the counter instead
of restarting it.
This works as a regression test only if the cached loader
isn't used, so the @setup decorator isn't used.
"""
engine = Engine(
loaders=[
(
"django.template.loaders.locmem.Loader",
{
"template": (
'{% for x in vars %}{% include "include" %}{% endfor %}'
),
"include": '{% include "next" %}',
"next": "{% load custom %}{% counter %}",
},
),
],
libraries={"custom": "template_tests.templatetags.custom"},
)
output = engine.render_to_string("template", {"vars": range(9)})
self.assertEqual(output, "012345678")
class IncludeNodeTests(SimpleTestCase):
def test_repr(self):
include_node = IncludeNode("app/template.html")
self.assertEqual(
repr(include_node),
"<IncludeNode: template='app/template.html'>",
)
|
3b66ba779add0541507cafe2ff97bb92ab2f3fa9521ddbbf0c6bd4546d328e45 | 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")
|
65b7092f4e0657810655fae93cf749bdf1fcee18166cecddb81df153302963b9 | 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, "")
|
7b1c443c2fdf241fa59d4ef5bfca0884368f33da1a362c9dc48d08c150c48fa0 | 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')",
)
|
574fa88864623bbb397dc580debf8eb6e1957392e032b7e56571909d3a92148c | 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()})
|
bf153898b90e0492e77098bb82044eaf8a95c0aebfa195d9a0e1ff58ae5f4aef | from django.template.base import TemplateSyntaxError
from django.template.context import Context
from django.template.loader_tags import BlockContext, BlockNode
from django.test import SimpleTestCase
from ..utils import SilentAttrClass, SilentGetItemClass, SomeClass, setup
basic_templates = {
"basic-syntax01": "something cool",
"basic-syntax02": "{{ headline }}",
"basic-syntax03": "{{ first }} --- {{ second }}",
}
class BasicSyntaxTests(SimpleTestCase):
@setup(basic_templates)
def test_basic_syntax01(self):
"""
Plain text should go through the template parser untouched.
"""
output = self.engine.render_to_string("basic-syntax01")
self.assertEqual(output, "something cool")
@setup(basic_templates)
def test_basic_syntax02(self):
"""
Variables should be replaced with their value in the current
context
"""
output = self.engine.render_to_string("basic-syntax02", {"headline": "Success"})
self.assertEqual(output, "Success")
@setup(basic_templates)
def test_basic_syntax03(self):
"""
More than one replacement variable is allowed in a template
"""
output = self.engine.render_to_string(
"basic-syntax03", {"first": 1, "second": 2}
)
self.assertEqual(output, "1 --- 2")
@setup({"basic-syntax04": "as{{ missing }}df"})
def test_basic_syntax04(self):
"""
Fail silently when a variable is not found in the current context
"""
output = self.engine.render_to_string("basic-syntax04")
if self.engine.string_if_invalid:
self.assertEqual(output, "asINVALIDdf")
else:
self.assertEqual(output, "asdf")
@setup({"basic-syntax06": "{{ multi word variable }}"})
def test_basic_syntax06(self):
"""
A variable may not contain more than one word
"""
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("basic-syntax06")
@setup({"basic-syntax07": "{{ }}"})
def test_basic_syntax07(self):
"""
Raise TemplateSyntaxError for empty variable tags.
"""
with self.assertRaisesMessage(
TemplateSyntaxError, "Empty variable tag on line 1"
):
self.engine.get_template("basic-syntax07")
@setup({"basic-syntax08": "{{ }}"})
def test_basic_syntax08(self):
"""
Raise TemplateSyntaxError for empty variable tags.
"""
with self.assertRaisesMessage(
TemplateSyntaxError, "Empty variable tag on line 1"
):
self.engine.get_template("basic-syntax08")
@setup({"basic-syntax09": "{{ var.method }}"})
def test_basic_syntax09(self):
"""
Attribute syntax allows a template to call an object's attribute
"""
output = self.engine.render_to_string("basic-syntax09", {"var": SomeClass()})
self.assertEqual(output, "SomeClass.method")
@setup({"basic-syntax10": "{{ var.otherclass.method }}"})
def test_basic_syntax10(self):
"""
Multiple levels of attribute access are allowed.
"""
output = self.engine.render_to_string("basic-syntax10", {"var": SomeClass()})
self.assertEqual(output, "OtherClass.method")
@setup({"basic-syntax11": "{{ var.blech }}"})
def test_basic_syntax11(self):
"""
Fail silently when a variable's attribute isn't found.
"""
output = self.engine.render_to_string("basic-syntax11", {"var": SomeClass()})
if self.engine.string_if_invalid:
self.assertEqual(output, "INVALID")
else:
self.assertEqual(output, "")
@setup({"basic-syntax12": "{{ var.__dict__ }}"})
def test_basic_syntax12(self):
"""
Raise TemplateSyntaxError when trying to access a variable
beginning with an underscore.
"""
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("basic-syntax12")
# Raise TemplateSyntaxError when trying to access a variable
# containing an illegal character.
@setup({"basic-syntax13": "{{ va>r }}"})
def test_basic_syntax13(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("basic-syntax13")
@setup({"basic-syntax14": "{{ (var.r) }}"})
def test_basic_syntax14(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("basic-syntax14")
@setup({"basic-syntax15": "{{ sp%am }}"})
def test_basic_syntax15(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("basic-syntax15")
@setup({"basic-syntax16": "{{ eggs! }}"})
def test_basic_syntax16(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("basic-syntax16")
@setup({"basic-syntax17": "{{ moo? }}"})
def test_basic_syntax17(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("basic-syntax17")
@setup({"basic-syntax18": "{{ foo.bar }}"})
def test_basic_syntax18(self):
"""
Attribute syntax allows a template to call a dictionary key's
value.
"""
output = self.engine.render_to_string("basic-syntax18", {"foo": {"bar": "baz"}})
self.assertEqual(output, "baz")
@setup({"basic-syntax19": "{{ foo.spam }}"})
def test_basic_syntax19(self):
"""
Fail silently when a variable's dictionary key isn't found.
"""
output = self.engine.render_to_string("basic-syntax19", {"foo": {"bar": "baz"}})
if self.engine.string_if_invalid:
self.assertEqual(output, "INVALID")
else:
self.assertEqual(output, "")
@setup({"basic-syntax20": "{{ var.method2 }}"})
def test_basic_syntax20(self):
"""
Fail silently when accessing a non-simple method
"""
output = self.engine.render_to_string("basic-syntax20", {"var": SomeClass()})
if self.engine.string_if_invalid:
self.assertEqual(output, "INVALID")
else:
self.assertEqual(output, "")
@setup({"basic-syntax20b": "{{ var.method5 }}"})
def test_basic_syntax20b(self):
"""
Don't silence a TypeError if it was raised inside a callable.
"""
template = self.engine.get_template("basic-syntax20b")
with self.assertRaises(TypeError):
template.render(Context({"var": SomeClass()}))
# Don't get confused when parsing something that is almost, but not
# quite, a template tag.
@setup({"basic-syntax21": "a {{ moo %} b"})
def test_basic_syntax21(self):
output = self.engine.render_to_string("basic-syntax21")
self.assertEqual(output, "a {{ moo %} b")
@setup({"basic-syntax22": "{{ moo #}"})
def test_basic_syntax22(self):
output = self.engine.render_to_string("basic-syntax22")
self.assertEqual(output, "{{ moo #}")
@setup({"basic-syntax23": "{{ moo #} {{ cow }}"})
def test_basic_syntax23(self):
"""
Treat "moo #} {{ cow" as the variable. Not ideal, but costly to work
around, so this triggers an error.
"""
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("basic-syntax23")
@setup({"basic-syntax24": "{{ moo\n }}"})
def test_basic_syntax24(self):
"""
Embedded newlines make it not-a-tag.
"""
output = self.engine.render_to_string("basic-syntax24")
self.assertEqual(output, "{{ moo\n }}")
# Literal strings are permitted inside variables, mostly for i18n
# purposes.
@setup({"basic-syntax25": '{{ "fred" }}'})
def test_basic_syntax25(self):
output = self.engine.render_to_string("basic-syntax25")
self.assertEqual(output, "fred")
@setup({"basic-syntax26": r'{{ "\"fred\"" }}'})
def test_basic_syntax26(self):
output = self.engine.render_to_string("basic-syntax26")
self.assertEqual(output, '"fred"')
@setup({"basic-syntax27": r'{{ _("\"fred\"") }}'})
def test_basic_syntax27(self):
output = self.engine.render_to_string("basic-syntax27")
self.assertEqual(output, '"fred"')
# #12554 -- Make sure a silent_variable_failure Exception is
# suppressed on dictionary and attribute lookup.
@setup({"basic-syntax28": "{{ a.b }}"})
def test_basic_syntax28(self):
output = self.engine.render_to_string(
"basic-syntax28", {"a": SilentGetItemClass()}
)
if self.engine.string_if_invalid:
self.assertEqual(output, "INVALID")
else:
self.assertEqual(output, "")
@setup({"basic-syntax29": "{{ a.b }}"})
def test_basic_syntax29(self):
output = self.engine.render_to_string(
"basic-syntax29", {"a": SilentAttrClass()}
)
if self.engine.string_if_invalid:
self.assertEqual(output, "INVALID")
else:
self.assertEqual(output, "")
# Something that starts like a number but has an extra lookup works
# as a lookup.
@setup({"basic-syntax30": "{{ 1.2.3 }}"})
def test_basic_syntax30(self):
output = self.engine.render_to_string(
"basic-syntax30", {"1": {"2": {"3": "d"}}}
)
self.assertEqual(output, "d")
@setup({"basic-syntax31": "{{ 1.2.3 }}"})
def test_basic_syntax31(self):
output = self.engine.render_to_string(
"basic-syntax31",
{"1": {"2": ("a", "b", "c", "d")}},
)
self.assertEqual(output, "d")
@setup({"basic-syntax32": "{{ 1.2.3 }}"})
def test_basic_syntax32(self):
output = self.engine.render_to_string(
"basic-syntax32",
{"1": (("x", "x", "x", "x"), ("y", "y", "y", "y"), ("a", "b", "c", "d"))},
)
self.assertEqual(output, "d")
@setup({"basic-syntax33": "{{ 1.2.3 }}"})
def test_basic_syntax33(self):
output = self.engine.render_to_string(
"basic-syntax33",
{"1": ("xxxx", "yyyy", "abcd")},
)
self.assertEqual(output, "d")
@setup({"basic-syntax34": "{{ 1.2.3 }}"})
def test_basic_syntax34(self):
output = self.engine.render_to_string(
"basic-syntax34", {"1": ({"x": "x"}, {"y": "y"}, {"z": "z", "3": "d"})}
)
self.assertEqual(output, "d")
# Numbers are numbers even if their digits are in the context.
@setup({"basic-syntax35": "{{ 1 }}"})
def test_basic_syntax35(self):
output = self.engine.render_to_string("basic-syntax35", {"1": "abc"})
self.assertEqual(output, "1")
@setup({"basic-syntax36": "{{ 1.2 }}"})
def test_basic_syntax36(self):
output = self.engine.render_to_string("basic-syntax36", {"1": "abc"})
self.assertEqual(output, "1.2")
@setup({"basic-syntax37": "{{ callable }}"})
def test_basic_syntax37(self):
"""
Call methods in the top level of the context.
"""
output = self.engine.render_to_string(
"basic-syntax37", {"callable": lambda: "foo bar"}
)
self.assertEqual(output, "foo bar")
@setup({"basic-syntax38": "{{ var.callable }}"})
def test_basic_syntax38(self):
"""
Call methods returned from dictionary lookups.
"""
output = self.engine.render_to_string(
"basic-syntax38", {"var": {"callable": lambda: "foo bar"}}
)
self.assertEqual(output, "foo bar")
@setup({"template": "{% block content %}"})
def test_unclosed_block(self):
msg = "Unclosed tag on line 1: 'block'. Looking for one of: endblock."
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.render_to_string("template")
@setup({"template": "{% if a %}"})
def test_unclosed_block2(self):
msg = "Unclosed tag on line 1: 'if'. Looking for one of: elif, else, endif."
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.render_to_string("template")
@setup({"tpl-str": "%s", "tpl-percent": "%%", "tpl-weird-percent": "% %s"})
def test_ignores_strings_that_look_like_format_interpolation(self):
output = self.engine.render_to_string("tpl-str")
self.assertEqual(output, "%s")
output = self.engine.render_to_string("tpl-percent")
self.assertEqual(output, "%%")
output = self.engine.render_to_string("tpl-weird-percent")
self.assertEqual(output, "% %s")
class BlockContextTests(SimpleTestCase):
def test_repr(self):
block_context = BlockContext()
block_context.add_blocks({"content": BlockNode("content", [])})
self.assertEqual(
repr(block_context),
"<BlockContext: blocks=defaultdict(<class 'list'>, "
"{'content': [<Block Node: content. Contents: []>]})>",
)
|
8cf8a82417ba93742a8e630cb7b93470f4198ced9d1f99bbafcee29247d28119 | 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")
|
4173cea31c326ddb3977e1675575101315fc9dd530cfb34c8d039cb026d1af0e | 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"}}
)
|
dda701664699b0d48bf8f3fb56a3ee3c7acb97d1f6c72c1cf7234bafc5494954 | from django.template import TemplateSyntaxError
from django.template.defaulttags import ForNode
from django.test import SimpleTestCase
from ..utils import setup
class ForTagTests(SimpleTestCase):
libraries = {"custom": "template_tests.templatetags.custom"}
@setup({"for-tag01": "{% for val in values %}{{ val }}{% endfor %}"})
def test_for_tag01(self):
output = self.engine.render_to_string("for-tag01", {"values": [1, 2, 3]})
self.assertEqual(output, "123")
@setup({"for-tag02": "{% for val in values reversed %}{{ val }}{% endfor %}"})
def test_for_tag02(self):
output = self.engine.render_to_string("for-tag02", {"values": [1, 2, 3]})
self.assertEqual(output, "321")
@setup(
{"for-tag-vars01": "{% for val in values %}{{ forloop.counter }}{% endfor %}"}
)
def test_for_tag_vars01(self):
output = self.engine.render_to_string("for-tag-vars01", {"values": [6, 6, 6]})
self.assertEqual(output, "123")
@setup(
{"for-tag-vars02": "{% for val in values %}{{ forloop.counter0 }}{% endfor %}"}
)
def test_for_tag_vars02(self):
output = self.engine.render_to_string("for-tag-vars02", {"values": [6, 6, 6]})
self.assertEqual(output, "012")
@setup(
{
"for-tag-vars03": (
"{% for val in values %}{{ forloop.revcounter }}{% endfor %}"
)
}
)
def test_for_tag_vars03(self):
output = self.engine.render_to_string("for-tag-vars03", {"values": [6, 6, 6]})
self.assertEqual(output, "321")
@setup(
{
"for-tag-vars04": (
"{% for val in values %}{{ forloop.revcounter0 }}{% endfor %}"
)
}
)
def test_for_tag_vars04(self):
output = self.engine.render_to_string("for-tag-vars04", {"values": [6, 6, 6]})
self.assertEqual(output, "210")
@setup(
{
"for-tag-vars05": "{% for val in values %}"
"{% if forloop.first %}f{% else %}x{% endif %}{% endfor %}"
}
)
def test_for_tag_vars05(self):
output = self.engine.render_to_string("for-tag-vars05", {"values": [6, 6, 6]})
self.assertEqual(output, "fxx")
@setup(
{
"for-tag-vars06": "{% for val in values %}"
"{% if forloop.last %}l{% else %}x{% endif %}{% endfor %}"
}
)
def test_for_tag_vars06(self):
output = self.engine.render_to_string("for-tag-vars06", {"values": [6, 6, 6]})
self.assertEqual(output, "xxl")
@setup(
{
"for-tag-unpack01": (
"{% for key,value in items %}{{ key }}:{{ value }}/{% endfor %}"
)
}
)
def test_for_tag_unpack01(self):
output = self.engine.render_to_string(
"for-tag-unpack01", {"items": (("one", 1), ("two", 2))}
)
self.assertEqual(output, "one:1/two:2/")
@setup(
{
"for-tag-unpack03": (
"{% for key, value in items %}{{ key }}:{{ value }}/{% endfor %}"
)
}
)
def test_for_tag_unpack03(self):
output = self.engine.render_to_string(
"for-tag-unpack03", {"items": (("one", 1), ("two", 2))}
)
self.assertEqual(output, "one:1/two:2/")
@setup(
{
"for-tag-unpack04": (
"{% for key , value in items %}{{ key }}:{{ value }}/{% endfor %}"
)
}
)
def test_for_tag_unpack04(self):
output = self.engine.render_to_string(
"for-tag-unpack04", {"items": (("one", 1), ("two", 2))}
)
self.assertEqual(output, "one:1/two:2/")
@setup(
{
"for-tag-unpack05": (
"{% for key ,value in items %}{{ key }}:{{ value }}/{% endfor %}"
)
}
)
def test_for_tag_unpack05(self):
output = self.engine.render_to_string(
"for-tag-unpack05", {"items": (("one", 1), ("two", 2))}
)
self.assertEqual(output, "one:1/two:2/")
@setup(
{
"for-tag-unpack06": (
"{% for key value in items %}{{ key }}:{{ value }}/{% endfor %}"
)
}
)
def test_for_tag_unpack06(self):
msg = "'for' tag received an invalid argument: for key value in items"
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.render_to_string(
"for-tag-unpack06", {"items": (("one", 1), ("two", 2))}
)
@setup(
{
"for-tag-unpack07": (
"{% for key,,value in items %}{{ key }}:{{ value }}/{% endfor %}"
)
}
)
def test_for_tag_unpack07(self):
msg = "'for' tag received an invalid argument: for key,,value in items"
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.render_to_string(
"for-tag-unpack07", {"items": (("one", 1), ("two", 2))}
)
@setup(
{
"for-tag-unpack08": (
"{% for key,value, in items %}{{ key }}:{{ value }}/{% endfor %}"
)
}
)
def test_for_tag_unpack08(self):
msg = "'for' tag received an invalid argument: for key,value, in items"
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.render_to_string(
"for-tag-unpack08", {"items": (("one", 1), ("two", 2))}
)
@setup({"double-quote": '{% for "k" in items %}{{ "k" }}/{% endfor %}'})
def test_unpack_double_quote(self):
msg = """'for' tag received an invalid argument: for "k" in items"""
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.render_to_string("double-quote", {"items": (1, 2)})
@setup({"single-quote": "{% for 'k' in items %}{{ k }}/{% endfor %}"})
def test_unpack_single_quote(self):
msg = """'for' tag received an invalid argument: for 'k' in items"""
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.render_to_string("single-quote", {"items": (1, 2)})
@setup({"vertical-bar": "{% for k|upper in items %}{{ k|upper }}/{% endfor %}"})
def test_unpack_vertical_bar(self):
msg = "'for' tag received an invalid argument: for k|upper in items"
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.render_to_string("vertical-bar", {"items": (1, 2)})
@setup(
{
"for-tag-unpack09": (
"{% for val in items %}{{ val.0 }}:{{ val.1 }}/{% endfor %}"
)
}
)
def test_for_tag_unpack09(self):
"""
A single loopvar doesn't truncate the list in val.
"""
output = self.engine.render_to_string(
"for-tag-unpack09", {"items": (("one", 1), ("two", 2))}
)
self.assertEqual(output, "one:1/two:2/")
@setup(
{
"for-tag-unpack13": (
"{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"
)
}
)
def test_for_tag_unpack13(self):
output = self.engine.render_to_string(
"for-tag-unpack13", {"items": (("one", 1, "carrot"), ("two", 2, "cheese"))}
)
if self.engine.string_if_invalid:
self.assertEqual(output, "one:1,carrot/two:2,cheese/")
else:
self.assertEqual(output, "one:1,carrot/two:2,cheese/")
@setup(
{
"for-tag-empty01": (
"{% for val in values %}{{ val }}{% empty %}empty text{% endfor %}"
)
}
)
def test_for_tag_empty01(self):
output = self.engine.render_to_string("for-tag-empty01", {"values": [1, 2, 3]})
self.assertEqual(output, "123")
@setup(
{
"for-tag-empty02": (
"{% for val in values %}{{ val }}{% empty %}values array empty"
"{% endfor %}"
)
}
)
def test_for_tag_empty02(self):
output = self.engine.render_to_string("for-tag-empty02", {"values": []})
self.assertEqual(output, "values array empty")
@setup(
{
"for-tag-empty03": "{% for val in values %}"
"{{ val }}{% empty %}values array not found{% endfor %}"
}
)
def test_for_tag_empty03(self):
output = self.engine.render_to_string("for-tag-empty03")
self.assertEqual(output, "values array not found")
@setup(
{
"for-tag-filter-ws": (
"{% load custom %}{% for x in s|noop:'x y' %}{{ x }}{% endfor %}"
)
}
)
def test_for_tag_filter_ws(self):
"""
#19882
"""
output = self.engine.render_to_string("for-tag-filter-ws", {"s": "abc"})
self.assertEqual(output, "abc")
@setup(
{"for-tag-unpack-strs": "{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}"}
)
def test_for_tag_unpack_strs(self):
output = self.engine.render_to_string(
"for-tag-unpack-strs", {"items": ("ab", "ac")}
)
self.assertEqual(output, "a:b/a:c/")
@setup({"for-tag-unpack10": "{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}"})
def test_for_tag_unpack10(self):
with self.assertRaisesMessage(
ValueError, "Need 2 values to unpack in for loop; got 3."
):
self.engine.render_to_string(
"for-tag-unpack10",
{"items": (("one", 1, "carrot"), ("two", 2, "orange"))},
)
@setup(
{
"for-tag-unpack11": (
"{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"
)
}
)
def test_for_tag_unpack11(self):
with self.assertRaisesMessage(
ValueError, "Need 3 values to unpack in for loop; got 2."
):
self.engine.render_to_string(
"for-tag-unpack11",
{"items": (("one", 1), ("two", 2))},
)
@setup(
{
"for-tag-unpack12": (
"{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"
)
}
)
def test_for_tag_unpack12(self):
with self.assertRaisesMessage(
ValueError, "Need 3 values to unpack in for loop; got 2."
):
self.engine.render_to_string(
"for-tag-unpack12", {"items": (("one", 1, "carrot"), ("two", 2))}
)
@setup({"for-tag-unpack14": "{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}"})
def test_for_tag_unpack14(self):
with self.assertRaisesMessage(
ValueError, "Need 2 values to unpack in for loop; got 1."
):
self.engine.render_to_string("for-tag-unpack14", {"items": (1, 2)})
@setup(
{
"main": '{% with alpha=alpha.values %}{% include "base" %}{% endwith %}_'
'{% with alpha=alpha.extra %}{% include "base" %}{% endwith %}',
"base": "{% for x, y in alpha %}{{ x }}:{{ y }},{% endfor %}",
}
)
def test_for_tag_context(self):
"""
ForNode.render() pops the values it pushes to the context (#28001).
"""
output = self.engine.render_to_string(
"main",
{
"alpha": {
"values": [("two", 2), ("four", 4)],
"extra": [("six", 6), ("eight", 8)],
},
},
)
self.assertEqual(output, "two:2,four:4,_six:6,eight:8,")
@setup({"invalid_for_loop": "{% for x items %}{{ x }}{% endfor %}"})
def test_invalid_arg(self):
msg = "'for' statements should have at least four words: for x items"
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.render_to_string("invalid_for_loop", {"items": (1, 2)})
@setup({"invalid_for_loop": "{% for x from items %}{{ x }}{% endfor %}"})
def test_invalid_in_keyword(self):
msg = "'for' statements should use the format 'for x in y': for x from items"
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.render_to_string("invalid_for_loop", {"items": (1, 2)})
class ForNodeTests(SimpleTestCase):
def test_repr(self):
node = ForNode(
"x",
"sequence",
is_reversed=True,
nodelist_loop=["val"],
nodelist_empty=["val2"],
)
self.assertEqual(
repr(node), "<ForNode: for x in sequence, tail_len: 1 reversed>"
)
|
ca9e43365344808be076002bfb3d10a69305ae3a6bf821d6aa8854019d30f267 | from django.template import TemplateSyntaxError
from django.test import SimpleTestCase
from ..utils import setup
class TemplateTagTests(SimpleTestCase):
@setup({"templatetag01": "{% templatetag openblock %}"})
def test_templatetag01(self):
output = self.engine.render_to_string("templatetag01")
self.assertEqual(output, "{%")
@setup({"templatetag02": "{% templatetag closeblock %}"})
def test_templatetag02(self):
output = self.engine.render_to_string("templatetag02")
self.assertEqual(output, "%}")
@setup({"templatetag03": "{% templatetag openvariable %}"})
def test_templatetag03(self):
output = self.engine.render_to_string("templatetag03")
self.assertEqual(output, "{{")
@setup({"templatetag04": "{% templatetag closevariable %}"})
def test_templatetag04(self):
output = self.engine.render_to_string("templatetag04")
self.assertEqual(output, "}}")
@setup({"templatetag05": "{% templatetag %}"})
def test_templatetag05(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("templatetag05")
@setup({"templatetag06": "{% templatetag foo %}"})
def test_templatetag06(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("templatetag06")
@setup({"templatetag07": "{% templatetag openbrace %}"})
def test_templatetag07(self):
output = self.engine.render_to_string("templatetag07")
self.assertEqual(output, "{")
@setup({"templatetag08": "{% templatetag closebrace %}"})
def test_templatetag08(self):
output = self.engine.render_to_string("templatetag08")
self.assertEqual(output, "}")
@setup({"templatetag09": "{% templatetag openbrace %}{% templatetag openbrace %}"})
def test_templatetag09(self):
output = self.engine.render_to_string("templatetag09")
self.assertEqual(output, "{{")
@setup(
{"templatetag10": "{% templatetag closebrace %}{% templatetag closebrace %}"}
)
def test_templatetag10(self):
output = self.engine.render_to_string("templatetag10")
self.assertEqual(output, "}}")
@setup({"templatetag11": "{% templatetag opencomment %}"})
def test_templatetag11(self):
output = self.engine.render_to_string("templatetag11")
self.assertEqual(output, "{#")
@setup({"templatetag12": "{% templatetag closecomment %}"})
def test_templatetag12(self):
output = self.engine.render_to_string("templatetag12")
self.assertEqual(output, "#}")
|
6dba70617e6f703d6936403e3108cd27d7864fd4f3a6ee91e6c5b9cc7ec3fd75 | 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)
|
097de1ef0ce19c9bee604c491ea4460925345a999e064171cd547feb06f667e5 | 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")
|
26305f3b3420220758b05ec5fc24077b269c706bcdf2236a9401d7aa3f573923 | 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")
|
995646d85a28054e1b16211c09d7fceeedf9a662d27a84b09948f71d0741ce42 | 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")
|
ee69531fb0ff037a73208c8de3d2b22a9409c86c40079b6efafe201e2329845c | from django.template import TemplateSyntaxError
from django.template.defaulttags import WithNode
from django.test import SimpleTestCase
from ..utils import setup
class WithTagTests(SimpleTestCase):
at_least_with_one_msg = "'with' expected at least one variable assignment"
@setup({"with01": "{% with key=dict.key %}{{ key }}{% endwith %}"})
def test_with01(self):
output = self.engine.render_to_string("with01", {"dict": {"key": 50}})
self.assertEqual(output, "50")
@setup({"legacywith01": "{% with dict.key as key %}{{ key }}{% endwith %}"})
def test_legacywith01(self):
output = self.engine.render_to_string("legacywith01", {"dict": {"key": 50}})
self.assertEqual(output, "50")
@setup(
{
"with02": "{{ key }}{% with key=dict.key %}"
"{{ key }}-{{ dict.key }}-{{ key }}"
"{% endwith %}{{ key }}"
}
)
def test_with02(self):
output = self.engine.render_to_string("with02", {"dict": {"key": 50}})
if self.engine.string_if_invalid:
self.assertEqual(output, "INVALID50-50-50INVALID")
else:
self.assertEqual(output, "50-50-50")
@setup(
{
"legacywith02": "{{ key }}{% with dict.key as key %}"
"{{ key }}-{{ dict.key }}-{{ key }}"
"{% endwith %}{{ key }}"
}
)
def test_legacywith02(self):
output = self.engine.render_to_string("legacywith02", {"dict": {"key": 50}})
if self.engine.string_if_invalid:
self.assertEqual(output, "INVALID50-50-50INVALID")
else:
self.assertEqual(output, "50-50-50")
@setup({"with03": "{% with a=alpha b=beta %}{{ a }}{{ b }}{% endwith %}"})
def test_with03(self):
output = self.engine.render_to_string("with03", {"alpha": "A", "beta": "B"})
self.assertEqual(output, "AB")
@setup({"with-error01": "{% with dict.key xx key %}{{ key }}{% endwith %}"})
def test_with_error01(self):
with self.assertRaisesMessage(TemplateSyntaxError, self.at_least_with_one_msg):
self.engine.render_to_string("with-error01", {"dict": {"key": 50}})
@setup({"with-error02": "{% with dict.key as %}{{ key }}{% endwith %}"})
def test_with_error02(self):
with self.assertRaisesMessage(TemplateSyntaxError, self.at_least_with_one_msg):
self.engine.render_to_string("with-error02", {"dict": {"key": 50}})
class WithNodeTests(SimpleTestCase):
def test_repr(self):
node = WithNode(nodelist=[], name="a", var="dict.key")
self.assertEqual(repr(node), "<WithNode>")
|
a2cbb80a4a352ad1cf76013ce07d769eab5671959f7ed575d5818cc22a48594c | 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")
|
33690e76116cd7346cca5536c355a4e262a187a516046b38e98f479f3ba94e87 | 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")
|
a55e3d8bbaf28e5ad98665257703c17f1386f6b88e19882d34c8607ed392a7b5 | 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, "")
|
4d6a8396b60f5128892aadcdee19c8f70bfb203d15ec754d33c1e4118832ac07 | 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")
|
2808718c6ca87e8b441144e1bbd472fb3b1faa9a3d76d01c8df387f37c6b2f7c | from django.contrib.auth.models import Group
from django.test import SimpleTestCase, override_settings
from ..utils import setup
@override_settings(DEBUG=True)
class DebugTests(SimpleTestCase):
@override_settings(DEBUG=False)
@setup({"non_debug": "{% debug %}"})
def test_non_debug(self):
output = self.engine.render_to_string("non_debug", {})
self.assertEqual(output, "")
@setup({"modules": "{% debug %}"})
def test_modules(self):
output = self.engine.render_to_string("modules", {})
self.assertIn(
"'django': <module 'django' ",
output,
)
@setup({"plain": "{% debug %}"})
def test_plain(self):
output = self.engine.render_to_string("plain", {"a": 1})
self.assertTrue(
output.startswith(
"{'a': 1}"
"{'False': False, 'None': None, "
"'True': True}\n\n{"
)
)
@setup({"non_ascii": "{% debug %}"})
def test_non_ascii(self):
group = Group(name="清風")
output = self.engine.render_to_string("non_ascii", {"group": group})
self.assertTrue(output.startswith("{'group': <Group: 清風>}"))
@setup({"script": "{% debug %}"})
def test_script(self):
output = self.engine.render_to_string("script", {"frag": "<script>"})
self.assertTrue(
output.startswith("{'frag': '<script>'}")
)
|
95a664de374ff156c0bb18abe7a7c732b36a310a1d6e436e6311fefbc2587821 | from django.template import TemplateDoesNotExist, TemplateSyntaxError
from django.test import SimpleTestCase
from ..utils import setup
from .test_extends import inheritance_templates
class ExceptionsTests(SimpleTestCase):
@setup({"exception01": "{% extends 'nonexistent' %}"})
def test_exception01(self):
"""
Raise exception for invalid template name
"""
with self.assertRaises(TemplateDoesNotExist):
self.engine.render_to_string("exception01")
@setup({"exception02": "{% extends nonexistent %}"})
def test_exception02(self):
"""
Raise exception for invalid variable template name
"""
if self.engine.string_if_invalid:
with self.assertRaises(TemplateDoesNotExist):
self.engine.render_to_string("exception02")
else:
with self.assertRaises(TemplateSyntaxError):
self.engine.render_to_string("exception02")
@setup(
{
"exception03": "{% extends 'inheritance01' %}"
"{% block first %}2{% endblock %}{% extends 'inheritance16' %}"
},
inheritance_templates,
)
def test_exception03(self):
"""
Raise exception for extra {% extends %} tags
"""
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("exception03")
@setup(
{
"exception04": (
"{% extends 'inheritance17' %}{% block first %}{% echo 400 %}5678"
"{% endblock %}"
)
},
inheritance_templates,
)
def test_exception04(self):
"""
Raise exception for custom tags used in child with {% load %} tag in
parent, not in child
"""
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("exception04")
@setup({"exception05": "{% block first %}{{ block.super }}{% endblock %}"})
def test_exception05(self):
"""
Raise exception for block.super used in base template
"""
with self.assertRaises(TemplateSyntaxError):
self.engine.render_to_string("exception05")
|
a5b5fc78fa519f4a6d5c75a8de36c557a4d090b70477c06d7b69487d9af8399d | 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)
|
443ae7e5bf43e310c9def47d8e6bad4cd2bc71e67eb6cedb36962b08c037b6e7 | 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,")
|
5bb4eb402536033fa5f9ccd3fbc6811658bc967cc11ebe0d482e3a604282ae16 | 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'>",
)
|
cf08082cecee2fb8e471530f121a32efb2210f66c43eec31e10a5194673d590f | from django.template import TemplateSyntaxError
from django.test import SimpleTestCase
from ..utils import setup
class ResetCycleTagTests(SimpleTestCase):
@setup({"resetcycle01": "{% resetcycle %}"})
def test_resetcycle01(self):
with self.assertRaisesMessage(TemplateSyntaxError, "No cycles in template."):
self.engine.get_template("resetcycle01")
@setup({"resetcycle02": "{% resetcycle undefinedcycle %}"})
def test_resetcycle02(self):
with self.assertRaisesMessage(
TemplateSyntaxError, "Named cycle 'undefinedcycle' does not exist."
):
self.engine.get_template("resetcycle02")
@setup({"resetcycle03": "{% cycle 'a' 'b' %}{% resetcycle undefinedcycle %}"})
def test_resetcycle03(self):
with self.assertRaisesMessage(
TemplateSyntaxError, "Named cycle 'undefinedcycle' does not exist."
):
self.engine.get_template("resetcycle03")
@setup({"resetcycle04": "{% cycle 'a' 'b' as ab %}{% resetcycle undefinedcycle %}"})
def test_resetcycle04(self):
with self.assertRaisesMessage(
TemplateSyntaxError, "Named cycle 'undefinedcycle' does not exist."
):
self.engine.get_template("resetcycle04")
@setup(
{
"resetcycle05": (
"{% for i in test %}{% cycle 'a' 'b' %}{% resetcycle %}{% endfor %}"
)
}
)
def test_resetcycle05(self):
output = self.engine.render_to_string("resetcycle05", {"test": list(range(5))})
self.assertEqual(output, "aaaaa")
@setup(
{
"resetcycle06": "{% cycle 'a' 'b' 'c' as abc %}"
"{% for i in test %}"
"{% cycle abc %}"
"{% cycle '-' '+' %}"
"{% resetcycle %}"
"{% endfor %}"
}
)
def test_resetcycle06(self):
output = self.engine.render_to_string("resetcycle06", {"test": list(range(5))})
self.assertEqual(output, "ab-c-a-b-c-")
@setup(
{
"resetcycle07": "{% cycle 'a' 'b' 'c' as abc %}"
"{% for i in test %}"
"{% resetcycle abc %}"
"{% cycle abc %}"
"{% cycle '-' '+' %}"
"{% endfor %}"
}
)
def test_resetcycle07(self):
output = self.engine.render_to_string("resetcycle07", {"test": list(range(5))})
self.assertEqual(output, "aa-a+a-a+a-")
@setup(
{
"resetcycle08": "{% for i in outer %}"
"{% for j in inner %}"
"{% cycle 'a' 'b' %}"
"{% endfor %}"
"{% resetcycle %}"
"{% endfor %}"
}
)
def test_resetcycle08(self):
output = self.engine.render_to_string(
"resetcycle08", {"outer": list(range(2)), "inner": list(range(3))}
)
self.assertEqual(output, "abaaba")
@setup(
{
"resetcycle09": "{% for i in outer %}"
"{% cycle 'a' 'b' %}"
"{% for j in inner %}"
"{% cycle 'X' 'Y' %}"
"{% endfor %}"
"{% resetcycle %}"
"{% endfor %}"
}
)
def test_resetcycle09(self):
output = self.engine.render_to_string(
"resetcycle09", {"outer": list(range(2)), "inner": list(range(3))}
)
self.assertEqual(output, "aXYXbXYX")
@setup(
{
"resetcycle10": "{% for i in test %}"
"{% cycle 'X' 'Y' 'Z' as XYZ %}"
"{% cycle 'a' 'b' 'c' as abc %}"
"{% if i == 1 %}"
"{% resetcycle abc %}"
"{% endif %}"
"{% endfor %}"
}
)
def test_resetcycle10(self):
output = self.engine.render_to_string("resetcycle10", {"test": list(range(5))})
self.assertEqual(output, "XaYbZaXbYc")
@setup(
{
"resetcycle11": "{% for i in test %}"
"{% cycle 'X' 'Y' 'Z' as XYZ %}"
"{% cycle 'a' 'b' 'c' as abc %}"
"{% if i == 1 %}"
"{% resetcycle XYZ %}"
"{% endif %}"
"{% endfor %}"
}
)
def test_resetcycle11(self):
output = self.engine.render_to_string("resetcycle11", {"test": list(range(5))})
self.assertEqual(output, "XaYbXcYaZb")
|
f0ee5f3a55df7d15586130c4db1a24f862b6b22385556e05d98561639abefbe4 | 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")
|
99dfc263e6401f38024bc721dae83ccc5dbfb970427fc60aff7d3fb7cec6f48d | from django.template import TemplateSyntaxError
from django.test import SimpleTestCase
from ..utils import setup
class SimpleTagTests(SimpleTestCase):
libraries = {"custom": "template_tests.templatetags.custom"}
@setup({"simpletag-renamed01": "{% load custom %}{% minusone 7 %}"})
def test_simpletag_renamed01(self):
output = self.engine.render_to_string("simpletag-renamed01")
self.assertEqual(output, "6")
@setup({"simpletag-renamed02": "{% load custom %}{% minustwo 7 %}"})
def test_simpletag_renamed02(self):
output = self.engine.render_to_string("simpletag-renamed02")
self.assertEqual(output, "5")
@setup({"simpletag-renamed03": "{% load custom %}{% minustwo_overridden_name 7 %}"})
def test_simpletag_renamed03(self):
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("simpletag-renamed03")
|
3c26be855de7a13a4ffd21ed9b445c8bd8a0b7468e4177881d516309d2e2cb56 | from django.test import SimpleTestCase
from ..utils import setup
class SpacelessTagTests(SimpleTestCase):
@setup(
{
"spaceless01": (
"{% spaceless %} <b> <i> text </i> </b> {% endspaceless %}"
)
}
)
def test_spaceless01(self):
output = self.engine.render_to_string("spaceless01")
self.assertEqual(output, "<b><i> text </i></b>")
@setup(
{
"spaceless02": (
"{% spaceless %} <b> \n <i> text </i> \n </b> {% endspaceless %}"
)
}
)
def test_spaceless02(self):
output = self.engine.render_to_string("spaceless02")
self.assertEqual(output, "<b><i> text </i></b>")
@setup({"spaceless03": "{% spaceless %}<b><i>text</i></b>{% endspaceless %}"})
def test_spaceless03(self):
output = self.engine.render_to_string("spaceless03")
self.assertEqual(output, "<b><i>text</i></b>")
@setup(
{
"spaceless04": (
"{% spaceless %}<b> <i>{{ text }}</i> </b>{% endspaceless %}"
)
}
)
def test_spaceless04(self):
output = self.engine.render_to_string("spaceless04", {"text": "This & that"})
self.assertEqual(output, "<b><i>This & that</i></b>")
@setup(
{
"spaceless05": "{% autoescape off %}{% spaceless %}"
"<b> <i>{{ text }}</i> </b>{% endspaceless %}"
"{% endautoescape %}"
}
)
def test_spaceless05(self):
output = self.engine.render_to_string("spaceless05", {"text": "This & that"})
self.assertEqual(output, "<b><i>This & that</i></b>")
@setup(
{
"spaceless06": (
"{% spaceless %}<b> <i>{{ text|safe }}</i> </b>{% endspaceless %}"
)
}
)
def test_spaceless06(self):
output = self.engine.render_to_string("spaceless06", {"text": "This & that"})
self.assertEqual(output, "<b><i>This & that</i></b>")
|
c1a5599a934edc866dbd515a05a8fc89e163f24dd18e2beed0120bf51dd98c1c | 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, "")
|
273eadac34bbabe11ff7230a354bf2959ee3c0fa22b86ad2ab202fc53b951f65 | 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])
|
f82f35d20eb3e0526127b0d6c7d172de473a7bc586f1e7cb77163a7daaffd423 | 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)
|
bb784295d25d7848888f73bb1d27e9539a06265efb37d4dde82dbec142947e10 | 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>")
|
3c57dba29c0d8f388676e62b991ff96ee3890fead6e20ae2bd0f9c0ee5975c6f | 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, "--")
|
5ba38a2a0b28a5c7ca58e9fc0f3ad2a7d53770c8429f3a0aa90abbb23eafdf1d | 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 ")
|
c781041664ceeffd8d55b729ad859839dbed1c4a67b2907552d123f9e6e1d8d0 | 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',
)
|
e8f5307a36f8fbb808e7a628292ba6646d0d07d47e01671c42ca550905d1732b | 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"), "")
|
cce6f7d7a0e158ce56744a7588f1d30dfa475226bac80abc57f54909cef75361 | 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")
|
63ab944cf0a781a5e21945a1c8188438aa27081c09997f637adf5814256d3a2b | 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",
)
|
95f1d414d988b12b0ebf6ac49e2b98d3d65f2760c6390e0175c9673e16ad7535 | 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")
|
911a9cb79cfeef029502bab1d9caf04ae4a4e0d6c48ee51b4abd2067fddb5368 | 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")
|
577344e871ac2445a8ea8cda7dfbcbdaa010c2e95733e5850826ba6183e00ceb | 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()
|
9c4b8d51ce1e164e3afe61b5ec1e56e21a4d0825cf43a3dab948588c57eadfd7 | 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>",
)
|
10763df9100a23964ad8dc8e5f6e2be4468fa25544f0f15bb88515832cb10df3 | 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",
)
|
347ab29b173325f2aa3a466615981c821c48786a3d925b271fd67f01f636682d | from django.template.defaultfilters import urlizetrunc
from django.test import SimpleTestCase
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>",
)
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="http://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="http://google.com" rel="nofollow">google.c…</a> ">'
"bar</a>buz",
)
|
f3da2d1cd28ad0df6546dbb6e7a2bc5f369565b064a0e07ee390d76ea3a5a6cf | 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>")
|
f7d2792ce34da2056fccdd7656519913ab016bfcbdf3565b12bc0d67e91a3b41 | 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")
|
419bfe6ec76c8227c690a3074b5a578a362382ab70d6d85966def85de02a4271 | 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",
)
|
75b5422bfed4eda8e4fb251ab0e5e499616620029e15388ba9577405e184d14c | 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")
|
781d303c1c75fffe32696ff349b4232275baf9d65829ee837df82a39ac700a52 | 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")
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"
)
|
1ea318bd77df132d368a43762cb471f087ca8db1ec8b53ba5e79629019dd8c30 | 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")
|
4d8b606b7d10d0a263dfc9bf66d15a911dd9b2b06887086244eeb8ec870c5996 | 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"])
|
5b115019cac37441ba07f44cb2d6165687270dc1a2a455d7e2687bc8f2d80ad7 | 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")
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)
|
f8d0b27a3fcbf9b2d7d60335460f967a9eda5572cd3ecce2209c8bfd44a1ed7e | 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",
)
|
ad53a72050163816ddeb9d019c66fc51927c5e0aa22a2158be9f33d274dcaf80 | from django.template.defaultfilters import urlize
from django.test import SimpleTestCase
from django.utils.functional import lazy
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 [email protected]"}
)
self.assertEqual(
output,
'Email me at <a href="mailto:[email protected]">[email protected]</a>',
)
@setup({"urlize08": "{{ a|urlize }}"})
def test_urlize08(self):
output = self.engine.render_to_string(
"urlize08", {"a": "Email me at <[email protected]>"}
)
self.assertEqual(
output,
'Email me at <<a href="mailto:[email protected]">[email protected]</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>",
)
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="http://www.google.com" rel="nofollow">www.google.com</a>',
)
self.assertEqual(
urlize("djangoproject.org"),
'<a href="http://djangoproject.org" rel="nofollow">djangoproject.org</a>',
)
self.assertEqual(
urlize("djangoproject.org/"),
'<a href="http://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="http://www.server.com" rel="nofollow">www.server.com</a>"'
"abc",
)
self.assertEqual(
urlize("www.server.com'abc"),
'<a href="http://www.server.com" rel="nofollow">www.server.com</a>''
"abc",
)
self.assertEqual(
urlize("www.server.com<abc"),
'<a href="http://www.server.com" rel="nofollow">www.server.com</a><abc',
)
self.assertEqual(
urlize("www.server.com>abc"),
'<a href="http://www.server.com" rel="nofollow">www.server.com</a>>abc',
)
def test_email(self):
self.assertEqual(
urlize("[email protected]"),
'<a href="mailto:[email protected]">[email protected]</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="http://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_nofollow(self):
"""
#12183 - Check urlize adds nofollow properly - see #12183
"""
self.assertEqual(
urlize("[email protected] or www.bar.com"),
'<a href="mailto:[email protected]">[email protected]</a> or '
'<a href="http://www.bar.com" rel="nofollow">www.bar.com</a>',
)
def test_idn(self):
"""
#13704 - Check urlize handles IDN correctly
"""
self.assertEqual(
urlize("http://c✶.ws"),
'<a href="http://xn--c-lgq.ws" rel="nofollow">http://c✶.ws</a>',
)
self.assertEqual(
urlize("www.c✶.ws"),
'<a href="http://www.xn--c-lgq.ws" rel="nofollow">www.c✶.ws</a>',
)
self.assertEqual(
urlize("c✶.org"), '<a href="http://xn--c-lgq.org" rel="nofollow">c✶.org</a>'
)
self.assertEqual(
urlize("info@c✶.org"), '<a href="mailto:[email protected]">info@c✶.org</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="http://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 protected]"), "[email protected]")
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_brackets(self):
"""
#19070 - Check urlize handles brackets properly
"""
self.assertEqual(
urlize("[see www.example.com]"),
'[see <a href="http://www.example.com" rel="nofollow">www.example.com</a>]',
)
self.assertEqual(
urlize("see test[at[example.com"),
'see <a href="http://test[at[example.com" rel="nofollow">'
"test[at[example.com</a>",
)
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 "[email protected]" afterward', autoescape=False),
'before "<a href="mailto:[email protected]">[email protected]</a>" afterward',
)
self.assertEqual(
urlize('before [email protected]" afterward', autoescape=False),
'before <a href="mailto:[email protected]">[email protected]</a>" afterward',
)
self.assertEqual(
urlize('before "[email protected] afterward', autoescape=False),
'before "<a href="mailto:[email protected]">[email protected]</a> afterward',
)
self.assertEqual(
urlize("before '[email protected]' afterward", autoescape=False),
"before '<a href=\"mailto:[email protected]\">[email protected]</a>' afterward",
)
self.assertEqual(
urlize("before [email protected]' afterward", autoescape=False),
'before <a href="mailto:[email protected]">[email protected]</a>\' afterward',
)
self.assertEqual(
urlize("before '[email protected] afterward", autoescape=False),
'before \'<a href="mailto:[email protected]">[email protected]</a> afterward',
)
def test_quote_commas(self):
"""
#20364 - Check urlize copes with commas following URLs in quotes
"""
self.assertEqual(
urlize(
'Email us at "[email protected]", or phone us at +xx.yy', autoescape=False
),
'Email us at "<a href="mailto:[email protected]">[email protected]</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="http://djangoproject.com" rel="nofollow">djangoproject.com'
"</a>! and enjoy.",
)
self.assertEqual(
urlize("Search for google.com/?q=! and see."),
'Search for <a href="http://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="http://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="http://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="http://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="http://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="http://www.google.com" rel="nofollow">www.google.com</a>',
)
|
5032ce4433afeac24b29bed3c40994c60cc07be40cceac813aa2a6339213caba | 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"), ""
)
|
e5e3dd47b152b30e579972df9e4ae26da70182f8d683cd3a26e86f9c74cae548 | 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")
|
fcae80c9485c940c3f18b543552a3b0c84c0146533ee700cb2199a5187a69b01 | 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")
|
6700e78b1c00f9aede28eef7f4777ad05aaade22218861047d779b3c3161a4b1 | 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)
|
7126a90901a591b9bf7f57303a974028e83abaafdf21e9ab78a13ce3e42daca4 | 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")
|
5b869c22e79f283145847075a000f8a8e4ed3f51e22dafe2485735686bffc484 | 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")
|
5b0fe9c2f6030f634e0d74d90a3851383c1d1609b900b993523af6f2f6a503ed | 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)
|
e71b9b9ebd1461f47b8f91c30ec4608c6aa24eb93d699450459a39b22fa9d586 | 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>",
)
|
cd56eb5a7034e7f0a3239411048118ad3691d55b297ddf5ee177ea8ed0c2547d | 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, "&, < -- &, <")
|
3906c13859d7c4fead4c044561f7576207e2b041abcfa7e9b8b4a0ce055ce815 | 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")
|
857a606e1a0b8b887e0da6cd86904076f236cbe56e039fdac0e2a0e95e0cee25 | 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",
)
|
7d288e881d6c161cfda776e2169125d16286aeec119a09858269d8bce5aa993f | 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")
|
0d0f6cb761ed3be8e725e541a50b364521869ad7d675de46dfe5d16a023e1278 | 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)
|
d4941aec684181f070a2acfccf8054e4e91110b56b93b6fa2c544383b7d844d2 | 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, "")
|
ec10d8d8094b1f4144c855f7a2c004dde61b7cbd92d5d332519b2b4c483622ff | 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")
|
feaec172f1a2d43b9fc15168719e3e6b0d32584998907a9784c9c0afce1e1b08 | 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")
|
967abbb91550c91eed58ed61a8025208edc51d0f1aaeeed900535a98eafd00fa | 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")
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")
|
fbf3602c0de7329feb982911b84e918948b13ac22bfae119646e1da2a95c6360 | 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)
|
3e3c6ed5516f59eeeaa005376c9318eca3f3a02b1c945123501fa5e693d258b7 | from django.template.defaultfilters import length_is
from django.test import SimpleTestCase
from ..utils import setup
class LengthIsTests(SimpleTestCase):
@setup({"length_is01": '{% if some_list|length_is:"4" %}Four{% endif %}'})
def test_length_is01(self):
output = self.engine.render_to_string(
"length_is01", {"some_list": ["4", None, True, {}]}
)
self.assertEqual(output, "Four")
@setup(
{
"length_is02": (
'{% if some_list|length_is:"4" %}Four{% else %}Not Four{% endif %}'
)
}
)
def test_length_is02(self):
output = self.engine.render_to_string(
"length_is02", {"some_list": ["4", None, True, {}, 17]}
)
self.assertEqual(output, "Not Four")
@setup({"length_is03": '{% if mystring|length_is:"4" %}Four{% endif %}'})
def test_length_is03(self):
output = self.engine.render_to_string("length_is03", {"mystring": "word"})
self.assertEqual(output, "Four")
@setup(
{
"length_is04": (
'{% if mystring|length_is:"4" %}Four{% else %}Not Four{% endif %}'
)
}
)
def test_length_is04(self):
output = self.engine.render_to_string("length_is04", {"mystring": "Python"})
self.assertEqual(output, "Not Four")
@setup(
{
"length_is05": (
'{% if mystring|length_is:"4" %}Four{% else %}Not Four{% endif %}'
)
}
)
def test_length_is05(self):
output = self.engine.render_to_string("length_is05", {"mystring": ""})
self.assertEqual(output, "Not Four")
@setup(
{
"length_is06": (
"{% with var|length as my_length %}{{ my_length }}{% endwith %}"
)
}
)
def test_length_is06(self):
output = self.engine.render_to_string("length_is06", {"var": "django"})
self.assertEqual(output, "6")
# Boolean return value from length_is should not be coerced to a string
@setup(
{
"length_is07": (
'{% if "X"|length_is:0 %}Length is 0{% else %}Length not 0{% endif %}'
)
}
)
def test_length_is07(self):
output = self.engine.render_to_string("length_is07", {})
self.assertEqual(output, "Length not 0")
@setup(
{
"length_is08": (
'{% if "X"|length_is:1 %}Length is 1{% else %}Length not 1{% endif %}'
)
}
)
def test_length_is08(self):
output = self.engine.render_to_string("length_is08", {})
self.assertEqual(output, "Length is 1")
# Invalid uses that should fail silently.
@setup({"length_is09": '{{ var|length_is:"fish" }}'})
def test_length_is09(self):
output = self.engine.render_to_string("length_is09", {"var": "django"})
self.assertEqual(output, "")
@setup({"length_is10": '{{ int|length_is:"1" }}'})
def test_length_is10(self):
output = self.engine.render_to_string("length_is10", {"int": 7})
self.assertEqual(output, "")
@setup({"length_is11": '{{ none|length_is:"1" }}'})
def test_length_is11(self):
output = self.engine.render_to_string("length_is11", {"none": None})
self.assertEqual(output, "")
class FunctionTests(SimpleTestCase):
def test_empty_list(self):
self.assertIs(length_is([], 0), True)
self.assertIs(length_is([], 1), False)
def test_string(self):
self.assertIs(length_is("a", 1), True)
self.assertIs(length_is("a", 10), False)
|
726b07c945439081d848addf2535f1c031a8ec1c49fa3c5907ee5245e277c56f | 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 …</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>")
|
7e3a8e1aa87d80a157e7046662660158d74e6be7be5e75004230422240934926 | 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 ")
|
07bd01da3e09756cf2985cd80e151775ae016dcb720017f712a0f4f21c775dfe | 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")
|
e50cc05efa697c1c10f15e2200c443fb48fd52b4a909e7b3f65bf1ce20771235 | 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)
|
b2cf0e4988d5f20a0410e77bd9358ebc394b1afbdfb5367b290939ddd9a6ee49 | 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"), "")
|
26c45ff3e399f984d69f4abd340decc76e640da0813cba1a569ea6cb600d7042 | 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)
|
b88823fee70feab38f7596e024f41ccb2becf40b6593cc446d0c7c8f350b3c45 | 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"), "")
|
faa91216e6f6eed2fb7be34b9a5bc58f5f668bf198fcae6af469fedeb5c7f128 | 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",
)
|
d2cd1487ae19f7dc809009d2d81438c4b93f65ed31fe4d1e948633acc730744c | 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)
|
ed63d10053d32808543bc0ab8e742e7b4f37cc42eddbcffc06844ba9fc1a286b | 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"
)
|
42cfb5aad2ab315b2590414975083767ca48f88bec28ab1d166a202b82e8ed22 | 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"))
|
278a8298f9c972eda8c1112657551ea592b2d85bfcb32a9b9b66d4e11c3b4939 | 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"
)
|
8689b70c5e37c7461eb96d68f1eb0e35a973d0b3c485308be7960a731bc06881 | 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")
|
04cc50384285cb7df666c51c72efc8e1ad4708b28818b53589f23bbfc69cdc98 | 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 ..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("foo"), "")
self.assertEqual(floatformat(13.1031, "bar"), "13.1031")
self.assertEqual(floatformat(18.125, 2), "18.13")
self.assertEqual(floatformat("foo", "bar"), "")
self.assertEqual(floatformat("¿Cómo esta usted?"), "")
self.assertEqual(floatformat(None), "")
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")
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"
)
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")
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")
|
3b5c756df5950d042cec2da683ad7bc4f401a1ecc316c1407ee63da90350147d | 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")
|
4ef0cb675a439a890709b35f791455100e872c82ffa84be0150137ad87511695 | 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>')
|
0ef94c38568125c4037edd2af4ebfb0f6ef00d0f280305cef5e076d9fce07e7a | 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")
|
8a7eb7882cf4bbb3d0f3a1a4358c7f4c81095c5546fe1fa68be567297e4d4674 | 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")
|
000d307ac4afe2244f802ed5ebf34f44487537dca919c5b7bf76d05db0090185 | 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"), ""
)
|
69ae9695a9e94f829c2611394f2dddd5216b4aac90726f6135d59518b3a3a872 | 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")
|
11cdf7ebed4753fa0a662aad6a3c0c44b62c7f9653a24e85916a23049e3a7bda | 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()
|
510af5493b249cbaeba635210e8435059f895929c9b0412088561b90d77c5ce1 | import operator
from django import template
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.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_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_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_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_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_tag
def simple_keyword_only_param(*, kwarg):
return "simple_keyword_only_param - Expected result: %s" % kwarg
@register.simple_tag
def simple_keyword_only_default(*, kwarg=42):
return "simple_keyword_only_default - Expected result: %s" % 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_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_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_tag
def simple_unlimited_args_kwargs(one, two="hi", *args, **kwargs):
"""Expected simple_unlimited_args_kwargs __doc__"""
# Sort the dictionary by key to guarantee the order for testing.
sorted_kwarg = sorted(kwargs.items(), key=operator.itemgetter(0))
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 sorted_kwarg),
)
simple_unlimited_args_kwargs.anything = "Expected simple_unlimited_args_kwargs __dict__"
@register.simple_tag(takes_context=True)
def simple_tag_without_context_parameter(arg):
"""Expected simple_tag_without_context_parameter __doc__"""
return "Expected result"
simple_tag_without_context_parameter.anything = (
"Expected simple_tag_without_context_parameter __dict__"
)
@register.simple_tag(takes_context=True)
def simple_tag_takes_context_without_params():
"""Expected simple_tag_takes_context_without_params __doc__"""
return "Expected result"
simple_tag_takes_context_without_params.anything = (
"Expected simple_tag_takes_context_without_params __dict__"
)
@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_tag(takes_context=True)
def escape_explicit(context):
"""A tag that uses escape explicitly"""
return escape("Hello {}!".format(context["name"]))
@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_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)
|
f5712ea3c3e91c3d2fb192210e2ed2a701b1ea4afff39131181dcbcbff5063df | import operator
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__"""
# Sort the dictionary by key to guarantee the order for testing.
sorted_kwarg = sorted(kwargs.items(), key=operator.itemgetter(0))
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 sorted_kwarg),
)
}
inclusion_unlimited_args_kwargs.anything = (
"Expected inclusion_unlimited_args_kwargs __dict__"
)
@register.inclusion_tag("inclusion.html", takes_context=True)
def inclusion_tag_without_context_parameter(arg):
"""Expected inclusion_tag_without_context_parameter __doc__"""
return {}
inclusion_tag_without_context_parameter.anything = (
"Expected inclusion_tag_without_context_parameter __dict__"
)
@register.inclusion_tag("inclusion.html", takes_context=True)
def inclusion_tag_takes_context_without_params():
"""Expected inclusion_tag_takes_context_without_params __doc__"""
return {}
inclusion_tag_takes_context_without_params.anything = (
"Expected inclusion_tag_takes_context_without_params __dict__"
)
@register.inclusion_tag("inclusion_extends1.html")
def inclusion_extends1():
return {}
@register.inclusion_tag("inclusion_extends2.html")
def inclusion_extends2():
return {}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.