diff options
author | Florian Apolloner <florian@apolloner.eu> | 2013-02-26 09:53:47 +0100 |
---|---|---|
committer | Florian Apolloner <florian@apolloner.eu> | 2013-02-26 14:36:57 +0100 |
commit | 89f40e36246100df6a11316c31a76712ebc6c501 (patch) | |
tree | 6e65639683ddaf2027908d1ecb1739e0e2ff853b /tests/templates | |
parent | b3d2ccb5bfbaf6e7fe1f98843baaa48c35a70950 (diff) | |
download | django-89f40e36246100df6a11316c31a76712ebc6c501.tar.gz |
Merged regressiontests and modeltests into the test root.
Diffstat (limited to 'tests/templates')
36 files changed, 3846 insertions, 0 deletions
diff --git a/tests/templates/__init__.py b/tests/templates/__init__.py new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/tests/templates/__init__.py diff --git a/tests/templates/alternate_urls.py b/tests/templates/alternate_urls.py new file mode 100644 index 0000000000..fa4985a9dc --- /dev/null +++ b/tests/templates/alternate_urls.py @@ -0,0 +1,16 @@ +# coding: utf-8 + +from __future__ import absolute_import + +from django.conf.urls import patterns, url + +from . import views + + +urlpatterns = patterns('', + # View returning a template response + (r'^template_response_view/$', views.template_response_view), + + # A view that can be hard to find... + url(r'^snark/', views.snark, name='snark'), +) diff --git a/tests/templates/callables.py b/tests/templates/callables.py new file mode 100644 index 0000000000..882a8c6e06 --- /dev/null +++ b/tests/templates/callables.py @@ -0,0 +1,113 @@ +from __future__ import unicode_literals + +from django import template +from django.utils.unittest import TestCase + +class CallableVariablesTests(TestCase): + + def test_callable(self): + + class Doodad(object): + def __init__(self, value): + self.num_calls = 0 + self.value = value + def __call__(self): + self.num_calls += 1 + return {"the_value": self.value} + + my_doodad = Doodad(42) + c = template.Context({"my_doodad": my_doodad}) + + # We can't access ``my_doodad.value`` in the template, because + # ``my_doodad.__call__`` will be invoked first, yielding a dictionary + # without a key ``value``. + t = template.Template('{{ my_doodad.value }}') + self.assertEqual(t.render(c), '') + + # We can confirm that the doodad has been called + self.assertEqual(my_doodad.num_calls, 1) + + # But we can access keys on the dict that's returned + # by ``__call__``, instead. + t = template.Template('{{ my_doodad.the_value }}') + self.assertEqual(t.render(c), '42') + self.assertEqual(my_doodad.num_calls, 2) + + def test_alters_data(self): + + class Doodad(object): + alters_data = True + def __init__(self, value): + self.num_calls = 0 + self.value = value + def __call__(self): + self.num_calls += 1 + return {"the_value": self.value} + + my_doodad = Doodad(42) + c = template.Context({"my_doodad": my_doodad}) + + # Since ``my_doodad.alters_data`` is True, the template system will not + # try to call our doodad but will use TEMPLATE_STRING_IF_INVALID + t = template.Template('{{ my_doodad.value }}') + self.assertEqual(t.render(c), '') + t = template.Template('{{ my_doodad.the_value }}') + self.assertEqual(t.render(c), '') + + # Double-check that the object was really never called during the + # template rendering. + self.assertEqual(my_doodad.num_calls, 0) + + def test_do_not_call(self): + + class Doodad(object): + do_not_call_in_templates = True + def __init__(self, value): + self.num_calls = 0 + self.value = value + def __call__(self): + self.num_calls += 1 + return {"the_value": self.value} + + my_doodad = Doodad(42) + c = template.Context({"my_doodad": my_doodad}) + + # Since ``my_doodad.do_not_call_in_templates`` is True, the template + # system will not try to call our doodad. We can access its attributes + # as normal, and we don't have access to the dict that it returns when + # called. + t = template.Template('{{ my_doodad.value }}') + self.assertEqual(t.render(c), '42') + t = template.Template('{{ my_doodad.the_value }}') + self.assertEqual(t.render(c), '') + + # Double-check that the object was really never called during the + # template rendering. + self.assertEqual(my_doodad.num_calls, 0) + + def test_do_not_call_and_alters_data(self): + # If we combine ``alters_data`` and ``do_not_call_in_templates``, the + # ``alters_data`` attribute will not make any difference in the + # template system's behavior. + + class Doodad(object): + do_not_call_in_templates = True + alters_data = True + def __init__(self, value): + self.num_calls = 0 + self.value = value + def __call__(self): + self.num_calls += 1 + return {"the_value": self.value} + + my_doodad = Doodad(42) + c = template.Context({"my_doodad": my_doodad}) + + t = template.Template('{{ my_doodad.value }}') + self.assertEqual(t.render(c), '42') + t = template.Template('{{ my_doodad.the_value }}') + self.assertEqual(t.render(c), '') + + # Double-check that the object was really never called during the + # template rendering. + self.assertEqual(my_doodad.num_calls, 0) diff --git a/tests/templates/context.py b/tests/templates/context.py new file mode 100644 index 0000000000..05c1dd57b9 --- /dev/null +++ b/tests/templates/context.py @@ -0,0 +1,16 @@ +# coding: utf-8 +from django.template import Context +from django.utils.unittest import TestCase + + +class ContextTests(TestCase): + def test_context(self): + c = Context({"a": 1, "b": "xyzzy"}) + self.assertEqual(c["a"], 1) + self.assertEqual(c.push(), {}) + c["a"] = 2 + self.assertEqual(c["a"], 2) + self.assertEqual(c.get("a"), 2) + self.assertEqual(c.pop(), {"a": 2}) + self.assertEqual(c["a"], 1) + self.assertEqual(c.get("foo", 42), 42) diff --git a/tests/templates/custom.py b/tests/templates/custom.py new file mode 100644 index 0000000000..4aea08237d --- /dev/null +++ b/tests/templates/custom.py @@ -0,0 +1,377 @@ +from __future__ import absolute_import, unicode_literals + +from django import template +from django.utils import six +from django.utils.unittest import TestCase + +from .templatetags import custom + + +class CustomFilterTests(TestCase): + def test_filter(self): + t = template.Template("{% load custom %}{{ string|trim:5 }}") + self.assertEqual( + t.render(template.Context({"string": "abcdefghijklmnopqrstuvwxyz"})), + "abcde" + ) + + +class CustomTagTests(TestCase): + def verify_tag(self, tag, name): + self.assertEqual(tag.__name__, name) + self.assertEqual(tag.__doc__, 'Expected %s __doc__' % name) + self.assertEqual(tag.__dict__['anything'], 'Expected %s __dict__' % name) + + def test_simple_tags(self): + c = template.Context({'value': 42}) + + t = template.Template('{% load custom %}{% no_params %}') + self.assertEqual(t.render(c), 'no_params - Expected result') + + t = template.Template('{% load custom %}{% one_param 37 %}') + self.assertEqual(t.render(c), 'one_param - Expected result: 37') + + t = template.Template('{% load custom %}{% explicit_no_context 37 %}') + self.assertEqual(t.render(c), 'explicit_no_context - Expected result: 37') + + t = template.Template('{% load custom %}{% no_params_with_context %}') + self.assertEqual(t.render(c), 'no_params_with_context - Expected result (context value: 42)') + + t = template.Template('{% load custom %}{% params_and_context 37 %}') + self.assertEqual(t.render(c), 'params_and_context - Expected result (context value: 42): 37') + + t = template.Template('{% load custom %}{% simple_two_params 37 42 %}') + self.assertEqual(t.render(c), 'simple_two_params - Expected result: 37, 42') + + t = template.Template('{% load custom %}{% simple_one_default 37 %}') + self.assertEqual(t.render(c), 'simple_one_default - Expected result: 37, hi') + + t = template.Template('{% load custom %}{% simple_one_default 37 two="hello" %}') + self.assertEqual(t.render(c), 'simple_one_default - Expected result: 37, hello') + + t = template.Template('{% load custom %}{% simple_one_default one=99 two="hello" %}') + self.assertEqual(t.render(c), 'simple_one_default - Expected result: 99, hello') + + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'simple_one_default' received unexpected keyword argument 'three'", + template.Template, '{% load custom %}{% simple_one_default 99 two="hello" three="foo" %}') + + t = template.Template('{% load custom %}{% simple_one_default 37 42 %}') + self.assertEqual(t.render(c), 'simple_one_default - Expected result: 37, 42') + + t = template.Template('{% load custom %}{% simple_unlimited_args 37 %}') + self.assertEqual(t.render(c), 'simple_unlimited_args - Expected result: 37, hi') + + t = template.Template('{% load custom %}{% simple_unlimited_args 37 42 56 89 %}') + self.assertEqual(t.render(c), 'simple_unlimited_args - Expected result: 37, 42, 56, 89') + + t = template.Template('{% load custom %}{% simple_only_unlimited_args %}') + self.assertEqual(t.render(c), 'simple_only_unlimited_args - Expected result: ') + + t = template.Template('{% load custom %}{% simple_only_unlimited_args 37 42 56 89 %}') + self.assertEqual(t.render(c), 'simple_only_unlimited_args - Expected result: 37, 42, 56, 89') + + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'simple_two_params' received too many positional arguments", + template.Template, '{% load custom %}{% simple_two_params 37 42 56 %}') + + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'simple_one_default' received too many positional arguments", + template.Template, '{% load custom %}{% simple_one_default 37 42 56 %}') + + t = template.Template('{% load custom %}{% simple_unlimited_args_kwargs 37 40|add:2 56 eggs="scrambled" four=1|add:3 %}') + self.assertEqual(t.render(c), 'simple_unlimited_args_kwargs - Expected result: 37, 42, 56 / eggs=scrambled, four=4') + + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'simple_unlimited_args_kwargs' received some positional argument\(s\) after some keyword argument\(s\)", + template.Template, '{% load custom %}{% simple_unlimited_args_kwargs 37 40|add:2 eggs="scrambled" 56 four=1|add:3 %}') + + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'simple_unlimited_args_kwargs' received multiple values for keyword argument 'eggs'", + template.Template, '{% load custom %}{% simple_unlimited_args_kwargs 37 eggs="scrambled" eggs="scrambled" %}') + + def test_simple_tag_registration(self): + # Test that the decorators preserve the decorated function's docstring, name and attributes. + self.verify_tag(custom.no_params, 'no_params') + self.verify_tag(custom.one_param, 'one_param') + self.verify_tag(custom.explicit_no_context, 'explicit_no_context') + self.verify_tag(custom.no_params_with_context, 'no_params_with_context') + self.verify_tag(custom.params_and_context, 'params_and_context') + self.verify_tag(custom.simple_unlimited_args_kwargs, 'simple_unlimited_args_kwargs') + self.verify_tag(custom.simple_tag_without_context_parameter, 'simple_tag_without_context_parameter') + + def test_simple_tag_missing_context(self): + # The 'context' parameter must be present when takes_context is True + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'simple_tag_without_context_parameter' is decorated with takes_context=True so it must have a first argument of 'context'", + template.Template, '{% load custom %}{% simple_tag_without_context_parameter 123 %}') + + def test_inclusion_tags(self): + c = template.Context({'value': 42}) + + t = template.Template('{% load custom %}{% inclusion_no_params %}') + self.assertEqual(t.render(c), 'inclusion_no_params - Expected result\n') + + t = template.Template('{% load custom %}{% inclusion_one_param 37 %}') + self.assertEqual(t.render(c), 'inclusion_one_param - Expected result: 37\n') + + t = template.Template('{% load custom %}{% inclusion_explicit_no_context 37 %}') + self.assertEqual(t.render(c), 'inclusion_explicit_no_context - Expected result: 37\n') + + t = template.Template('{% load custom %}{% inclusion_no_params_with_context %}') + self.assertEqual(t.render(c), 'inclusion_no_params_with_context - Expected result (context value: 42)\n') + + t = template.Template('{% load custom %}{% inclusion_params_and_context 37 %}') + self.assertEqual(t.render(c), 'inclusion_params_and_context - Expected result (context value: 42): 37\n') + + t = template.Template('{% load custom %}{% inclusion_two_params 37 42 %}') + self.assertEqual(t.render(c), 'inclusion_two_params - Expected result: 37, 42\n') + + t = template.Template('{% load custom %}{% inclusion_one_default 37 %}') + self.assertEqual(t.render(c), 'inclusion_one_default - Expected result: 37, hi\n') + + t = template.Template('{% load custom %}{% inclusion_one_default 37 two="hello" %}') + self.assertEqual(t.render(c), 'inclusion_one_default - Expected result: 37, hello\n') + + t = template.Template('{% load custom %}{% inclusion_one_default one=99 two="hello" %}') + self.assertEqual(t.render(c), 'inclusion_one_default - Expected result: 99, hello\n') + + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'inclusion_one_default' received unexpected keyword argument 'three'", + template.Template, '{% load custom %}{% inclusion_one_default 99 two="hello" three="foo" %}') + + t = template.Template('{% load custom %}{% inclusion_one_default 37 42 %}') + self.assertEqual(t.render(c), 'inclusion_one_default - Expected result: 37, 42\n') + + t = template.Template('{% load custom %}{% inclusion_unlimited_args 37 %}') + self.assertEqual(t.render(c), 'inclusion_unlimited_args - Expected result: 37, hi\n') + + t = template.Template('{% load custom %}{% inclusion_unlimited_args 37 42 56 89 %}') + self.assertEqual(t.render(c), 'inclusion_unlimited_args - Expected result: 37, 42, 56, 89\n') + + t = template.Template('{% load custom %}{% inclusion_only_unlimited_args %}') + self.assertEqual(t.render(c), 'inclusion_only_unlimited_args - Expected result: \n') + + t = template.Template('{% load custom %}{% inclusion_only_unlimited_args 37 42 56 89 %}') + self.assertEqual(t.render(c), 'inclusion_only_unlimited_args - Expected result: 37, 42, 56, 89\n') + + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'inclusion_two_params' received too many positional arguments", + template.Template, '{% load custom %}{% inclusion_two_params 37 42 56 %}') + + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'inclusion_one_default' received too many positional arguments", + template.Template, '{% load custom %}{% inclusion_one_default 37 42 56 %}') + + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'inclusion_one_default' did not receive value\(s\) for the argument\(s\): 'one'", + template.Template, '{% load custom %}{% inclusion_one_default %}') + + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'inclusion_unlimited_args' did not receive value\(s\) for the argument\(s\): 'one'", + template.Template, '{% load custom %}{% inclusion_unlimited_args %}') + + t = template.Template('{% load custom %}{% inclusion_unlimited_args_kwargs 37 40|add:2 56 eggs="scrambled" four=1|add:3 %}') + self.assertEqual(t.render(c), 'inclusion_unlimited_args_kwargs - Expected result: 37, 42, 56 / eggs=scrambled, four=4\n') + + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'inclusion_unlimited_args_kwargs' received some positional argument\(s\) after some keyword argument\(s\)", + template.Template, '{% load custom %}{% inclusion_unlimited_args_kwargs 37 40|add:2 eggs="scrambled" 56 four=1|add:3 %}') + + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'inclusion_unlimited_args_kwargs' received multiple values for keyword argument 'eggs'", + template.Template, '{% load custom %}{% inclusion_unlimited_args_kwargs 37 eggs="scrambled" eggs="scrambled" %}') + + def test_include_tag_missing_context(self): + # The 'context' parameter must be present when takes_context is True + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'inclusion_tag_without_context_parameter' is decorated with takes_context=True so it must have a first argument of 'context'", + template.Template, '{% load custom %}{% inclusion_tag_without_context_parameter 123 %}') + + def test_inclusion_tags_from_template(self): + c = template.Context({'value': 42}) + + t = template.Template('{% load custom %}{% inclusion_no_params_from_template %}') + self.assertEqual(t.render(c), 'inclusion_no_params_from_template - Expected result\n') + + t = template.Template('{% load custom %}{% inclusion_one_param_from_template 37 %}') + self.assertEqual(t.render(c), 'inclusion_one_param_from_template - Expected result: 37\n') + + t = template.Template('{% load custom %}{% inclusion_explicit_no_context_from_template 37 %}') + self.assertEqual(t.render(c), 'inclusion_explicit_no_context_from_template - Expected result: 37\n') + + t = template.Template('{% load custom %}{% inclusion_no_params_with_context_from_template %}') + self.assertEqual(t.render(c), 'inclusion_no_params_with_context_from_template - Expected result (context value: 42)\n') + + t = template.Template('{% load custom %}{% inclusion_params_and_context_from_template 37 %}') + self.assertEqual(t.render(c), 'inclusion_params_and_context_from_template - Expected result (context value: 42): 37\n') + + t = template.Template('{% load custom %}{% inclusion_two_params_from_template 37 42 %}') + self.assertEqual(t.render(c), 'inclusion_two_params_from_template - Expected result: 37, 42\n') + + t = template.Template('{% load custom %}{% inclusion_one_default_from_template 37 %}') + self.assertEqual(t.render(c), 'inclusion_one_default_from_template - Expected result: 37, hi\n') + + t = template.Template('{% load custom %}{% inclusion_one_default_from_template 37 42 %}') + self.assertEqual(t.render(c), 'inclusion_one_default_from_template - Expected result: 37, 42\n') + + t = template.Template('{% load custom %}{% inclusion_unlimited_args_from_template 37 %}') + self.assertEqual(t.render(c), 'inclusion_unlimited_args_from_template - Expected result: 37, hi\n') + + t = template.Template('{% load custom %}{% inclusion_unlimited_args_from_template 37 42 56 89 %}') + self.assertEqual(t.render(c), 'inclusion_unlimited_args_from_template - Expected result: 37, 42, 56, 89\n') + + t = template.Template('{% load custom %}{% inclusion_only_unlimited_args_from_template %}') + self.assertEqual(t.render(c), 'inclusion_only_unlimited_args_from_template - Expected result: \n') + + t = template.Template('{% load custom %}{% inclusion_only_unlimited_args_from_template 37 42 56 89 %}') + self.assertEqual(t.render(c), 'inclusion_only_unlimited_args_from_template - Expected result: 37, 42, 56, 89\n') + + def test_inclusion_tag_registration(self): + # Test that the decorators preserve the decorated function's docstring, name and attributes. + self.verify_tag(custom.inclusion_no_params, 'inclusion_no_params') + self.verify_tag(custom.inclusion_one_param, 'inclusion_one_param') + self.verify_tag(custom.inclusion_explicit_no_context, 'inclusion_explicit_no_context') + self.verify_tag(custom.inclusion_no_params_with_context, 'inclusion_no_params_with_context') + self.verify_tag(custom.inclusion_params_and_context, 'inclusion_params_and_context') + self.verify_tag(custom.inclusion_two_params, 'inclusion_two_params') + self.verify_tag(custom.inclusion_one_default, 'inclusion_one_default') + self.verify_tag(custom.inclusion_unlimited_args, 'inclusion_unlimited_args') + self.verify_tag(custom.inclusion_only_unlimited_args, 'inclusion_only_unlimited_args') + self.verify_tag(custom.inclusion_tag_without_context_parameter, 'inclusion_tag_without_context_parameter') + self.verify_tag(custom.inclusion_tag_use_l10n, 'inclusion_tag_use_l10n') + self.verify_tag(custom.inclusion_tag_current_app, 'inclusion_tag_current_app') + self.verify_tag(custom.inclusion_unlimited_args_kwargs, 'inclusion_unlimited_args_kwargs') + + def test_15070_current_app(self): + """ + Test that inclusion tag passes down `current_app` of context to the + Context of the included/rendered template as well. + """ + c = template.Context({}) + t = template.Template('{% load custom %}{% inclusion_tag_current_app %}') + self.assertEqual(t.render(c).strip(), 'None') + + c.current_app = 'advanced' + self.assertEqual(t.render(c).strip(), 'advanced') + + def test_15070_use_l10n(self): + """ + Test that inclusion tag passes down `use_l10n` of context to the + Context of the included/rendered template as well. + """ + c = template.Context({}) + t = template.Template('{% load custom %}{% inclusion_tag_use_l10n %}') + self.assertEqual(t.render(c).strip(), 'None') + + c.use_l10n = True + self.assertEqual(t.render(c).strip(), 'True') + + def test_assignment_tags(self): + c = template.Context({'value': 42}) + + t = template.Template('{% load custom %}{% assignment_no_params as var %}The result is: {{ var }}') + self.assertEqual(t.render(c), 'The result is: assignment_no_params - Expected result') + + t = template.Template('{% load custom %}{% assignment_one_param 37 as var %}The result is: {{ var }}') + self.assertEqual(t.render(c), 'The result is: assignment_one_param - Expected result: 37') + + t = template.Template('{% load custom %}{% assignment_explicit_no_context 37 as var %}The result is: {{ var }}') + self.assertEqual(t.render(c), 'The result is: assignment_explicit_no_context - Expected result: 37') + + t = template.Template('{% load custom %}{% assignment_no_params_with_context as var %}The result is: {{ var }}') + self.assertEqual(t.render(c), 'The result is: assignment_no_params_with_context - Expected result (context value: 42)') + + t = template.Template('{% load custom %}{% assignment_params_and_context 37 as var %}The result is: {{ var }}') + self.assertEqual(t.render(c), 'The result is: assignment_params_and_context - Expected result (context value: 42): 37') + + t = template.Template('{% load custom %}{% assignment_two_params 37 42 as var %}The result is: {{ var }}') + self.assertEqual(t.render(c), 'The result is: assignment_two_params - Expected result: 37, 42') + + t = template.Template('{% load custom %}{% assignment_one_default 37 as var %}The result is: {{ var }}') + self.assertEqual(t.render(c), 'The result is: assignment_one_default - Expected result: 37, hi') + + t = template.Template('{% load custom %}{% assignment_one_default 37 two="hello" as var %}The result is: {{ var }}') + self.assertEqual(t.render(c), 'The result is: assignment_one_default - Expected result: 37, hello') + + t = template.Template('{% load custom %}{% assignment_one_default one=99 two="hello" as var %}The result is: {{ var }}') + self.assertEqual(t.render(c), 'The result is: assignment_one_default - Expected result: 99, hello') + + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'assignment_one_default' received unexpected keyword argument 'three'", + template.Template, '{% load custom %}{% assignment_one_default 99 two="hello" three="foo" as var %}') + + t = template.Template('{% load custom %}{% assignment_one_default 37 42 as var %}The result is: {{ var }}') + self.assertEqual(t.render(c), 'The result is: assignment_one_default - Expected result: 37, 42') + + t = template.Template('{% load custom %}{% assignment_unlimited_args 37 as var %}The result is: {{ var }}') + self.assertEqual(t.render(c), 'The result is: assignment_unlimited_args - Expected result: 37, hi') + + t = template.Template('{% load custom %}{% assignment_unlimited_args 37 42 56 89 as var %}The result is: {{ var }}') + self.assertEqual(t.render(c), 'The result is: assignment_unlimited_args - Expected result: 37, 42, 56, 89') + + t = template.Template('{% load custom %}{% assignment_only_unlimited_args as var %}The result is: {{ var }}') + self.assertEqual(t.render(c), 'The result is: assignment_only_unlimited_args - Expected result: ') + + t = template.Template('{% load custom %}{% assignment_only_unlimited_args 37 42 56 89 as var %}The result is: {{ var }}') + self.assertEqual(t.render(c), 'The result is: assignment_only_unlimited_args - Expected result: 37, 42, 56, 89') + + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'assignment_one_param' tag takes at least 2 arguments and the second last argument must be 'as'", + template.Template, '{% load custom %}{% assignment_one_param 37 %}The result is: {{ var }}') + + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'assignment_one_param' tag takes at least 2 arguments and the second last argument must be 'as'", + template.Template, '{% load custom %}{% assignment_one_param 37 as %}The result is: {{ var }}') + + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'assignment_one_param' tag takes at least 2 arguments and the second last argument must be 'as'", + template.Template, '{% load custom %}{% assignment_one_param 37 ass var %}The result is: {{ var }}') + + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'assignment_two_params' received too many positional arguments", + template.Template, '{% load custom %}{% assignment_two_params 37 42 56 as var %}The result is: {{ var }}') + + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'assignment_one_default' received too many positional arguments", + template.Template, '{% load custom %}{% assignment_one_default 37 42 56 as var %}The result is: {{ var }}') + + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'assignment_one_default' did not receive value\(s\) for the argument\(s\): 'one'", + template.Template, '{% load custom %}{% assignment_one_default as var %}The result is: {{ var }}') + + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'assignment_unlimited_args' did not receive value\(s\) for the argument\(s\): 'one'", + template.Template, '{% load custom %}{% assignment_unlimited_args as var %}The result is: {{ var }}') + + t = template.Template('{% load custom %}{% assignment_unlimited_args_kwargs 37 40|add:2 56 eggs="scrambled" four=1|add:3 as var %}The result is: {{ var }}') + self.assertEqual(t.render(c), 'The result is: assignment_unlimited_args_kwargs - Expected result: 37, 42, 56 / eggs=scrambled, four=4') + + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'assignment_unlimited_args_kwargs' received some positional argument\(s\) after some keyword argument\(s\)", + template.Template, '{% load custom %}{% assignment_unlimited_args_kwargs 37 40|add:2 eggs="scrambled" 56 four=1|add:3 as var %}The result is: {{ var }}') + + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'assignment_unlimited_args_kwargs' received multiple values for keyword argument 'eggs'", + template.Template, '{% load custom %}{% assignment_unlimited_args_kwargs 37 eggs="scrambled" eggs="scrambled" as var %}The result is: {{ var }}') + + def test_assignment_tag_registration(self): + # Test that the decorators preserve the decorated function's docstring, name and attributes. + self.verify_tag(custom.assignment_no_params, 'assignment_no_params') + self.verify_tag(custom.assignment_one_param, 'assignment_one_param') + self.verify_tag(custom.assignment_explicit_no_context, 'assignment_explicit_no_context') + self.verify_tag(custom.assignment_no_params_with_context, 'assignment_no_params_with_context') + self.verify_tag(custom.assignment_params_and_context, 'assignment_params_and_context') + self.verify_tag(custom.assignment_one_default, 'assignment_one_default') + self.verify_tag(custom.assignment_two_params, 'assignment_two_params') + self.verify_tag(custom.assignment_unlimited_args, 'assignment_unlimited_args') + self.verify_tag(custom.assignment_only_unlimited_args, 'assignment_only_unlimited_args') + self.verify_tag(custom.assignment_unlimited_args, 'assignment_unlimited_args') + self.verify_tag(custom.assignment_unlimited_args_kwargs, 'assignment_unlimited_args_kwargs') + self.verify_tag(custom.assignment_tag_without_context_parameter, 'assignment_tag_without_context_parameter') + + def test_assignment_tag_missing_context(self): + # The 'context' parameter must be present when takes_context is True + six.assertRaisesRegex(self, template.TemplateSyntaxError, + "'assignment_tag_without_context_parameter' is decorated with takes_context=True so it must have a first argument of 'context'", + template.Template, '{% load custom %}{% assignment_tag_without_context_parameter 123 as var %}') diff --git a/tests/templates/eggs/tagsegg.egg b/tests/templates/eggs/tagsegg.egg Binary files differnew file mode 100644 index 0000000000..3941914b81 --- /dev/null +++ b/tests/templates/eggs/tagsegg.egg diff --git a/tests/templates/filters.py b/tests/templates/filters.py new file mode 100644 index 0000000000..7ba1681fd5 --- /dev/null +++ b/tests/templates/filters.py @@ -0,0 +1,371 @@ +# coding: utf-8 +""" +Tests for template filters (as opposed to template tags). + +The tests are hidden inside a function so that things like timestamps and +timezones are only evaluated at the moment of execution and will therefore be +consistent. +""" +from __future__ import unicode_literals + +from datetime import date, datetime, time, timedelta + +from django.test.utils import str_prefix +from django.utils.tzinfo import LocalTimezone, FixedOffset +from django.utils.safestring import mark_safe +from django.utils.encoding import python_2_unicode_compatible + +# These two classes are used to test auto-escaping of __unicode__ output. +@python_2_unicode_compatible +class UnsafeClass: + def __str__(self): + return 'you & me' + +@python_2_unicode_compatible +class SafeClass: + def __str__(self): + return mark_safe('you > me') + +# RESULT SYNTAX -- +# 'template_name': ('template contents', 'context dict', +# 'expected string output' or Exception class) +def get_filter_tests(): + now = datetime.now() + now_tz = datetime.now(LocalTimezone(now)) + now_tz_i = datetime.now(FixedOffset((3 * 60) + 15)) # imaginary time zone + today = date.today() + + return { + # Default compare with datetime.now() + 'filter-timesince01' : ('{{ a|timesince }}', {'a': datetime.now() + timedelta(minutes=-1, seconds = -10)}, '1 minute'), + 'filter-timesince02' : ('{{ a|timesince }}', {'a': datetime.now() - timedelta(days=1, minutes = 1)}, '1 day'), + 'filter-timesince03' : ('{{ a|timesince }}', {'a': datetime.now() - timedelta(hours=1, minutes=25, seconds = 10)}, '1 hour, 25 minutes'), + + # Compare to a given parameter + 'filter-timesince04' : ('{{ a|timesince:b }}', {'a':now - timedelta(days=2), 'b':now - timedelta(days=1)}, '1 day'), + 'filter-timesince05' : ('{{ a|timesince:b }}', {'a':now - timedelta(days=2, minutes=1), 'b':now - timedelta(days=2)}, '1 minute'), + + # Check that timezone is respected + 'filter-timesince06' : ('{{ a|timesince:b }}', {'a':now_tz - timedelta(hours=8), 'b':now_tz}, '8 hours'), + + # Regression for #7443 + 'filter-timesince07': ('{{ earlier|timesince }}', { 'earlier': now - timedelta(days=7) }, '1 week'), + 'filter-timesince08': ('{{ earlier|timesince:now }}', { 'now': now, 'earlier': now - timedelta(days=7) }, '1 week'), + 'filter-timesince09': ('{{ later|timesince }}', { 'later': now + timedelta(days=7) }, '0 minutes'), + 'filter-timesince10': ('{{ later|timesince:now }}', { 'now': now, 'later': now + timedelta(days=7) }, '0 minutes'), + + # Ensures that differing timezones are calculated correctly + 'filter-timesince11' : ('{{ a|timesince }}', {'a': now}, '0 minutes'), + 'filter-timesince12' : ('{{ a|timesince }}', {'a': now_tz}, '0 minutes'), + 'filter-timesince13' : ('{{ a|timesince }}', {'a': now_tz_i}, '0 minutes'), + 'filter-timesince14' : ('{{ a|timesince:b }}', {'a': now_tz, 'b': now_tz_i}, '0 minutes'), + 'filter-timesince15' : ('{{ a|timesince:b }}', {'a': now, 'b': now_tz_i}, ''), + 'filter-timesince16' : ('{{ a|timesince:b }}', {'a': now_tz_i, 'b': now}, ''), + + # Regression for #9065 (two date objects). + 'filter-timesince17' : ('{{ a|timesince:b }}', {'a': today, 'b': today}, '0 minutes'), + 'filter-timesince18' : ('{{ a|timesince:b }}', {'a': today, 'b': today + timedelta(hours=24)}, '1 day'), + + # Default compare with datetime.now() + 'filter-timeuntil01' : ('{{ a|timeuntil }}', {'a':datetime.now() + timedelta(minutes=2, seconds = 10)}, '2 minutes'), + 'filter-timeuntil02' : ('{{ a|timeuntil }}', {'a':(datetime.now() + timedelta(days=1, seconds = 10))}, '1 day'), + 'filter-timeuntil03' : ('{{ a|timeuntil }}', {'a':(datetime.now() + timedelta(hours=8, minutes=10, seconds = 10))}, '8 hours, 10 minutes'), + + # Compare to a given parameter + 'filter-timeuntil04' : ('{{ a|timeuntil:b }}', {'a':now - timedelta(days=1), 'b':now - timedelta(days=2)}, '1 day'), + 'filter-timeuntil05' : ('{{ a|timeuntil:b }}', {'a':now - timedelta(days=2), 'b':now - timedelta(days=2, minutes=1)}, '1 minute'), + + # Regression for #7443 + 'filter-timeuntil06': ('{{ earlier|timeuntil }}', { 'earlier': now - timedelta(days=7) }, '0 minutes'), + 'filter-timeuntil07': ('{{ earlier|timeuntil:now }}', { 'now': now, 'earlier': now - timedelta(days=7) }, '0 minutes'), + 'filter-timeuntil08': ('{{ later|timeuntil }}', { 'later': now + timedelta(days=7, hours=1) }, '1 week'), + 'filter-timeuntil09': ('{{ later|timeuntil:now }}', { 'now': now, 'later': now + timedelta(days=7) }, '1 week'), + + # Ensures that differing timezones are calculated correctly + 'filter-timeuntil10' : ('{{ a|timeuntil }}', {'a': now_tz_i}, '0 minutes'), + 'filter-timeuntil11' : ('{{ a|timeuntil:b }}', {'a': now_tz_i, 'b': now_tz}, '0 minutes'), + + # Regression for #9065 (two date objects). + 'filter-timeuntil12' : ('{{ a|timeuntil:b }}', {'a': today, 'b': today}, '0 minutes'), + 'filter-timeuntil13' : ('{{ a|timeuntil:b }}', {'a': today, 'b': today - timedelta(hours=24)}, '1 day'), + + 'filter-addslash01': ("{% autoescape off %}{{ a|addslashes }} {{ b|addslashes }}{% endautoescape %}", {"a": "<a>'", "b": mark_safe("<a>'")}, r"<a>\' <a>\'"), + 'filter-addslash02': ("{{ a|addslashes }} {{ b|addslashes }}", {"a": "<a>'", "b": mark_safe("<a>'")}, r"<a>\' <a>\'"), + + 'filter-capfirst01': ("{% autoescape off %}{{ a|capfirst }} {{ b|capfirst }}{% endautoescape %}", {"a": "fred>", "b": mark_safe("fred>")}, "Fred> Fred>"), + 'filter-capfirst02': ("{{ a|capfirst }} {{ b|capfirst }}", {"a": "fred>", "b": mark_safe("fred>")}, "Fred> Fred>"), + + # Note that applying fix_ampsersands in autoescape mode leads to + # double escaping. + 'filter-fix_ampersands01': ("{% autoescape off %}{{ a|fix_ampersands }} {{ b|fix_ampersands }}{% endautoescape %}", {"a": "a&b", "b": mark_safe("a&b")}, "a&b a&b"), + 'filter-fix_ampersands02': ("{{ a|fix_ampersands }} {{ b|fix_ampersands }}", {"a": "a&b", "b": mark_safe("a&b")}, "a&amp;b a&b"), + + 'filter-floatformat01': ("{% autoescape off %}{{ a|floatformat }} {{ b|floatformat }}{% endautoescape %}", {"a": "1.42", "b": mark_safe("1.42")}, "1.4 1.4"), + 'filter-floatformat02': ("{{ a|floatformat }} {{ b|floatformat }}", {"a": "1.42", "b": mark_safe("1.42")}, "1.4 1.4"), + + # The contents of "linenumbers" is escaped according to the current + # autoescape setting. + 'filter-linenumbers01': ("{{ a|linenumbers }} {{ b|linenumbers }}", {"a": "one\n<two>\nthree", "b": mark_safe("one\n<two>\nthree")}, "1. one\n2. <two>\n3. three 1. one\n2. <two>\n3. three"), + 'filter-linenumbers02': ("{% autoescape off %}{{ a|linenumbers }} {{ b|linenumbers }}{% endautoescape %}", {"a": "one\n<two>\nthree", "b": mark_safe("one\n<two>\nthree")}, "1. one\n2. <two>\n3. three 1. one\n2. <two>\n3. three"), + + 'filter-lower01': ("{% autoescape off %}{{ a|lower }} {{ b|lower }}{% endautoescape %}", {"a": "Apple & banana", "b": mark_safe("Apple & banana")}, "apple & banana apple & banana"), + 'filter-lower02': ("{{ a|lower }} {{ b|lower }}", {"a": "Apple & banana", "b": mark_safe("Apple & banana")}, "apple & banana apple & banana"), + + # The make_list filter can destroy existing escaping, so the results are + # escaped. + 'filter-make_list01': ("{% autoescape off %}{{ a|make_list }}{% endautoescape %}", {"a": mark_safe("&")}, str_prefix("[%(_)s'&']")), + 'filter-make_list02': ("{{ a|make_list }}", {"a": mark_safe("&")}, str_prefix("[%(_)s'&']")), + 'filter-make_list03': ('{% autoescape off %}{{ a|make_list|stringformat:"s"|safe }}{% endautoescape %}', {"a": mark_safe("&")}, str_prefix("[%(_)s'&']")), + 'filter-make_list04': ('{{ a|make_list|stringformat:"s"|safe }}', {"a": mark_safe("&")}, str_prefix("[%(_)s'&']")), + + # Running slugify on a pre-escaped string leads to odd behavior, + # but the result is still safe. + 'filter-slugify01': ("{% autoescape off %}{{ a|slugify }} {{ b|slugify }}{% endautoescape %}", {"a": "a & b", "b": mark_safe("a & b")}, "a-b a-amp-b"), + 'filter-slugify02': ("{{ a|slugify }} {{ b|slugify }}", {"a": "a & b", "b": mark_safe("a & b")}, "a-b a-amp-b"), + + # Notice that escaping is applied *after* any filters, so the string + # formatting here only needs to deal with pre-escaped characters. + 'filter-stringformat01': ('{% autoescape off %}.{{ a|stringformat:"5s" }}. .{{ b|stringformat:"5s" }}.{% endautoescape %}', + {"a": "a<b", "b": mark_safe("a<b")}, ". a<b. . a<b."), + 'filter-stringformat02': ('.{{ a|stringformat:"5s" }}. .{{ b|stringformat:"5s" }}.', {"a": "a<b", "b": mark_safe("a<b")}, + ". a<b. . a<b."), + + # Test the title filter + 'filter-title1' : ('{{ a|title }}', {'a' : 'JOE\'S CRAB SHACK'}, 'Joe's Crab Shack'), + 'filter-title2' : ('{{ a|title }}', {'a' : '555 WEST 53RD STREET'}, '555 West 53rd Street'), + + 'filter-truncatewords01': ('{% autoescape off %}{{ a|truncatewords:"2" }} {{ b|truncatewords:"2"}}{% endautoescape %}', + {"a": "alpha & bravo", "b": mark_safe("alpha & bravo")}, "alpha & ... alpha & ..."), + 'filter-truncatewords02': ('{{ a|truncatewords:"2" }} {{ b|truncatewords:"2"}}', + {"a": "alpha & bravo", "b": mark_safe("alpha & bravo")}, "alpha & ... alpha & ..."), + + 'filter-truncatechars01': ('{{ a|truncatechars:5 }}', {'a': "Testing, testing"}, "Te..."), + 'filter-truncatechars02': ('{{ a|truncatechars:7 }}', {'a': "Testing"}, "Testing"), + + # The "upper" filter messes up entities (which are case-sensitive), + # so it's not safe for non-escaping purposes. + 'filter-upper01': ('{% autoescape off %}{{ a|upper }} {{ b|upper }}{% endautoescape %}', {"a": "a & b", "b": mark_safe("a & b")}, "A & B A & B"), + 'filter-upper02': ('{{ a|upper }} {{ b|upper }}', {"a": "a & b", "b": mark_safe("a & b")}, "A & B A &AMP; B"), + + 'filter-urlize01': ('{% autoescape off %}{{ a|urlize }} {{ b|urlize }}{% endautoescape %}', {"a": "http://example.com/?x=&y=", "b": mark_safe("http://example.com?x=&y=")}, '<a href="http://example.com/?x=&y=" rel="nofollow">http://example.com/?x=&y=</a> <a href="http://example.com?x=&y=" rel="nofollow">http://example.com?x=&y=</a>'), + 'filter-urlize02': ('{{ a|urlize }} {{ b|urlize }}', {"a": "http://example.com/?x=&y=", "b": mark_safe("http://example.com?x=&y=")}, '<a href="http://example.com/?x=&y=" rel="nofollow">http://example.com/?x=&y=</a> <a href="http://example.com?x=&y=" rel="nofollow">http://example.com?x=&y=</a>'), + 'filter-urlize03': ('{% autoescape off %}{{ a|urlize }}{% endautoescape %}', {"a": mark_safe("a & b")}, 'a & b'), + 'filter-urlize04': ('{{ a|urlize }}', {"a": mark_safe("a & b")}, 'a & b'), + + # This will lead to a nonsense result, but at least it won't be + # exploitable for XSS purposes when auto-escaping is on. + 'filter-urlize05': ('{% autoescape off %}{{ a|urlize }}{% endautoescape %}', {"a": "<script>alert('foo')</script>"}, "<script>alert('foo')</script>"), + 'filter-urlize06': ('{{ a|urlize }}', {"a": "<script>alert('foo')</script>"}, '<script>alert('foo')</script>'), + + # mailto: testing for urlize + 'filter-urlize07': ('{{ a|urlize }}', {"a": "Email me at me@example.com"}, 'Email me at <a href="mailto:me@example.com">me@example.com</a>'), + 'filter-urlize08': ('{{ a|urlize }}', {"a": "Email me at <me@example.com>"}, 'Email me at <<a href="mailto:me@example.com">me@example.com</a>>'), + + 'filter-urlizetrunc01': ('{% autoescape off %}{{ a|urlizetrunc:"8" }} {{ b|urlizetrunc:"8" }}{% endautoescape %}', {"a": '"Unsafe" http://example.com/x=&y=', "b": mark_safe('"Safe" http://example.com?x=&y=')}, '"Unsafe" <a href="http://example.com/x=&y=" rel="nofollow">http:...</a> "Safe" <a href="http://example.com?x=&y=" rel="nofollow">http:...</a>'), + 'filter-urlizetrunc02': ('{{ a|urlizetrunc:"8" }} {{ b|urlizetrunc:"8" }}', {"a": '"Unsafe" http://example.com/x=&y=', "b": mark_safe('"Safe" http://example.com?x=&y=')}, '"Unsafe" <a href="http://example.com/x=&y=" rel="nofollow">http:...</a> "Safe" <a href="http://example.com?x=&y=" rel="nofollow">http:...</a>'), + + 'filter-wordcount01': ('{% autoescape off %}{{ a|wordcount }} {{ b|wordcount }}{% endautoescape %}', {"a": "a & b", "b": mark_safe("a & b")}, "3 3"), + 'filter-wordcount02': ('{{ a|wordcount }} {{ b|wordcount }}', {"a": "a & b", "b": mark_safe("a & b")}, "3 3"), + + 'filter-wordwrap01': ('{% autoescape off %}{{ a|wordwrap:"3" }} {{ b|wordwrap:"3" }}{% endautoescape %}', {"a": "a & b", "b": mark_safe("a & b")}, "a &\nb a &\nb"), + 'filter-wordwrap02': ('{{ a|wordwrap:"3" }} {{ b|wordwrap:"3" }}', {"a": "a & b", "b": mark_safe("a & b")}, "a &\nb a &\nb"), + + 'filter-ljust01': ('{% autoescape off %}.{{ a|ljust:"5" }}. .{{ b|ljust:"5" }}.{% endautoescape %}', {"a": "a&b", "b": mark_safe("a&b")}, ".a&b . .a&b ."), + 'filter-ljust02': ('.{{ a|ljust:"5" }}. .{{ b|ljust:"5" }}.', {"a": "a&b", "b": mark_safe("a&b")}, ".a&b . .a&b ."), + + 'filter-rjust01': ('{% autoescape off %}.{{ a|rjust:"5" }}. .{{ b|rjust:"5" }}.{% endautoescape %}', {"a": "a&b", "b": mark_safe("a&b")}, ". a&b. . a&b."), + 'filter-rjust02': ('.{{ a|rjust:"5" }}. .{{ b|rjust:"5" }}.', {"a": "a&b", "b": mark_safe("a&b")}, ". a&b. . a&b."), + + 'filter-center01': ('{% autoescape off %}.{{ a|center:"5" }}. .{{ b|center:"5" }}.{% endautoescape %}', {"a": "a&b", "b": mark_safe("a&b")}, ". a&b . . a&b ."), + 'filter-center02': ('.{{ a|center:"5" }}. .{{ b|center:"5" }}.', {"a": "a&b", "b": mark_safe("a&b")}, ". a&b . . a&b ."), + + 'filter-cut01': ('{% autoescape off %}{{ a|cut:"x" }} {{ b|cut:"x" }}{% endautoescape %}', {"a": "x&y", "b": mark_safe("x&y")}, "&y &y"), + 'filter-cut02': ('{{ a|cut:"x" }} {{ b|cut:"x" }}', {"a": "x&y", "b": mark_safe("x&y")}, "&y &y"), + 'filter-cut03': ('{% autoescape off %}{{ a|cut:"&" }} {{ b|cut:"&" }}{% endautoescape %}', {"a": "x&y", "b": mark_safe("x&y")}, "xy xamp;y"), + 'filter-cut04': ('{{ a|cut:"&" }} {{ b|cut:"&" }}', {"a": "x&y", "b": mark_safe("x&y")}, "xy xamp;y"), + # Passing ';' to cut can break existing HTML entities, so those strings + # are auto-escaped. + 'filter-cut05': ('{% autoescape off %}{{ a|cut:";" }} {{ b|cut:";" }}{% endautoescape %}', {"a": "x&y", "b": mark_safe("x&y")}, "x&y x&y"), + 'filter-cut06': ('{{ a|cut:";" }} {{ b|cut:";" }}', {"a": "x&y", "b": mark_safe("x&y")}, "x&y x&ampy"), + + # The "escape" filter works the same whether autoescape is on or off, + # but it has no effect on strings already marked as safe. + 'filter-escape01': ('{{ a|escape }} {{ b|escape }}', {"a": "x&y", "b": mark_safe("x&y")}, "x&y x&y"), + 'filter-escape02': ('{% autoescape off %}{{ a|escape }} {{ b|escape }}{% endautoescape %}', {"a": "x&y", "b": mark_safe("x&y")}, "x&y x&y"), + + # It is only applied once, regardless of the number of times it + # appears in a chain. + 'filter-escape03': ('{% autoescape off %}{{ a|escape|escape }}{% endautoescape %}', {"a": "x&y"}, "x&y"), + 'filter-escape04': ('{{ a|escape|escape }}', {"a": "x&y"}, "x&y"), + + # Force_escape is applied immediately. It can be used to provide + # double-escaping, for example. + 'filter-force-escape01': ('{% autoescape off %}{{ a|force_escape }}{% endautoescape %}', {"a": "x&y"}, "x&y"), + 'filter-force-escape02': ('{{ a|force_escape }}', {"a": "x&y"}, "x&y"), + 'filter-force-escape03': ('{% autoescape off %}{{ a|force_escape|force_escape }}{% endautoescape %}', {"a": "x&y"}, "x&amp;y"), + 'filter-force-escape04': ('{{ a|force_escape|force_escape }}', {"a": "x&y"}, "x&amp;y"), + + # Because the result of force_escape is "safe", an additional + # escape filter has no effect. + 'filter-force-escape05': ('{% autoescape off %}{{ a|force_escape|escape }}{% endautoescape %}', {"a": "x&y"}, "x&y"), + 'filter-force-escape06': ('{{ a|force_escape|escape }}', {"a": "x&y"}, "x&y"), + 'filter-force-escape07': ('{% autoescape off %}{{ a|escape|force_escape }}{% endautoescape %}', {"a": "x&y"}, "x&y"), + 'filter-force-escape08': ('{{ a|escape|force_escape }}', {"a": "x&y"}, "x&y"), + + # The contents in "linebreaks" and "linebreaksbr" are escaped + # according to the current autoescape setting. + 'filter-linebreaks01': ('{{ a|linebreaks }} {{ b|linebreaks }}', {"a": "x&\ny", "b": mark_safe("x&\ny")}, "<p>x&<br />y</p> <p>x&<br />y</p>"), + 'filter-linebreaks02': ('{% autoescape off %}{{ a|linebreaks }} {{ b|linebreaks }}{% endautoescape %}', {"a": "x&\ny", "b": mark_safe("x&\ny")}, "<p>x&<br />y</p> <p>x&<br />y</p>"), + + 'filter-linebreaksbr01': ('{{ a|linebreaksbr }} {{ b|linebreaksbr }}', {"a": "x&\ny", "b": mark_safe("x&\ny")}, "x&<br />y x&<br />y"), + 'filter-linebreaksbr02': ('{% autoescape off %}{{ a|linebreaksbr }} {{ b|linebreaksbr }}{% endautoescape %}', {"a": "x&\ny", "b": mark_safe("x&\ny")}, "x&<br />y x&<br />y"), + + 'filter-safe01': ("{{ a }} -- {{ a|safe }}", {"a": "<b>hello</b>"}, "<b>hello</b> -- <b>hello</b>"), + 'filter-safe02': ("{% autoescape off %}{{ a }} -- {{ a|safe }}{% endautoescape %}", {"a": "<b>hello</b>"}, "<b>hello</b> -- <b>hello</b>"), + + 'filter-safeseq01': ('{{ a|join:", " }} -- {{ a|safeseq|join:", " }}', {"a": ["&", "<"]}, "&, < -- &, <"), + 'filter-safeseq02': ('{% autoescape off %}{{ a|join:", " }} -- {{ a|safeseq|join:", " }}{% endautoescape %}', {"a": ["&", "<"]}, "&, < -- &, <"), + + 'filter-removetags01': ('{{ a|removetags:"a b" }} {{ b|removetags:"a b" }}', {"a": "<a>x</a> <p><b>y</b></p>", "b": mark_safe("<a>x</a> <p><b>y</b></p>")}, "x <p>y</p> x <p>y</p>"), + 'filter-removetags02': ('{% autoescape off %}{{ a|removetags:"a b" }} {{ b|removetags:"a b" }}{% endautoescape %}', {"a": "<a>x</a> <p><b>y</b></p>", "b": mark_safe("<a>x</a> <p><b>y</b></p>")}, "x <p>y</p> x <p>y</p>"), + + 'filter-striptags01': ('{{ a|striptags }} {{ b|striptags }}', {"a": "<a>x</a> <p><b>y</b></p>", "b": mark_safe("<a>x</a> <p><b>y</b></p>")}, "x y x y"), + 'filter-striptags02': ('{% autoescape off %}{{ a|striptags }} {{ b|striptags }}{% endautoescape %}', {"a": "<a>x</a> <p><b>y</b></p>", "b": mark_safe("<a>x</a> <p><b>y</b></p>")}, "x y x y"), + + 'filter-first01': ('{{ a|first }} {{ b|first }}', {"a": ["a&b", "x"], "b": [mark_safe("a&b"), "x"]}, "a&b a&b"), + 'filter-first02': ('{% autoescape off %}{{ a|first }} {{ b|first }}{% endautoescape %}', {"a": ["a&b", "x"], "b": [mark_safe("a&b"), "x"]}, "a&b a&b"), + + 'filter-last01': ('{{ a|last }} {{ b|last }}', {"a": ["x", "a&b"], "b": ["x", mark_safe("a&b")]}, "a&b a&b"), + 'filter-last02': ('{% autoescape off %}{{ a|last }} {{ b|last }}{% endautoescape %}', {"a": ["x", "a&b"], "b": ["x", mark_safe("a&b")]}, "a&b a&b"), + + 'filter-random01': ('{{ a|random }} {{ b|random }}', {"a": ["a&b", "a&b"], "b": [mark_safe("a&b"), mark_safe("a&b")]}, "a&b a&b"), + 'filter-random02': ('{% autoescape off %}{{ a|random }} {{ b|random }}{% endautoescape %}', {"a": ["a&b", "a&b"], "b": [mark_safe("a&b"), mark_safe("a&b")]}, "a&b a&b"), + + 'filter-slice01': ('{{ a|slice:"1:3" }} {{ b|slice:"1:3" }}', {"a": "a&b", "b": mark_safe("a&b")}, "&b &b"), + 'filter-slice02': ('{% autoescape off %}{{ a|slice:"1:3" }} {{ b|slice:"1:3" }}{% endautoescape %}', {"a": "a&b", "b": mark_safe("a&b")}, "&b &b"), + + 'filter-unordered_list01': ('{{ a|unordered_list }}', {"a": ["x>", [["<y", []]]]}, "\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>"), + 'filter-unordered_list02': ('{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}', {"a": ["x>", [["<y", []]]]}, "\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>"), + 'filter-unordered_list03': ('{{ a|unordered_list }}', {"a": ["x>", [[mark_safe("<y"), []]]]}, "\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>"), + 'filter-unordered_list04': ('{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}', {"a": ["x>", [[mark_safe("<y"), []]]]}, "\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>"), + 'filter-unordered_list05': ('{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}', {"a": ["x>", [["<y", []]]]}, "\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>"), + + # 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. + 'filter-default01': ('{{ a|default:"x<" }}', {"a": ""}, "x<"), + 'filter-default02': ('{% autoescape off %}{{ a|default:"x<" }}{% endautoescape %}', {"a": ""}, "x<"), + 'filter-default03': ('{{ a|default:"x<" }}', {"a": mark_safe("x>")}, "x>"), + 'filter-default04': ('{% autoescape off %}{{ a|default:"x<" }}{% endautoescape %}', {"a": mark_safe("x>")}, "x>"), + + 'filter-default_if_none01': ('{{ a|default:"x<" }}', {"a": None}, "x<"), + 'filter-default_if_none02': ('{% autoescape off %}{{ a|default:"x<" }}{% endautoescape %}', {"a": None}, "x<"), + + 'filter-phone2numeric01': ('{{ a|phone2numeric }} {{ b|phone2numeric }}', {"a": "<1-800-call-me>", "b": mark_safe("<1-800-call-me>") }, "<1-800-2255-63> <1-800-2255-63>"), + 'filter-phone2numeric02': ('{% autoescape off %}{{ a|phone2numeric }} {{ b|phone2numeric }}{% endautoescape %}', {"a": "<1-800-call-me>", "b": mark_safe("<1-800-call-me>") }, "<1-800-2255-63> <1-800-2255-63>"), + 'filter-phone2numeric03': ('{{ a|phone2numeric }}', {"a": "How razorback-jumping frogs can level six piqued gymnasts!"}, "469 729672225-5867464 37647 226 53835 749 747833 49662787!"), + + # Ensure iriencode keeps safe strings: + 'filter-iriencode01': ('{{ url|iriencode }}', {'url': '?test=1&me=2'}, '?test=1&me=2'), + 'filter-iriencode02': ('{% autoescape off %}{{ url|iriencode }}{% endautoescape %}', {'url': '?test=1&me=2'}, '?test=1&me=2'), + 'filter-iriencode03': ('{{ url|iriencode }}', {'url': mark_safe('?test=1&me=2')}, '?test=1&me=2'), + 'filter-iriencode04': ('{% autoescape off %}{{ url|iriencode }}{% endautoescape %}', {'url': mark_safe('?test=1&me=2')}, '?test=1&me=2'), + + # urlencode + 'filter-urlencode01': ('{{ url|urlencode }}', {'url': '/test&"/me?/'}, '/test%26%22/me%3F/'), + 'filter-urlencode02': ('/test/{{ urlbit|urlencode:"" }}/', {'urlbit': 'escape/slash'}, '/test/escape%2Fslash/'), + + # Chaining a bunch of safeness-preserving filters should not alter + # the safe status either way. + 'chaining01': ('{{ a|capfirst|center:"7" }}.{{ b|capfirst|center:"7" }}', {"a": "a < b", "b": mark_safe("a < b")}, " A < b . A < b "), + 'chaining02': ('{% autoescape off %}{{ a|capfirst|center:"7" }}.{{ b|capfirst|center:"7" }}{% endautoescape %}', {"a": "a < b", "b": mark_safe("a < b")}, " A < b . A < b "), + + # Using a filter that forces a string back to unsafe: + 'chaining03': ('{{ a|cut:"b"|capfirst }}.{{ b|cut:"b"|capfirst }}', {"a": "a < b", "b": mark_safe("a < b")}, "A < .A < "), + 'chaining04': ('{% autoescape off %}{{ a|cut:"b"|capfirst }}.{{ b|cut:"b"|capfirst }}{% endautoescape %}', {"a": "a < b", "b": mark_safe("a < b")}, "A < .A < "), + + # Using a filter that forces safeness does not lead to double-escaping + 'chaining05': ('{{ a|escape|capfirst }}', {"a": "a < b"}, "A < b"), + 'chaining06': ('{% autoescape off %}{{ a|escape|capfirst }}{% endautoescape %}', {"a": "a < b"}, "A < b"), + + # Force to safe, then back (also showing why using force_escape too + # early in a chain can lead to unexpected results). + 'chaining07': ('{{ a|force_escape|cut:";" }}', {"a": "a < b"}, "a &lt b"), + 'chaining08': ('{% autoescape off %}{{ a|force_escape|cut:";" }}{% endautoescape %}', {"a": "a < b"}, "a < b"), + 'chaining09': ('{{ a|cut:";"|force_escape }}', {"a": "a < b"}, "a < b"), + 'chaining10': ('{% autoescape off %}{{ a|cut:";"|force_escape }}{% endautoescape %}', {"a": "a < b"}, "a < b"), + 'chaining11': ('{{ a|cut:"b"|safe }}', {"a": "a < b"}, "a < "), + 'chaining12': ('{% autoescape off %}{{ a|cut:"b"|safe }}{% endautoescape %}', {"a": "a < b"}, "a < "), + 'chaining13': ('{{ a|safe|force_escape }}', {"a": "a < b"}, "a < b"), + 'chaining14': ('{% autoescape off %}{{ a|safe|force_escape }}{% endautoescape %}', {"a": "a < b"}, "a < b"), + + # Filters decorated with stringfilter still respect is_safe. + 'autoescape-stringfilter01': (r'{{ unsafe|capfirst }}', {'unsafe': UnsafeClass()}, 'You & me'), + 'autoescape-stringfilter02': (r'{% autoescape off %}{{ unsafe|capfirst }}{% endautoescape %}', {'unsafe': UnsafeClass()}, 'You & me'), + 'autoescape-stringfilter03': (r'{{ safe|capfirst }}', {'safe': SafeClass()}, 'You > me'), + 'autoescape-stringfilter04': (r'{% autoescape off %}{{ safe|capfirst }}{% endautoescape %}', {'safe': SafeClass()}, 'You > me'), + + 'escapejs01': (r'{{ a|escapejs }}', {'a': 'testing\r\njavascript \'string" <b>escaping</b>'}, 'testing\\u000D\\u000Ajavascript \\u0027string\\u0022 \\u003Cb\\u003Eescaping\\u003C/b\\u003E'), + 'escapejs02': (r'{% autoescape off %}{{ a|escapejs }}{% endautoescape %}', {'a': 'testing\r\njavascript \'string" <b>escaping</b>'}, 'testing\\u000D\\u000Ajavascript \\u0027string\\u0022 \\u003Cb\\u003Eescaping\\u003C/b\\u003E'), + + + # length filter. + 'length01': ('{{ list|length }}', {'list': ['4', None, True, {}]}, '4'), + 'length02': ('{{ list|length }}', {'list': []}, '0'), + 'length03': ('{{ string|length }}', {'string': ''}, '0'), + 'length04': ('{{ string|length }}', {'string': 'django'}, '6'), + # Invalid uses that should fail silently. + 'length05': ('{{ int|length }}', {'int': 7}, ''), + 'length06': ('{{ None|length }}', {'None': None}, ''), + + # length_is filter. + 'length_is01': ('{% if some_list|length_is:"4" %}Four{% endif %}', {'some_list': ['4', None, True, {}]}, 'Four'), + 'length_is02': ('{% if some_list|length_is:"4" %}Four{% else %}Not Four{% endif %}', {'some_list': ['4', None, True, {}, 17]}, 'Not Four'), + 'length_is03': ('{% if mystring|length_is:"4" %}Four{% endif %}', {'mystring': 'word'}, 'Four'), + 'length_is04': ('{% if mystring|length_is:"4" %}Four{% else %}Not Four{% endif %}', {'mystring': 'Python'}, 'Not Four'), + 'length_is05': ('{% if mystring|length_is:"4" %}Four{% else %}Not Four{% endif %}', {'mystring': ''}, 'Not Four'), + 'length_is06': ('{% with var|length as my_length %}{{ my_length }}{% endwith %}', {'var': 'django'}, '6'), + # Boolean return value from length_is should not be coerced to a string + 'length_is07': (r'{% if "X"|length_is:0 %}Length is 0{% else %}Length not 0{% endif %}', {}, 'Length not 0'), + 'length_is08': (r'{% if "X"|length_is:1 %}Length is 1{% else %}Length not 1{% endif %}', {}, 'Length is 1'), + # Invalid uses that should fail silently. + 'length_is09': ('{{ var|length_is:"fish" }}', {'var': 'django'}, ''), + 'length_is10': ('{{ int|length_is:"1" }}', {'int': 7}, ''), + 'length_is11': ('{{ none|length_is:"1" }}', {'none': None}, ''), + + 'join01': (r'{{ a|join:", " }}', {'a': ['alpha', 'beta & me']}, 'alpha, beta & me'), + 'join02': (r'{% autoescape off %}{{ a|join:", " }}{% endautoescape %}', {'a': ['alpha', 'beta & me']}, 'alpha, beta & me'), + 'join03': (r'{{ a|join:" & " }}', {'a': ['alpha', 'beta & me']}, 'alpha & beta & me'), + 'join04': (r'{% autoescape off %}{{ a|join:" & " }}{% endautoescape %}', {'a': ['alpha', 'beta & me']}, 'alpha & beta & me'), + + # Test that joining with unsafe joiners don't result in unsafe strings (#11377) + 'join05': (r'{{ a|join:var }}', {'a': ['alpha', 'beta & me'], 'var': ' & '}, 'alpha & beta & me'), + 'join06': (r'{{ a|join:var }}', {'a': ['alpha', 'beta & me'], 'var': mark_safe(' & ')}, 'alpha & beta & me'), + 'join07': (r'{{ a|join:var|lower }}', {'a': ['Alpha', 'Beta & me'], 'var': ' & ' }, 'alpha & beta & me'), + 'join08': (r'{{ a|join:var|lower }}', {'a': ['Alpha', 'Beta & me'], 'var': mark_safe(' & ')}, 'alpha & beta & me'), + + 'date01': (r'{{ d|date:"m" }}', {'d': datetime(2008, 1, 1)}, '01'), + 'date02': (r'{{ d|date }}', {'d': datetime(2008, 1, 1)}, 'Jan. 1, 2008'), + #Ticket 9520: Make sure |date doesn't blow up on non-dates + 'date03': (r'{{ d|date:"m" }}', {'d': 'fail_string'}, ''), + # ISO date formats + 'date04': (r'{{ d|date:"o" }}', {'d': datetime(2008, 12, 29)}, '2009'), + 'date05': (r'{{ d|date:"o" }}', {'d': datetime(2010, 1, 3)}, '2009'), + # Timezone name + 'date06': (r'{{ d|date:"e" }}', {'d': datetime(2009, 3, 12, tzinfo=FixedOffset(30))}, '+0030'), + 'date07': (r'{{ d|date:"e" }}', {'d': datetime(2009, 3, 12)}, ''), + # Ticket 19370: Make sure |date doesn't blow up on a midnight time object + 'date08': (r'{{ t|date:"H:i" }}', {'t': time(0, 1)}, '00:01'), + 'date09': (r'{{ t|date:"H:i" }}', {'t': time(0, 0)}, '00:00'), + + # Tests for #11687 and #16676 + 'add01': (r'{{ i|add:"5" }}', {'i': 2000}, '2005'), + 'add02': (r'{{ i|add:"napis" }}', {'i': 2000}, ''), + 'add03': (r'{{ i|add:16 }}', {'i': 'not_an_int'}, ''), + 'add04': (r'{{ i|add:"16" }}', {'i': 'not_an_int'}, 'not_an_int16'), + 'add05': (r'{{ l1|add:l2 }}', {'l1': [1, 2], 'l2': [3, 4]}, '[1, 2, 3, 4]'), + 'add06': (r'{{ t1|add:t2 }}', {'t1': (3, 4), 't2': (1, 2)}, '(3, 4, 1, 2)'), + 'add07': (r'{{ d|add:t }}', {'d': date(2000, 1, 1), 't': timedelta(10)}, 'Jan. 11, 2000'), + } diff --git a/tests/templates/loaders.py b/tests/templates/loaders.py new file mode 100644 index 0000000000..b77965203f --- /dev/null +++ b/tests/templates/loaders.py @@ -0,0 +1,156 @@ +""" +Test cases for the template loaders + +Note: This test requires setuptools! +""" + +from django.conf import settings + +if __name__ == '__main__': + settings.configure() + +import sys +import pkg_resources +import imp +import os.path + +from django.template import TemplateDoesNotExist, Context +from django.template.loaders.eggs import Loader as EggLoader +from django.template import loader +from django.utils import unittest, six +from django.utils._os import upath +from django.utils.six import StringIO + + +# Mock classes and objects for pkg_resources functions. +class MockProvider(pkg_resources.NullProvider): + def __init__(self, module): + pkg_resources.NullProvider.__init__(self, module) + self.module = module + + def _has(self, path): + return path in self.module._resources + + def _isdir(self, path): + return False + + def get_resource_stream(self, manager, resource_name): + return self.module._resources[resource_name] + + def _get(self, path): + return self.module._resources[path].read() + +class MockLoader(object): + pass + +def create_egg(name, resources): + """ + Creates a mock egg with a list of resources. + + name: The name of the module. + resources: A dictionary of resources. Keys are the names and values the data. + """ + egg = imp.new_module(name) + egg.__loader__ = MockLoader() + egg._resources = resources + sys.modules[name] = egg + + +class EggLoaderTest(unittest.TestCase): + def setUp(self): + pkg_resources._provider_factories[MockLoader] = MockProvider + + self.empty_egg = create_egg("egg_empty", {}) + self.egg_1 = create_egg("egg_1", { + os.path.normcase('templates/y.html'): StringIO("y"), + os.path.normcase('templates/x.txt'): StringIO("x"), + }) + self._old_installed_apps = settings.INSTALLED_APPS + settings.INSTALLED_APPS = [] + + def tearDown(self): + settings.INSTALLED_APPS = self._old_installed_apps + + def test_empty(self): + "Loading any template on an empty egg should fail" + settings.INSTALLED_APPS = ['egg_empty'] + egg_loader = EggLoader() + self.assertRaises(TemplateDoesNotExist, egg_loader.load_template_source, "not-existing.html") + + def test_non_existing(self): + "Template loading fails if the template is not in the egg" + settings.INSTALLED_APPS = ['egg_1'] + egg_loader = EggLoader() + self.assertRaises(TemplateDoesNotExist, egg_loader.load_template_source, "not-existing.html") + + def test_existing(self): + "A template can be loaded from an egg" + settings.INSTALLED_APPS = ['egg_1'] + egg_loader = EggLoader() + contents, template_name = egg_loader.load_template_source("y.html") + self.assertEqual(contents, "y") + self.assertEqual(template_name, "egg:egg_1:templates/y.html") + + def test_not_installed(self): + "Loading an existent template from an egg not included in INSTALLED_APPS should fail" + settings.INSTALLED_APPS = [] + egg_loader = EggLoader() + self.assertRaises(TemplateDoesNotExist, egg_loader.load_template_source, "y.html") + +class CachedLoader(unittest.TestCase): + def setUp(self): + self.old_TEMPLATE_LOADERS = settings.TEMPLATE_LOADERS + settings.TEMPLATE_LOADERS = ( + ('django.template.loaders.cached.Loader', ( + 'django.template.loaders.filesystem.Loader', + ) + ), + ) + def tearDown(self): + settings.TEMPLATE_LOADERS = self.old_TEMPLATE_LOADERS + + def test_templatedir_caching(self): + "Check that the template directories form part of the template cache key. Refs #13573" + # Retrive a template specifying a template directory to check + t1, name = loader.find_template('test.html', (os.path.join(os.path.dirname(upath(__file__)), 'templates', 'first'),)) + # Now retrieve the same template name, but from a different directory + t2, name = loader.find_template('test.html', (os.path.join(os.path.dirname(upath(__file__)), 'templates', 'second'),)) + + # The two templates should not have the same content + self.assertNotEqual(t1.render(Context({})), t2.render(Context({}))) + +class RenderToStringTest(unittest.TestCase): + + def setUp(self): + self._old_TEMPLATE_DIRS = settings.TEMPLATE_DIRS + settings.TEMPLATE_DIRS = ( + os.path.join(os.path.dirname(upath(__file__)), 'templates'), + ) + + def tearDown(self): + settings.TEMPLATE_DIRS = self._old_TEMPLATE_DIRS + + def test_basic(self): + self.assertEqual(loader.render_to_string('test_context.html'), 'obj:') + + def test_basic_context(self): + self.assertEqual(loader.render_to_string('test_context.html', + {'obj': 'test'}), 'obj:test') + + def test_existing_context_kept_clean(self): + context = Context({'obj': 'before'}) + output = loader.render_to_string('test_context.html', {'obj': 'after'}, + context_instance=context) + self.assertEqual(output, 'obj:after') + self.assertEqual(context['obj'], 'before') + + def test_empty_list(self): + six.assertRaisesRegex(self, TemplateDoesNotExist, + 'No template names provided$', + loader.render_to_string, []) + + + def test_select_templates_from_empty_list(self): + six.assertRaisesRegex(self, TemplateDoesNotExist, + 'No template names provided$', + loader.select_template, []) diff --git a/tests/templates/models.py b/tests/templates/models.py new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/tests/templates/models.py diff --git a/tests/templates/nodelist.py b/tests/templates/nodelist.py new file mode 100644 index 0000000000..97aa5af6a7 --- /dev/null +++ b/tests/templates/nodelist.py @@ -0,0 +1,58 @@ +from django.template import VariableNode, Context +from django.template.loader import get_template_from_string +from django.utils.unittest import TestCase +from django.test.utils import override_settings + +class NodelistTest(TestCase): + + def test_for(self): + source = '{% for i in 1 %}{{ a }}{% endfor %}' + template = get_template_from_string(source) + vars = template.nodelist.get_nodes_by_type(VariableNode) + self.assertEqual(len(vars), 1) + + def test_if(self): + source = '{% if x %}{{ a }}{% endif %}' + template = get_template_from_string(source) + vars = template.nodelist.get_nodes_by_type(VariableNode) + self.assertEqual(len(vars), 1) + + def test_ifequal(self): + source = '{% ifequal x y %}{{ a }}{% endifequal %}' + template = get_template_from_string(source) + vars = template.nodelist.get_nodes_by_type(VariableNode) + self.assertEqual(len(vars), 1) + + def test_ifchanged(self): + source = '{% ifchanged x %}{{ a }}{% endifchanged %}' + template = get_template_from_string(source) + vars = template.nodelist.get_nodes_by_type(VariableNode) + self.assertEqual(len(vars), 1) + + +class ErrorIndexTest(TestCase): + """ + Checks whether index of error is calculated correctly in + template debugger in for loops. Refs ticket #5831 + """ + @override_settings(DEBUG=True, TEMPLATE_DEBUG = True) + def test_correct_exception_index(self): + tests = [ + ('{% load bad_tag %}{% for i in range %}{% badsimpletag %}{% endfor %}', (38, 56)), + ('{% load bad_tag %}{% for i in range %}{% for j in range %}{% badsimpletag %}{% endfor %}{% endfor %}', (58, 76)), + ('{% load bad_tag %}{% for i in range %}{% badsimpletag %}{% for j in range %}Hello{% endfor %}{% endfor %}', (38, 56)), + ('{% load bad_tag %}{% for i in range %}{% for j in five %}{% badsimpletag %}{% endfor %}{% endfor %}', (38, 57)), + ('{% load bad_tag %}{% for j in five %}{% badsimpletag %}{% endfor %}', (18, 37)), + ] + context = Context({ + 'range': range(5), + 'five': 5, + }) + for source, expected_error_source_index in tests: + template = get_template_from_string(source) + try: + template.render(context) + except (RuntimeError, TypeError) as e: + error_source_index = e.django_template_source[1] + self.assertEqual(error_source_index, + expected_error_source_index) diff --git a/tests/templates/parser.py b/tests/templates/parser.py new file mode 100644 index 0000000000..9422da80d7 --- /dev/null +++ b/tests/templates/parser.py @@ -0,0 +1,95 @@ +""" +Testing some internals of the template processing. These are *not* examples to be copied in user code. +""" +from __future__ import unicode_literals + +from django.template import (TokenParser, FilterExpression, Parser, Variable, + Template, TemplateSyntaxError) +from django.test.utils import override_settings +from django.utils.unittest import TestCase +from django.utils import six + + +class ParserTests(TestCase): + def test_token_parsing(self): + # Tests for TokenParser behavior in the face of quoted strings with + # spaces. + + p = TokenParser("tag thevar|filter sometag") + self.assertEqual(p.tagname, "tag") + self.assertEqual(p.value(), "thevar|filter") + self.assertTrue(p.more()) + self.assertEqual(p.tag(), "sometag") + self.assertFalse(p.more()) + + p = TokenParser('tag "a value"|filter sometag') + self.assertEqual(p.tagname, "tag") + self.assertEqual(p.value(), '"a value"|filter') + self.assertTrue(p.more()) + self.assertEqual(p.tag(), "sometag") + self.assertFalse(p.more()) + + p = TokenParser("tag 'a value'|filter sometag") + self.assertEqual(p.tagname, "tag") + self.assertEqual(p.value(), "'a value'|filter") + self.assertTrue(p.more()) + self.assertEqual(p.tag(), "sometag") + self.assertFalse(p.more()) + + def test_filter_parsing(self): + c = {"article": {"section": "News"}} + p = Parser("") + + def fe_test(s, val): + self.assertEqual(FilterExpression(s, p).resolve(c), val) + + fe_test("article.section", "News") + fe_test("article.section|upper", "NEWS") + fe_test('"News"', "News") + fe_test("'News'", "News") + fe_test(r'"Some \"Good\" News"', 'Some "Good" News') + fe_test(r'"Some \"Good\" News"', 'Some "Good" News') + fe_test(r"'Some \'Bad\' News'", "Some 'Bad' News") + + fe = FilterExpression(r'"Some \"Good\" News"', p) + self.assertEqual(fe.filters, []) + self.assertEqual(fe.var, 'Some "Good" News') + + # Filtered variables should reject access of attributes beginning with + # underscores. + self.assertRaises(TemplateSyntaxError, + FilterExpression, "article._hidden|upper", p + ) + + def test_variable_parsing(self): + c = {"article": {"section": "News"}} + self.assertEqual(Variable("article.section").resolve(c), "News") + self.assertEqual(Variable('"News"').resolve(c), "News") + self.assertEqual(Variable("'News'").resolve(c), "News") + + # Translated strings are handled correctly. + self.assertEqual(Variable("_(article.section)").resolve(c), "News") + self.assertEqual(Variable('_("Good News")').resolve(c), "Good News") + self.assertEqual(Variable("_('Better News')").resolve(c), "Better News") + + # Escaped quotes work correctly as well. + self.assertEqual( + Variable(r'"Some \"Good\" News"').resolve(c), 'Some "Good" News' + ) + self.assertEqual( + Variable(r"'Some \'Better\' News'").resolve(c), "Some 'Better' News" + ) + + # Variables should reject access of attributes beginning with + # underscores. + self.assertRaises(TemplateSyntaxError, + Variable, "article._hidden" + ) + + @override_settings(DEBUG=True, TEMPLATE_DEBUG=True) + def test_compile_filter_error(self): + # regression test for #19819 + msg = "Could not parse the remainder: '@bar' from 'foo@bar'" + with six.assertRaisesRegex(self, TemplateSyntaxError, msg) as cm: + Template("{% if 1 %}{{ foo@bar }}{% endif %}") + self.assertEqual(cm.exception.django_template_source[1], (10, 23)) diff --git a/tests/templates/response.py b/tests/templates/response.py new file mode 100644 index 0000000000..c4da50af6b --- /dev/null +++ b/tests/templates/response.py @@ -0,0 +1,352 @@ +from __future__ import unicode_literals + +import os +import pickle +import time +from datetime import datetime + +from django.test import RequestFactory, TestCase +from django.conf import settings +from django.template import Template, Context +from django.template.response import (TemplateResponse, SimpleTemplateResponse, + ContentNotRenderedError) +from django.test.utils import override_settings +from django.utils._os import upath + +def test_processor(request): + return {'processors': 'yes'} +test_processor_name = 'regressiontests.templates.response.test_processor' + + +# A test middleware that installs a temporary URLConf +class CustomURLConfMiddleware(object): + def process_request(self, request): + request.urlconf = 'regressiontests.templates.alternate_urls' + + +class SimpleTemplateResponseTest(TestCase): + + def _response(self, template='foo', *args, **kwargs): + return SimpleTemplateResponse(Template(template), *args, **kwargs) + + def test_template_resolving(self): + response = SimpleTemplateResponse('first/test.html') + response.render() + self.assertEqual(response.content, b'First template\n') + + templates = ['foo.html', 'second/test.html', 'first/test.html'] + response = SimpleTemplateResponse(templates) + response.render() + self.assertEqual(response.content, b'Second template\n') + + response = self._response() + response.render() + self.assertEqual(response.content, b'foo') + + def test_explicit_baking(self): + # explicit baking + response = self._response() + self.assertFalse(response.is_rendered) + response.render() + self.assertTrue(response.is_rendered) + + def test_render(self): + # response is not re-rendered without the render call + response = self._response().render() + self.assertEqual(response.content, b'foo') + + # rebaking doesn't change the rendered content + response.template_name = Template('bar{{ baz }}') + response.render() + self.assertEqual(response.content, b'foo') + + # but rendered content can be overridden by manually + # setting content + response.content = 'bar' + self.assertEqual(response.content, b'bar') + + def test_iteration_unrendered(self): + # unrendered response raises an exception on iteration + response = self._response() + self.assertFalse(response.is_rendered) + + def iteration(): + for x in response: + pass + self.assertRaises(ContentNotRenderedError, iteration) + self.assertFalse(response.is_rendered) + + def test_iteration_rendered(self): + # iteration works for rendered responses + response = self._response().render() + res = [x for x in response] + self.assertEqual(res, [b'foo']) + + def test_content_access_unrendered(self): + # unrendered response raises an exception when content is accessed + response = self._response() + self.assertFalse(response.is_rendered) + self.assertRaises(ContentNotRenderedError, lambda: response.content) + self.assertFalse(response.is_rendered) + + def test_content_access_rendered(self): + # rendered response content can be accessed + response = self._response().render() + self.assertEqual(response.content, b'foo') + + def test_set_content(self): + # content can be overriden + response = self._response() + self.assertFalse(response.is_rendered) + response.content = 'spam' + self.assertTrue(response.is_rendered) + self.assertEqual(response.content, b'spam') + response.content = 'baz' + self.assertEqual(response.content, b'baz') + + def test_dict_context(self): + response = self._response('{{ foo }}{{ processors }}', + {'foo': 'bar'}) + self.assertEqual(response.context_data, {'foo': 'bar'}) + response.render() + self.assertEqual(response.content, b'bar') + + def test_context_instance(self): + response = self._response('{{ foo }}{{ processors }}', + Context({'foo': 'bar'})) + self.assertEqual(response.context_data.__class__, Context) + response.render() + self.assertEqual(response.content, b'bar') + + def test_kwargs(self): + response = self._response(content_type = 'application/json', status=504) + self.assertEqual(response['content-type'], 'application/json') + self.assertEqual(response.status_code, 504) + + def test_args(self): + response = SimpleTemplateResponse('', {}, 'application/json', 504) + self.assertEqual(response['content-type'], 'application/json') + self.assertEqual(response.status_code, 504) + + def test_post_callbacks(self): + "Rendering a template response triggers the post-render callbacks" + post = [] + + def post1(obj): + post.append('post1') + def post2(obj): + post.append('post2') + + response = SimpleTemplateResponse('first/test.html', {}) + response.add_post_render_callback(post1) + response.add_post_render_callback(post2) + + # When the content is rendered, all the callbacks are invoked, too. + response.render() + self.assertEqual(response.content, b'First template\n') + self.assertEqual(post, ['post1','post2']) + + + def test_pickling(self): + # Create a template response. The context is + # known to be unpickleable (e.g., a function). + response = SimpleTemplateResponse('first/test.html', { + 'value': 123, + 'fn': datetime.now, + }) + self.assertRaises(ContentNotRenderedError, + pickle.dumps, response) + + # But if we render the response, we can pickle it. + response.render() + pickled_response = pickle.dumps(response) + unpickled_response = pickle.loads(pickled_response) + + self.assertEqual(unpickled_response.content, response.content) + self.assertEqual(unpickled_response['content-type'], response['content-type']) + self.assertEqual(unpickled_response.status_code, response.status_code) + + # ...and the unpickled reponse doesn't have the + # template-related attributes, so it can't be re-rendered + template_attrs = ('template_name', 'context_data', '_post_render_callbacks') + for attr in template_attrs: + self.assertFalse(hasattr(unpickled_response, attr)) + + # ...and requesting any of those attributes raises an exception + for attr in template_attrs: + with self.assertRaises(AttributeError): + getattr(unpickled_response, attr) + + def test_repickling(self): + response = SimpleTemplateResponse('first/test.html', { + 'value': 123, + 'fn': datetime.now, + }) + self.assertRaises(ContentNotRenderedError, + pickle.dumps, response) + + response.render() + pickled_response = pickle.dumps(response) + unpickled_response = pickle.loads(pickled_response) + repickled_response = pickle.dumps(unpickled_response) + + def test_pickling_cookie(self): + response = SimpleTemplateResponse('first/test.html', { + 'value': 123, + 'fn': datetime.now, + }) + + response.cookies['key'] = 'value' + + response.render() + pickled_response = pickle.dumps(response, pickle.HIGHEST_PROTOCOL) + unpickled_response = pickle.loads(pickled_response) + + self.assertEqual(unpickled_response.cookies['key'].value, 'value') + + +@override_settings( + TEMPLATE_CONTEXT_PROCESSORS=[test_processor_name], + TEMPLATE_DIRS=(os.path.join(os.path.dirname(upath(__file__)), 'templates')), +) +class TemplateResponseTest(TestCase): + + def setUp(self): + self.factory = RequestFactory() + + def _response(self, template='foo', *args, **kwargs): + return TemplateResponse(self.factory.get('/'), Template(template), + *args, **kwargs) + + def test_render(self): + response = self._response('{{ foo }}{{ processors }}').render() + self.assertEqual(response.content, b'yes') + + def test_render_with_requestcontext(self): + response = self._response('{{ foo }}{{ processors }}', + {'foo': 'bar'}).render() + self.assertEqual(response.content, b'baryes') + + def test_render_with_context(self): + response = self._response('{{ foo }}{{ processors }}', + Context({'foo': 'bar'})).render() + self.assertEqual(response.content, b'bar') + + def test_kwargs(self): + response = self._response(content_type = 'application/json', + status=504) + self.assertEqual(response['content-type'], 'application/json') + self.assertEqual(response.status_code, 504) + + def test_args(self): + response = TemplateResponse(self.factory.get('/'), '', {}, + 'application/json', 504) + self.assertEqual(response['content-type'], 'application/json') + self.assertEqual(response.status_code, 504) + + def test_custom_app(self): + response = self._response('{{ foo }}', current_app="foobar") + + rc = response.resolve_context(response.context_data) + + self.assertEqual(rc.current_app, 'foobar') + + def test_pickling(self): + # Create a template response. The context is + # known to be unpickleable (e.g., a function). + response = TemplateResponse(self.factory.get('/'), + 'first/test.html', { + 'value': 123, + 'fn': datetime.now, + }) + self.assertRaises(ContentNotRenderedError, + pickle.dumps, response) + + # But if we render the response, we can pickle it. + response.render() + pickled_response = pickle.dumps(response) + unpickled_response = pickle.loads(pickled_response) + + self.assertEqual(unpickled_response.content, response.content) + self.assertEqual(unpickled_response['content-type'], response['content-type']) + self.assertEqual(unpickled_response.status_code, response.status_code) + + # ...and the unpickled reponse doesn't have the + # template-related attributes, so it can't be re-rendered + template_attrs = ('template_name', 'context_data', + '_post_render_callbacks', '_request', '_current_app') + for attr in template_attrs: + self.assertFalse(hasattr(unpickled_response, attr)) + + # ...and requesting any of those attributes raises an exception + for attr in template_attrs: + with self.assertRaises(AttributeError): + getattr(unpickled_response, attr) + + def test_repickling(self): + response = SimpleTemplateResponse('first/test.html', { + 'value': 123, + 'fn': datetime.now, + }) + self.assertRaises(ContentNotRenderedError, + pickle.dumps, response) + + response.render() + pickled_response = pickle.dumps(response) + unpickled_response = pickle.loads(pickled_response) + repickled_response = pickle.dumps(unpickled_response) + + +class CustomURLConfTest(TestCase): + urls = 'regressiontests.templates.urls' + + def setUp(self): + self.old_MIDDLEWARE_CLASSES = settings.MIDDLEWARE_CLASSES + settings.MIDDLEWARE_CLASSES = list(settings.MIDDLEWARE_CLASSES) + [ + 'regressiontests.templates.response.CustomURLConfMiddleware' + ] + + def tearDown(self): + settings.MIDDLEWARE_CLASSES = self.old_MIDDLEWARE_CLASSES + + def test_custom_urlconf(self): + response = self.client.get('/template_response_view/') + self.assertEqual(response.status_code, 200) + self.assertContains(response, 'This is where you can find the snark: /snark/') + + +class CacheMiddlewareTest(TestCase): + urls = 'regressiontests.templates.alternate_urls' + + def setUp(self): + self.old_MIDDLEWARE_CLASSES = settings.MIDDLEWARE_CLASSES + self.CACHE_MIDDLEWARE_SECONDS = settings.CACHE_MIDDLEWARE_SECONDS + + settings.CACHE_MIDDLEWARE_SECONDS = 2.0 + settings.MIDDLEWARE_CLASSES = list(settings.MIDDLEWARE_CLASSES) + [ + 'django.middleware.cache.FetchFromCacheMiddleware', + 'django.middleware.cache.UpdateCacheMiddleware', + ] + + def tearDown(self): + settings.MIDDLEWARE_CLASSES = self.old_MIDDLEWARE_CLASSES + settings.CACHE_MIDDLEWARE_SECONDS = self.CACHE_MIDDLEWARE_SECONDS + + def test_middleware_caching(self): + response = self.client.get('/template_response_view/') + self.assertEqual(response.status_code, 200) + + time.sleep(1.0) + + response2 = self.client.get('/template_response_view/') + self.assertEqual(response2.status_code, 200) + + self.assertEqual(response.content, response2.content) + + time.sleep(2.0) + + # Let the cache expire and test again + response2 = self.client.get('/template_response_view/') + self.assertEqual(response2.status_code, 200) + + self.assertNotEqual(response.content, response2.content) diff --git a/tests/templates/smartif.py b/tests/templates/smartif.py new file mode 100644 index 0000000000..3a705ca663 --- /dev/null +++ b/tests/templates/smartif.py @@ -0,0 +1,53 @@ +from django.template.smartif import IfParser +from django.utils import unittest + +class SmartIfTests(unittest.TestCase): + + def assertCalcEqual(self, expected, tokens): + self.assertEqual(expected, IfParser(tokens).parse().eval({})) + + # We only test things here that are difficult to test elsewhere + # Many other tests are found in the main tests for builtin template tags + # Test parsing via the printed parse tree + def test_not(self): + var = IfParser(["not", False]).parse() + self.assertEqual("(not (literal False))", repr(var)) + self.assertTrue(var.eval({})) + + self.assertFalse(IfParser(["not", True]).parse().eval({})) + + def test_or(self): + var = IfParser([True, "or", False]).parse() + self.assertEqual("(or (literal True) (literal False))", repr(var)) + self.assertTrue(var.eval({})) + + def test_in(self): + list_ = [1,2,3] + self.assertCalcEqual(True, [1, 'in', list_]) + self.assertCalcEqual(False, [1, 'in', None]) + self.assertCalcEqual(False, [None, 'in', list_]) + + def test_not_in(self): + list_ = [1,2,3] + self.assertCalcEqual(False, [1, 'not', 'in', list_]) + self.assertCalcEqual(True, [4, 'not', 'in', list_]) + self.assertCalcEqual(False, [1, 'not', 'in', None]) + self.assertCalcEqual(True, [None, 'not', 'in', list_]) + + def test_precedence(self): + # (False and False) or True == True <- we want this one, like Python + # False and (False or True) == False + self.assertCalcEqual(True, [False, 'and', False, 'or', True]) + + # True or (False and False) == True <- we want this one, like Python + # (True or False) and False == False + self.assertCalcEqual(True, [True, 'or', False, 'and', False]) + + # (1 or 1) == 2 -> False + # 1 or (1 == 2) -> True <- we want this one + self.assertCalcEqual(True, [1, 'or', 1, '==', 2]) + + self.assertCalcEqual(True, [True, '==', True, 'or', True, '==', False]) + + self.assertEqual("(or (and (== (literal 1) (literal 2)) (literal 3)) (literal 4))", + repr(IfParser([1, '==', 2, 'and', 3, 'or', 4]).parse())) diff --git a/tests/templates/templates/broken_base.html b/tests/templates/templates/broken_base.html new file mode 100644 index 0000000000..aa41f44de2 --- /dev/null +++ b/tests/templates/templates/broken_base.html @@ -0,0 +1 @@ +{% include "missing.html" %} diff --git a/tests/templates/templates/first/test.html b/tests/templates/templates/first/test.html new file mode 100644 index 0000000000..6029fe5507 --- /dev/null +++ b/tests/templates/templates/first/test.html @@ -0,0 +1 @@ +First template diff --git a/tests/templates/templates/inclusion.html b/tests/templates/templates/inclusion.html new file mode 100644 index 0000000000..4000d3aadb --- /dev/null +++ b/tests/templates/templates/inclusion.html @@ -0,0 +1 @@ +{{ result }} diff --git a/tests/templates/templates/response.html b/tests/templates/templates/response.html new file mode 100644 index 0000000000..96ab97f54f --- /dev/null +++ b/tests/templates/templates/response.html @@ -0,0 +1,2 @@ +This is where you can find the snark: {% url "snark" %} +{% now "U.u" %} diff --git a/tests/templates/templates/second/test.html b/tests/templates/templates/second/test.html new file mode 100644 index 0000000000..d9b316f465 --- /dev/null +++ b/tests/templates/templates/second/test.html @@ -0,0 +1 @@ +Second template diff --git a/tests/templates/templates/ssi include with spaces.html b/tests/templates/templates/ssi include with spaces.html new file mode 100644 index 0000000000..1c85648861 --- /dev/null +++ b/tests/templates/templates/ssi include with spaces.html @@ -0,0 +1 @@ +This is for testing an ssi include with spaces in its name. {{ test }} diff --git a/tests/templates/templates/ssi_include.html b/tests/templates/templates/ssi_include.html new file mode 100644 index 0000000000..58d5926fbb --- /dev/null +++ b/tests/templates/templates/ssi_include.html @@ -0,0 +1 @@ +This is for testing an ssi include. {{ test }} diff --git a/tests/templates/templates/test_context.html b/tests/templates/templates/test_context.html new file mode 100644 index 0000000000..a100f03de6 --- /dev/null +++ b/tests/templates/templates/test_context.html @@ -0,0 +1 @@ +obj:{{ obj }}
\ No newline at end of file diff --git a/tests/templates/templates/test_extends_error.html b/tests/templates/templates/test_extends_error.html new file mode 100644 index 0000000000..fc74690de6 --- /dev/null +++ b/tests/templates/templates/test_extends_error.html @@ -0,0 +1 @@ +{% extends "broken_base.html" %} diff --git a/tests/templates/templates/test_incl_tag_current_app.html b/tests/templates/templates/test_incl_tag_current_app.html new file mode 100644 index 0000000000..ab2fe63b6f --- /dev/null +++ b/tests/templates/templates/test_incl_tag_current_app.html @@ -0,0 +1 @@ +{% load custom %}{% current_app %} diff --git a/tests/templates/templates/test_incl_tag_use_l10n.html b/tests/templates/templates/test_incl_tag_use_l10n.html new file mode 100644 index 0000000000..3054960d16 --- /dev/null +++ b/tests/templates/templates/test_incl_tag_use_l10n.html @@ -0,0 +1 @@ +{% load custom %}{% use_l10n %} diff --git a/tests/templates/templates/test_include_error.html b/tests/templates/templates/test_include_error.html new file mode 100644 index 0000000000..6db959380e --- /dev/null +++ b/tests/templates/templates/test_include_error.html @@ -0,0 +1 @@ +{% include "missing.html" %}
\ No newline at end of file diff --git a/tests/templates/templatetags/__init__.py b/tests/templates/templatetags/__init__.py new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/tests/templates/templatetags/__init__.py diff --git a/tests/templates/templatetags/bad_tag.py b/tests/templates/templatetags/bad_tag.py new file mode 100644 index 0000000000..3cceb31eb0 --- /dev/null +++ b/tests/templates/templatetags/bad_tag.py @@ -0,0 +1,12 @@ +from django import template + + +register = template.Library() + +@register.tag +def badtag(parser, token): + raise RuntimeError("I am a bad tag") + +@register.simple_tag +def badsimpletag(): + raise RuntimeError("I am a bad simpletag") diff --git a/tests/templates/templatetags/broken_tag.py b/tests/templates/templatetags/broken_tag.py new file mode 100644 index 0000000000..d69ddaeb2c --- /dev/null +++ b/tests/templates/templatetags/broken_tag.py @@ -0,0 +1 @@ +from django import Xtemplate
\ No newline at end of file diff --git a/tests/templates/templatetags/custom.py b/tests/templates/templatetags/custom.py new file mode 100644 index 0000000000..32035ab59e --- /dev/null +++ b/tests/templates/templatetags/custom.py @@ -0,0 +1,313 @@ +import operator + +from django import template +from django.template.defaultfilters import stringfilter +from django.template.loader import get_template +from django.utils import six + +register = template.Library() + +@register.filter +@stringfilter +def trim(value, num): + return value[:num] + +@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 +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_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([six.text_type(arg) for arg in [one, two] + list(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([six.text_type(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(six.iteritems(kwargs), key=operator.itemgetter(0)) + return "simple_unlimited_args_kwargs - Expected result: %s / %s" % ( + ', '.join([six.text_type(arg) for arg in [one, two] + list(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 current_app(context): + return "%s" % context.current_app + +@register.simple_tag(takes_context=True) +def use_l10n(context): + return "%s" % 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.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(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(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(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(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(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(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(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([six.text_type(arg) for arg in [one, two] + list(args)]))} +inclusion_unlimited_args.anything = "Expected inclusion_unlimited_args __dict__" + +@register.inclusion_tag(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([six.text_type(arg) for arg in [one, two] + list(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([six.text_type(arg) for arg in args]))} +inclusion_only_unlimited_args.anything = "Expected inclusion_only_unlimited_args __dict__" + +@register.inclusion_tag(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([six.text_type(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_current_app.html', takes_context=True) +def inclusion_tag_current_app(context): + """Expected inclusion_tag_current_app __doc__""" + return {} +inclusion_tag_current_app.anything = "Expected inclusion_tag_current_app __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(six.iteritems(kwargs), key=operator.itemgetter(0)) + return {"result": "inclusion_unlimited_args_kwargs - Expected result: %s / %s" % ( + ', '.join([six.text_type(arg) for arg in [one, two] + list(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.assignment_tag +def assignment_no_params(): + """Expected assignment_no_params __doc__""" + return "assignment_no_params - Expected result" +assignment_no_params.anything = "Expected assignment_no_params __dict__" + +@register.assignment_tag +def assignment_one_param(arg): + """Expected assignment_one_param __doc__""" + return "assignment_one_param - Expected result: %s" % arg +assignment_one_param.anything = "Expected assignment_one_param __dict__" + +@register.assignment_tag(takes_context=False) +def assignment_explicit_no_context(arg): + """Expected assignment_explicit_no_context __doc__""" + return "assignment_explicit_no_context - Expected result: %s" % arg +assignment_explicit_no_context.anything = "Expected assignment_explicit_no_context __dict__" + +@register.assignment_tag(takes_context=True) +def assignment_no_params_with_context(context): + """Expected assignment_no_params_with_context __doc__""" + return "assignment_no_params_with_context - Expected result (context value: %s)" % context['value'] +assignment_no_params_with_context.anything = "Expected assignment_no_params_with_context __dict__" + +@register.assignment_tag(takes_context=True) +def assignment_params_and_context(context, arg): + """Expected assignment_params_and_context __doc__""" + return "assignment_params_and_context - Expected result (context value: %s): %s" % (context['value'], arg) +assignment_params_and_context.anything = "Expected assignment_params_and_context __dict__" + +@register.assignment_tag +def assignment_two_params(one, two): + """Expected assignment_two_params __doc__""" + return "assignment_two_params - Expected result: %s, %s" % (one, two) +assignment_two_params.anything = "Expected assignment_two_params __dict__" + +@register.assignment_tag +def assignment_one_default(one, two='hi'): + """Expected assignment_one_default __doc__""" + return "assignment_one_default - Expected result: %s, %s" % (one, two) +assignment_one_default.anything = "Expected assignment_one_default __dict__" + +@register.assignment_tag +def assignment_unlimited_args(one, two='hi', *args): + """Expected assignment_unlimited_args __doc__""" + return "assignment_unlimited_args - Expected result: %s" % (', '.join([six.text_type(arg) for arg in [one, two] + list(args)])) +assignment_unlimited_args.anything = "Expected assignment_unlimited_args __dict__" + +@register.assignment_tag +def assignment_only_unlimited_args(*args): + """Expected assignment_only_unlimited_args __doc__""" + return "assignment_only_unlimited_args - Expected result: %s" % ', '.join([six.text_type(arg) for arg in args]) +assignment_only_unlimited_args.anything = "Expected assignment_only_unlimited_args __dict__" + +@register.assignment_tag +def assignment_unlimited_args_kwargs(one, two='hi', *args, **kwargs): + """Expected assignment_unlimited_args_kwargs __doc__""" + # Sort the dictionary by key to guarantee the order for testing. + sorted_kwarg = sorted(six.iteritems(kwargs), key=operator.itemgetter(0)) + return "assignment_unlimited_args_kwargs - Expected result: %s / %s" % ( + ', '.join([six.text_type(arg) for arg in [one, two] + list(args)]), + ', '.join(['%s=%s' % (k, v) for (k, v) in sorted_kwarg]) + ) +assignment_unlimited_args_kwargs.anything = "Expected assignment_unlimited_args_kwargs __dict__" + +@register.assignment_tag(takes_context=True) +def assignment_tag_without_context_parameter(arg): + """Expected assignment_tag_without_context_parameter __doc__""" + return "Expected result" +assignment_tag_without_context_parameter.anything = "Expected assignment_tag_without_context_parameter __dict__" diff --git a/tests/templates/templatetags/subpackage/__init__.py b/tests/templates/templatetags/subpackage/__init__.py new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/tests/templates/templatetags/subpackage/__init__.py diff --git a/tests/templates/templatetags/subpackage/echo.py b/tests/templates/templatetags/subpackage/echo.py new file mode 100644 index 0000000000..0e4e862887 --- /dev/null +++ b/tests/templates/templatetags/subpackage/echo.py @@ -0,0 +1,7 @@ +from django import template + +register = template.Library() + +@register.simple_tag +def echo2(arg): + return arg diff --git a/tests/templates/templatetags/subpackage/echo_invalid.py b/tests/templates/templatetags/subpackage/echo_invalid.py new file mode 100644 index 0000000000..c12ea65507 --- /dev/null +++ b/tests/templates/templatetags/subpackage/echo_invalid.py @@ -0,0 +1 @@ +import nonexistent.module diff --git a/tests/templates/tests.py b/tests/templates/tests.py new file mode 100644 index 0000000000..176972fb25 --- /dev/null +++ b/tests/templates/tests.py @@ -0,0 +1,1818 @@ +# -*- coding: utf-8 -*- +from __future__ import absolute_import, unicode_literals + +from django.conf import settings + +if __name__ == '__main__': + # When running this file in isolation, we need to set up the configuration + # before importing 'template'. + settings.configure() + +from datetime import date, datetime, timedelta +import time +import os +import sys +import traceback +try: + from urllib.parse import urljoin +except ImportError: # Python 2 + from urlparse import urljoin +import warnings + +from django import template +from django.core import urlresolvers +from django.template import (base as template_base, loader, Context, + RequestContext, Template, TemplateSyntaxError) +from django.template.loaders import app_directories, filesystem, cached +from django.test import RequestFactory, TestCase +from django.test.utils import (setup_test_template_loader, + restore_template_loaders, override_settings) +from django.utils import unittest +from django.utils.encoding import python_2_unicode_compatible +from django.utils.formats import date_format +from django.utils._os import upath +from django.utils.translation import activate, deactivate, ugettext as _ +from django.utils.safestring import mark_safe +from django.utils import six +from django.utils.tzinfo import LocalTimezone + +from .callables import CallableVariablesTests +from .context import ContextTests +from .custom import CustomTagTests, CustomFilterTests +from .parser import ParserTests +from .unicode import UnicodeTests +from .nodelist import NodelistTest, ErrorIndexTest +from .smartif import SmartIfTests +from .response import (TemplateResponseTest, CacheMiddlewareTest, + SimpleTemplateResponseTest, CustomURLConfTest) + +try: + from .loaders import RenderToStringTest, EggLoaderTest +except ImportError as e: + if "pkg_resources" in e.args[0]: + pass # If setuptools isn't installed, that's fine. Just move on. + else: + raise + +# NumPy installed? +try: + import numpy +except ImportError: + numpy = False + +from . import filters + +################################# +# Custom template tag for tests # +################################# + +register = template.Library() + +class EchoNode(template.Node): + def __init__(self, contents): + self.contents = contents + + def render(self, context): + return " ".join(self.contents) + +def do_echo(parser, token): + return EchoNode(token.contents.split()[1:]) + +def do_upper(value): + return value.upper() + +register.tag("echo", do_echo) +register.tag("other_echo", do_echo) +register.filter("upper", do_upper) + +template.libraries['testtags'] = register + +##################################### +# Helper objects for template tests # +##################################### + +class SomeException(Exception): + silent_variable_failure = True + +class SomeOtherException(Exception): + pass + +class ContextStackException(Exception): + pass + +class ShouldNotExecuteException(Exception): + pass + +class SomeClass: + def __init__(self): + self.otherclass = OtherClass() + + def method(self): + return "SomeClass.method" + + def method2(self, o): + return o + + def method3(self): + raise SomeException + + def method4(self): + raise SomeOtherException + + def __getitem__(self, key): + if key == 'silent_fail_key': + raise SomeException + elif key == 'noisy_fail_key': + raise SomeOtherException + raise KeyError + + def silent_fail_attribute(self): + raise SomeException + silent_fail_attribute = property(silent_fail_attribute) + + def noisy_fail_attribute(self): + raise SomeOtherException + noisy_fail_attribute = property(noisy_fail_attribute) + +class OtherClass: + def method(self): + return "OtherClass.method" + +class TestObj(object): + def is_true(self): + return True + + def is_false(self): + return False + + def is_bad(self): + raise ShouldNotExecuteException() + +class SilentGetItemClass(object): + def __getitem__(self, key): + raise SomeException + +class SilentAttrClass(object): + def b(self): + raise SomeException + b = property(b) + +@python_2_unicode_compatible +class UTF8Class: + "Class whose __str__ returns non-ASCII data on Python 2" + def __str__(self): + return 'ŠĐĆŽćžšđ' + +@override_settings(MEDIA_URL="/media/", STATIC_URL="/static/") +class Templates(TestCase): + + def test_loaders_security(self): + ad_loader = app_directories.Loader() + fs_loader = filesystem.Loader() + def test_template_sources(path, template_dirs, expected_sources): + if isinstance(expected_sources, list): + # Fix expected sources so they are abspathed + expected_sources = [os.path.abspath(s) for s in expected_sources] + # Test the two loaders (app_directores and filesystem). + func1 = lambda p, t: list(ad_loader.get_template_sources(p, t)) + func2 = lambda p, t: list(fs_loader.get_template_sources(p, t)) + for func in (func1, func2): + if isinstance(expected_sources, list): + self.assertEqual(func(path, template_dirs), expected_sources) + else: + self.assertRaises(expected_sources, func, path, template_dirs) + + template_dirs = ['/dir1', '/dir2'] + test_template_sources('index.html', template_dirs, + ['/dir1/index.html', '/dir2/index.html']) + test_template_sources('/etc/passwd', template_dirs, []) + test_template_sources('etc/passwd', template_dirs, + ['/dir1/etc/passwd', '/dir2/etc/passwd']) + test_template_sources('../etc/passwd', template_dirs, []) + test_template_sources('../../../etc/passwd', template_dirs, []) + test_template_sources('/dir1/index.html', template_dirs, + ['/dir1/index.html']) + test_template_sources('../dir2/index.html', template_dirs, + ['/dir2/index.html']) + test_template_sources('/dir1blah', template_dirs, []) + test_template_sources('../dir1blah', template_dirs, []) + + # UTF-8 bytestrings are permitted. + test_template_sources(b'\xc3\x85ngstr\xc3\xb6m', template_dirs, + ['/dir1/Ångström', '/dir2/Ångström']) + # Unicode strings are permitted. + test_template_sources('Ångström', template_dirs, + ['/dir1/Ångström', '/dir2/Ångström']) + test_template_sources('Ångström', [b'/Stra\xc3\x9fe'], ['/Straße/Ångström']) + test_template_sources(b'\xc3\x85ngstr\xc3\xb6m', [b'/Stra\xc3\x9fe'], + ['/Straße/Ångström']) + # Invalid UTF-8 encoding in bytestrings is not. Should raise a + # semi-useful error message. + test_template_sources(b'\xc3\xc3', template_dirs, UnicodeDecodeError) + + # Case insensitive tests (for win32). Not run unless we're on + # a case insensitive operating system. + if os.path.normcase('/TEST') == os.path.normpath('/test'): + template_dirs = ['/dir1', '/DIR2'] + test_template_sources('index.html', template_dirs, + ['/dir1/index.html', '/DIR2/index.html']) + test_template_sources('/DIR1/index.HTML', template_dirs, + ['/DIR1/index.HTML']) + + def test_loader_debug_origin(self): + # Turn TEMPLATE_DEBUG on, so that the origin file name will be kept with + # the compiled templates. + old_td, settings.TEMPLATE_DEBUG = settings.TEMPLATE_DEBUG, True + old_loaders = loader.template_source_loaders + + try: + loader.template_source_loaders = (filesystem.Loader(),) + + # We rely on the fact that runtests.py sets up TEMPLATE_DIRS to + # point to a directory containing a login.html file. Also that + # the file system and app directories loaders both inherit the + # load_template method from the BaseLoader class, so we only need + # to test one of them. + load_name = 'login.html' + template = loader.get_template(load_name) + template_name = template.nodelist[0].source[0].name + self.assertTrue(template_name.endswith(load_name), + 'Template loaded by filesystem loader has incorrect name for debug page: %s' % template_name) + + # Aso test the cached loader, since it overrides load_template + cache_loader = cached.Loader(('',)) + cache_loader._cached_loaders = loader.template_source_loaders + loader.template_source_loaders = (cache_loader,) + + template = loader.get_template(load_name) + template_name = template.nodelist[0].source[0].name + self.assertTrue(template_name.endswith(load_name), + 'Template loaded through cached loader has incorrect name for debug page: %s' % template_name) + + template = loader.get_template(load_name) + template_name = template.nodelist[0].source[0].name + self.assertTrue(template_name.endswith(load_name), + 'Cached template loaded through cached loader has incorrect name for debug page: %s' % template_name) + finally: + loader.template_source_loaders = old_loaders + settings.TEMPLATE_DEBUG = old_td + + + def test_include_missing_template(self): + """ + Tests that the correct template is identified as not existing + when {% include %} specifies a template that does not exist. + """ + + # TEMPLATE_DEBUG must be true, otherwise the exception raised + # during {% include %} processing will be suppressed. + old_td, settings.TEMPLATE_DEBUG = settings.TEMPLATE_DEBUG, True + old_loaders = loader.template_source_loaders + + try: + # Test the base loader class via the app loader. load_template + # from base is used by all shipped loaders excepting cached, + # which has its own test. + loader.template_source_loaders = (app_directories.Loader(),) + + load_name = 'test_include_error.html' + r = None + try: + tmpl = loader.select_template([load_name]) + r = tmpl.render(template.Context({})) + except template.TemplateDoesNotExist as e: + settings.TEMPLATE_DEBUG = old_td + self.assertEqual(e.args[0], 'missing.html') + self.assertEqual(r, None, 'Template rendering unexpectedly succeeded, produced: ->%r<-' % r) + finally: + loader.template_source_loaders = old_loaders + settings.TEMPLATE_DEBUG = old_td + + + def test_extends_include_missing_baseloader(self): + """ + Tests that 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. See #12787. + """ + + # TEMPLATE_DEBUG must be true, otherwise the exception raised + # during {% include %} processing will be suppressed. + old_td, settings.TEMPLATE_DEBUG = settings.TEMPLATE_DEBUG, True + old_loaders = loader.template_source_loaders + + try: + # Test the base loader class via the app loader. load_template + # from base is used by all shipped loaders excepting cached, + # which has its own test. + loader.template_source_loaders = (app_directories.Loader(),) + + load_name = 'test_extends_error.html' + tmpl = loader.get_template(load_name) + r = None + try: + r = tmpl.render(template.Context({})) + except template.TemplateDoesNotExist as e: + settings.TEMPLATE_DEBUG = old_td + self.assertEqual(e.args[0], 'missing.html') + self.assertEqual(r, None, 'Template rendering unexpectedly succeeded, produced: ->%r<-' % r) + finally: + loader.template_source_loaders = old_loaders + settings.TEMPLATE_DEBUG = old_td + + def test_extends_include_missing_cachedloader(self): + """ + Same as test_extends_include_missing_baseloader, only tests + behavior of the cached loader instead of BaseLoader. + """ + + old_td, settings.TEMPLATE_DEBUG = settings.TEMPLATE_DEBUG, True + old_loaders = loader.template_source_loaders + + try: + cache_loader = cached.Loader(('',)) + cache_loader._cached_loaders = (app_directories.Loader(),) + loader.template_source_loaders = (cache_loader,) + + load_name = 'test_extends_error.html' + tmpl = loader.get_template(load_name) + r = None + try: + r = tmpl.render(template.Context({})) + except template.TemplateDoesNotExist as e: + self.assertEqual(e.args[0], 'missing.html') + self.assertEqual(r, None, 'Template rendering unexpectedly succeeded, produced: ->%r<-' % r) + + # For the cached loader, repeat the test, to ensure the first attempt did not cache a + # result that behaves incorrectly on subsequent attempts. + tmpl = loader.get_template(load_name) + try: + tmpl.render(template.Context({})) + except template.TemplateDoesNotExist as e: + self.assertEqual(e.args[0], 'missing.html') + self.assertEqual(r, None, 'Template rendering unexpectedly succeeded, produced: ->%r<-' % r) + finally: + loader.template_source_loaders = old_loaders + settings.TEMPLATE_DEBUG = old_td + + def test_token_smart_split(self): + # Regression test for #7027 + token = template.Token(template.TOKEN_BLOCK, 'sometag _("Page not found") value|yesno:_("yes,no")') + split = token.split_contents() + self.assertEqual(split, ["sometag", '_("Page not found")', 'value|yesno:_("yes,no")']) + + @override_settings(SETTINGS_MODULE=None, TEMPLATE_DEBUG=True) + def test_url_reverse_no_settings_module(self): + # Regression test for #9005 + t = Template('{% url will_not_match %}') + c = Context() + with self.assertRaises(urlresolvers.NoReverseMatch): + t.render(c) + + @override_settings(TEMPLATE_STRING_IF_INVALID='%s is invalid', SETTINGS_MODULE='also_something') + def test_url_reverse_view_name(self): + # Regression test for #19827 + t = Template('{% url will_not_match %}') + c = Context() + try: + t.render(c) + except urlresolvers.NoReverseMatch: + tb = sys.exc_info()[2] + depth = 0 + while tb.tb_next is not None: + tb = tb.tb_next + depth += 1 + self.assertTrue(depth > 5, + "The traceback context was lost when reraising the traceback. See #19827") + + def test_url_explicit_exception_for_old_syntax_at_run_time(self): + # Regression test for #19280 + t = Template('{% url path.to.view %}') # not quoted = old syntax + c = Context() + with six.assertRaisesRegex(self, urlresolvers.NoReverseMatch, + "The syntax changed in Django 1.5, see the docs."): + t.render(c) + + def test_url_explicit_exception_for_old_syntax_at_compile_time(self): + # Regression test for #19392 + with six.assertRaisesRegex(self, template.TemplateSyntaxError, + "The syntax of 'url' changed in Django 1.5, see the docs."): + t = Template('{% url my-view %}') # not a variable = old syntax + + @override_settings(DEBUG=True, TEMPLATE_DEBUG=True) + def test_no_wrapped_exception(self): + """ + The template system doesn't wrap exceptions, but annotates them. + Refs #16770 + """ + c = Context({"coconuts": lambda: 42 / 0}) + t = Template("{{ coconuts }}") + with self.assertRaises(ZeroDivisionError) as cm: + t.render(c) + + self.assertEqual(cm.exception.django_template_source[1], (0, 14)) + + def test_invalid_block_suggestion(self): + # See #7876 + try: + t = Template("{% if 1 %}lala{% endblock %}{% endif %}") + except TemplateSyntaxError as e: + self.assertEqual(e.args[0], "Invalid block tag: 'endblock', expected 'elif', 'else' or 'endif'") + + def test_ifchanged_concurrency(self): + # Tests for #15849 + template = Template('[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 {0}'.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 {0}'.format(output1)) + + def test_ifchanged_render_once(self): + """ Test for ticket #19890. The content of ifchanged template tag was + rendered twice.""" + template = Template('{% ifchanged %}{% cycle "1st time" "2nd time" %}{% endifchanged %}') + output = template.render(Context({})) + self.assertEqual(output, '1st time') + + def test_templates(self): + template_tests = self.get_template_tests() + filter_tests = filters.get_filter_tests() + + # Quickly check that we aren't accidentally using a name in both + # template and filter tests. + overlapping_names = [name for name in filter_tests if name in template_tests] + assert not overlapping_names, 'Duplicate test name(s): %s' % ', '.join(overlapping_names) + + template_tests.update(filter_tests) + + cache_loader = setup_test_template_loader( + dict([(name, t[0]) for name, t in six.iteritems(template_tests)]), + use_cached_loader=True, + ) + + failures = [] + tests = sorted(template_tests.items()) + + # Turn TEMPLATE_DEBUG off, because tests assume that. + old_td, settings.TEMPLATE_DEBUG = settings.TEMPLATE_DEBUG, False + + # Set TEMPLATE_STRING_IF_INVALID to a known string. + old_invalid = settings.TEMPLATE_STRING_IF_INVALID + expected_invalid_str = 'INVALID' + + # Set ALLOWED_INCLUDE_ROOTS so that ssi works. + old_allowed_include_roots = settings.ALLOWED_INCLUDE_ROOTS + settings.ALLOWED_INCLUDE_ROOTS = ( + os.path.dirname(os.path.abspath(upath(__file__))), + ) + + # Warm the URL reversing cache. This ensures we don't pay the cost + # warming the cache during one of the tests. + urlresolvers.reverse('regressiontests.templates.views.client_action', + kwargs={'id':0,'action':"update"}) + + for name, vals in tests: + if isinstance(vals[2], tuple): + normal_string_result = vals[2][0] + invalid_string_result = vals[2][1] + + if isinstance(invalid_string_result, tuple): + expected_invalid_str = 'INVALID %s' + invalid_string_result = invalid_string_result[0] % invalid_string_result[1] + template_base.invalid_var_format_string = True + + try: + template_debug_result = vals[2][2] + except IndexError: + template_debug_result = normal_string_result + + else: + normal_string_result = vals[2] + invalid_string_result = vals[2] + template_debug_result = vals[2] + + if 'LANGUAGE_CODE' in vals[1]: + activate(vals[1]['LANGUAGE_CODE']) + else: + activate('en-us') + + for invalid_str, template_debug, result in [ + ('', False, normal_string_result), + (expected_invalid_str, False, invalid_string_result), + ('', True, template_debug_result) + ]: + settings.TEMPLATE_STRING_IF_INVALID = invalid_str + settings.TEMPLATE_DEBUG = template_debug + for is_cached in (False, True): + try: + try: + with warnings.catch_warnings(): + # Ignore pending deprecations of the old syntax of the 'cycle' and 'firstof' tags. + warnings.filterwarnings("ignore", category=PendingDeprecationWarning, module='django.template.base') + test_template = loader.get_template(name) + except ShouldNotExecuteException: + failures.append("Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Template loading invoked method that shouldn't have been invoked." % (is_cached, invalid_str, template_debug, name)) + + try: + output = self.render(test_template, vals) + except ShouldNotExecuteException: + failures.append("Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Template rendering invoked method that shouldn't have been invoked." % (is_cached, invalid_str, template_debug, name)) + except ContextStackException: + failures.append("Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Context stack was left imbalanced" % (is_cached, invalid_str, template_debug, name)) + continue + except Exception: + exc_type, exc_value, exc_tb = sys.exc_info() + if exc_type != result: + tb = '\n'.join(traceback.format_exception(exc_type, exc_value, exc_tb)) + failures.append("Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Got %s, exception: %s\n%s" % (is_cached, invalid_str, template_debug, name, exc_type, exc_value, tb)) + continue + if output != result: + failures.append("Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Expected %r, got %r" % (is_cached, invalid_str, template_debug, name, result, output)) + cache_loader.reset() + + if 'LANGUAGE_CODE' in vals[1]: + deactivate() + + if template_base.invalid_var_format_string: + expected_invalid_str = 'INVALID' + template_base.invalid_var_format_string = False + + restore_template_loaders() + deactivate() + settings.TEMPLATE_DEBUG = old_td + settings.TEMPLATE_STRING_IF_INVALID = old_invalid + settings.ALLOWED_INCLUDE_ROOTS = old_allowed_include_roots + + self.assertEqual(failures, [], "Tests failed:\n%s\n%s" % + ('-'*70, ("\n%s\n" % ('-'*70)).join(failures))) + + def render(self, test_template, vals): + context = template.Context(vals[1]) + before_stack_size = len(context.dicts) + output = test_template.render(context) + if len(context.dicts) != before_stack_size: + raise ContextStackException + return output + + def get_template_tests(self): + # SYNTAX -- + # 'template_name': ('template contents', 'context dict', 'expected string output' or Exception class) + basedir = os.path.dirname(os.path.abspath(upath(__file__))) + tests = { + ### BASIC SYNTAX ################################################ + + # Plain text should go through the template parser untouched + 'basic-syntax01': ("something cool", {}, "something cool"), + + # Variables should be replaced with their value in the current + # context + 'basic-syntax02': ("{{ headline }}", {'headline':'Success'}, "Success"), + + # More than one replacement variable is allowed in a template + 'basic-syntax03': ("{{ first }} --- {{ second }}", {"first" : 1, "second" : 2}, "1 --- 2"), + + # Fail silently when a variable is not found in the current context + 'basic-syntax04': ("as{{ missing }}df", {}, ("asdf","asINVALIDdf")), + + # A variable may not contain more than one word + 'basic-syntax06': ("{{ multi word variable }}", {}, template.TemplateSyntaxError), + + # Raise TemplateSyntaxError for empty variable tags + 'basic-syntax07': ("{{ }}", {}, template.TemplateSyntaxError), + 'basic-syntax08': ("{{ }}", {}, template.TemplateSyntaxError), + + # Attribute syntax allows a template to call an object's attribute + 'basic-syntax09': ("{{ var.method }}", {"var": SomeClass()}, "SomeClass.method"), + + # Multiple levels of attribute access are allowed + 'basic-syntax10': ("{{ var.otherclass.method }}", {"var": SomeClass()}, "OtherClass.method"), + + # Fail silently when a variable's attribute isn't found + 'basic-syntax11': ("{{ var.blech }}", {"var": SomeClass()}, ("","INVALID")), + + # Raise TemplateSyntaxError when trying to access a variable beginning with an underscore + 'basic-syntax12': ("{{ var.__dict__ }}", {"var": SomeClass()}, template.TemplateSyntaxError), + + # Raise TemplateSyntaxError when trying to access a variable containing an illegal character + 'basic-syntax13': ("{{ va>r }}", {}, template.TemplateSyntaxError), + 'basic-syntax14': ("{{ (var.r) }}", {}, template.TemplateSyntaxError), + 'basic-syntax15': ("{{ sp%am }}", {}, template.TemplateSyntaxError), + 'basic-syntax16': ("{{ eggs! }}", {}, template.TemplateSyntaxError), + 'basic-syntax17': ("{{ moo? }}", {}, template.TemplateSyntaxError), + + # Attribute syntax allows a template to call a dictionary key's value + 'basic-syntax18': ("{{ foo.bar }}", {"foo" : {"bar" : "baz"}}, "baz"), + + # Fail silently when a variable's dictionary key isn't found + 'basic-syntax19': ("{{ foo.spam }}", {"foo" : {"bar" : "baz"}}, ("","INVALID")), + + # Fail silently when accessing a non-simple method + 'basic-syntax20': ("{{ var.method2 }}", {"var": SomeClass()}, ("","INVALID")), + + # Don't get confused when parsing something that is almost, but not + # quite, a template tag. + 'basic-syntax21': ("a {{ moo %} b", {}, "a {{ moo %} b"), + 'basic-syntax22': ("{{ moo #}", {}, "{{ moo #}"), + + # Will try to treat "moo #} {{ cow" as the variable. Not ideal, but + # costly to work around, so this triggers an error. + 'basic-syntax23': ("{{ moo #} {{ cow }}", {"cow": "cow"}, template.TemplateSyntaxError), + + # Embedded newlines make it not-a-tag. + 'basic-syntax24': ("{{ moo\n }}", {}, "{{ moo\n }}"), + + # Literal strings are permitted inside variables, mostly for i18n + # purposes. + 'basic-syntax25': ('{{ "fred" }}', {}, "fred"), + 'basic-syntax26': (r'{{ "\"fred\"" }}', {}, "\"fred\""), + 'basic-syntax27': (r'{{ _("\"fred\"") }}', {}, "\"fred\""), + + # regression test for ticket #12554 + # make sure a silent_variable_failure Exception is supressed + # on dictionary and attribute lookup + 'basic-syntax28': ("{{ a.b }}", {'a': SilentGetItemClass()}, ('', 'INVALID')), + 'basic-syntax29': ("{{ a.b }}", {'a': SilentAttrClass()}, ('', 'INVALID')), + + # Something that starts like a number but has an extra lookup works as a lookup. + 'basic-syntax30': ("{{ 1.2.3 }}", {"1": {"2": {"3": "d"}}}, "d"), + 'basic-syntax31': ("{{ 1.2.3 }}", {"1": {"2": ("a", "b", "c", "d")}}, "d"), + 'basic-syntax32': ("{{ 1.2.3 }}", {"1": (("x", "x", "x", "x"), ("y", "y", "y", "y"), ("a", "b", "c", "d"))}, "d"), + 'basic-syntax33': ("{{ 1.2.3 }}", {"1": ("xxxx", "yyyy", "abcd")}, "d"), + 'basic-syntax34': ("{{ 1.2.3 }}", {"1": ({"x": "x"}, {"y": "y"}, {"z": "z", "3": "d"})}, "d"), + + # Numbers are numbers even if their digits are in the context. + 'basic-syntax35': ("{{ 1 }}", {"1": "abc"}, "1"), + 'basic-syntax36': ("{{ 1.2 }}", {"1": "abc"}, "1.2"), + + # Call methods in the top level of the context + 'basic-syntax37': ('{{ callable }}', {"callable": lambda: "foo bar"}, "foo bar"), + + # Call methods returned from dictionary lookups + 'basic-syntax38': ('{{ var.callable }}', {"var": {"callable": lambda: "foo bar"}}, "foo bar"), + + 'builtins01': ('{{ True }}', {}, "True"), + 'builtins02': ('{{ False }}', {}, "False"), + 'builtins03': ('{{ None }}', {}, "None"), + + # List-index syntax allows a template to access a certain item of a subscriptable object. + 'list-index01': ("{{ var.1 }}", {"var": ["first item", "second item"]}, "second item"), + + # Fail silently when the list index is out of range. + 'list-index02': ("{{ var.5 }}", {"var": ["first item", "second item"]}, ("", "INVALID")), + + # Fail silently when the variable is not a subscriptable object. + 'list-index03': ("{{ var.1 }}", {"var": None}, ("", "INVALID")), + + # Fail silently when variable is a dict without the specified key. + 'list-index04': ("{{ var.1 }}", {"var": {}}, ("", "INVALID")), + + # Dictionary lookup wins out when dict's key is a string. + 'list-index05': ("{{ var.1 }}", {"var": {'1': "hello"}}, "hello"), + + # 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. + 'list-index06': ("{{ var.1 }}", {"var": {1: "hello"}}, "hello"), + + # Dictionary lookup wins out when there is a string and int version of the key. + 'list-index07': ("{{ var.1 }}", {"var": {'1': "hello", 1: "world"}}, "hello"), + + # Basic filter usage + 'filter-syntax01': ("{{ var|upper }}", {"var": "Django is the greatest!"}, "DJANGO IS THE GREATEST!"), + + # Chained filters + 'filter-syntax02': ("{{ var|upper|lower }}", {"var": "Django is the greatest!"}, "django is the greatest!"), + + # Allow spaces before the filter pipe + 'filter-syntax03': ("{{ var |upper }}", {"var": "Django is the greatest!"}, "DJANGO IS THE GREATEST!"), + + # Allow spaces after the filter pipe + 'filter-syntax04': ("{{ var| upper }}", {"var": "Django is the greatest!"}, "DJANGO IS THE GREATEST!"), + + # Raise TemplateSyntaxError for a nonexistent filter + 'filter-syntax05': ("{{ var|does_not_exist }}", {}, template.TemplateSyntaxError), + + # Raise TemplateSyntaxError when trying to access a filter containing an illegal character + 'filter-syntax06': ("{{ var|fil(ter) }}", {}, template.TemplateSyntaxError), + + # Raise TemplateSyntaxError for invalid block tags + 'filter-syntax07': ("{% nothing_to_see_here %}", {}, template.TemplateSyntaxError), + + # Raise TemplateSyntaxError for empty block tags + 'filter-syntax08': ("{% %}", {}, template.TemplateSyntaxError), + + # Chained filters, with an argument to the first one + 'filter-syntax09': ('{{ var|removetags:"b i"|upper|lower }}', {"var": "<b><i>Yes</i></b>"}, "yes"), + + # Literal string as argument is always "safe" from auto-escaping.. + 'filter-syntax10': (r'{{ var|default_if_none:" endquote\" hah" }}', + {"var": None}, ' endquote" hah'), + + # Variable as argument + 'filter-syntax11': (r'{{ var|default_if_none:var2 }}', {"var": None, "var2": "happy"}, 'happy'), + + # Default argument testing + 'filter-syntax12': (r'{{ var|yesno:"yup,nup,mup" }} {{ var|yesno }}', {"var": True}, 'yup yes'), + + # Fail silently for methods that raise an exception with a + # "silent_variable_failure" attribute + 'filter-syntax13': (r'1{{ var.method3 }}2', {"var": SomeClass()}, ("12", "1INVALID2")), + + # In methods that raise an exception without a + # "silent_variable_attribute" set to True, the exception propagates + 'filter-syntax14': (r'1{{ var.method4 }}2', {"var": SomeClass()}, (SomeOtherException, SomeOtherException)), + + # Escaped backslash in argument + 'filter-syntax15': (r'{{ var|default_if_none:"foo\bar" }}', {"var": None}, r'foo\bar'), + + # Escaped backslash using known escape char + 'filter-syntax16': (r'{{ var|default_if_none:"foo\now" }}', {"var": None}, r'foo\now'), + + # Empty strings can be passed as arguments to filters + 'filter-syntax17': (r'{{ var|join:"" }}', {'var': ['a', 'b', 'c']}, 'abc'), + + # Make sure that any unicode strings are converted to bytestrings + # in the final output. + 'filter-syntax18': (r'{{ var }}', {'var': UTF8Class()}, '\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111'), + + # Numbers as filter arguments should work + 'filter-syntax19': ('{{ var|truncatewords:1 }}', {"var": "hello world"}, "hello ..."), + + #filters should accept empty string constants + 'filter-syntax20': ('{{ ""|default_if_none:"was none" }}', {}, ""), + + # Fail silently for non-callable attribute and dict lookups which + # raise an exception with a "silent_variable_failure" attribute + 'filter-syntax21': (r'1{{ var.silent_fail_key }}2', {"var": SomeClass()}, ("12", "1INVALID2")), + 'filter-syntax22': (r'1{{ var.silent_fail_attribute }}2', {"var": SomeClass()}, ("12", "1INVALID2")), + + # In attribute and dict lookups that raise an unexpected exception + # without a "silent_variable_attribute" set to True, the exception + # propagates + 'filter-syntax23': (r'1{{ var.noisy_fail_key }}2', {"var": SomeClass()}, (SomeOtherException, SomeOtherException)), + 'filter-syntax24': (r'1{{ var.noisy_fail_attribute }}2', {"var": SomeClass()}, (SomeOtherException, SomeOtherException)), + + ### COMMENT SYNTAX ######################################################## + 'comment-syntax01': ("{# this is hidden #}hello", {}, "hello"), + 'comment-syntax02': ("{# this is hidden #}hello{# foo #}", {}, "hello"), + + # Comments can contain invalid stuff. + 'comment-syntax03': ("foo{# {% if %} #}", {}, "foo"), + 'comment-syntax04': ("foo{# {% endblock %} #}", {}, "foo"), + 'comment-syntax05': ("foo{# {% somerandomtag %} #}", {}, "foo"), + 'comment-syntax06': ("foo{# {% #}", {}, "foo"), + 'comment-syntax07': ("foo{# %} #}", {}, "foo"), + 'comment-syntax08': ("foo{# %} #}bar", {}, "foobar"), + 'comment-syntax09': ("foo{# {{ #}", {}, "foo"), + 'comment-syntax10': ("foo{# }} #}", {}, "foo"), + 'comment-syntax11': ("foo{# { #}", {}, "foo"), + 'comment-syntax12': ("foo{# } #}", {}, "foo"), + + ### COMMENT TAG ########################################################### + 'comment-tag01': ("{% comment %}this is hidden{% endcomment %}hello", {}, "hello"), + 'comment-tag02': ("{% comment %}this is hidden{% endcomment %}hello{% comment %}foo{% endcomment %}", {}, "hello"), + + # Comment tag can contain invalid stuff. + 'comment-tag03': ("foo{% comment %} {% if %} {% endcomment %}", {}, "foo"), + 'comment-tag04': ("foo{% comment %} {% endblock %} {% endcomment %}", {}, "foo"), + 'comment-tag05': ("foo{% comment %} {% somerandomtag %} {% endcomment %}", {}, "foo"), + + ### CYCLE TAG ############################################################# + 'cycle01': ('{% cycle a %}', {}, template.TemplateSyntaxError), + 'cycle02': ('{% cycle a,b,c as abc %}{% cycle abc %}', {}, 'ab'), + 'cycle03': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}', {}, 'abc'), + 'cycle04': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}', {}, 'abca'), + 'cycle05': ('{% cycle %}', {}, template.TemplateSyntaxError), + 'cycle06': ('{% cycle a %}', {}, template.TemplateSyntaxError), + 'cycle07': ('{% cycle a,b,c as foo %}{% cycle bar %}', {}, template.TemplateSyntaxError), + 'cycle08': ('{% cycle a,b,c as foo %}{% cycle foo %}{{ foo }}{{ foo }}{% cycle foo %}{{ foo }}', {}, 'abbbcc'), + 'cycle09': ("{% for i in test %}{% cycle a,b %}{{ i }},{% endfor %}", {'test': range(5)}, 'a0,b1,a2,b3,a4,'), + 'cycle10': ("{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}", {}, 'ab'), + 'cycle11': ("{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}", {}, 'abc'), + 'cycle12': ("{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}", {}, 'abca'), + 'cycle13': ("{% for i in test %}{% cycle 'a' 'b' %}{{ i }},{% endfor %}", {'test': range(5)}, 'a0,b1,a2,b3,a4,'), + 'cycle14': ("{% cycle one two as foo %}{% cycle foo %}", {'one': '1','two': '2'}, '12'), + 'cycle15': ("{% for i in test %}{% cycle aye bee %}{{ i }},{% endfor %}", {'test': range(5), 'aye': 'a', 'bee': 'b'}, 'a0,b1,a2,b3,a4,'), + 'cycle16': ("{% cycle one|lower two as foo %}{% cycle foo %}", {'one': 'A','two': '2'}, 'a2'), + 'cycle17': ("{% cycle 'a' 'b' 'c' as abc silent %}{% cycle abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}", {}, ""), + 'cycle18': ("{% cycle 'a' 'b' 'c' as foo invalid_flag %}", {}, template.TemplateSyntaxError), + 'cycle19': ("{% cycle 'a' 'b' as silent %}{% cycle silent %}", {}, "ab"), + 'cycle20': ("{% cycle one two as foo %} & {% cycle foo %}", {'one' : 'A & B', 'two' : 'C & D'}, "A & B & C & D"), + 'cycle21': ("{% filter force_escape %}{% cycle one two as foo %} & {% cycle foo %}{% endfilter %}", {'one' : 'A & B', 'two' : 'C & D'}, "A & B & C & D"), + 'cycle22': ("{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ x }}{% endfor %}", {'values': [1,2,3,4]}, "1234"), + 'cycle23': ("{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ abc }}{{ x }}{% endfor %}", {'values': [1,2,3,4]}, "a1b2c3a4"), + 'included-cycle': ('{{ abc }}', {'abc': 'xxx'}, 'xxx'), + 'cycle24': ("{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{% include 'included-cycle' %}{% endfor %}", {'values': [1,2,3,4]}, "abca"), + 'cycle25': ('{% cycle a as abc %}', {'a': '<'}, '<'), + + 'cycle26': ('{% load cycle from future %}{% cycle a b as ab %}{% cycle ab %}', {'a': '<', 'b': '>'}, '<>'), + 'cycle27': ('{% load cycle from future %}{% autoescape off %}{% cycle a b as ab %}{% cycle ab %}{% endautoescape %}', {'a': '<', 'b': '>'}, '<>'), + 'cycle28': ('{% load cycle from future %}{% cycle a|safe b as ab %}{% cycle ab %}', {'a': '<', 'b': '>'}, '<>'), + + ### EXCEPTIONS ############################################################ + + # Raise exception for invalid template name + 'exception01': ("{% extends 'nonexistent' %}", {}, (template.TemplateDoesNotExist, template.TemplateDoesNotExist)), + + # Raise exception for invalid template name (in variable) + 'exception02': ("{% extends nonexistent %}", {}, (template.TemplateSyntaxError, template.TemplateDoesNotExist)), + + # Raise exception for extra {% extends %} tags + 'exception03': ("{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% extends 'inheritance16' %}", {}, template.TemplateSyntaxError), + + # Raise exception for custom tags used in child with {% load %} tag in parent, not in child + 'exception04': ("{% extends 'inheritance17' %}{% block first %}{% echo 400 %}5678{% endblock %}", {}, template.TemplateSyntaxError), + + ### FILTER TAG ############################################################ + 'filter01': ('{% filter upper %}{% endfilter %}', {}, ''), + 'filter02': ('{% filter upper %}django{% endfilter %}', {}, 'DJANGO'), + 'filter03': ('{% filter upper|lower %}django{% endfilter %}', {}, 'django'), + 'filter04': ('{% filter cut:remove %}djangospam{% endfilter %}', {'remove': 'spam'}, 'django'), + + ### FIRSTOF TAG ########################################################### + 'firstof01': ('{% firstof a b c %}', {'a':0,'b':0,'c':0}, ''), + 'firstof02': ('{% firstof a b c %}', {'a':1,'b':0,'c':0}, '1'), + 'firstof03': ('{% firstof a b c %}', {'a':0,'b':2,'c':0}, '2'), + 'firstof04': ('{% firstof a b c %}', {'a':0,'b':0,'c':3}, '3'), + 'firstof05': ('{% firstof a b c %}', {'a':1,'b':2,'c':3}, '1'), + 'firstof06': ('{% firstof a b c %}', {'b':0,'c':3}, '3'), + 'firstof07': ('{% firstof a b "c" %}', {'a':0}, 'c'), + 'firstof08': ('{% firstof a b "c and d" %}', {'a':0,'b':0}, 'c and d'), + 'firstof09': ('{% firstof %}', {}, template.TemplateSyntaxError), + 'firstof10': ('{% firstof a %}', {'a': '<'}, '<'), + + 'firstof11': ('{% load firstof from future %}{% firstof a b %}', {'a': '<', 'b': '>'}, '<'), + 'firstof12': ('{% load firstof from future %}{% firstof a b %}', {'a': '', 'b': '>'}, '>'), + 'firstof13': ('{% load firstof from future %}{% autoescape off %}{% firstof a %}{% endautoescape %}', {'a': '<'}, '<'), + 'firstof14': ('{% load firstof from future %}{% firstof a|safe b %}', {'a': '<'}, '<'), + + ### FOR TAG ############################################################### + 'for-tag01': ("{% for val in values %}{{ val }}{% endfor %}", {"values": [1, 2, 3]}, "123"), + 'for-tag02': ("{% for val in values reversed %}{{ val }}{% endfor %}", {"values": [1, 2, 3]}, "321"), + 'for-tag-vars01': ("{% for val in values %}{{ forloop.counter }}{% endfor %}", {"values": [6, 6, 6]}, "123"), + 'for-tag-vars02': ("{% for val in values %}{{ forloop.counter0 }}{% endfor %}", {"values": [6, 6, 6]}, "012"), + 'for-tag-vars03': ("{% for val in values %}{{ forloop.revcounter }}{% endfor %}", {"values": [6, 6, 6]}, "321"), + 'for-tag-vars04': ("{% for val in values %}{{ forloop.revcounter0 }}{% endfor %}", {"values": [6, 6, 6]}, "210"), + 'for-tag-vars05': ("{% for val in values %}{% if forloop.first %}f{% else %}x{% endif %}{% endfor %}", {"values": [6, 6, 6]}, "fxx"), + 'for-tag-vars06': ("{% for val in values %}{% if forloop.last %}l{% else %}x{% endif %}{% endfor %}", {"values": [6, 6, 6]}, "xxl"), + 'for-tag-unpack01': ("{% for key,value in items %}{{ key }}:{{ value }}/{% endfor %}", {"items": (('one', 1), ('two', 2))}, "one:1/two:2/"), + 'for-tag-unpack03': ("{% for key, value in items %}{{ key }}:{{ value }}/{% endfor %}", {"items": (('one', 1), ('two', 2))}, "one:1/two:2/"), + 'for-tag-unpack04': ("{% for key , value in items %}{{ key }}:{{ value }}/{% endfor %}", {"items": (('one', 1), ('two', 2))}, "one:1/two:2/"), + 'for-tag-unpack05': ("{% for key ,value in items %}{{ key }}:{{ value }}/{% endfor %}", {"items": (('one', 1), ('two', 2))}, "one:1/two:2/"), + 'for-tag-unpack06': ("{% for key value in items %}{{ key }}:{{ value }}/{% endfor %}", {"items": (('one', 1), ('two', 2))}, template.TemplateSyntaxError), + 'for-tag-unpack07': ("{% for key,,value in items %}{{ key }}:{{ value }}/{% endfor %}", {"items": (('one', 1), ('two', 2))}, template.TemplateSyntaxError), + 'for-tag-unpack08': ("{% for key,value, in items %}{{ key }}:{{ value }}/{% endfor %}", {"items": (('one', 1), ('two', 2))}, template.TemplateSyntaxError), + # Ensure that a single loopvar doesn't truncate the list in val. + 'for-tag-unpack09': ("{% for val in items %}{{ val.0 }}:{{ val.1 }}/{% endfor %}", {"items": (('one', 1), ('two', 2))}, "one:1/two:2/"), + # Otherwise, silently truncate if the length of loopvars differs to the length of each set of items. + 'for-tag-unpack10': ("{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}", {"items": (('one', 1, 'carrot'), ('two', 2, 'orange'))}, "one:1/two:2/"), + 'for-tag-unpack11': ("{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}", {"items": (('one', 1), ('two', 2))}, ("one:1,/two:2,/", "one:1,INVALID/two:2,INVALID/")), + 'for-tag-unpack12': ("{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}", {"items": (('one', 1, 'carrot'), ('two', 2))}, ("one:1,carrot/two:2,/", "one:1,carrot/two:2,INVALID/")), + 'for-tag-unpack13': ("{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}", {"items": (('one', 1, 'carrot'), ('two', 2, 'cheese'))}, ("one:1,carrot/two:2,cheese/", "one:1,carrot/two:2,cheese/")), + 'for-tag-unpack14': ("{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}", {"items": (1, 2)}, (":/:/", "INVALID:INVALID/INVALID:INVALID/")), + 'for-tag-empty01': ("{% for val in values %}{{ val }}{% empty %}empty text{% endfor %}", {"values": [1, 2, 3]}, "123"), + 'for-tag-empty02': ("{% for val in values %}{{ val }}{% empty %}values array empty{% endfor %}", {"values": []}, "values array empty"), + 'for-tag-empty03': ("{% for val in values %}{{ val }}{% empty %}values array not found{% endfor %}", {}, "values array not found"), + # Ticket 19882 + 'for-tag-filter-ws': ("{% load custom %}{% for x in s|noop:'x y' %}{{ x }}{% endfor %}", {'s': 'abc'}, 'abc'), + + ### IF TAG ################################################################ + 'if-tag01': ("{% if foo %}yes{% else %}no{% endif %}", {"foo": True}, "yes"), + 'if-tag02': ("{% if foo %}yes{% else %}no{% endif %}", {"foo": False}, "no"), + 'if-tag03': ("{% if foo %}yes{% else %}no{% endif %}", {}, "no"), + + 'if-tag04': ("{% if foo %}foo{% elif bar %}bar{% endif %}", {'foo': True}, "foo"), + 'if-tag05': ("{% if foo %}foo{% elif bar %}bar{% endif %}", {'bar': True}, "bar"), + 'if-tag06': ("{% if foo %}foo{% elif bar %}bar{% endif %}", {}, ""), + 'if-tag07': ("{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}", {'foo': True}, "foo"), + 'if-tag08': ("{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}", {'bar': True}, "bar"), + 'if-tag09': ("{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}", {}, "nothing"), + 'if-tag10': ("{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}", {'foo': True}, "foo"), + 'if-tag11': ("{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}", {'bar': True}, "bar"), + 'if-tag12': ("{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}", {'baz': True}, "baz"), + 'if-tag13': ("{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}", {}, "nothing"), + + # Filters + 'if-tag-filter01': ("{% if foo|length == 5 %}yes{% else %}no{% endif %}", {'foo': 'abcde'}, "yes"), + 'if-tag-filter02': ("{% if foo|upper == 'ABC' %}yes{% else %}no{% endif %}", {}, "no"), + + # Equality + 'if-tag-eq01': ("{% if foo == bar %}yes{% else %}no{% endif %}", {}, "yes"), + 'if-tag-eq02': ("{% if foo == bar %}yes{% else %}no{% endif %}", {'foo': 1}, "no"), + 'if-tag-eq03': ("{% if foo == bar %}yes{% else %}no{% endif %}", {'foo': 1, 'bar': 1}, "yes"), + 'if-tag-eq04': ("{% if foo == bar %}yes{% else %}no{% endif %}", {'foo': 1, 'bar': 2}, "no"), + 'if-tag-eq05': ("{% if foo == '' %}yes{% else %}no{% endif %}", {}, "no"), + + # Comparison + 'if-tag-gt-01': ("{% if 2 > 1 %}yes{% else %}no{% endif %}", {}, "yes"), + 'if-tag-gt-02': ("{% if 1 > 1 %}yes{% else %}no{% endif %}", {}, "no"), + 'if-tag-gte-01': ("{% if 1 >= 1 %}yes{% else %}no{% endif %}", {}, "yes"), + 'if-tag-gte-02': ("{% if 1 >= 2 %}yes{% else %}no{% endif %}", {}, "no"), + 'if-tag-lt-01': ("{% if 1 < 2 %}yes{% else %}no{% endif %}", {}, "yes"), + 'if-tag-lt-02': ("{% if 1 < 1 %}yes{% else %}no{% endif %}", {}, "no"), + 'if-tag-lte-01': ("{% if 1 <= 1 %}yes{% else %}no{% endif %}", {}, "yes"), + 'if-tag-lte-02': ("{% if 2 <= 1 %}yes{% else %}no{% endif %}", {}, "no"), + + # Contains + 'if-tag-in-01': ("{% if 1 in x %}yes{% else %}no{% endif %}", {'x':[1]}, "yes"), + 'if-tag-in-02': ("{% if 2 in x %}yes{% else %}no{% endif %}", {'x':[1]}, "no"), + 'if-tag-not-in-01': ("{% if 1 not in x %}yes{% else %}no{% endif %}", {'x':[1]}, "no"), + 'if-tag-not-in-02': ("{% if 2 not in x %}yes{% else %}no{% endif %}", {'x':[1]}, "yes"), + + # AND + 'if-tag-and01': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'yes'), + 'if-tag-and02': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'no'), + 'if-tag-and03': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'no'), + 'if-tag-and04': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'no'), + 'if-tag-and05': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': False}, 'no'), + 'if-tag-and06': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'bar': False}, 'no'), + 'if-tag-and07': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': True}, 'no'), + 'if-tag-and08': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'bar': True}, 'no'), + + # OR + 'if-tag-or01': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'yes'), + 'if-tag-or02': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'yes'), + 'if-tag-or03': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'yes'), + 'if-tag-or04': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'no'), + 'if-tag-or05': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': False}, 'no'), + 'if-tag-or06': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'bar': False}, 'no'), + 'if-tag-or07': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': True}, 'yes'), + 'if-tag-or08': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'bar': True}, 'yes'), + + # multiple ORs + 'if-tag-or09': ("{% if foo or bar or baz %}yes{% else %}no{% endif %}", {'baz': True}, 'yes'), + + # NOT + 'if-tag-not01': ("{% if not foo %}no{% else %}yes{% endif %}", {'foo': True}, 'yes'), + 'if-tag-not02': ("{% if not not foo %}no{% else %}yes{% endif %}", {'foo': True}, 'no'), + # not03 to not05 removed, now TemplateSyntaxErrors + + 'if-tag-not06': ("{% if foo and not bar %}yes{% else %}no{% endif %}", {}, 'no'), + 'if-tag-not07': ("{% if foo and not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'no'), + 'if-tag-not08': ("{% if foo and not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'yes'), + 'if-tag-not09': ("{% if foo and not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'no'), + 'if-tag-not10': ("{% if foo and not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'no'), + + 'if-tag-not11': ("{% if not foo and bar %}yes{% else %}no{% endif %}", {}, 'no'), + 'if-tag-not12': ("{% if not foo and bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'no'), + 'if-tag-not13': ("{% if not foo and bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'no'), + 'if-tag-not14': ("{% if not foo and bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'yes'), + 'if-tag-not15': ("{% if not foo and bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'no'), + + 'if-tag-not16': ("{% if foo or not bar %}yes{% else %}no{% endif %}", {}, 'yes'), + 'if-tag-not17': ("{% if foo or not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'yes'), + 'if-tag-not18': ("{% if foo or not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'yes'), + 'if-tag-not19': ("{% if foo or not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'no'), + 'if-tag-not20': ("{% if foo or not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'yes'), + + 'if-tag-not21': ("{% if not foo or bar %}yes{% else %}no{% endif %}", {}, 'yes'), + 'if-tag-not22': ("{% if not foo or bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'yes'), + 'if-tag-not23': ("{% if not foo or bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'no'), + 'if-tag-not24': ("{% if not foo or bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'yes'), + 'if-tag-not25': ("{% if not foo or bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'yes'), + + 'if-tag-not26': ("{% if not foo and not bar %}yes{% else %}no{% endif %}", {}, 'yes'), + 'if-tag-not27': ("{% if not foo and not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'no'), + 'if-tag-not28': ("{% if not foo and not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'no'), + 'if-tag-not29': ("{% if not foo and not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'no'), + 'if-tag-not30': ("{% if not foo and not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'yes'), + + 'if-tag-not31': ("{% if not foo or not bar %}yes{% else %}no{% endif %}", {}, 'yes'), + 'if-tag-not32': ("{% if not foo or not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'no'), + 'if-tag-not33': ("{% if not foo or not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'yes'), + 'if-tag-not34': ("{% if not foo or not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'yes'), + 'if-tag-not35': ("{% if not foo or not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'yes'), + + # Various syntax errors + 'if-tag-error01': ("{% if %}yes{% endif %}", {}, template.TemplateSyntaxError), + 'if-tag-error02': ("{% if foo and %}yes{% else %}no{% endif %}", {'foo': True}, template.TemplateSyntaxError), + 'if-tag-error03': ("{% if foo or %}yes{% else %}no{% endif %}", {'foo': True}, template.TemplateSyntaxError), + 'if-tag-error04': ("{% if not foo and %}yes{% else %}no{% endif %}", {'foo': True}, template.TemplateSyntaxError), + 'if-tag-error05': ("{% if not foo or %}yes{% else %}no{% endif %}", {'foo': True}, template.TemplateSyntaxError), + 'if-tag-error06': ("{% if abc def %}yes{% endif %}", {}, template.TemplateSyntaxError), + 'if-tag-error07': ("{% if not %}yes{% endif %}", {}, template.TemplateSyntaxError), + 'if-tag-error08': ("{% if and %}yes{% endif %}", {}, template.TemplateSyntaxError), + 'if-tag-error09': ("{% if or %}yes{% endif %}", {}, template.TemplateSyntaxError), + 'if-tag-error10': ("{% if == %}yes{% endif %}", {}, template.TemplateSyntaxError), + 'if-tag-error11': ("{% if 1 == %}yes{% endif %}", {}, template.TemplateSyntaxError), + 'if-tag-error12': ("{% if a not b %}yes{% endif %}", {}, template.TemplateSyntaxError), + + # If evaluations are shortcircuited where possible + # If is_bad is invoked, it will raise a ShouldNotExecuteException + 'if-tag-shortcircuit01': ('{% if x.is_true or x.is_bad %}yes{% else %}no{% endif %}', {'x': TestObj()}, "yes"), + 'if-tag-shortcircuit02': ('{% if x.is_false and x.is_bad %}yes{% else %}no{% endif %}', {'x': TestObj()}, "no"), + + # Non-existent args + 'if-tag-badarg01':("{% if x|default_if_none:y %}yes{% endif %}", {}, ''), + 'if-tag-badarg02':("{% if x|default_if_none:y %}yes{% endif %}", {'y': 0}, ''), + 'if-tag-badarg03':("{% if x|default_if_none:y %}yes{% endif %}", {'y': 1}, 'yes'), + 'if-tag-badarg04':("{% if x|default_if_none:y %}yes{% else %}no{% endif %}", {}, 'no'), + + # Additional, more precise parsing tests are in SmartIfTests + + ### IFCHANGED TAG ######################################################### + 'ifchanged01': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,2,3)}, '123'), + 'ifchanged02': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,1,3)}, '13'), + 'ifchanged03': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,1,1)}, '1'), + 'ifchanged04': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 2, 3), 'numx': (2, 2, 2)}, '122232'), + 'ifchanged05': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (1, 2, 3)}, '1123123123'), + 'ifchanged06': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (2, 2, 2)}, '1222'), + '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 %}', {'num': (1, 1, 1), 'numx': (2, 2, 2), 'numy': (3, 3, 3)}, '1233323332333'), + 'ifchanged08': ('{% for data in datalist %}{% for c,d in data %}{% if c %}{% ifchanged %}{{ d }}{% endifchanged %}{% endif %}{% endfor %}{% endfor %}', {'datalist': [[(1, 'a'), (1, 'a'), (0, 'b'), (1, 'c')], [(0, 'a'), (1, 'c'), (1, 'd'), (1, 'd'), (0, 'e')]]}, 'accd'), + + # Test one parameter given to ifchanged. + 'ifchanged-param01': ('{% for n in num %}{% ifchanged n %}..{% endifchanged %}{{ n }}{% endfor %}', { 'num': (1,2,3) }, '..1..2..3'), + 'ifchanged-param02': ('{% for n in num %}{% for x in numx %}{% ifchanged n %}..{% endifchanged %}{{ x }}{% endfor %}{% endfor %}', { 'num': (1,2,3), 'numx': (5,6,7) }, '..567..567..567'), + + # Test multiple parameters to ifchanged. + 'ifchanged-param03': ('{% for n in num %}{{ n }}{% for x in numx %}{% ifchanged x n %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', { 'num': (1,1,2), 'numx': (5,6,6) }, '156156256'), + + # 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. + 'ifchanged-param04': ('{% for d in days %}{% ifchanged %}{{ d.day }}{% endifchanged %}{% for h in d.hours %}{% ifchanged d h %}{{ h }}{% endifchanged %}{% endfor %}{% endfor %}', {'days':[{'day':1, 'hours':[1,2,3]},{'day':2, 'hours':[3]},] }, '112323'), + + # Logically the same as above, just written with explicit + # ifchanged for the day. + '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 %}', {'days':[{'day':1, 'hours':[1,2,3]},{'day':2, 'hours':[3]},] }, '112323'), + + # Test the else clause of ifchanged. + 'ifchanged-else01': ('{% for id in ids %}{{ id }}{% ifchanged id %}-first{% else %}-other{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-first,1-other,2-first,2-other,2-other,3-first,'), + + 'ifchanged-else02': ('{% for id in ids %}{{ id }}-{% ifchanged id %}{% cycle red,blue %}{% else %}grey{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-red,1-grey,2-blue,2-grey,2-grey,3-red,'), + 'ifchanged-else03': ('{% for id in ids %}{{ id }}{% ifchanged id %}-{% cycle red,blue %}{% else %}{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-red,1,2-blue,2,2,3-red,'), + + 'ifchanged-else04': ('{% for id in ids %}{% ifchanged %}***{{ id }}*{% else %}...{% endifchanged %}{{ forloop.counter }}{% endfor %}', {'ids': [1,1,2,2,2,3,4]}, '***1*1...2***2*3...4...5***3*6***4*7'), + + # Test whitespace in filter arguments + 'ifchanged-filter-ws': ('{% load custom %}{% for n in num %}{% ifchanged n|noop:"x y" %}..{% endifchanged %}{{ n }}{% endfor %}', {'num': (1,2,3)}, '..1..2..3'), + + ### IFEQUAL TAG ########################################################### + 'ifequal01': ("{% ifequal a b %}yes{% endifequal %}", {"a": 1, "b": 2}, ""), + 'ifequal02': ("{% ifequal a b %}yes{% endifequal %}", {"a": 1, "b": 1}, "yes"), + 'ifequal03': ("{% ifequal a b %}yes{% else %}no{% endifequal %}", {"a": 1, "b": 2}, "no"), + 'ifequal04': ("{% ifequal a b %}yes{% else %}no{% endifequal %}", {"a": 1, "b": 1}, "yes"), + 'ifequal05': ("{% ifequal a 'test' %}yes{% else %}no{% endifequal %}", {"a": "test"}, "yes"), + 'ifequal06': ("{% ifequal a 'test' %}yes{% else %}no{% endifequal %}", {"a": "no"}, "no"), + 'ifequal07': ('{% ifequal a "test" %}yes{% else %}no{% endifequal %}', {"a": "test"}, "yes"), + 'ifequal08': ('{% ifequal a "test" %}yes{% else %}no{% endifequal %}', {"a": "no"}, "no"), + 'ifequal09': ('{% ifequal a "test" %}yes{% else %}no{% endifequal %}', {}, "no"), + 'ifequal10': ('{% ifequal a b %}yes{% else %}no{% endifequal %}', {}, "yes"), + + # SMART SPLITTING + 'ifequal-split01': ('{% ifequal a "test man" %}yes{% else %}no{% endifequal %}', {}, "no"), + 'ifequal-split02': ('{% ifequal a "test man" %}yes{% else %}no{% endifequal %}', {'a': 'foo'}, "no"), + 'ifequal-split03': ('{% ifequal a "test man" %}yes{% else %}no{% endifequal %}', {'a': 'test man'}, "yes"), + 'ifequal-split04': ("{% ifequal a 'test man' %}yes{% else %}no{% endifequal %}", {'a': 'test man'}, "yes"), + 'ifequal-split05': ("{% ifequal a 'i \"love\" you' %}yes{% else %}no{% endifequal %}", {'a': ''}, "no"), + 'ifequal-split06': ("{% ifequal a 'i \"love\" you' %}yes{% else %}no{% endifequal %}", {'a': 'i "love" you'}, "yes"), + 'ifequal-split07': ("{% ifequal a 'i \"love\" you' %}yes{% else %}no{% endifequal %}", {'a': 'i love you'}, "no"), + 'ifequal-split08': (r"{% ifequal a 'I\'m happy' %}yes{% else %}no{% endifequal %}", {'a': "I'm happy"}, "yes"), + 'ifequal-split09': (r"{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}", {'a': r"slash\man"}, "yes"), + 'ifequal-split10': (r"{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}", {'a': r"slashman"}, "no"), + + # NUMERIC RESOLUTION + 'ifequal-numeric01': ('{% ifequal x 5 %}yes{% endifequal %}', {'x': '5'}, ''), + 'ifequal-numeric02': ('{% ifequal x 5 %}yes{% endifequal %}', {'x': 5}, 'yes'), + 'ifequal-numeric03': ('{% ifequal x 5.2 %}yes{% endifequal %}', {'x': 5}, ''), + 'ifequal-numeric04': ('{% ifequal x 5.2 %}yes{% endifequal %}', {'x': 5.2}, 'yes'), + 'ifequal-numeric05': ('{% ifequal x 0.2 %}yes{% endifequal %}', {'x': .2}, 'yes'), + 'ifequal-numeric06': ('{% ifequal x .2 %}yes{% endifequal %}', {'x': .2}, 'yes'), + 'ifequal-numeric07': ('{% ifequal x 2. %}yes{% endifequal %}', {'x': 2}, ''), + 'ifequal-numeric08': ('{% ifequal x "5" %}yes{% endifequal %}', {'x': 5}, ''), + 'ifequal-numeric09': ('{% ifequal x "5" %}yes{% endifequal %}', {'x': '5'}, 'yes'), + 'ifequal-numeric10': ('{% ifequal x -5 %}yes{% endifequal %}', {'x': -5}, 'yes'), + 'ifequal-numeric11': ('{% ifequal x -5.2 %}yes{% endifequal %}', {'x': -5.2}, 'yes'), + 'ifequal-numeric12': ('{% ifequal x +5 %}yes{% endifequal %}', {'x': 5}, 'yes'), + + # FILTER EXPRESSIONS AS ARGUMENTS + 'ifequal-filter01': ('{% ifequal a|upper "A" %}x{% endifequal %}', {'a': 'a'}, 'x'), + 'ifequal-filter02': ('{% ifequal "A" a|upper %}x{% endifequal %}', {'a': 'a'}, 'x'), + 'ifequal-filter03': ('{% ifequal a|upper b|upper %}x{% endifequal %}', {'a': 'x', 'b': 'X'}, 'x'), + 'ifequal-filter04': ('{% ifequal x|slice:"1" "a" %}x{% endifequal %}', {'x': 'aaa'}, 'x'), + 'ifequal-filter05': ('{% ifequal x|slice:"1"|upper "A" %}x{% endifequal %}', {'x': 'aaa'}, 'x'), + + ### IFNOTEQUAL TAG ######################################################## + 'ifnotequal01': ("{% ifnotequal a b %}yes{% endifnotequal %}", {"a": 1, "b": 2}, "yes"), + 'ifnotequal02': ("{% ifnotequal a b %}yes{% endifnotequal %}", {"a": 1, "b": 1}, ""), + 'ifnotequal03': ("{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}", {"a": 1, "b": 2}, "yes"), + 'ifnotequal04': ("{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}", {"a": 1, "b": 1}, "no"), + + ## INCLUDE TAG ########################################################### + 'include01': ('{% include "basic-syntax01" %}', {}, "something cool"), + 'include02': ('{% include "basic-syntax02" %}', {'headline': 'Included'}, "Included"), + 'include03': ('{% include template_name %}', {'template_name': 'basic-syntax02', 'headline': 'Included'}, "Included"), + 'include04': ('a{% include "nonexistent" %}b', {}, ("ab", "ab", template.TemplateDoesNotExist)), + 'include 05': ('template with a space', {}, 'template with a space'), + 'include06': ('{% include "include 05"%}', {}, 'template with a space'), + + # extra inline context + 'include07': ('{% include "basic-syntax02" with headline="Inline" %}', {'headline': 'Included'}, 'Inline'), + 'include08': ('{% include headline with headline="Dynamic" %}', {'headline': 'basic-syntax02'}, 'Dynamic'), + 'include09': ('{{ first }}--{% include "basic-syntax03" with first=second|lower|upper second=first|upper %}--{{ second }}', {'first': 'Ul', 'second': 'lU'}, 'Ul--LU --- UL--lU'), + + # isolated context + 'include10': ('{% include "basic-syntax03" only %}', {'first': '1'}, (' --- ', 'INVALID --- INVALID')), + 'include11': ('{% include "basic-syntax03" only with second=2 %}', {'first': '1'}, (' --- 2', 'INVALID --- 2')), + 'include12': ('{% include "basic-syntax03" with first=1 only %}', {'second': '2'}, ('1 --- ', '1 --- INVALID')), + + # autoescape context + 'include13': ('{% autoescape off %}{% include "basic-syntax03" %}{% endautoescape %}', {'first': '&'}, ('& --- ', '& --- INVALID')), + 'include14': ('{% autoescape off %}{% include "basic-syntax03" with first=var1 only %}{% endautoescape %}', {'var1': '&'}, ('& --- ', '& --- INVALID')), + + 'include-error01': ('{% include "basic-syntax01" with %}', {}, template.TemplateSyntaxError), + 'include-error02': ('{% include "basic-syntax01" with "no key" %}', {}, template.TemplateSyntaxError), + 'include-error03': ('{% include "basic-syntax01" with dotted.arg="error" %}', {}, template.TemplateSyntaxError), + 'include-error04': ('{% include "basic-syntax01" something_random %}', {}, template.TemplateSyntaxError), + 'include-error05': ('{% include "basic-syntax01" foo="duplicate" foo="key" %}', {}, template.TemplateSyntaxError), + 'include-error06': ('{% include "basic-syntax01" only only %}', {}, template.TemplateSyntaxError), + + ### INCLUSION ERROR REPORTING ############################################# + 'include-fail1': ('{% load bad_tag %}{% badtag %}', {}, RuntimeError), + 'include-fail2': ('{% load broken_tag %}', {}, template.TemplateSyntaxError), + 'include-error07': ('{% include "include-fail1" %}', {}, ('', '', RuntimeError)), + 'include-error08': ('{% include "include-fail2" %}', {}, ('', '', template.TemplateSyntaxError)), + 'include-error09': ('{% include failed_include %}', {'failed_include': 'include-fail1'}, ('', '', RuntimeError)), + 'include-error10': ('{% include failed_include %}', {'failed_include': 'include-fail2'}, ('', '', template.TemplateSyntaxError)), + + + ### NAMED ENDBLOCKS ####################################################### + + # Basic test + 'namedendblocks01': ("1{% block first %}_{% block second %}2{% endblock second %}_{% endblock first %}3", {}, '1_2_3'), + + # Unbalanced blocks + 'namedendblocks02': ("1{% block first %}_{% block second %}2{% endblock first %}_{% endblock second %}3", {}, template.TemplateSyntaxError), + 'namedendblocks03': ("1{% block first %}_{% block second %}2{% endblock %}_{% endblock second %}3", {}, template.TemplateSyntaxError), + 'namedendblocks04': ("1{% block first %}_{% block second %}2{% endblock second %}_{% endblock third %}3", {}, template.TemplateSyntaxError), + 'namedendblocks05': ("1{% block first %}_{% block second %}2{% endblock first %}", {}, template.TemplateSyntaxError), + + # Mixed named and unnamed endblocks + 'namedendblocks06': ("1{% block first %}_{% block second %}2{% endblock %}_{% endblock first %}3", {}, '1_2_3'), + 'namedendblocks07': ("1{% block first %}_{% block second %}2{% endblock second %}_{% endblock %}3", {}, '1_2_3'), + + ### INHERITANCE ########################################################### + + # Standard template with no inheritance + 'inheritance01': ("1{% block first %}&{% endblock %}3{% block second %}_{% endblock %}", {}, '1&3_'), + + # Standard two-level inheritance + 'inheritance02': ("{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}", {}, '1234'), + + # Three-level with no redefinitions on third level + 'inheritance03': ("{% extends 'inheritance02' %}", {}, '1234'), + + # Two-level with no redefinitions on second level + 'inheritance04': ("{% extends 'inheritance01' %}", {}, '1&3_'), + + # Two-level with double quotes instead of single quotes + 'inheritance05': ('{% extends "inheritance02" %}', {}, '1234'), + + # Three-level with variable parent-template name + 'inheritance06': ("{% extends foo %}", {'foo': 'inheritance02'}, '1234'), + + # Two-level with one block defined, one block not defined + 'inheritance07': ("{% extends 'inheritance01' %}{% block second %}5{% endblock %}", {}, '1&35'), + + # Three-level with one block defined on this level, two blocks defined next level + 'inheritance08': ("{% extends 'inheritance02' %}{% block second %}5{% endblock %}", {}, '1235'), + + # Three-level with second and third levels blank + 'inheritance09': ("{% extends 'inheritance04' %}", {}, '1&3_'), + + # Three-level with space NOT in a block -- should be ignored + 'inheritance10': ("{% extends 'inheritance04' %} ", {}, '1&3_'), + + # Three-level with both blocks defined on this level, but none on second level + 'inheritance11': ("{% extends 'inheritance04' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}", {}, '1234'), + + # Three-level with this level providing one and second level providing the other + 'inheritance12': ("{% extends 'inheritance07' %}{% block first %}2{% endblock %}", {}, '1235'), + + # Three-level with this level overriding second level + 'inheritance13': ("{% extends 'inheritance02' %}{% block first %}a{% endblock %}{% block second %}b{% endblock %}", {}, '1a3b'), + + # A block defined only in a child template shouldn't be displayed + 'inheritance14': ("{% extends 'inheritance01' %}{% block newblock %}NO DISPLAY{% endblock %}", {}, '1&3_'), + + # A block within another block + 'inheritance15': ("{% extends 'inheritance01' %}{% block first %}2{% block inner %}inner{% endblock %}{% endblock %}", {}, '12inner3_'), + + # A block within another block (level 2) + 'inheritance16': ("{% extends 'inheritance15' %}{% block inner %}out{% endblock %}", {}, '12out3_'), + + # {% load %} tag (parent -- setup for exception04) + 'inheritance17': ("{% load testtags %}{% block first %}1234{% endblock %}", {}, '1234'), + + # {% load %} tag (standard usage, without inheritance) + 'inheritance18': ("{% load testtags %}{% echo this that theother %}5678", {}, 'this that theother5678'), + + # {% load %} tag (within a child template) + 'inheritance19': ("{% extends 'inheritance01' %}{% block first %}{% load testtags %}{% echo 400 %}5678{% endblock %}", {}, '140056783_'), + + # Two-level inheritance with {{ block.super }} + 'inheritance20': ("{% extends 'inheritance01' %}{% block first %}{{ block.super }}a{% endblock %}", {}, '1&a3_'), + + # Three-level inheritance with {{ block.super }} from parent + 'inheritance21': ("{% extends 'inheritance02' %}{% block first %}{{ block.super }}a{% endblock %}", {}, '12a34'), + + # Three-level inheritance with {{ block.super }} from grandparent + 'inheritance22': ("{% extends 'inheritance04' %}{% block first %}{{ block.super }}a{% endblock %}", {}, '1&a3_'), + + # Three-level inheritance with {{ block.super }} from parent and grandparent + 'inheritance23': ("{% extends 'inheritance20' %}{% block first %}{{ block.super }}b{% endblock %}", {}, '1&ab3_'), + + # Inheritance from local context without use of template loader + 'inheritance24': ("{% extends context_template %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}", {'context_template': template.Template("1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}")}, '1234'), + + # Inheritance from local context with variable parent template + 'inheritance25': ("{% extends context_template.1 %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}", {'context_template': [template.Template("Wrong"), template.Template("1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}")]}, '1234'), + + # Set up a base template to extend + 'inheritance26': ("no tags", {}, 'no tags'), + + # Inheritance from a template that doesn't have any blocks + 'inheritance27': ("{% extends 'inheritance26' %}", {}, 'no tags'), + + # Set up a base template with a space in it. + 'inheritance 28': ("{% block first %}!{% endblock %}", {}, '!'), + + # Inheritance from a template with a space in its name should work. + 'inheritance29': ("{% extends 'inheritance 28' %}", {}, '!'), + + # Base template, putting block in a conditional {% if %} tag + 'inheritance30': ("1{% if optional %}{% block opt %}2{% endblock %}{% endif %}3", {'optional': True}, '123'), + + # Inherit from a template with block wrapped in an {% if %} tag (in parent), still gets overridden + 'inheritance31': ("{% extends 'inheritance30' %}{% block opt %}two{% endblock %}", {'optional': True}, '1two3'), + 'inheritance32': ("{% extends 'inheritance30' %}{% block opt %}two{% endblock %}", {}, '13'), + + # Base template, putting block in a conditional {% ifequal %} tag + 'inheritance33': ("1{% ifequal optional 1 %}{% block opt %}2{% endblock %}{% endifequal %}3", {'optional': 1}, '123'), + + # Inherit from a template with block wrapped in an {% ifequal %} tag (in parent), still gets overridden + 'inheritance34': ("{% extends 'inheritance33' %}{% block opt %}two{% endblock %}", {'optional': 1}, '1two3'), + 'inheritance35': ("{% extends 'inheritance33' %}{% block opt %}two{% endblock %}", {'optional': 2}, '13'), + + # Base template, putting block in a {% for %} tag + 'inheritance36': ("{% for n in numbers %}_{% block opt %}{{ n }}{% endblock %}{% endfor %}_", {'numbers': '123'}, '_1_2_3_'), + + # Inherit from a template with block wrapped in an {% for %} tag (in parent), still gets overridden + 'inheritance37': ("{% extends 'inheritance36' %}{% block opt %}X{% endblock %}", {'numbers': '123'}, '_X_X_X_'), + 'inheritance38': ("{% extends 'inheritance36' %}{% block opt %}X{% endblock %}", {}, '_'), + + # The super block will still be found. + 'inheritance39': ("{% extends 'inheritance30' %}{% block opt %}new{{ block.super }}{% endblock %}", {'optional': True}, '1new23'), + 'inheritance40': ("{% extends 'inheritance33' %}{% block opt %}new{{ block.super }}{% endblock %}", {'optional': 1}, '1new23'), + 'inheritance41': ("{% extends 'inheritance36' %}{% block opt %}new{{ block.super }}{% endblock %}", {'numbers': '123'}, '_new1_new2_new3_'), + + # Expression starting and ending with a quote + 'inheritance42': ("{% extends 'inheritance02'|cut:' ' %}", {}, '1234'), + + ### LOADING TAG LIBRARIES ################################################# + 'load01': ("{% load testtags subpackage.echo %}{% echo test %} {% echo2 \"test\" %}", {}, "test test"), + 'load02': ("{% load subpackage.echo %}{% echo2 \"test\" %}", {}, "test"), + + # {% load %} tag, importing individual tags + 'load03': ("{% load echo from testtags %}{% echo this that theother %}", {}, 'this that theother'), + 'load04': ("{% load echo other_echo from testtags %}{% echo this that theother %} {% other_echo and another thing %}", {}, 'this that theother and another thing'), + 'load05': ("{% load echo upper from testtags %}{% echo this that theother %} {{ statement|upper }}", {'statement': 'not shouting'}, 'this that theother NOT SHOUTING'), + 'load06': ("{% load echo2 from subpackage.echo %}{% echo2 \"test\" %}", {}, "test"), + + # {% load %} tag errors + 'load07': ("{% load echo other_echo bad_tag from testtags %}", {}, template.TemplateSyntaxError), + 'load08': ("{% load echo other_echo bad_tag from %}", {}, template.TemplateSyntaxError), + 'load09': ("{% load from testtags %}", {}, template.TemplateSyntaxError), + 'load10': ("{% load echo from bad_library %}", {}, template.TemplateSyntaxError), + 'load11': ("{% load subpackage.echo_invalid %}", {}, template.TemplateSyntaxError), + 'load12': ("{% load subpackage.missing %}", {}, template.TemplateSyntaxError), + + ### I18N ################################################################## + + # {% spaceless %} tag + 'spaceless01': ("{% spaceless %} <b> <i> text </i> </b> {% endspaceless %}", {}, "<b><i> text </i></b>"), + 'spaceless02': ("{% spaceless %} <b> \n <i> text </i> \n </b> {% endspaceless %}", {}, "<b><i> text </i></b>"), + 'spaceless03': ("{% spaceless %}<b><i>text</i></b>{% endspaceless %}", {}, "<b><i>text</i></b>"), + 'spaceless04': ("{% spaceless %}<b> <i>{{ text }}</i> </b>{% endspaceless %}", {'text' : 'This & that'}, "<b><i>This & that</i></b>"), + 'spaceless05': ("{% autoescape off %}{% spaceless %}<b> <i>{{ text }}</i> </b>{% endspaceless %}{% endautoescape %}", {'text' : 'This & that'}, "<b><i>This & that</i></b>"), + 'spaceless06': ("{% spaceless %}<b> <i>{{ text|safe }}</i> </b>{% endspaceless %}", {'text' : 'This & that'}, "<b><i>This & that</i></b>"), + + # simple translation of a string delimited by ' + 'i18n01': ("{% load i18n %}{% trans 'xxxyyyxxx' %}", {}, "xxxyyyxxx"), + + # simple translation of a string delimited by " + 'i18n02': ('{% load i18n %}{% trans "xxxyyyxxx" %}', {}, "xxxyyyxxx"), + + # simple translation of a variable + 'i18n03': ('{% load i18n %}{% blocktrans %}{{ anton }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, "Å"), + + # simple translation of a variable and filter + 'i18n04': ('{% load i18n %}{% blocktrans with berta=anton|lower %}{{ berta }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, 'å'), + 'legacyi18n04': ('{% load i18n %}{% blocktrans with anton|lower as berta %}{{ berta }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, 'å'), + + # simple translation of a string with interpolation + 'i18n05': ('{% load i18n %}{% blocktrans %}xxx{{ anton }}xxx{% endblocktrans %}', {'anton': 'yyy'}, "xxxyyyxxx"), + + # simple translation of a string to german + 'i18n06': ('{% load i18n %}{% trans "Page not found" %}', {'LANGUAGE_CODE': 'de'}, "Seite nicht gefunden"), + + # translation of singular form + 'i18n07': ('{% load i18n %}{% blocktrans count counter=number %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 1}, "singular"), + 'legacyi18n07': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 1}, "singular"), + + # translation of plural form + 'i18n08': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 2}, "2 plural"), + 'legacyi18n08': ('{% load i18n %}{% blocktrans count counter=number %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 2}, "2 plural"), + + # simple non-translation (only marking) of a string to german + 'i18n09': ('{% load i18n %}{% trans "Page not found" noop %}', {'LANGUAGE_CODE': 'de'}, "Page not found"), + + # translation of a variable with a translated filter + 'i18n10': ('{{ bool|yesno:_("yes,no,maybe") }}', {'bool': True, 'LANGUAGE_CODE': 'de'}, 'Ja'), + + # translation of a variable with a non-translated filter + 'i18n11': ('{{ bool|yesno:"ja,nein" }}', {'bool': True}, 'ja'), + + # usage of the get_available_languages tag + 'i18n12': ('{% load i18n %}{% get_available_languages as langs %}{% for lang in langs %}{% ifequal lang.0 "de" %}{{ lang.0 }}{% endifequal %}{% endfor %}', {}, 'de'), + + # translation of constant strings + 'i18n13': ('{{ _("Password") }}', {'LANGUAGE_CODE': 'de'}, 'Passwort'), + 'i18n14': ('{% cycle "foo" _("Password") _(\'Password\') as c %} {% cycle c %} {% cycle c %}', {'LANGUAGE_CODE': 'de'}, 'foo Passwort Passwort'), + 'i18n15': ('{{ absent|default:_("Password") }}', {'LANGUAGE_CODE': 'de', 'absent': ""}, 'Passwort'), + 'i18n16': ('{{ _("<") }}', {'LANGUAGE_CODE': 'de'}, '<'), + + # Escaping inside blocktrans and trans works as if it was directly in the + # template. + 'i18n17': ('{% load i18n %}{% blocktrans with berta=anton|escape %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α & β'), + 'i18n18': ('{% load i18n %}{% blocktrans with berta=anton|force_escape %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α & β'), + 'i18n19': ('{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}', {'andrew': 'a & b'}, 'a & b'), + 'i18n20': ('{% load i18n %}{% trans andrew %}', {'andrew': 'a & b'}, 'a & b'), + 'i18n21': ('{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}', {'andrew': mark_safe('a & b')}, 'a & b'), + 'i18n22': ('{% load i18n %}{% trans andrew %}', {'andrew': mark_safe('a & b')}, 'a & b'), + 'legacyi18n17': ('{% load i18n %}{% blocktrans with anton|escape as berta %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α & β'), + 'legacyi18n18': ('{% load i18n %}{% blocktrans with anton|force_escape as berta %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α & β'), + + # Use filters with the {% trans %} tag, #5972 + 'i18n23': ('{% load i18n %}{% trans "Page not found"|capfirst|slice:"6:" %}', {'LANGUAGE_CODE': 'de'}, 'nicht gefunden'), + 'i18n24': ("{% load i18n %}{% trans 'Page not found'|upper %}", {'LANGUAGE_CODE': 'de'}, 'SEITE NICHT GEFUNDEN'), + 'i18n25': ('{% load i18n %}{% trans somevar|upper %}', {'somevar': 'Page not found', 'LANGUAGE_CODE': 'de'}, 'SEITE NICHT GEFUNDEN'), + + # translation of plural form with extra field in singular form (#13568) + 'i18n26': ('{% load i18n %}{% blocktrans with extra_field=myextra_field count counter=number %}singular {{ extra_field }}{% plural %}plural{% endblocktrans %}', {'number': 1, 'myextra_field': 'test'}, "singular test"), + 'legacyi18n26': ('{% load i18n %}{% blocktrans with myextra_field as extra_field count number as counter %}singular {{ extra_field }}{% plural %}plural{% endblocktrans %}', {'number': 1, 'myextra_field': 'test'}, "singular test"), + + # translation of singular form in russian (#14126) + 'i18n27': ('{% load i18n %}{% blocktrans count counter=number %}{{ counter }} result{% plural %}{{ counter }} results{% endblocktrans %}', {'number': 1, 'LANGUAGE_CODE': 'ru'}, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442'), + 'legacyi18n27': ('{% load i18n %}{% blocktrans count number as counter %}{{ counter }} result{% plural %}{{ counter }} results{% endblocktrans %}', {'number': 1, 'LANGUAGE_CODE': 'ru'}, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442'), + + # simple translation of multiple variables + 'i18n28': ('{% load i18n %}{% blocktrans with a=anton b=berta %}{{ a }} + {{ b }}{% endblocktrans %}', {'anton': 'α', 'berta': 'β'}, 'α + β'), + 'legacyi18n28': ('{% load i18n %}{% blocktrans with anton as a and berta as b %}{{ a }} + {{ b }}{% endblocktrans %}', {'anton': 'α', 'berta': 'β'}, 'α + β'), + + # retrieving language information + 'i18n28_2': ('{% load i18n %}{% get_language_info for "de" as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {}, 'de: German/Deutsch bidi=False'), + 'i18n29': ('{% load i18n %}{% get_language_info for LANGUAGE_CODE as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {'LANGUAGE_CODE': 'fi'}, 'fi: Finnish/suomi bidi=False'), + 'i18n30': ('{% load i18n %}{% get_language_info_list for langcodes as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': ['it', 'no']}, 'it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; '), + 'i18n31': ('{% load i18n %}{% get_language_info_list for langcodes as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': (('sl', 'Slovenian'), ('fa', 'Persian'))}, 'sl: Slovenian/Sloven\u0161\u010dina bidi=False; fa: Persian/\u0641\u0627\u0631\u0633\u06cc bidi=True; '), + 'i18n32': ('{% load i18n %}{{ "hu"|language_name }} {{ "hu"|language_name_local }} {{ "hu"|language_bidi }}', {}, 'Hungarian Magyar False'), + 'i18n33': ('{% load i18n %}{{ langcode|language_name }} {{ langcode|language_name_local }} {{ langcode|language_bidi }}', {'langcode': 'nl'}, 'Dutch Nederlands False'), + + # blocktrans handling of variables which are not in the context. + 'i18n34': ('{% load i18n %}{% blocktrans %}{{ missing }}{% endblocktrans %}', {}, ''), + + # trans tag with as var + 'i18n35': ('{% load i18n %}{% trans "Page not found" as page_not_found %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, "Seite nicht gefunden"), + 'i18n36': ('{% load i18n %}{% trans "Page not found" noop as page_not_found %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, "Page not found"), + 'i18n36': ('{% load i18n %}{% trans "Page not found" as page_not_found noop %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, "Page not found"), + 'i18n37': ('{% load i18n %}{% trans "Page not found" as page_not_found %}{% blocktrans %}Error: {{ page_not_found }}{% endblocktrans %}', {'LANGUAGE_CODE': 'de'}, "Error: Seite nicht gefunden"), + + # Test whitespace in filter arguments + 'i18n38': ('{% load i18n custom %}{% get_language_info for "de"|noop:"x y" as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {}, 'de: German/Deutsch bidi=False'), + 'i18n38_2': ('{% load i18n custom %}{% get_language_info_list for langcodes|noop:"x y" as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': ['it', 'no']}, 'it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; '), + + ### HANDLING OF TEMPLATE_STRING_IF_INVALID ################################### + + 'invalidstr01': ('{{ var|default:"Foo" }}', {}, ('Foo','INVALID')), + 'invalidstr02': ('{{ var|default_if_none:"Foo" }}', {}, ('','INVALID')), + 'invalidstr03': ('{% for v in var %}({{ v }}){% endfor %}', {}, ''), + 'invalidstr04': ('{% if var %}Yes{% else %}No{% endif %}', {}, 'No'), + 'invalidstr04_2': ('{% if var|default:"Foo" %}Yes{% else %}No{% endif %}', {}, 'Yes'), + 'invalidstr05': ('{{ var }}', {}, ('', ('INVALID %s', 'var'))), + 'invalidstr06': ('{{ var.prop }}', {'var': {}}, ('', ('INVALID %s', 'var.prop'))), + + ### MULTILINE ############################################################# + + 'multiline01': (""" + Hello, + boys. + How + are + you + gentlemen. + """, + {}, + """ + Hello, + boys. + How + are + you + gentlemen. + """), + + ### REGROUP TAG ########################################################### + 'regroup01': ('{% regroup data by bar as grouped %}' + '{% for group in grouped %}' + '{{ group.grouper }}:' + '{% for item in group.list %}' + '{{ item.foo }}' + '{% endfor %},' + '{% endfor %}', + {'data': [ {'foo':'c', 'bar':1}, + {'foo':'d', 'bar':1}, + {'foo':'a', 'bar':2}, + {'foo':'b', 'bar':2}, + {'foo':'x', 'bar':3} ]}, + '1:cd,2:ab,3:x,'), + + # Test for silent failure when target variable isn't found + 'regroup02': ('{% regroup data by bar as grouped %}' + '{% for group in grouped %}' + '{{ group.grouper }}:' + '{% for item in group.list %}' + '{{ item.foo }}' + '{% endfor %},' + '{% endfor %}', + {}, ''), + + # Regression tests for #17675 + # The date template filter has expects_localtime = True + '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 %}', + {'data': [{'at': date(2012, 2, 14)}, + {'at': date(2012, 2, 28)}, + {'at': date(2012, 7, 4)}]}, + '02:1428,07:04,'), + # The join template filter has needs_autoescape = True + 'regroup04': ('{% regroup data by bar|join:"" as grouped %}' + '{% for group in grouped %}' + '{{ group.grouper }}:' + '{% for item in group.list %}' + '{{ item.foo|first }}' + '{% endfor %},' + '{% endfor %}', + {'data': [{'foo': 'x', 'bar': ['ab', 'c']}, + {'foo': 'y', 'bar': ['a', 'bc']}, + {'foo': 'z', 'bar': ['a', 'd']}]}, + 'abc:xy,ad:z,'), + + # Test syntax + 'regroup05': ('{% regroup data by bar as %}', {}, + template.TemplateSyntaxError), + 'regroup06': ('{% regroup data by bar thisaintright grouped %}', {}, + template.TemplateSyntaxError), + 'regroup07': ('{% regroup data thisaintright bar as grouped %}', {}, + template.TemplateSyntaxError), + 'regroup08': ('{% regroup data by bar as grouped toomanyargs %}', {}, + template.TemplateSyntaxError), + + ### SSI TAG ######################################################## + + # Test normal behavior + 'ssi01': ('{%% ssi "%s" %%}' % os.path.join(basedir, 'templates', 'ssi_include.html'), {}, 'This is for testing an ssi include. {{ test }}\n'), + 'ssi02': ('{%% ssi "%s" %%}' % os.path.join(basedir, 'not_here'), {}, ''), + 'ssi03': ("{%% ssi '%s' %%}" % os.path.join(basedir, 'not_here'), {}, ''), + + # Test passing as a variable + 'ssi04': ('{% load ssi from future %}{% ssi ssi_file %}', {'ssi_file': os.path.join(basedir, 'templates', 'ssi_include.html')}, 'This is for testing an ssi include. {{ test }}\n'), + 'ssi05': ('{% load ssi from future %}{% ssi ssi_file %}', {'ssi_file': 'no_file'}, ''), + + # Test parsed output + 'ssi06': ('{%% ssi "%s" parsed %%}' % os.path.join(basedir, 'templates', 'ssi_include.html'), {'test': 'Look ma! It parsed!'}, 'This is for testing an ssi include. Look ma! It parsed!\n'), + 'ssi07': ('{%% ssi "%s" parsed %%}' % os.path.join(basedir, 'not_here'), {'test': 'Look ma! It parsed!'}, ''), + + # Test space in file name + 'ssi08': ('{%% ssi "%s" %%}' % os.path.join(basedir, 'templates', 'ssi include with spaces.html'), {}, 'This is for testing an ssi include with spaces in its name. {{ test }}\n'), + 'ssi09': ('{%% ssi "%s" parsed %%}' % os.path.join(basedir, 'templates', 'ssi include with spaces.html'), {'test': 'Look ma! It parsed!'}, 'This is for testing an ssi include with spaces in its name. Look ma! It parsed!\n'), + + ### TEMPLATETAG TAG ####################################################### + 'templatetag01': ('{% templatetag openblock %}', {}, '{%'), + 'templatetag02': ('{% templatetag closeblock %}', {}, '%}'), + 'templatetag03': ('{% templatetag openvariable %}', {}, '{{'), + 'templatetag04': ('{% templatetag closevariable %}', {}, '}}'), + 'templatetag05': ('{% templatetag %}', {}, template.TemplateSyntaxError), + 'templatetag06': ('{% templatetag foo %}', {}, template.TemplateSyntaxError), + 'templatetag07': ('{% templatetag openbrace %}', {}, '{'), + 'templatetag08': ('{% templatetag closebrace %}', {}, '}'), + 'templatetag09': ('{% templatetag openbrace %}{% templatetag openbrace %}', {}, '{{'), + 'templatetag10': ('{% templatetag closebrace %}{% templatetag closebrace %}', {}, '}}'), + 'templatetag11': ('{% templatetag opencomment %}', {}, '{#'), + 'templatetag12': ('{% templatetag closecomment %}', {}, '#}'), + + # Simple tags with customized names + 'simpletag-renamed01': ('{% load custom %}{% minusone 7 %}', {}, '6'), + 'simpletag-renamed02': ('{% load custom %}{% minustwo 7 %}', {}, '5'), + 'simpletag-renamed03': ('{% load custom %}{% minustwo_overridden_name 7 %}', {}, template.TemplateSyntaxError), + + ### WIDTHRATIO TAG ######################################################## + 'widthratio01': ('{% widthratio a b 0 %}', {'a':50,'b':100}, '0'), + 'widthratio02': ('{% widthratio a b 100 %}', {'a':0,'b':0}, '0'), + 'widthratio03': ('{% widthratio a b 100 %}', {'a':0,'b':100}, '0'), + 'widthratio04': ('{% widthratio a b 100 %}', {'a':50,'b':100}, '50'), + 'widthratio05': ('{% widthratio a b 100 %}', {'a':100,'b':100}, '100'), + + # 62.5 should round to 63 on Python 2 and 62 on Python 3 + # See http://docs.python.org/py3k/whatsnew/3.0.html + 'widthratio06': ('{% widthratio a b 100 %}', {'a':50,'b':80}, '62' if six.PY3 else '63'), + + # 71.4 should round to 71 + 'widthratio07': ('{% widthratio a b 100 %}', {'a':50,'b':70}, '71'), + + # Raise exception if we don't have 3 args, last one an integer + 'widthratio08': ('{% widthratio %}', {}, template.TemplateSyntaxError), + 'widthratio09': ('{% widthratio a b %}', {'a':50,'b':100}, template.TemplateSyntaxError), + 'widthratio10': ('{% widthratio a b 100.0 %}', {'a':50,'b':100}, '50'), + + # #10043: widthratio should allow max_width to be a variable + 'widthratio11': ('{% widthratio a b c %}', {'a':50,'b':100, 'c': 100}, '50'), + + # #18739: widthratio should handle None args consistently with non-numerics + 'widthratio12a': ('{% widthratio a b c %}', {'a':'a','b':100,'c':100}, ''), + 'widthratio12b': ('{% widthratio a b c %}', {'a':None,'b':100,'c':100}, ''), + 'widthratio13a': ('{% widthratio a b c %}', {'a':0,'b':'b','c':100}, ''), + 'widthratio13b': ('{% widthratio a b c %}', {'a':0,'b':None,'c':100}, ''), + 'widthratio14a': ('{% widthratio a b c %}', {'a':0,'b':100,'c':'c'}, template.TemplateSyntaxError), + 'widthratio14b': ('{% widthratio a b c %}', {'a':0,'b':100,'c':None}, template.TemplateSyntaxError), + + # Test whitespace in filter argument + 'widthratio15': ('{% load custom %}{% widthratio a|noop:"x y" b 0 %}', {'a':50,'b':100}, '0'), + + ### WITH TAG ######################################################## + 'with01': ('{% with key=dict.key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, '50'), + 'legacywith01': ('{% with dict.key as key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, '50'), + + 'with02': ('{{ key }}{% with key=dict.key %}{{ key }}-{{ dict.key }}-{{ key }}{% endwith %}{{ key }}', {'dict': {'key': 50}}, ('50-50-50', 'INVALID50-50-50INVALID')), + 'legacywith02': ('{{ key }}{% with dict.key as key %}{{ key }}-{{ dict.key }}-{{ key }}{% endwith %}{{ key }}', {'dict': {'key': 50}}, ('50-50-50', 'INVALID50-50-50INVALID')), + + 'with03': ('{% with a=alpha b=beta %}{{ a }}{{ b }}{% endwith %}', {'alpha': 'A', 'beta': 'B'}, 'AB'), + + 'with-error01': ('{% with dict.key xx key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, template.TemplateSyntaxError), + 'with-error02': ('{% with dict.key as %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, template.TemplateSyntaxError), + + ### NOW TAG ######################################################## + # Simple case + 'now01': ('{% now "j n Y" %}', {}, "%d %d %d" % ( + datetime.now().day, datetime.now().month, datetime.now().year)), + # Check parsing of locale strings + 'now02': ('{% now "DATE_FORMAT" %}', {}, date_format(datetime.now())), + # Also accept simple quotes - #15092 + 'now03': ("{% now 'j n Y' %}", {}, "%d %d %d" % ( + datetime.now().day, datetime.now().month, datetime.now().year)), + 'now04': ("{% now 'DATE_FORMAT' %}", {}, date_format(datetime.now())), + 'now05': ('''{% now 'j "n" Y'%}''', {}, '''%d "%d" %d''' % ( + datetime.now().day, datetime.now().month, datetime.now().year)), + 'now06': ('''{% now "j 'n' Y"%}''', {}, '''%d '%d' %d''' % ( + datetime.now().day, datetime.now().month, datetime.now().year)), + + ### URL TAG ######################################################## + # Successes + 'url01': ('{% url "regressiontests.templates.views.client" client.id %}', {'client': {'id': 1}}, '/url_tag/client/1/'), + 'url02': ('{% url "regressiontests.templates.views.client_action" id=client.id action="update" %}', {'client': {'id': 1}}, '/url_tag/client/1/update/'), + 'url02a': ('{% url "regressiontests.templates.views.client_action" client.id "update" %}', {'client': {'id': 1}}, '/url_tag/client/1/update/'), + 'url02b': ("{% url 'regressiontests.templates.views.client_action' id=client.id action='update' %}", {'client': {'id': 1}}, '/url_tag/client/1/update/'), + 'url02c': ("{% url 'regressiontests.templates.views.client_action' client.id 'update' %}", {'client': {'id': 1}}, '/url_tag/client/1/update/'), + 'url03': ('{% url "regressiontests.templates.views.index" %}', {}, '/url_tag/'), + 'url04': ('{% url "named.client" client.id %}', {'client': {'id': 1}}, '/url_tag/named-client/1/'), + 'url05': ('{% url "метка_оператора" v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'), + 'url06': ('{% url "метка_оператора_2" tag=v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'), + 'url07': ('{% url "regressiontests.templates.views.client2" tag=v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'), + 'url08': ('{% url "метка_оператора" v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'), + 'url09': ('{% url "метка_оператора_2" tag=v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'), + 'url10': ('{% url "regressiontests.templates.views.client_action" id=client.id action="two words" %}', {'client': {'id': 1}}, '/url_tag/client/1/two%20words/'), + 'url11': ('{% url "regressiontests.templates.views.client_action" id=client.id action="==" %}', {'client': {'id': 1}}, '/url_tag/client/1/==/'), + 'url12': ('{% url "regressiontests.templates.views.client_action" id=client.id action="," %}', {'client': {'id': 1}}, '/url_tag/client/1/,/'), + 'url13': ('{% url "regressiontests.templates.views.client_action" id=client.id action=arg|join:"-" %}', {'client': {'id': 1}, 'arg':['a','b']}, '/url_tag/client/1/a-b/'), + 'url14': ('{% url "regressiontests.templates.views.client_action" client.id arg|join:"-" %}', {'client': {'id': 1}, 'arg':['a','b']}, '/url_tag/client/1/a-b/'), + 'url15': ('{% url "regressiontests.templates.views.client_action" 12 "test" %}', {}, '/url_tag/client/12/test/'), + 'url18': ('{% url "regressiontests.templates.views.client" "1,2" %}', {}, '/url_tag/client/1,2/'), + + 'url19': ('{% url named_url client.id %}', {'named_url': 'regressiontests.templates.views.client', 'client': {'id': 1}}, '/url_tag/client/1/'), + 'url20': ('{% url url_name_in_var client.id %}', {'url_name_in_var': 'named.client', 'client': {'id': 1}}, '/url_tag/named-client/1/'), + + # Failures + 'url-fail01': ('{% url %}', {}, template.TemplateSyntaxError), + 'url-fail02': ('{% url "no_such_view" %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)), + 'url-fail03': ('{% url "regressiontests.templates.views.client" %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)), + 'url-fail04': ('{% url "view" id, %}', {}, template.TemplateSyntaxError), + 'url-fail05': ('{% url "view" id= %}', {}, template.TemplateSyntaxError), + 'url-fail06': ('{% url "view" a.id=id %}', {}, template.TemplateSyntaxError), + 'url-fail07': ('{% url "view" a.id!id %}', {}, template.TemplateSyntaxError), + 'url-fail08': ('{% url "view" id="unterminatedstring %}', {}, template.TemplateSyntaxError), + 'url-fail09': ('{% url "view" id=", %}', {}, template.TemplateSyntaxError), + + 'url-fail11': ('{% url named_url %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)), + 'url-fail12': ('{% url named_url %}', {'named_url': 'no_such_view'}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)), + 'url-fail13': ('{% url named_url %}', {'named_url': 'regressiontests.templates.views.client'}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)), + 'url-fail14': ('{% url named_url id, %}', {'named_url': 'view'}, template.TemplateSyntaxError), + 'url-fail15': ('{% url named_url id= %}', {'named_url': 'view'}, template.TemplateSyntaxError), + 'url-fail16': ('{% url named_url a.id=id %}', {'named_url': 'view'}, template.TemplateSyntaxError), + 'url-fail17': ('{% url named_url a.id!id %}', {'named_url': 'view'}, template.TemplateSyntaxError), + 'url-fail18': ('{% url named_url id="unterminatedstring %}', {'named_url': 'view'}, template.TemplateSyntaxError), + 'url-fail19': ('{% url named_url id=", %}', {'named_url': 'view'}, template.TemplateSyntaxError), + + # {% url ... as var %} + 'url-asvar01': ('{% url "regressiontests.templates.views.index" as url %}', {}, ''), + 'url-asvar02': ('{% url "regressiontests.templates.views.index" as url %}{{ url }}', {}, '/url_tag/'), + 'url-asvar03': ('{% url "no_such_view" as url %}{{ url }}', {}, ''), + + ### CACHE TAG ###################################################### + 'cache03': ('{% load cache %}{% cache 2 test %}cache03{% endcache %}', {}, 'cache03'), + 'cache04': ('{% load cache %}{% cache 2 test %}cache04{% endcache %}', {}, 'cache03'), + 'cache05': ('{% load cache %}{% cache 2 test foo %}cache05{% endcache %}', {'foo': 1}, 'cache05'), + 'cache06': ('{% load cache %}{% cache 2 test foo %}cache06{% endcache %}', {'foo': 2}, 'cache06'), + 'cache07': ('{% load cache %}{% cache 2 test foo %}cache07{% endcache %}', {'foo': 1}, 'cache05'), + + # Allow first argument to be a variable. + 'cache08': ('{% load cache %}{% cache time test foo %}cache08{% endcache %}', {'foo': 2, 'time': 2}, 'cache06'), + + # Raise exception if we don't have at least 2 args, first one integer. + 'cache11': ('{% load cache %}{% cache %}{% endcache %}', {}, template.TemplateSyntaxError), + 'cache12': ('{% load cache %}{% cache 1 %}{% endcache %}', {}, template.TemplateSyntaxError), + 'cache13': ('{% load cache %}{% cache foo bar %}{% endcache %}', {}, template.TemplateSyntaxError), + 'cache14': ('{% load cache %}{% cache foo bar %}{% endcache %}', {'foo': 'fail'}, template.TemplateSyntaxError), + 'cache15': ('{% load cache %}{% cache foo bar %}{% endcache %}', {'foo': []}, template.TemplateSyntaxError), + + # Regression test for #7460. + 'cache16': ('{% load cache %}{% cache 1 foo bar %}{% endcache %}', {'foo': 'foo', 'bar': 'with spaces'}, ''), + + # Regression test for #11270. + 'cache17': ('{% load cache %}{% cache 10 long_cache_key poem %}Some Content{% endcache %}', {'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 dont.'}, 'Some Content'), + + # Test whitespace in filter arguments + 'cache18': ('{% load cache custom %}{% cache 2|noop:"x y" cache18 %}cache18{% endcache %}', {}, 'cache18'), + + + ### AUTOESCAPE TAG ############################################## + 'autoescape-tag01': ("{% autoescape off %}hello{% endautoescape %}", {}, "hello"), + 'autoescape-tag02': ("{% autoescape off %}{{ first }}{% endautoescape %}", {"first": "<b>hello</b>"}, "<b>hello</b>"), + 'autoescape-tag03': ("{% autoescape on %}{{ first }}{% endautoescape %}", {"first": "<b>hello</b>"}, "<b>hello</b>"), + + # Autoescape disabling and enabling nest in a predictable way. + 'autoescape-tag04': ("{% autoescape off %}{{ first }} {% autoescape on%}{{ first }}{% endautoescape %}{% endautoescape %}", {"first": "<a>"}, "<a> <a>"), + + 'autoescape-tag05': ("{% autoescape on %}{{ first }}{% endautoescape %}", {"first": "<b>first</b>"}, "<b>first</b>"), + + # Strings (ASCII or unicode) already marked as "safe" are not + # auto-escaped + 'autoescape-tag06': ("{{ first }}", {"first": mark_safe("<b>first</b>")}, "<b>first</b>"), + 'autoescape-tag07': ("{% autoescape on %}{{ first }}{% endautoescape %}", {"first": mark_safe("<b>Apple</b>")}, "<b>Apple</b>"), + + # Literal string arguments to filters, if used in the result, are + # safe. + 'autoescape-tag08': (r'{% autoescape on %}{{ var|default_if_none:" endquote\" hah" }}{% endautoescape %}', {"var": None}, ' endquote" hah'), + + # Objects which return safe strings as their __unicode__ method + # won't get double-escaped. + 'autoescape-tag09': (r'{{ unsafe }}', {'unsafe': filters.UnsafeClass()}, 'you & me'), + 'autoescape-tag10': (r'{{ safe }}', {'safe': filters.SafeClass()}, 'you > me'), + + # The "safe" and "escape" filters cannot work due to internal + # implementation details (fortunately, the (no)autoescape block + # tags can be used in those cases) + 'autoescape-filtertag01': ("{{ first }}{% filter safe %}{{ first }} x<y{% endfilter %}", {"first": "<a>"}, template.TemplateSyntaxError), + + # ifqeual compares unescaped vales. + 'autoescape-ifequal01': ('{% ifequal var "this & that" %}yes{% endifequal %}', { "var": "this & that" }, "yes"), + + # Arguments to filters are 'safe' and manipulate their input unescaped. + 'autoescape-filters01': ('{{ var|cut:"&" }}', { "var": "this & that" }, "this that" ), + 'autoescape-filters02': ('{{ var|join:" & \" }}', { "var": ("Tom", "Dick", "Harry") }, "Tom & Dick & Harry"), + + # Literal strings are safe. + 'autoescape-literals01': ('{{ "this & that" }}',{}, "this & that"), + + # Iterating over strings outputs safe characters. + 'autoescape-stringiterations01': ('{% for l in var %}{{ l }},{% endfor %}', {'var': 'K&R'}, "K,&,R,"), + + # Escape requirement survives lookup. + 'autoescape-lookup01': ('{{ var.key }}', { "var": {"key": "this & that" }}, "this & that"), + + # Static template tags + 'static-prefixtag01': ('{% load static %}{% get_static_prefix %}', {}, settings.STATIC_URL), + 'static-prefixtag02': ('{% load static %}{% get_static_prefix as static_prefix %}{{ static_prefix }}', {}, settings.STATIC_URL), + 'static-prefixtag03': ('{% load static %}{% get_media_prefix %}', {}, settings.MEDIA_URL), + 'static-prefixtag04': ('{% load static %}{% get_media_prefix as media_prefix %}{{ media_prefix }}', {}, settings.MEDIA_URL), + 'static-statictag01': ('{% load static %}{% static "admin/base.css" %}', {}, urljoin(settings.STATIC_URL, 'admin/base.css')), + 'static-statictag02': ('{% load static %}{% static base_css %}', {'base_css': 'admin/base.css'}, urljoin(settings.STATIC_URL, 'admin/base.css')), + 'static-statictag03': ('{% load static %}{% static "admin/base.css" as foo %}{{ foo }}', {}, urljoin(settings.STATIC_URL, 'admin/base.css')), + 'static-statictag04': ('{% load static %}{% static base_css as foo %}{{ foo }}', {'base_css': 'admin/base.css'}, urljoin(settings.STATIC_URL, 'admin/base.css')), + + # Verbatim template tag outputs contents without rendering. + 'verbatim-tag01': ('{% verbatim %}{{bare }}{% endverbatim %}', {}, '{{bare }}'), + 'verbatim-tag02': ('{% verbatim %}{% endif %}{% endverbatim %}', {}, '{% endif %}'), + 'verbatim-tag03': ("{% verbatim %}It's the {% verbatim %} tag{% endverbatim %}", {}, "It's the {% verbatim %} tag"), + 'verbatim-tag04': ('{% verbatim %}{% verbatim %}{% endverbatim %}{% endverbatim %}', {}, template.TemplateSyntaxError), + 'verbatim-tag05': ('{% verbatim %}{% endverbatim %}{% verbatim %}{% endverbatim %}', {}, ''), + 'verbatim-tag06': ("{% verbatim special %}Don't {% endverbatim %} just yet{% endverbatim special %}", {}, "Don't {% endverbatim %} just yet"), + } + + if numpy: + tests.update({ + # Numpy's array-index syntax allows a template to access a certain item of a subscriptable object. + 'numpy-array-index01': ("{{ var.1 }}", {"var": numpy.array(["first item", "second item"])}, "second item"), + + # Fail silently when the array index is out of range. + 'numpy-array-index02': ("{{ var.5 }}", {"var": numpy.array(["first item", "second item"])}, ("", "INVALID")), + }) + + + return tests + +class TemplateTagLoading(unittest.TestCase): + + def setUp(self): + self.old_path = sys.path[:] + self.old_apps = settings.INSTALLED_APPS + self.egg_dir = '%s/eggs' % os.path.dirname(upath(__file__)) + self.old_tag_modules = template_base.templatetags_modules + template_base.templatetags_modules = [] + + def tearDown(self): + settings.INSTALLED_APPS = self.old_apps + sys.path = self.old_path + template_base.templatetags_modules = self.old_tag_modules + + def test_load_error(self): + ttext = "{% load broken_tag %}" + self.assertRaises(template.TemplateSyntaxError, template.Template, ttext) + try: + template.Template(ttext) + except template.TemplateSyntaxError as e: + self.assertTrue('ImportError' in e.args[0]) + self.assertTrue('Xtemplate' in e.args[0]) + + def test_load_error_egg(self): + ttext = "{% load broken_egg %}" + egg_name = '%s/tagsegg.egg' % self.egg_dir + sys.path.append(egg_name) + settings.INSTALLED_APPS = ('tagsegg',) + self.assertRaises(template.TemplateSyntaxError, template.Template, ttext) + try: + template.Template(ttext) + except template.TemplateSyntaxError as e: + self.assertTrue('ImportError' in e.args[0]) + self.assertTrue('Xtemplate' in e.args[0]) + + def test_load_working_egg(self): + ttext = "{% load working_egg %}" + egg_name = '%s/tagsegg.egg' % self.egg_dir + sys.path.append(egg_name) + settings.INSTALLED_APPS = ('tagsegg',) + t = template.Template(ttext) + + +class RequestContextTests(unittest.TestCase): + + def setUp(self): + templates = { + 'child': Template('{{ var|default:"none" }}'), + } + setup_test_template_loader(templates) + self.fake_request = RequestFactory().get('/') + + def tearDown(self): + restore_template_loaders() + + def test_include_only(self): + """ + Regression test for #15721, ``{% include %}`` and ``RequestContext`` + not playing together nicely. + """ + ctx = RequestContext(self.fake_request, {'var': 'parent'}) + self.assertEqual( + template.Template('{% include "child" %}').render(ctx), + 'parent' + ) + self.assertEqual( + template.Template('{% include "child" only %}').render(ctx), + 'none' + ) diff --git a/tests/templates/unicode.py b/tests/templates/unicode.py new file mode 100644 index 0000000000..7cb2a28d15 --- /dev/null +++ b/tests/templates/unicode.py @@ -0,0 +1,32 @@ +# -*- coding: utf-8 -*- +from __future__ import unicode_literals + +from django.template import Template, TemplateEncodingError, Context +from django.utils.safestring import SafeData +from django.utils import six +from django.utils.unittest import TestCase + + +class UnicodeTests(TestCase): + def test_template(self): + # Templates can be created from unicode strings. + t1 = Template('ŠĐĆŽćžšđ {{ var }}') + # Templates can also be created from bytestrings. These are assumed to + # be encoded using UTF-8. + s = b'\xc5\xa0\xc4\x90\xc4\x86\xc5\xbd\xc4\x87\xc5\xbe\xc5\xa1\xc4\x91 {{ var }}' + t2 = Template(s) + s = b'\x80\xc5\xc0' + self.assertRaises(TemplateEncodingError, Template, s) + + # Contexts can be constructed from unicode or UTF-8 bytestrings. + c1 = Context({b"var": b"foo"}) + c2 = Context({"var": b"foo"}) + c3 = Context({b"var": "Đđ"}) + c4 = Context({"var": b"\xc4\x90\xc4\x91"}) + + # Since both templates and all four contexts represent the same thing, + # they all render the same (and are returned as unicode objects and + # "safe" objects as well, for auto-escaping purposes). + self.assertEqual(t1.render(c3), t2.render(c3)) + self.assertIsInstance(t1.render(c3), six.text_type) + self.assertIsInstance(t1.render(c3), SafeData) diff --git a/tests/templates/urls.py b/tests/templates/urls.py new file mode 100644 index 0000000000..fe7f9c1f30 --- /dev/null +++ b/tests/templates/urls.py @@ -0,0 +1,20 @@ +# coding: utf-8 +from __future__ import absolute_import, unicode_literals + +from django.conf.urls import patterns, url +from . import views + + +urlpatterns = patterns('', + + # Test urls for testing reverse lookups + (r'^$', views.index), + (r'^client/([\d,]+)/$', views.client), + (r'^client/(?P<id>\d+)/(?P<action>[^/]+)/$', views.client_action), + (r'^client/(?P<client_id>\d+)/(?P<action>[^/]+)/$', views.client_action), + url(r'^named-client/(\d+)/$', views.client2, name="named.client"), + + # Unicode strings are permitted everywhere. + url(r'^Юникод/(\w+)/$', views.client2, name="метка_оператора"), + url(r'^Юникод/(?P<tag>\S+)/$', 'regressiontests.templates.views.client2', name="метка_оператора_2"), +) diff --git a/tests/templates/views.py b/tests/templates/views.py new file mode 100644 index 0000000000..ed15893239 --- /dev/null +++ b/tests/templates/views.py @@ -0,0 +1,22 @@ +# Fake views for testing url reverse lookup +from django.http import HttpResponse +from django.template.response import TemplateResponse + + +def index(request): + pass + +def client(request, id): + pass + +def client_action(request, id, action): + pass + +def client2(request, tag): + pass + +def template_response_view(request): + return TemplateResponse(request, 'response.html', {}) + +def snark(request): + return HttpResponse('Found him!') |