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, "&lt;") @setup({"firstof11": "{% firstof a b %}"}) def test_firstof11(self): output = self.engine.render_to_string("firstof11", {"a": "<", "b": ">"}) self.assertEqual(output, "&lt;") @setup({"firstof12": "{% firstof a b %}"}) def test_firstof12(self): output = self.engine.render_to_string("firstof12", {"a": "", "b": ">"}) self.assertEqual(output, "&gt;") @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&quoted.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, "&lt;b&gt;hello&lt;/b&gt;") # 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> &lt;a&gt;") @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, "&lt;b&gt;first&lt;/b&gt;") # 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 &amp; 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 &gt; 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,&amp;,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 &amp; 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 %} &amp; {% cycle foo %}"}) def test_cycle20(self): output = self.engine.render_to_string( "cycle20", {"two": "C & D", "one": "A & B"} ) self.assertEqual(output, "A &amp; B &amp; C &amp; 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;amp; B &amp; C &amp;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, "&lt;") @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, "&lt;&gt;") @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, "<&gt;") @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( "&#x27;django&#x27;: &lt;module &#x27;django&#x27; ", output, ) @setup({"plain": "{% debug %}"}) def test_plain(self): output = self.engine.render_to_string("plain", {"a": 1}) self.assertTrue( output.startswith( "{&#x27;a&#x27;: 1}" "{&#x27;False&#x27;: False, &#x27;None&#x27;: None, " "&#x27;True&#x27;: 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("{&#x27;group&#x27;: &lt;Group: 清風&gt;}")) @setup({"script": "{% debug %}"}) def test_script(self): output = self.engine.render_to_string("script", {"frag": "<script>"}) self.assertTrue( output.startswith("{&#x27;frag&#x27;: &#x27;&lt;script&gt;&#x27;}") )
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/!$&amp;&#x27;()*+,;=~:@,/") @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 &amp; 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&amp;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&lt;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&amp;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&amp;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&amp;y") @setup({"escape04": "{{ a|escape|escape }}"}) def test_escape04(self): output = self.engine.render_to_string("escape04", {"a": "x&y"}) self.assertEqual(output, "x&amp;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, "&lt;some html &amp; special characters &gt; 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 &amp; 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 &amp; 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&amp;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&gt;")} ) self.assertEqual(output, "Fred> Fred&gt;") @setup({"capfirst02": "{{ a|capfirst }} {{ b|capfirst }}"}) def test_capfirst02(self): output = self.engine.render_to_string( "capfirst02", {"a": "fred>", "b": mark_safe("fred&gt;")} ) self.assertEqual(output, "Fred&gt; Fred&gt;") 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&gt;\n\t<ul>\n\t\t<li>&lt;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&gt;\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>&lt;a&gt;item 1&lt;/a&gt;</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-&lt;a&gt;c&lt;/a&gt;</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-&lt;a&gt;c&lt;/a&gt;</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&amp;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&amp;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;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;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&amp;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&amp;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;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;amp;y") class FunctionTests(SimpleTestCase): def test_escape(self): escaped = force_escape("<some html & special characters > here") self.assertEqual(escaped, "&lt;some html &amp; special characters &gt; here") self.assertIsInstance(escaped, SafeData) def test_unicode(self): self.assertEqual( force_escape("<some html & special characters > here ĐÅ€£"), "&lt;some html &amp; special characters &gt; 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("&quot;Safe&quot; http://example.com?x=&amp;y="), }, ) self.assertEqual( output, '"Unsafe" ' '<a href="http://example.com/x=&amp;y=" rel="nofollow">http://…</a> ' "&quot;Safe&quot; " '<a href="http://example.com?x=&amp;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("&quot;Safe&quot; http://example.com?x=&amp;y="), }, ) self.assertEqual( output, '&quot;Unsafe&quot; <a href="http://example.com/x=&amp;y=" rel="nofollow">' "http://…</a> " '&quot;Safe&quot; <a href="http://example.com?x=&amp;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&amp;q=some+long+url&amp;' 'btnG=Search&amp;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&lt;a href=&quot; <a href="http://google.com" rel="nofollow">google.com' "</a> &quot;&gt;bar&lt;/a&gt;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, "&lt;b&gt;hello&lt;/b&gt; -- <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"&lt;a&gt;\&#x27; <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 &amp;\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 &amp; bravo")}, ) self.assertEqual(output, "alpha & … alpha &amp; …") @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 &amp; bravo")}, ) self.assertEqual(output, "alpha &amp; … alpha &amp; …") 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&amp;y")} ) self.assertEqual(output, "&y &amp;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&amp;y")} ) self.assertEqual(output, "&amp;y &amp;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&amp;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&amp;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&amp;y")} ) self.assertEqual(output, "x&y x&ampy") @setup({"cut06": '{{ a|cut:";" }} {{ b|cut:";" }}'}) def test_cut06(self): output = self.engine.render_to_string( "cut06", {"a": "x&y", "b": mark_safe("x&amp;y")} ) self.assertEqual(output, "x&amp;y x&amp;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, "[&#x27;&amp;&#x27;]") @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 &amp; 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:" &amp; " }}'}) def test_join03(self): output = self.engine.render_to_string("join03", {"a": ["alpha", "beta & me"]}) self.assertEqual(output, "alpha &amp; beta &amp; me") @setup({"join04": '{% autoescape off %}{{ a|join:" &amp; " }}{% endautoescape %}'}) def test_join04(self): output = self.engine.render_to_string("join04", {"a": ["alpha", "beta & me"]}) self.assertEqual(output, "alpha &amp; 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 &amp; beta &amp; 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 &amp; 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 &amp; beta &amp; 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 &amp; 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>"), "&lt;a&gt;&lt;br&gt;&lt;img&gt;&lt;br&gt;&lt;/a&gt;", ) def test_autoescape_off(self): self.assertEqual( join(["<a>", "<img>", "</a>"], "<br>", autoescape=False), "<a>&lt;br&gt;<img>&lt;br&gt;</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&lt;two&gt;\nthree")}, ) self.assertEqual( output, "1. one\n2. &lt;two&gt;\n3. three 1. one\n2. &lt;two&gt;\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&lt;two&gt;\nthree")}, ) self.assertEqual( output, "1. one\n2. <two>\n3. three 1. one\n2. &lt;two&gt;\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. &lt;a&gt;bar&lt;/a&gt;\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=&amp;y=&lt;2&gt;"), }, ) self.assertEqual( output, '<a href="http://example.com/?x=&amp;y=" rel="nofollow">' "http://example.com/?x=&y=</a> " '<a href="http://example.com?x=&amp;y=%3C2%3E" rel="nofollow">' "http://example.com?x=&amp;y=&lt;2&gt;</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=&amp;y="), }, ) self.assertEqual( output, '<a href="http://example.com/?x=&amp;y=" rel="nofollow">' "http://example.com/?x=&amp;y=</a> " '<a href="http://example.com?x=&amp;y=" rel="nofollow">' "http://example.com?x=&amp;y=</a>", ) @setup({"urlize03": "{% autoescape off %}{{ a|urlize }}{% endautoescape %}"}) def test_urlize03(self): output = self.engine.render_to_string("urlize03", {"a": mark_safe("a &amp; b")}) self.assertEqual(output, "a &amp; b") @setup({"urlize04": "{{ a|urlize }}"}) def test_urlize04(self): output = self.engine.render_to_string("urlize04", {"a": mark_safe("a &amp; b")}) self.assertEqual(output, "a &amp; 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, "&lt;script&gt;alert(&#x27;foo&#x27;)&lt;/script&gt;") # 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 &lt;<a href="mailto:[email protected]">[email protected]</a>&gt;', ) @setup({"urlize09": "{% autoescape off %}{{ a|urlize }}{% endautoescape %}"}) def test_urlize09(self): output = self.engine.render_to_string( "urlize09", {"a": "http://example.com/?x=&amp;y=&lt;2&gt;"} ) self.assertEqual( output, '<a href="http://example.com/?x=&amp;y=%3C2%3E" rel="nofollow">' "http://example.com/?x=&amp;y=&lt;2&gt;</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>&quot;' "abc", ) self.assertEqual( urlize("www.server.com'abc"), '<a href="http://www.server.com" rel="nofollow">www.server.com</a>&#x27;' "abc", ) self.assertEqual( urlize("www.server.com<abc"), '<a href="http://www.server.com" rel="nofollow">www.server.com</a>&lt;abc', ) self.assertEqual( urlize("www.server.com>abc"), '<a href="http://www.server.com" rel="nofollow">www.server.com</a>&gt;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>.,:;)&quot;!", ) 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 = ( ("()", ("(", ")")), ("<>", ("&lt;", "&gt;")), ("[]", ("[", "]")), ('""', ("&quot;", "&quot;")), ("''", ("&#x27;", "&#x27;")), ) 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&lt;a href=&quot; <a href="http://google.com" rel="nofollow">google.com' "</a> &quot;&gt;bar&lt;/a&gt;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&#x27;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 &amp; 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 &gt; 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 &gt; 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 &amp; banana")} ) self.assertEqual(output, "apple & banana apple &amp; 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 &amp; banana")} ) self.assertEqual(output, "apple &amp; banana apple &amp; 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&amp;<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>&lt;a&gt;bar&lt;/a&gt;<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, "&amp;, &lt; -- &, <") @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 &lt; 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 &lt; .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 &lt; 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 &lt; 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 &amp;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 &lt 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 &lt; 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 &lt; 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 &lt; 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 &lt; 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&amp;<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>&lt;a&gt;bar&lt;/a&gt;<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&amp;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, "&amp;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&amp;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&amp;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 &amp; 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 &amp; 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&iacute;as! &#x00bf;C&oacute;mo est&aacute;?</i>", 3 ), "<i>Buenos d&iacute;as! &#x00bf;C&oacute;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&amp;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&amp;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 &amp; b")} ) self.assertEqual(output, "A & B A &AMP; 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 &amp; b")} ) self.assertEqual(output, "A &amp; B A &amp;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, "&lt;1-800-2255-63&gt; <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 {}