From 9c19aff7c7561e3a82978a272ecdaad40dda5c00 Mon Sep 17 00:00:00 2001 From: django-bot Date: Thu, 3 Feb 2022 20:24:19 +0100 Subject: Refs #33476 -- Reformatted code with Black. --- tests/template_tests/alternate_urls.py | 5 +- tests/template_tests/filter_tests/test_add.py | 63 +- .../template_tests/filter_tests/test_addslashes.py | 26 +- .../template_tests/filter_tests/test_autoescape.py | 40 +- tests/template_tests/filter_tests/test_capfirst.py | 24 +- tests/template_tests/filter_tests/test_center.py | 22 +- tests/template_tests/filter_tests/test_chaining.py | 131 ++-- tests/template_tests/filter_tests/test_cut.py | 60 +- tests/template_tests/filter_tests/test_date.py | 75 +- tests/template_tests/filter_tests/test_default.py | 36 +- .../filter_tests/test_default_if_none.py | 7 +- tests/template_tests/filter_tests/test_dictsort.py | 109 +-- .../filter_tests/test_dictsortreversed.py | 53 +- .../filter_tests/test_divisibleby.py | 1 - tests/template_tests/filter_tests/test_escape.py | 33 +- tests/template_tests/filter_tests/test_escapejs.py | 60 +- .../filter_tests/test_filesizeformat.py | 73 +- tests/template_tests/filter_tests/test_first.py | 22 +- .../filter_tests/test_floatformat.py | 158 ++-- .../filter_tests/test_force_escape.py | 57 +- .../template_tests/filter_tests/test_get_digit.py | 3 +- .../template_tests/filter_tests/test_iriencode.py | 41 +- tests/template_tests/filter_tests/test_join.py | 72 +- .../filter_tests/test_json_script.py | 12 +- tests/template_tests/filter_tests/test_last.py | 21 +- tests/template_tests/filter_tests/test_length.py | 52 +- .../template_tests/filter_tests/test_length_is.py | 110 +-- .../template_tests/filter_tests/test_linebreaks.py | 43 +- .../filter_tests/test_linebreaksbr.py | 33 +- .../filter_tests/test_linenumbers.py | 41 +- tests/template_tests/filter_tests/test_ljust.py | 26 +- tests/template_tests/filter_tests/test_lower.py | 24 +- .../template_tests/filter_tests/test_make_list.py | 29 +- .../filter_tests/test_phone2numeric.py | 33 +- .../template_tests/filter_tests/test_pluralize.py | 60 +- tests/template_tests/filter_tests/test_random.py | 17 +- tests/template_tests/filter_tests/test_rjust.py | 24 +- tests/template_tests/filter_tests/test_safe.py | 13 +- tests/template_tests/filter_tests/test_safeseq.py | 17 +- tests/template_tests/filter_tests/test_slice.py | 40 +- tests/template_tests/filter_tests/test_slugify.py | 39 +- .../filter_tests/test_stringformat.py | 48 +- .../template_tests/filter_tests/test_striptags.py | 38 +- tests/template_tests/filter_tests/test_time.py | 61 +- .../template_tests/filter_tests/test_timesince.py | 143 ++-- .../template_tests/filter_tests/test_timeuntil.py | 133 ++-- tests/template_tests/filter_tests/test_title.py | 20 +- .../filter_tests/test_truncatechars.py | 23 +- .../filter_tests/test_truncatechars_html.py | 30 +- .../filter_tests/test_truncatewords.py | 38 +- .../filter_tests/test_truncatewords_html.py | 36 +- .../filter_tests/test_unordered_list.py | 132 ++-- tests/template_tests/filter_tests/test_upper.py | 27 +- .../template_tests/filter_tests/test_urlencode.py | 18 +- tests/template_tests/filter_tests/test_urlize.py | 226 +++--- .../filter_tests/test_urlizetrunc.py | 45 +- .../template_tests/filter_tests/test_wordcount.py | 28 +- tests/template_tests/filter_tests/test_wordwrap.py | 58 +- tests/template_tests/filter_tests/test_yesno.py | 29 +- .../template_tests/filter_tests/timezone_utils.py | 7 +- tests/template_tests/syntax_tests/i18n/base.py | 2 +- .../syntax_tests/i18n/test_blocktranslate.py | 805 +++++++++++++-------- .../syntax_tests/i18n/test_filters.py | 76 +- .../i18n/test_get_available_languages.py | 20 +- .../syntax_tests/i18n/test_get_current_language.py | 6 +- .../i18n/test_get_current_language_bidi.py | 6 +- .../syntax_tests/i18n/test_get_language_info.py | 54 +- .../i18n/test_get_language_info_list.py | 70 +- .../syntax_tests/i18n/test_language.py | 10 +- .../syntax_tests/i18n/test_translate.py | 272 ++++--- .../syntax_tests/i18n/test_underscore_syntax.py | 98 +-- .../template_tests/syntax_tests/test_autoescape.py | 155 ++-- tests/template_tests/syntax_tests/test_basic.py | 253 +++---- tests/template_tests/syntax_tests/test_builtins.py | 19 +- tests/template_tests/syntax_tests/test_cache.py | 211 +++--- tests/template_tests/syntax_tests/test_comment.py | 111 +-- tests/template_tests/syntax_tests/test_cycle.py | 267 ++++--- tests/template_tests/syntax_tests/test_debug.py | 47 +- .../template_tests/syntax_tests/test_exceptions.py | 29 +- tests/template_tests/syntax_tests/test_extends.py | 294 ++++---- .../syntax_tests/test_filter_syntax.py | 139 ++-- .../template_tests/syntax_tests/test_filter_tag.py | 41 +- tests/template_tests/syntax_tests/test_firstof.py | 103 ++- tests/template_tests/syntax_tests/test_for.py | 350 ++++++--- tests/template_tests/syntax_tests/test_if.py | 761 ++++++++++--------- .../template_tests/syntax_tests/test_if_changed.py | 348 ++++++--- tests/template_tests/syntax_tests/test_include.py | 307 ++++---- .../syntax_tests/test_invalid_string.py | 64 +- .../template_tests/syntax_tests/test_list_index.py | 55 +- tests/template_tests/syntax_tests/test_load.py | 76 +- tests/template_tests/syntax_tests/test_lorem.py | 33 +- .../template_tests/syntax_tests/test_multiline.py | 5 +- .../syntax_tests/test_named_endblock.py | 75 +- tests/template_tests/syntax_tests/test_now.py | 97 ++- tests/template_tests/syntax_tests/test_numpy.py | 19 +- tests/template_tests/syntax_tests/test_regroup.py | 197 +++-- .../template_tests/syntax_tests/test_resetcycle.py | 169 +++-- tests/template_tests/syntax_tests/test_setup.py | 23 +- .../template_tests/syntax_tests/test_simple_tag.py | 18 +- .../template_tests/syntax_tests/test_spaceless.py | 49 +- tests/template_tests/syntax_tests/test_static.py | 95 ++- .../syntax_tests/test_template_tag.py | 71 +- tests/template_tests/syntax_tests/test_url.py | 296 ++++---- tests/template_tests/syntax_tests/test_verbatim.py | 55 +- .../syntax_tests/test_width_ratio.py | 160 ++-- tests/template_tests/syntax_tests/test_with.py | 62 +- tests/template_tests/templatetags/custom.py | 46 +- tests/template_tests/templatetags/inclusion.py | 177 +++-- tests/template_tests/templatetags/tag_27584.py | 4 +- tests/template_tests/templatetags/testtags.py | 4 +- tests/template_tests/test_autoreloader.py | 100 +-- tests/template_tests/test_base.py | 44 +- tests/template_tests/test_callables.py | 36 +- tests/template_tests/test_context.py | 220 +++--- tests/template_tests/test_custom.py | 498 ++++++++----- tests/template_tests/test_engine.py | 103 +-- tests/template_tests/test_extends.py | 159 ++-- tests/template_tests/test_extends_relative.py | 65 +- tests/template_tests/test_library.py | 109 +-- tests/template_tests/test_loaders.py | 177 +++-- tests/template_tests/test_logging.py | 22 +- tests/template_tests/test_nodelist.py | 55 +- tests/template_tests/test_origin.py | 14 +- tests/template_tests/test_parser.py | 57 +- tests/template_tests/test_response.py | 296 ++++---- tests/template_tests/test_smartif.py | 29 +- tests/template_tests/tests.py | 57 +- tests/template_tests/urls.py | 27 +- tests/template_tests/utils.py | 31 +- tests/template_tests/views.py | 4 +- 130 files changed, 6799 insertions(+), 4953 deletions(-) (limited to 'tests/template_tests') diff --git a/tests/template_tests/alternate_urls.py b/tests/template_tests/alternate_urls.py index 181e5c50a5..236f393dd0 100644 --- a/tests/template_tests/alternate_urls.py +++ b/tests/template_tests/alternate_urls.py @@ -4,8 +4,7 @@ from . import views urlpatterns = [ # View returning a template response - path('template_response_view/', views.template_response_view), - + path("template_response_view/", views.template_response_view), # A view that can be hard to find... - path('snark/', views.snark, name='snark'), + path("snark/", views.snark, name="snark"), ] diff --git a/tests/template_tests/filter_tests/test_add.py b/tests/template_tests/filter_tests/test_add.py index b5786ca136..9b798f4aa7 100644 --- a/tests/template_tests/filter_tests/test_add.py +++ b/tests/template_tests/filter_tests/test_add.py @@ -12,59 +12,60 @@ class AddTests(SimpleTestCase): Tests for #11687 and #16676 """ - @setup({'add01': '{{ i|add:"5" }}'}) + @setup({"add01": '{{ i|add:"5" }}'}) def test_add01(self): - output = self.engine.render_to_string('add01', {'i': 2000}) - self.assertEqual(output, '2005') + output = self.engine.render_to_string("add01", {"i": 2000}) + self.assertEqual(output, "2005") - @setup({'add02': '{{ i|add:"napis" }}'}) + @setup({"add02": '{{ i|add:"napis" }}'}) def test_add02(self): - output = self.engine.render_to_string('add02', {'i': 2000}) - self.assertEqual(output, '') + output = self.engine.render_to_string("add02", {"i": 2000}) + self.assertEqual(output, "") - @setup({'add03': '{{ i|add:16 }}'}) + @setup({"add03": "{{ i|add:16 }}"}) def test_add03(self): - output = self.engine.render_to_string('add03', {'i': 'not_an_int'}) - self.assertEqual(output, '') + output = self.engine.render_to_string("add03", {"i": "not_an_int"}) + self.assertEqual(output, "") - @setup({'add04': '{{ i|add:"16" }}'}) + @setup({"add04": '{{ i|add:"16" }}'}) def test_add04(self): - output = self.engine.render_to_string('add04', {'i': 'not_an_int'}) - self.assertEqual(output, 'not_an_int16') + output = self.engine.render_to_string("add04", {"i": "not_an_int"}) + self.assertEqual(output, "not_an_int16") - @setup({'add05': '{{ l1|add:l2 }}'}) + @setup({"add05": "{{ l1|add:l2 }}"}) def test_add05(self): - output = self.engine.render_to_string('add05', {'l1': [1, 2], 'l2': [3, 4]}) - self.assertEqual(output, '[1, 2, 3, 4]') + output = self.engine.render_to_string("add05", {"l1": [1, 2], "l2": [3, 4]}) + self.assertEqual(output, "[1, 2, 3, 4]") - @setup({'add06': '{{ t1|add:t2 }}'}) + @setup({"add06": "{{ t1|add:t2 }}"}) def test_add06(self): - output = self.engine.render_to_string('add06', {'t1': (3, 4), 't2': (1, 2)}) - self.assertEqual(output, '(3, 4, 1, 2)') + output = self.engine.render_to_string("add06", {"t1": (3, 4), "t2": (1, 2)}) + self.assertEqual(output, "(3, 4, 1, 2)") - @setup({'add07': '{{ d|add:t }}'}) + @setup({"add07": "{{ d|add:t }}"}) def test_add07(self): - output = self.engine.render_to_string('add07', {'d': date(2000, 1, 1), 't': timedelta(10)}) - self.assertEqual(output, 'Jan. 11, 2000') + output = self.engine.render_to_string( + "add07", {"d": date(2000, 1, 1), "t": timedelta(10)} + ) + self.assertEqual(output, "Jan. 11, 2000") - @setup({'add08': '{{ s1|add:lazy_s2 }}'}) + @setup({"add08": "{{ s1|add:lazy_s2 }}"}) def test_add08(self): output = self.engine.render_to_string( - 'add08', - {'s1': 'string', 'lazy_s2': gettext_lazy('lazy')}, + "add08", + {"s1": "string", "lazy_s2": gettext_lazy("lazy")}, ) - self.assertEqual(output, 'stringlazy') + self.assertEqual(output, "stringlazy") - @setup({'add09': '{{ lazy_s1|add:lazy_s2 }}'}) + @setup({"add09": "{{ lazy_s1|add:lazy_s2 }}"}) def test_add09(self): output = self.engine.render_to_string( - 'add09', - {'lazy_s1': gettext_lazy('string'), 'lazy_s2': gettext_lazy('lazy')}, + "add09", + {"lazy_s1": gettext_lazy("string"), "lazy_s2": gettext_lazy("lazy")}, ) - self.assertEqual(output, 'stringlazy') + self.assertEqual(output, "stringlazy") class FunctionTests(SimpleTestCase): - def test_add(self): - self.assertEqual(add('1', '2'), 3) + self.assertEqual(add("1", "2"), 3) diff --git a/tests/template_tests/filter_tests/test_addslashes.py b/tests/template_tests/filter_tests/test_addslashes.py index ede25cfb14..2626918f3d 100644 --- a/tests/template_tests/filter_tests/test_addslashes.py +++ b/tests/template_tests/filter_tests/test_addslashes.py @@ -6,28 +6,34 @@ from ..utils import setup class AddslashesTests(SimpleTestCase): - - @setup({'addslashes01': '{% autoescape off %}{{ a|addslashes }} {{ b|addslashes }}{% endautoescape %}'}) + @setup( + { + "addslashes01": "{% autoescape off %}{{ a|addslashes }} {{ b|addslashes }}{% endautoescape %}" + } + ) def test_addslashes01(self): - output = self.engine.render_to_string('addslashes01', {"a": "'", "b": mark_safe("'")}) + output = self.engine.render_to_string( + "addslashes01", {"a": "'", "b": mark_safe("'")} + ) self.assertEqual(output, r"\' \'") - @setup({'addslashes02': '{{ a|addslashes }} {{ b|addslashes }}'}) + @setup({"addslashes02": "{{ a|addslashes }} {{ b|addslashes }}"}) def test_addslashes02(self): - output = self.engine.render_to_string('addslashes02', {"a": "'", "b": mark_safe("'")}) + output = self.engine.render_to_string( + "addslashes02", {"a": "'", "b": mark_safe("'")} + ) self.assertEqual(output, r"<a>\' \'") class FunctionTests(SimpleTestCase): - def test_quotes(self): self.assertEqual( - addslashes('"double quotes" and \'single quotes\''), - '\\"double quotes\\" and \\\'single quotes\\\'', + addslashes("\"double quotes\" and 'single quotes'"), + "\\\"double quotes\\\" and \\'single quotes\\'", ) def test_backslashes(self): - self.assertEqual(addslashes(r'\ : backslashes, too'), '\\\\ : backslashes, too') + self.assertEqual(addslashes(r"\ : backslashes, too"), "\\\\ : backslashes, too") def test_non_string_input(self): - self.assertEqual(addslashes(123), '123') + self.assertEqual(addslashes(123), "123") diff --git a/tests/template_tests/filter_tests/test_autoescape.py b/tests/template_tests/filter_tests/test_autoescape.py index 35faada9c6..de58956f2c 100644 --- a/tests/template_tests/filter_tests/test_autoescape.py +++ b/tests/template_tests/filter_tests/test_autoescape.py @@ -8,22 +8,38 @@ class AutoescapeStringfilterTests(SimpleTestCase): Filters decorated with stringfilter still respect is_safe. """ - @setup({'autoescape-stringfilter01': '{{ unsafe|capfirst }}'}) + @setup({"autoescape-stringfilter01": "{{ unsafe|capfirst }}"}) def test_autoescape_stringfilter01(self): - output = self.engine.render_to_string('autoescape-stringfilter01', {'unsafe': UnsafeClass()}) - self.assertEqual(output, 'You & me') + output = self.engine.render_to_string( + "autoescape-stringfilter01", {"unsafe": UnsafeClass()} + ) + self.assertEqual(output, "You & me") - @setup({'autoescape-stringfilter02': '{% autoescape off %}{{ unsafe|capfirst }}{% endautoescape %}'}) + @setup( + { + "autoescape-stringfilter02": "{% autoescape off %}{{ unsafe|capfirst }}{% endautoescape %}" + } + ) def test_autoescape_stringfilter02(self): - output = self.engine.render_to_string('autoescape-stringfilter02', {'unsafe': UnsafeClass()}) - self.assertEqual(output, 'You & me') + output = self.engine.render_to_string( + "autoescape-stringfilter02", {"unsafe": UnsafeClass()} + ) + self.assertEqual(output, "You & me") - @setup({'autoescape-stringfilter03': '{{ safe|capfirst }}'}) + @setup({"autoescape-stringfilter03": "{{ safe|capfirst }}"}) def test_autoescape_stringfilter03(self): - output = self.engine.render_to_string('autoescape-stringfilter03', {'safe': SafeClass()}) - self.assertEqual(output, 'You > me') + output = self.engine.render_to_string( + "autoescape-stringfilter03", {"safe": SafeClass()} + ) + self.assertEqual(output, "You > me") - @setup({'autoescape-stringfilter04': '{% autoescape off %}{{ safe|capfirst }}{% endautoescape %}'}) + @setup( + { + "autoescape-stringfilter04": "{% autoescape off %}{{ safe|capfirst }}{% endautoescape %}" + } + ) def test_autoescape_stringfilter04(self): - output = self.engine.render_to_string('autoescape-stringfilter04', {'safe': SafeClass()}) - self.assertEqual(output, 'You > me') + output = self.engine.render_to_string( + "autoescape-stringfilter04", {"safe": SafeClass()} + ) + self.assertEqual(output, "You > me") diff --git a/tests/template_tests/filter_tests/test_capfirst.py b/tests/template_tests/filter_tests/test_capfirst.py index bcdf1e0203..3c489e6a1f 100644 --- a/tests/template_tests/filter_tests/test_capfirst.py +++ b/tests/template_tests/filter_tests/test_capfirst.py @@ -6,19 +6,25 @@ from ..utils import setup class CapfirstTests(SimpleTestCase): - - @setup({'capfirst01': '{% autoescape off %}{{ a|capfirst }} {{ b|capfirst }}{% endautoescape %}'}) + @setup( + { + "capfirst01": "{% autoescape off %}{{ a|capfirst }} {{ b|capfirst }}{% endautoescape %}" + } + ) def test_capfirst01(self): - output = self.engine.render_to_string('capfirst01', {'a': 'fred>', 'b': mark_safe('fred>')}) - self.assertEqual(output, 'Fred> Fred>') + output = self.engine.render_to_string( + "capfirst01", {"a": "fred>", "b": mark_safe("fred>")} + ) + self.assertEqual(output, "Fred> Fred>") - @setup({'capfirst02': '{{ a|capfirst }} {{ b|capfirst }}'}) + @setup({"capfirst02": "{{ a|capfirst }} {{ b|capfirst }}"}) def test_capfirst02(self): - output = self.engine.render_to_string('capfirst02', {'a': 'fred>', 'b': mark_safe('fred>')}) - self.assertEqual(output, 'Fred> Fred>') + output = self.engine.render_to_string( + "capfirst02", {"a": "fred>", "b": mark_safe("fred>")} + ) + self.assertEqual(output, "Fred> Fred>") class FunctionTests(SimpleTestCase): - def test_capfirst(self): - self.assertEqual(capfirst('hello world'), 'Hello world') + self.assertEqual(capfirst("hello world"), "Hello world") diff --git a/tests/template_tests/filter_tests/test_center.py b/tests/template_tests/filter_tests/test_center.py index c37b7f80c0..0a18294d88 100644 --- a/tests/template_tests/filter_tests/test_center.py +++ b/tests/template_tests/filter_tests/test_center.py @@ -6,22 +6,28 @@ from ..utils import setup class CenterTests(SimpleTestCase): - - @setup({'center01': '{% autoescape off %}.{{ a|center:"5" }}. .{{ b|center:"5" }}.{% endautoescape %}'}) + @setup( + { + "center01": '{% autoescape off %}.{{ a|center:"5" }}. .{{ b|center:"5" }}.{% endautoescape %}' + } + ) def test_center01(self): - output = self.engine.render_to_string('center01', {"a": "a&b", "b": mark_safe("a&b")}) + output = self.engine.render_to_string( + "center01", {"a": "a&b", "b": mark_safe("a&b")} + ) self.assertEqual(output, ". a&b . . a&b .") - @setup({'center02': '.{{ a|center:"5" }}. .{{ b|center:"5" }}.'}) + @setup({"center02": '.{{ a|center:"5" }}. .{{ b|center:"5" }}.'}) def test_center02(self): - output = self.engine.render_to_string('center02', {"a": "a&b", "b": mark_safe("a&b")}) + output = self.engine.render_to_string( + "center02", {"a": "a&b", "b": mark_safe("a&b")} + ) self.assertEqual(output, ". a&b . . a&b .") class FunctionTests(SimpleTestCase): - def test_center(self): - self.assertEqual(center('test', 6), ' test ') + self.assertEqual(center("test", 6), " test ") def test_non_string_input(self): - self.assertEqual(center(123, 5), ' 123 ') + self.assertEqual(center(123, 5), " 123 ") diff --git a/tests/template_tests/filter_tests/test_chaining.py b/tests/template_tests/filter_tests/test_chaining.py index 9bc3976f37..942707820f 100644 --- a/tests/template_tests/filter_tests/test_chaining.py +++ b/tests/template_tests/filter_tests/test_chaining.py @@ -9,81 +9,108 @@ class ChainingTests(SimpleTestCase): Chaining safeness-preserving filters should not alter the safe status. """ - @setup({'chaining01': '{{ a|capfirst|center:"7" }}.{{ b|capfirst|center:"7" }}'}) + @setup({"chaining01": '{{ a|capfirst|center:"7" }}.{{ b|capfirst|center:"7" }}'}) def test_chaining01(self): - output = self.engine.render_to_string('chaining01', {'a': 'a < b', 'b': mark_safe('a < b')}) - self.assertEqual(output, ' A < b . A < b ') - - @setup({ - 'chaining02': - '{% autoescape off %}{{ a|capfirst|center:"7" }}.{{ b|capfirst|center:"7" }}{% endautoescape %}' - }) + output = self.engine.render_to_string( + "chaining01", {"a": "a < b", "b": mark_safe("a < b")} + ) + self.assertEqual(output, " A < b . A < b ") + + @setup( + { + "chaining02": '{% autoescape off %}{{ a|capfirst|center:"7" }}.{{ b|capfirst|center:"7" }}{% endautoescape %}' + } + ) def test_chaining02(self): - output = self.engine.render_to_string('chaining02', {'a': 'a < b', 'b': mark_safe('a < b')}) - self.assertEqual(output, ' A < b . A < b ') + output = self.engine.render_to_string( + "chaining02", {"a": "a < b", "b": mark_safe("a < b")} + ) + self.assertEqual(output, " A < b . A < b ") # Using a filter that forces a string back to unsafe: - @setup({'chaining03': '{{ a|cut:"b"|capfirst }}.{{ b|cut:"b"|capfirst }}'}) + @setup({"chaining03": '{{ a|cut:"b"|capfirst }}.{{ b|cut:"b"|capfirst }}'}) def test_chaining03(self): - output = self.engine.render_to_string('chaining03', {'a': 'a < b', 'b': mark_safe('a < b')}) - self.assertEqual(output, 'A < .A < ') - - @setup({ - 'chaining04': '{% autoescape off %}{{ a|cut:"b"|capfirst }}.{{ b|cut:"b"|capfirst }}{% endautoescape %}' - }) + output = self.engine.render_to_string( + "chaining03", {"a": "a < b", "b": mark_safe("a < b")} + ) + self.assertEqual(output, "A < .A < ") + + @setup( + { + "chaining04": '{% autoescape off %}{{ a|cut:"b"|capfirst }}.{{ b|cut:"b"|capfirst }}{% endautoescape %}' + } + ) def test_chaining04(self): - output = self.engine.render_to_string('chaining04', {'a': 'a < b', 'b': mark_safe('a < b')}) - self.assertEqual(output, 'A < .A < ') + output = self.engine.render_to_string( + "chaining04", {"a": "a < b", "b": mark_safe("a < b")} + ) + self.assertEqual(output, "A < .A < ") # Using a filter that forces safeness does not lead to double-escaping - @setup({'chaining05': '{{ a|escape|capfirst }}'}) + @setup({"chaining05": "{{ a|escape|capfirst }}"}) def test_chaining05(self): - output = self.engine.render_to_string('chaining05', {'a': 'a < b'}) - self.assertEqual(output, 'A < b') + output = self.engine.render_to_string("chaining05", {"a": "a < b"}) + self.assertEqual(output, "A < b") - @setup({'chaining06': '{% autoescape off %}{{ a|escape|capfirst }}{% endautoescape %}'}) + @setup( + {"chaining06": "{% autoescape off %}{{ a|escape|capfirst }}{% endautoescape %}"} + ) def test_chaining06(self): - output = self.engine.render_to_string('chaining06', {'a': 'a < b'}) - self.assertEqual(output, 'A < b') + output = self.engine.render_to_string("chaining06", {"a": "a < b"}) + self.assertEqual(output, "A < b") # Force to safe, then back (also showing why using force_escape too # early in a chain can lead to unexpected results). - @setup({'chaining07': '{{ a|force_escape|cut:";" }}'}) + @setup({"chaining07": '{{ a|force_escape|cut:";" }}'}) def test_chaining07(self): - output = self.engine.render_to_string('chaining07', {'a': 'a < b'}) - self.assertEqual(output, 'a &lt b') - - @setup({'chaining08': '{% autoescape off %}{{ a|force_escape|cut:";" }}{% endautoescape %}'}) + output = self.engine.render_to_string("chaining07", {"a": "a < b"}) + self.assertEqual(output, "a &lt b") + + @setup( + { + "chaining08": '{% autoescape off %}{{ a|force_escape|cut:";" }}{% endautoescape %}' + } + ) def test_chaining08(self): - output = self.engine.render_to_string('chaining08', {'a': 'a < b'}) - self.assertEqual(output, 'a < b') + output = self.engine.render_to_string("chaining08", {"a": "a < b"}) + self.assertEqual(output, "a < b") - @setup({'chaining09': '{{ a|cut:";"|force_escape }}'}) + @setup({"chaining09": '{{ a|cut:";"|force_escape }}'}) def test_chaining09(self): - output = self.engine.render_to_string('chaining09', {'a': 'a < b'}) - self.assertEqual(output, 'a < b') - - @setup({'chaining10': '{% autoescape off %}{{ a|cut:";"|force_escape }}{% endautoescape %}'}) + output = self.engine.render_to_string("chaining09", {"a": "a < b"}) + self.assertEqual(output, "a < b") + + @setup( + { + "chaining10": '{% autoescape off %}{{ a|cut:";"|force_escape }}{% endautoescape %}' + } + ) def test_chaining10(self): - output = self.engine.render_to_string('chaining10', {'a': 'a < b'}) - self.assertEqual(output, 'a < b') + output = self.engine.render_to_string("chaining10", {"a": "a < b"}) + self.assertEqual(output, "a < b") - @setup({'chaining11': '{{ a|cut:"b"|safe }}'}) + @setup({"chaining11": '{{ a|cut:"b"|safe }}'}) def test_chaining11(self): - output = self.engine.render_to_string('chaining11', {'a': 'a < b'}) - self.assertEqual(output, 'a < ') + output = self.engine.render_to_string("chaining11", {"a": "a < b"}) + self.assertEqual(output, "a < ") - @setup({'chaining12': '{% autoescape off %}{{ a|cut:"b"|safe }}{% endautoescape %}'}) + @setup( + {"chaining12": '{% autoescape off %}{{ a|cut:"b"|safe }}{% endautoescape %}'} + ) def test_chaining12(self): - output = self.engine.render_to_string('chaining12', {'a': 'a < b'}) - self.assertEqual(output, 'a < ') + output = self.engine.render_to_string("chaining12", {"a": "a < b"}) + self.assertEqual(output, "a < ") - @setup({'chaining13': '{{ a|safe|force_escape }}'}) + @setup({"chaining13": "{{ a|safe|force_escape }}"}) def test_chaining13(self): - output = self.engine.render_to_string('chaining13', {"a": "a < b"}) - self.assertEqual(output, 'a < b') - - @setup({'chaining14': '{% autoescape off %}{{ a|safe|force_escape }}{% endautoescape %}'}) + output = self.engine.render_to_string("chaining13", {"a": "a < b"}) + self.assertEqual(output, "a < b") + + @setup( + { + "chaining14": "{% autoescape off %}{{ a|safe|force_escape }}{% endautoescape %}" + } + ) def test_chaining14(self): - output = self.engine.render_to_string('chaining14', {"a": "a < b"}) - self.assertEqual(output, 'a < b') + output = self.engine.render_to_string("chaining14", {"a": "a < b"}) + self.assertEqual(output, "a < b") diff --git a/tests/template_tests/filter_tests/test_cut.py b/tests/template_tests/filter_tests/test_cut.py index 6b4baa2645..adf1468709 100644 --- a/tests/template_tests/filter_tests/test_cut.py +++ b/tests/template_tests/filter_tests/test_cut.py @@ -6,50 +6,74 @@ from ..utils import setup class CutTests(SimpleTestCase): - - @setup({'cut01': '{% autoescape off %}{{ a|cut:"x" }} {{ b|cut:"x" }}{% endautoescape %}'}) + @setup( + { + "cut01": '{% autoescape off %}{{ a|cut:"x" }} {{ b|cut:"x" }}{% endautoescape %}' + } + ) def test_cut01(self): - output = self.engine.render_to_string('cut01', {"a": "x&y", "b": mark_safe("x&y")}) + output = self.engine.render_to_string( + "cut01", {"a": "x&y", "b": mark_safe("x&y")} + ) self.assertEqual(output, "&y &y") - @setup({'cut02': '{{ a|cut:"x" }} {{ b|cut:"x" }}'}) + @setup({"cut02": '{{ a|cut:"x" }} {{ b|cut:"x" }}'}) def test_cut02(self): - output = self.engine.render_to_string('cut02', {"a": "x&y", "b": mark_safe("x&y")}) + output = self.engine.render_to_string( + "cut02", {"a": "x&y", "b": mark_safe("x&y")} + ) self.assertEqual(output, "&y &y") - @setup({'cut03': '{% autoescape off %}{{ a|cut:"&" }} {{ b|cut:"&" }}{% endautoescape %}'}) + @setup( + { + "cut03": '{% autoescape off %}{{ a|cut:"&" }} {{ b|cut:"&" }}{% endautoescape %}' + } + ) def test_cut03(self): - output = self.engine.render_to_string('cut03', {"a": "x&y", "b": mark_safe("x&y")}) + output = self.engine.render_to_string( + "cut03", {"a": "x&y", "b": mark_safe("x&y")} + ) self.assertEqual(output, "xy xamp;y") - @setup({'cut04': '{{ a|cut:"&" }} {{ b|cut:"&" }}'}) + @setup({"cut04": '{{ a|cut:"&" }} {{ b|cut:"&" }}'}) def test_cut04(self): - output = self.engine.render_to_string('cut04', {"a": "x&y", "b": mark_safe("x&y")}) + output = self.engine.render_to_string( + "cut04", {"a": "x&y", "b": mark_safe("x&y")} + ) self.assertEqual(output, "xy xamp;y") # Passing ';' to cut can break existing HTML entities, so those strings # are auto-escaped. - @setup({'cut05': '{% autoescape off %}{{ a|cut:";" }} {{ b|cut:";" }}{% endautoescape %}'}) + @setup( + { + "cut05": '{% autoescape off %}{{ a|cut:";" }} {{ b|cut:";" }}{% endautoescape %}' + } + ) def test_cut05(self): - output = self.engine.render_to_string('cut05', {"a": "x&y", "b": mark_safe("x&y")}) + output = self.engine.render_to_string( + "cut05", {"a": "x&y", "b": mark_safe("x&y")} + ) self.assertEqual(output, "x&y x&y") - @setup({'cut06': '{{ a|cut:";" }} {{ b|cut:";" }}'}) + @setup({"cut06": '{{ a|cut:";" }} {{ b|cut:";" }}'}) def test_cut06(self): - output = self.engine.render_to_string('cut06', {"a": "x&y", "b": mark_safe("x&y")}) + output = self.engine.render_to_string( + "cut06", {"a": "x&y", "b": mark_safe("x&y")} + ) self.assertEqual(output, "x&y x&ampy") class FunctionTests(SimpleTestCase): - def test_character(self): - self.assertEqual(cut('a string to be mangled', 'a'), ' string to be mngled') + self.assertEqual(cut("a string to be mangled", "a"), " string to be mngled") def test_characters(self): - self.assertEqual(cut('a string to be mangled', 'ng'), 'a stri to be maled') + self.assertEqual(cut("a string to be mangled", "ng"), "a stri to be maled") def test_non_matching_string(self): - self.assertEqual(cut('a string to be mangled', 'strings'), 'a string to be mangled') + self.assertEqual( + cut("a string to be mangled", "strings"), "a string to be mangled" + ) def test_non_string_input(self): - self.assertEqual(cut(123, '2'), '13') + self.assertEqual(cut(123, "2"), "13") diff --git a/tests/template_tests/filter_tests/test_date.py b/tests/template_tests/filter_tests/test_date.py index b2bdfa2bbb..a7c694d50e 100644 --- a/tests/template_tests/filter_tests/test_date.py +++ b/tests/template_tests/filter_tests/test_date.py @@ -9,76 +9,77 @@ from .timezone_utils import TimezoneTestCase class DateTests(TimezoneTestCase): - - @setup({'date01': '{{ d|date:"m" }}'}) + @setup({"date01": '{{ d|date:"m" }}'}) def test_date01(self): - output = self.engine.render_to_string('date01', {'d': datetime(2008, 1, 1)}) - self.assertEqual(output, '01') + output = self.engine.render_to_string("date01", {"d": datetime(2008, 1, 1)}) + self.assertEqual(output, "01") - @setup({'date02': '{{ d|date }}'}) + @setup({"date02": "{{ d|date }}"}) def test_date02(self): - output = self.engine.render_to_string('date02', {'d': datetime(2008, 1, 1)}) - self.assertEqual(output, 'Jan. 1, 2008') + output = self.engine.render_to_string("date02", {"d": datetime(2008, 1, 1)}) + self.assertEqual(output, "Jan. 1, 2008") - @setup({'date02_l10n': '{{ d|date }}'}) + @setup({"date02_l10n": "{{ d|date }}"}) def test_date02_l10n(self): """Without arg, the active language's DATE_FORMAT is used.""" - with translation.override('fr'): - output = self.engine.render_to_string('date02_l10n', {'d': datetime(2008, 1, 1)}) - self.assertEqual(output, '1 janvier 2008') + with translation.override("fr"): + output = self.engine.render_to_string( + "date02_l10n", {"d": datetime(2008, 1, 1)} + ) + self.assertEqual(output, "1 janvier 2008") - @setup({'date03': '{{ d|date:"m" }}'}) + @setup({"date03": '{{ d|date:"m" }}'}) def test_date03(self): """ #9520: Make sure |date doesn't blow up on non-dates """ - output = self.engine.render_to_string('date03', {'d': 'fail_string'}) - self.assertEqual(output, '') + output = self.engine.render_to_string("date03", {"d": "fail_string"}) + self.assertEqual(output, "") # ISO date formats - @setup({'date04': '{{ d|date:"o" }}'}) + @setup({"date04": '{{ d|date:"o" }}'}) def test_date04(self): - output = self.engine.render_to_string('date04', {'d': datetime(2008, 12, 29)}) - self.assertEqual(output, '2009') + output = self.engine.render_to_string("date04", {"d": datetime(2008, 12, 29)}) + self.assertEqual(output, "2009") - @setup({'date05': '{{ d|date:"o" }}'}) + @setup({"date05": '{{ d|date:"o" }}'}) def test_date05(self): - output = self.engine.render_to_string('date05', {'d': datetime(2010, 1, 3)}) - self.assertEqual(output, '2009') + output = self.engine.render_to_string("date05", {"d": datetime(2010, 1, 3)}) + self.assertEqual(output, "2009") # Timezone name - @setup({'date06': '{{ d|date:"e" }}'}) + @setup({"date06": '{{ d|date:"e" }}'}) def test_date06(self): output = self.engine.render_to_string( - 'date06', {'d': datetime(2009, 3, 12, tzinfo=timezone.get_fixed_timezone(30))} + "date06", + {"d": datetime(2009, 3, 12, tzinfo=timezone.get_fixed_timezone(30))}, ) - self.assertEqual(output, '+0030') + self.assertEqual(output, "+0030") - @setup({'date07': '{{ d|date:"e" }}'}) + @setup({"date07": '{{ d|date:"e" }}'}) def test_date07(self): - output = self.engine.render_to_string('date07', {'d': datetime(2009, 3, 12)}) - self.assertEqual(output, '') + output = self.engine.render_to_string("date07", {"d": datetime(2009, 3, 12)}) + self.assertEqual(output, "") # #19370: Make sure |date doesn't blow up on a midnight time object - @setup({'date08': '{{ t|date:"H:i" }}'}) + @setup({"date08": '{{ t|date:"H:i" }}'}) def test_date08(self): - output = self.engine.render_to_string('date08', {'t': time(0, 1)}) - self.assertEqual(output, '00:01') + output = self.engine.render_to_string("date08", {"t": time(0, 1)}) + self.assertEqual(output, "00:01") - @setup({'date09': '{{ t|date:"H:i" }}'}) + @setup({"date09": '{{ t|date:"H:i" }}'}) def test_date09(self): - output = self.engine.render_to_string('date09', {'t': time(0, 0)}) - self.assertEqual(output, '00:00') + output = self.engine.render_to_string("date09", {"t": time(0, 0)}) + self.assertEqual(output, "00:00") class FunctionTests(SimpleTestCase): - def test_date(self): - self.assertEqual(date(datetime(2005, 12, 29), "d F Y"), '29 December 2005') + self.assertEqual(date(datetime(2005, 12, 29), "d F Y"), "29 December 2005") def test_no_args(self): - self.assertEqual(date(''), '') - self.assertEqual(date(None), '') + self.assertEqual(date(""), "") + self.assertEqual(date(None), "") def test_escape_characters(self): - self.assertEqual(date(datetime(2005, 12, 29), r'jS \o\f F'), '29th of December') + self.assertEqual(date(datetime(2005, 12, 29), r"jS \o\f F"), "29th of December") diff --git a/tests/template_tests/filter_tests/test_default.py b/tests/template_tests/filter_tests/test_default.py index 4b6b9dd684..20621f610f 100644 --- a/tests/template_tests/filter_tests/test_default.py +++ b/tests/template_tests/filter_tests/test_default.py @@ -14,47 +14,49 @@ class DefaultTests(SimpleTestCase): variable string interferes with the test result. """ - @setup({'default01': '{{ a|default:"x<" }}'}) + @setup({"default01": '{{ a|default:"x<" }}'}) def test_default01(self): - output = self.engine.render_to_string('default01', {"a": ""}) + output = self.engine.render_to_string("default01", {"a": ""}) self.assertEqual(output, "x<") - @setup({'default02': '{% autoescape off %}{{ a|default:"x<" }}{% endautoescape %}'}) + @setup({"default02": '{% autoescape off %}{{ a|default:"x<" }}{% endautoescape %}'}) def test_default02(self): - output = self.engine.render_to_string('default02', {"a": ""}) + output = self.engine.render_to_string("default02", {"a": ""}) self.assertEqual(output, "x<") - @setup({'default03': '{{ a|default:"x<" }}'}) + @setup({"default03": '{{ a|default:"x<" }}'}) def test_default03(self): - output = self.engine.render_to_string('default03', {"a": mark_safe("x>")}) + output = self.engine.render_to_string("default03", {"a": mark_safe("x>")}) self.assertEqual(output, "x>") - @setup({'default04': '{% autoescape off %}{{ a|default:"x<" }}{% endautoescape %}'}) + @setup({"default04": '{% autoescape off %}{{ a|default:"x<" }}{% endautoescape %}'}) def test_default04(self): - output = self.engine.render_to_string('default04', {"a": mark_safe("x>")}) + output = self.engine.render_to_string("default04", {"a": mark_safe("x>")}) self.assertEqual(output, "x>") class DefaultIfNoneTests(SimpleTestCase): - - @setup({'default_if_none01': '{{ a|default:"x<" }}'}) + @setup({"default_if_none01": '{{ a|default:"x<" }}'}) def test_default_if_none01(self): - output = self.engine.render_to_string('default_if_none01', {"a": None}) + output = self.engine.render_to_string("default_if_none01", {"a": None}) self.assertEqual(output, "x<") - @setup({'default_if_none02': '{% autoescape off %}{{ a|default:"x<" }}{% endautoescape %}'}) + @setup( + { + "default_if_none02": '{% autoescape off %}{{ a|default:"x<" }}{% endautoescape %}' + } + ) def test_default_if_none02(self): - output = self.engine.render_to_string('default_if_none02', {"a": None}) + output = self.engine.render_to_string("default_if_none02", {"a": None}) self.assertEqual(output, "x<") class FunctionTests(SimpleTestCase): - def test_value(self): - self.assertEqual(default('val', 'default'), 'val') + self.assertEqual(default("val", "default"), "val") def test_none(self): - self.assertEqual(default(None, 'default'), 'default') + self.assertEqual(default(None, "default"), "default") def test_empty_string(self): - self.assertEqual(default('', 'default'), 'default') + self.assertEqual(default("", "default"), "default") diff --git a/tests/template_tests/filter_tests/test_default_if_none.py b/tests/template_tests/filter_tests/test_default_if_none.py index 45bd666913..a805f4cea4 100644 --- a/tests/template_tests/filter_tests/test_default_if_none.py +++ b/tests/template_tests/filter_tests/test_default_if_none.py @@ -3,12 +3,11 @@ from django.test import SimpleTestCase class FunctionTests(SimpleTestCase): - def test_value(self): - self.assertEqual(default_if_none("val", 'default'), 'val') + self.assertEqual(default_if_none("val", "default"), "val") def test_none(self): - self.assertEqual(default_if_none(None, 'default'), 'default') + self.assertEqual(default_if_none(None, "default"), "default") def test_empty_string(self): - self.assertEqual(default_if_none('', 'default'), '') + self.assertEqual(default_if_none("", "default"), "") diff --git a/tests/template_tests/filter_tests/test_dictsort.py b/tests/template_tests/filter_tests/test_dictsort.py index 3de247fd86..9f0cd8a0f0 100644 --- a/tests/template_tests/filter_tests/test_dictsort.py +++ b/tests/template_tests/filter_tests/test_dictsort.py @@ -3,49 +3,50 @@ from django.test import SimpleTestCase class User: - password = 'abc' + password = "abc" - _private = 'private' + _private = "private" @property def test_property(self): - return 'cde' + return "cde" def test_method(self): """This is just a test method.""" class FunctionTests(SimpleTestCase): - def test_property_resolver(self): user = User() - dict_data = {'a': { - 'b1': {'c': 'result1'}, - 'b2': user, - 'b3': {'0': 'result2'}, - 'b4': [0, 1, 2], - }} - list_data = ['a', 'b', 'c'] + dict_data = { + "a": { + "b1": {"c": "result1"}, + "b2": user, + "b3": {"0": "result2"}, + "b4": [0, 1, 2], + } + } + list_data = ["a", "b", "c"] tests = [ - ('a.b1.c', dict_data, 'result1'), - ('a.b2.password', dict_data, 'abc'), - ('a.b2.test_property', dict_data, 'cde'), + ("a.b1.c", dict_data, "result1"), + ("a.b2.password", dict_data, "abc"), + ("a.b2.test_property", dict_data, "cde"), # The method should not get called. - ('a.b2.test_method', dict_data, user.test_method), - ('a.b3.0', dict_data, 'result2'), - (0, list_data, 'a'), + ("a.b2.test_method", dict_data, user.test_method), + ("a.b3.0", dict_data, "result2"), + (0, list_data, "a"), ] for arg, data, expected_value in tests: with self.subTest(arg=arg): self.assertEqual(_property_resolver(arg)(data), expected_value) # Invalid lookups. fail_tests = [ - ('a.b1.d', dict_data, AttributeError), - ('a.b2.password.0', dict_data, AttributeError), - ('a.b2._private', dict_data, AttributeError), - ('a.b4.0', dict_data, AttributeError), - ('a', list_data, AttributeError), - ('0', list_data, TypeError), + ("a.b1.d", dict_data, AttributeError), + ("a.b2.password.0", dict_data, AttributeError), + ("a.b2._private", dict_data, AttributeError), + ("a.b4.0", dict_data, AttributeError), + ("a", list_data, AttributeError), + ("0", list_data, TypeError), (4, list_data, IndexError), ] for arg, data, expected_exception in fail_tests: @@ -55,17 +56,21 @@ class FunctionTests(SimpleTestCase): def test_sort(self): sorted_dicts = dictsort( - [{'age': 23, 'name': 'Barbara-Ann'}, - {'age': 63, 'name': 'Ra Ra Rasputin'}, - {'name': 'Jonny B Goode', 'age': 18}], - 'age', + [ + {"age": 23, "name": "Barbara-Ann"}, + {"age": 63, "name": "Ra Ra Rasputin"}, + {"name": "Jonny B Goode", "age": 18}, + ], + "age", ) self.assertEqual( [sorted(dict.items()) for dict in sorted_dicts], - [[('age', 18), ('name', 'Jonny B Goode')], - [('age', 23), ('name', 'Barbara-Ann')], - [('age', 63), ('name', 'Ra Ra Rasputin')]], + [ + [("age", 18), ("name", "Jonny B Goode")], + [("age", 23), ("name", "Barbara-Ann")], + [("age", 63), ("name", "Ra Ra Rasputin")], + ], ) def test_dictsort_complex_sorting_key(self): @@ -74,44 +79,46 @@ class FunctionTests(SimpleTestCase): on keys like 'foo.bar'. """ data = [ - {'foo': {'bar': 1, 'baz': 'c'}}, - {'foo': {'bar': 2, 'baz': 'b'}}, - {'foo': {'bar': 3, 'baz': 'a'}}, + {"foo": {"bar": 1, "baz": "c"}}, + {"foo": {"bar": 2, "baz": "b"}}, + {"foo": {"bar": 3, "baz": "a"}}, ] - sorted_data = dictsort(data, 'foo.baz') + sorted_data = dictsort(data, "foo.baz") - self.assertEqual([d['foo']['bar'] for d in sorted_data], [3, 2, 1]) + self.assertEqual([d["foo"]["bar"] for d in sorted_data], [3, 2, 1]) def test_sort_list_of_tuples(self): - data = [('a', '42'), ('c', 'string'), ('b', 'foo')] - expected = [('a', '42'), ('b', 'foo'), ('c', 'string')] + data = [("a", "42"), ("c", "string"), ("b", "foo")] + expected = [("a", "42"), ("b", "foo"), ("c", "string")] self.assertEqual(dictsort(data, 0), expected) def test_sort_list_of_tuple_like_dicts(self): data = [ - {'0': 'a', '1': '42'}, - {'0': 'c', '1': 'string'}, - {'0': 'b', '1': 'foo'}, + {"0": "a", "1": "42"}, + {"0": "c", "1": "string"}, + {"0": "b", "1": "foo"}, ] expected = [ - {'0': 'a', '1': '42'}, - {'0': 'b', '1': 'foo'}, - {'0': 'c', '1': 'string'}, + {"0": "a", "1": "42"}, + {"0": "b", "1": "foo"}, + {"0": "c", "1": "string"}, ] - self.assertEqual(dictsort(data, '0'), expected) + self.assertEqual(dictsort(data, "0"), expected) def test_invalid_values(self): """ If dictsort is passed something other than a list of dictionaries, fail silently. """ - self.assertEqual(dictsort([1, 2, 3], 'age'), '') - self.assertEqual(dictsort('Hello!', 'age'), '') - self.assertEqual(dictsort({'a': 1}, 'age'), '') - self.assertEqual(dictsort(1, 'age'), '') + self.assertEqual(dictsort([1, 2, 3], "age"), "") + self.assertEqual(dictsort("Hello!", "age"), "") + self.assertEqual(dictsort({"a": 1}, "age"), "") + self.assertEqual(dictsort(1, "age"), "") def test_invalid_args(self): """Fail silently if invalid lookups are passed.""" - self.assertEqual(dictsort([{}], '._private'), '') - self.assertEqual(dictsort([{'_private': 'test'}], '_private'), '') - self.assertEqual(dictsort([{'nested': {'_private': 'test'}}], 'nested._private'), '') + self.assertEqual(dictsort([{}], "._private"), "") + self.assertEqual(dictsort([{"_private": "test"}], "_private"), "") + self.assertEqual( + dictsort([{"nested": {"_private": "test"}}], "nested._private"), "" + ) diff --git a/tests/template_tests/filter_tests/test_dictsortreversed.py b/tests/template_tests/filter_tests/test_dictsortreversed.py index e2e24e3128..c7cf40d1b4 100644 --- a/tests/template_tests/filter_tests/test_dictsortreversed.py +++ b/tests/template_tests/filter_tests/test_dictsortreversed.py @@ -3,52 +3,57 @@ from django.test import SimpleTestCase class FunctionTests(SimpleTestCase): - def test_sort(self): sorted_dicts = dictsortreversed( - [{'age': 23, 'name': 'Barbara-Ann'}, - {'age': 63, 'name': 'Ra Ra Rasputin'}, - {'name': 'Jonny B Goode', 'age': 18}], - 'age', + [ + {"age": 23, "name": "Barbara-Ann"}, + {"age": 63, "name": "Ra Ra Rasputin"}, + {"name": "Jonny B Goode", "age": 18}, + ], + "age", ) self.assertEqual( [sorted(dict.items()) for dict in sorted_dicts], - [[('age', 63), ('name', 'Ra Ra Rasputin')], - [('age', 23), ('name', 'Barbara-Ann')], - [('age', 18), ('name', 'Jonny B Goode')]], + [ + [("age", 63), ("name", "Ra Ra Rasputin")], + [("age", 23), ("name", "Barbara-Ann")], + [("age", 18), ("name", "Jonny B Goode")], + ], ) def test_sort_list_of_tuples(self): - data = [('a', '42'), ('c', 'string'), ('b', 'foo')] - expected = [('c', 'string'), ('b', 'foo'), ('a', '42')] + data = [("a", "42"), ("c", "string"), ("b", "foo")] + expected = [("c", "string"), ("b", "foo"), ("a", "42")] self.assertEqual(dictsortreversed(data, 0), expected) def test_sort_list_of_tuple_like_dicts(self): data = [ - {'0': 'a', '1': '42'}, - {'0': 'c', '1': 'string'}, - {'0': 'b', '1': 'foo'}, + {"0": "a", "1": "42"}, + {"0": "c", "1": "string"}, + {"0": "b", "1": "foo"}, ] expected = [ - {'0': 'c', '1': 'string'}, - {'0': 'b', '1': 'foo'}, - {'0': 'a', '1': '42'}, + {"0": "c", "1": "string"}, + {"0": "b", "1": "foo"}, + {"0": "a", "1": "42"}, ] - self.assertEqual(dictsortreversed(data, '0'), expected) + self.assertEqual(dictsortreversed(data, "0"), expected) def test_invalid_values(self): """ If dictsortreversed is passed something other than a list of dictionaries, fail silently. """ - self.assertEqual(dictsortreversed([1, 2, 3], 'age'), '') - self.assertEqual(dictsortreversed('Hello!', 'age'), '') - self.assertEqual(dictsortreversed({'a': 1}, 'age'), '') - self.assertEqual(dictsortreversed(1, 'age'), '') + self.assertEqual(dictsortreversed([1, 2, 3], "age"), "") + self.assertEqual(dictsortreversed("Hello!", "age"), "") + self.assertEqual(dictsortreversed({"a": 1}, "age"), "") + self.assertEqual(dictsortreversed(1, "age"), "") def test_invalid_args(self): """Fail silently if invalid lookups are passed.""" - self.assertEqual(dictsortreversed([{}], '._private'), '') - self.assertEqual(dictsortreversed([{'_private': 'test'}], '_private'), '') - self.assertEqual(dictsortreversed([{'nested': {'_private': 'test'}}], 'nested._private'), '') + self.assertEqual(dictsortreversed([{}], "._private"), "") + self.assertEqual(dictsortreversed([{"_private": "test"}], "_private"), "") + self.assertEqual( + dictsortreversed([{"nested": {"_private": "test"}}], "nested._private"), "" + ) diff --git a/tests/template_tests/filter_tests/test_divisibleby.py b/tests/template_tests/filter_tests/test_divisibleby.py index f0dda1f0b6..27807de213 100644 --- a/tests/template_tests/filter_tests/test_divisibleby.py +++ b/tests/template_tests/filter_tests/test_divisibleby.py @@ -3,7 +3,6 @@ from django.test import SimpleTestCase class FunctionTests(SimpleTestCase): - def test_true(self): self.assertIs(divisibleby(4, 2), True) diff --git a/tests/template_tests/filter_tests/test_escape.py b/tests/template_tests/filter_tests/test_escape.py index 22d5ca7d55..16471ad53f 100644 --- a/tests/template_tests/filter_tests/test_escape.py +++ b/tests/template_tests/filter_tests/test_escape.py @@ -12,34 +12,41 @@ class EscapeTests(SimpleTestCase): but it has no effect on strings already marked as safe. """ - @setup({'escape01': '{{ a|escape }} {{ b|escape }}'}) + @setup({"escape01": "{{ a|escape }} {{ b|escape }}"}) def test_escape01(self): - output = self.engine.render_to_string('escape01', {"a": "x&y", "b": mark_safe("x&y")}) + output = self.engine.render_to_string( + "escape01", {"a": "x&y", "b": mark_safe("x&y")} + ) self.assertEqual(output, "x&y x&y") - @setup({'escape02': '{% autoescape off %}{{ a|escape }} {{ b|escape }}{% endautoescape %}'}) + @setup( + { + "escape02": "{% autoescape off %}{{ a|escape }} {{ b|escape }}{% endautoescape %}" + } + ) def test_escape02(self): - output = self.engine.render_to_string('escape02', {"a": "x&y", "b": mark_safe("x&y")}) + output = self.engine.render_to_string( + "escape02", {"a": "x&y", "b": mark_safe("x&y")} + ) self.assertEqual(output, "x&y x&y") - @setup({'escape03': '{% autoescape off %}{{ a|escape|escape }}{% endautoescape %}'}) + @setup({"escape03": "{% autoescape off %}{{ a|escape|escape }}{% endautoescape %}"}) def test_escape03(self): - output = self.engine.render_to_string('escape03', {"a": "x&y"}) + output = self.engine.render_to_string("escape03", {"a": "x&y"}) self.assertEqual(output, "x&y") - @setup({'escape04': '{{ a|escape|escape }}'}) + @setup({"escape04": "{{ a|escape|escape }}"}) def test_escape04(self): - output = self.engine.render_to_string('escape04', {"a": "x&y"}) + output = self.engine.render_to_string("escape04", {"a": "x&y"}) self.assertEqual(output, "x&y") def test_escape_lazy_string(self): - add_html = lazy(lambda string: string + 'special characters > here', str) - escaped = escape(add_html(' here", str) + escaped = escape(add_html("escaping'}) - self.assertEqual(output, 'testing\\u000D\\u000Ajavascript ' - '\\u0027string\\u0022 \\u003Cb\\u003E' - 'escaping\\u003C/b\\u003E') + output = self.engine.render_to_string( + "escapejs01", {"a": "testing\r\njavascript 'string\" escaping"} + ) + self.assertEqual( + output, + "testing\\u000D\\u000Ajavascript " + "\\u0027string\\u0022 \\u003Cb\\u003E" + "escaping\\u003C/b\\u003E", + ) - @setup({'escapejs02': '{% autoescape off %}{{ a|escapejs }}{% endautoescape %}'}) + @setup({"escapejs02": "{% autoescape off %}{{ a|escapejs }}{% endautoescape %}"}) def test_escapejs02(self): - output = self.engine.render_to_string('escapejs02', {'a': 'testing\r\njavascript \'string" escaping'}) - self.assertEqual(output, 'testing\\u000D\\u000Ajavascript ' - '\\u0027string\\u0022 \\u003Cb\\u003E' - 'escaping\\u003C/b\\u003E') + output = self.engine.render_to_string( + "escapejs02", {"a": "testing\r\njavascript 'string\" escaping"} + ) + self.assertEqual( + output, + "testing\\u000D\\u000Ajavascript " + "\\u0027string\\u0022 \\u003Cb\\u003E" + "escaping\\u003C/b\\u003E", + ) class FunctionTests(SimpleTestCase): - def test_quotes(self): self.assertEqual( - escapejs_filter('"double quotes" and \'single quotes\''), - '\\u0022double quotes\\u0022 and \\u0027single quotes\\u0027', + escapejs_filter("\"double quotes\" and 'single quotes'"), + "\\u0022double quotes\\u0022 and \\u0027single quotes\\u0027", ) def test_backslashes(self): - self.assertEqual(escapejs_filter(r'\ : backslashes, too'), '\\u005C : backslashes, too') + self.assertEqual( + escapejs_filter(r"\ : backslashes, too"), "\\u005C : backslashes, too" + ) def test_whitespace(self): self.assertEqual( - escapejs_filter('and lots of whitespace: \r\n\t\v\f\b'), - 'and lots of whitespace: \\u000D\\u000A\\u0009\\u000B\\u000C\\u0008', + escapejs_filter("and lots of whitespace: \r\n\t\v\f\b"), + "and lots of whitespace: \\u000D\\u000A\\u0009\\u000B\\u000C\\u0008", ) def test_script(self): self.assertEqual( - escapejs_filter(r''), - '\\u003Cscript\\u003Eand this\\u003C/script\\u003E', + escapejs_filter(r""), + "\\u003Cscript\\u003Eand this\\u003C/script\\u003E", ) def test_paragraph_separator(self): self.assertEqual( - escapejs_filter('paragraph separator:\u2029and line separator:\u2028'), - 'paragraph separator:\\u2029and line separator:\\u2028', + escapejs_filter("paragraph separator:\u2029and line separator:\u2028"), + "paragraph separator:\\u2029and line separator:\\u2028", ) def test_lazy_string(self): - append_script = lazy(lambda string: r'' + string, str) + append_script = lazy(lambda string: r"" + string, str) self.assertEqual( - escapejs_filter(append_script('whitespace: \r\n\t\v\f\b')), - '\\u003Cscript\\u003Ethis\\u003C/script\\u003E' - 'whitespace: \\u000D\\u000A\\u0009\\u000B\\u000C\\u0008' + escapejs_filter(append_script("whitespace: \r\n\t\v\f\b")), + "\\u003Cscript\\u003Ethis\\u003C/script\\u003E" + "whitespace: \\u000D\\u000A\\u0009\\u000B\\u000C\\u0008", ) diff --git a/tests/template_tests/filter_tests/test_filesizeformat.py b/tests/template_tests/filter_tests/test_filesizeformat.py index 3b3e02eadb..fee742f9d5 100644 --- a/tests/template_tests/filter_tests/test_filesizeformat.py +++ b/tests/template_tests/filter_tests/test_filesizeformat.py @@ -4,25 +4,24 @@ from django.utils import translation class FunctionTests(SimpleTestCase): - def test_formats(self): tests = [ - (0, '0\xa0bytes'), - (1, '1\xa0byte'), - (1023, '1023\xa0bytes'), - (1024, '1.0\xa0KB'), - (10 * 1024, '10.0\xa0KB'), - (1024 * 1024 - 1, '1024.0\xa0KB'), - (1024 * 1024, '1.0\xa0MB'), - (1024 * 1024 * 50, '50.0\xa0MB'), - (1024 * 1024 * 1024 - 1, '1024.0\xa0MB'), - (1024 * 1024 * 1024, '1.0\xa0GB'), - (1024 * 1024 * 1024 * 1024, '1.0\xa0TB'), - (1024 * 1024 * 1024 * 1024 * 1024, '1.0\xa0PB'), - (1024 * 1024 * 1024 * 1024 * 1024 * 2000, '2000.0\xa0PB'), - (complex(1, -1), '0\xa0bytes'), - ('', '0\xa0bytes'), - ('\N{GREEK SMALL LETTER ALPHA}', '0\xa0bytes'), + (0, "0\xa0bytes"), + (1, "1\xa0byte"), + (1023, "1023\xa0bytes"), + (1024, "1.0\xa0KB"), + (10 * 1024, "10.0\xa0KB"), + (1024 * 1024 - 1, "1024.0\xa0KB"), + (1024 * 1024, "1.0\xa0MB"), + (1024 * 1024 * 50, "50.0\xa0MB"), + (1024 * 1024 * 1024 - 1, "1024.0\xa0MB"), + (1024 * 1024 * 1024, "1.0\xa0GB"), + (1024 * 1024 * 1024 * 1024, "1.0\xa0TB"), + (1024 * 1024 * 1024 * 1024 * 1024, "1.0\xa0PB"), + (1024 * 1024 * 1024 * 1024 * 1024 * 2000, "2000.0\xa0PB"), + (complex(1, -1), "0\xa0bytes"), + ("", "0\xa0bytes"), + ("\N{GREEK SMALL LETTER ALPHA}", "0\xa0bytes"), ] for value, expected in tests: with self.subTest(value=value): @@ -30,33 +29,33 @@ class FunctionTests(SimpleTestCase): def test_localized_formats(self): tests = [ - (0, '0\xa0Bytes'), - (1, '1\xa0Byte'), - (1023, '1023\xa0Bytes'), - (1024, '1,0\xa0KB'), - (10 * 1024, '10,0\xa0KB'), - (1024 * 1024 - 1, '1024,0\xa0KB'), - (1024 * 1024, '1,0\xa0MB'), - (1024 * 1024 * 50, '50,0\xa0MB'), - (1024 * 1024 * 1024 - 1, '1024,0\xa0MB'), - (1024 * 1024 * 1024, '1,0\xa0GB'), - (1024 * 1024 * 1024 * 1024, '1,0\xa0TB'), - (1024 * 1024 * 1024 * 1024 * 1024, '1,0\xa0PB'), - (1024 * 1024 * 1024 * 1024 * 1024 * 2000, '2000,0\xa0PB'), - (complex(1, -1), '0\xa0Bytes'), - ('', '0\xa0Bytes'), - ('\N{GREEK SMALL LETTER ALPHA}', '0\xa0Bytes'), + (0, "0\xa0Bytes"), + (1, "1\xa0Byte"), + (1023, "1023\xa0Bytes"), + (1024, "1,0\xa0KB"), + (10 * 1024, "10,0\xa0KB"), + (1024 * 1024 - 1, "1024,0\xa0KB"), + (1024 * 1024, "1,0\xa0MB"), + (1024 * 1024 * 50, "50,0\xa0MB"), + (1024 * 1024 * 1024 - 1, "1024,0\xa0MB"), + (1024 * 1024 * 1024, "1,0\xa0GB"), + (1024 * 1024 * 1024 * 1024, "1,0\xa0TB"), + (1024 * 1024 * 1024 * 1024 * 1024, "1,0\xa0PB"), + (1024 * 1024 * 1024 * 1024 * 1024 * 2000, "2000,0\xa0PB"), + (complex(1, -1), "0\xa0Bytes"), + ("", "0\xa0Bytes"), + ("\N{GREEK SMALL LETTER ALPHA}", "0\xa0Bytes"), ] - with translation.override('de'): + with translation.override("de"): for value, expected in tests: with self.subTest(value=value): self.assertEqual(filesizeformat(value), expected) def test_negative_numbers(self): tests = [ - (-1, '-1\xa0byte'), - (-100, '-100\xa0bytes'), - (-1024 * 1024 * 50, '-50.0\xa0MB'), + (-1, "-1\xa0byte"), + (-100, "-100\xa0bytes"), + (-1024 * 1024 * 50, "-50.0\xa0MB"), ] for value, expected in tests: with self.subTest(value=value): diff --git a/tests/template_tests/filter_tests/test_first.py b/tests/template_tests/filter_tests/test_first.py index efba48f870..7a1849cd88 100644 --- a/tests/template_tests/filter_tests/test_first.py +++ b/tests/template_tests/filter_tests/test_first.py @@ -6,25 +6,31 @@ from ..utils import setup class FirstTests(SimpleTestCase): - - @setup({'first01': '{{ a|first }} {{ b|first }}'}) + @setup({"first01": "{{ a|first }} {{ b|first }}"}) def test_first01(self): - output = self.engine.render_to_string('first01', {"a": ["a&b", "x"], "b": [mark_safe("a&b"), "x"]}) + output = self.engine.render_to_string( + "first01", {"a": ["a&b", "x"], "b": [mark_safe("a&b"), "x"]} + ) self.assertEqual(output, "a&b a&b") - @setup({'first02': '{% autoescape off %}{{ a|first }} {{ b|first }}{% endautoescape %}'}) + @setup( + { + "first02": "{% autoescape off %}{{ a|first }} {{ b|first }}{% endautoescape %}" + } + ) def test_first02(self): - output = self.engine.render_to_string('first02', {"a": ["a&b", "x"], "b": [mark_safe("a&b"), "x"]}) + output = self.engine.render_to_string( + "first02", {"a": ["a&b", "x"], "b": [mark_safe("a&b"), "x"]} + ) self.assertEqual(output, "a&b a&b") class FunctionTests(SimpleTestCase): - def test_list(self): self.assertEqual(first([0, 1, 2]), 0) def test_empty_string(self): - self.assertEqual(first(''), '') + self.assertEqual(first(""), "") def test_string(self): - self.assertEqual(first('test'), 't') + self.assertEqual(first("test"), "t") diff --git a/tests/template_tests/filter_tests/test_floatformat.py b/tests/template_tests/filter_tests/test_floatformat.py index 1035fb96da..d7eb5f2076 100644 --- a/tests/template_tests/filter_tests/test_floatformat.py +++ b/tests/template_tests/filter_tests/test_floatformat.py @@ -9,93 +9,107 @@ from ..utils import setup class FloatformatTests(SimpleTestCase): - - @setup({'floatformat01': '{% autoescape off %}{{ a|floatformat }} {{ b|floatformat }}{% endautoescape %}'}) + @setup( + { + "floatformat01": "{% autoescape off %}{{ a|floatformat }} {{ b|floatformat }}{% endautoescape %}" + } + ) def test_floatformat01(self): - output = self.engine.render_to_string('floatformat01', {"a": "1.42", "b": mark_safe("1.42")}) + output = self.engine.render_to_string( + "floatformat01", {"a": "1.42", "b": mark_safe("1.42")} + ) self.assertEqual(output, "1.4 1.4") - @setup({'floatformat02': '{{ a|floatformat }} {{ b|floatformat }}'}) + @setup({"floatformat02": "{{ a|floatformat }} {{ b|floatformat }}"}) def test_floatformat02(self): - output = self.engine.render_to_string('floatformat02', {"a": "1.42", "b": mark_safe("1.42")}) + output = self.engine.render_to_string( + "floatformat02", {"a": "1.42", "b": mark_safe("1.42")} + ) self.assertEqual(output, "1.4 1.4") class FunctionTests(SimpleTestCase): - def test_inputs(self): - self.assertEqual(floatformat(7.7), '7.7') - self.assertEqual(floatformat(7.0), '7') - self.assertEqual(floatformat(0.7), '0.7') - self.assertEqual(floatformat(-0.7), '-0.7') - self.assertEqual(floatformat(0.07), '0.1') - self.assertEqual(floatformat(-0.07), '-0.1') - self.assertEqual(floatformat(0.007), '0.0') - self.assertEqual(floatformat(0.0), '0') - self.assertEqual(floatformat(7.7, 0), '8') - self.assertEqual(floatformat(7.7, 3), '7.700') - self.assertEqual(floatformat(6.000000, 3), '6.000') - self.assertEqual(floatformat(6.200000, 3), '6.200') - self.assertEqual(floatformat(6.200000, -3), '6.200') - self.assertEqual(floatformat(13.1031, -3), '13.103') - self.assertEqual(floatformat(11.1197, -2), '11.12') - self.assertEqual(floatformat(11.0000, -2), '11') - self.assertEqual(floatformat(11.000001, -2), '11.00') - self.assertEqual(floatformat(8.2798, 3), '8.280') - self.assertEqual(floatformat(5555.555, 2), '5555.56') - self.assertEqual(floatformat(001.3000, 2), '1.30') - self.assertEqual(floatformat(0.12345, 2), '0.12') - self.assertEqual(floatformat(Decimal('555.555'), 2), '555.56') - self.assertEqual(floatformat(Decimal('09.000')), '9') - self.assertEqual(floatformat('foo'), '') - self.assertEqual(floatformat(13.1031, 'bar'), '13.1031') - self.assertEqual(floatformat(18.125, 2), '18.13') - self.assertEqual(floatformat('foo', 'bar'), '') - self.assertEqual(floatformat('¿Cómo esta usted?'), '') - self.assertEqual(floatformat(None), '') - self.assertEqual(floatformat(-1.323297138040798e+35, 2), '-132329713804079800000000000000000000.00') - self.assertEqual(floatformat(-1.323297138040798e+35, -2), '-132329713804079800000000000000000000') - self.assertEqual(floatformat(1.5e-15, 20), '0.00000000000000150000') - self.assertEqual(floatformat(1.5e-15, -20), '0.00000000000000150000') - self.assertEqual(floatformat(1.00000000000000015, 16), '1.0000000000000002') + self.assertEqual(floatformat(7.7), "7.7") + self.assertEqual(floatformat(7.0), "7") + self.assertEqual(floatformat(0.7), "0.7") + self.assertEqual(floatformat(-0.7), "-0.7") + self.assertEqual(floatformat(0.07), "0.1") + self.assertEqual(floatformat(-0.07), "-0.1") + self.assertEqual(floatformat(0.007), "0.0") + self.assertEqual(floatformat(0.0), "0") + self.assertEqual(floatformat(7.7, 0), "8") + self.assertEqual(floatformat(7.7, 3), "7.700") + self.assertEqual(floatformat(6.000000, 3), "6.000") + self.assertEqual(floatformat(6.200000, 3), "6.200") + self.assertEqual(floatformat(6.200000, -3), "6.200") + self.assertEqual(floatformat(13.1031, -3), "13.103") + self.assertEqual(floatformat(11.1197, -2), "11.12") + self.assertEqual(floatformat(11.0000, -2), "11") + self.assertEqual(floatformat(11.000001, -2), "11.00") + self.assertEqual(floatformat(8.2798, 3), "8.280") + self.assertEqual(floatformat(5555.555, 2), "5555.56") + self.assertEqual(floatformat(001.3000, 2), "1.30") + self.assertEqual(floatformat(0.12345, 2), "0.12") + self.assertEqual(floatformat(Decimal("555.555"), 2), "555.56") + self.assertEqual(floatformat(Decimal("09.000")), "9") + self.assertEqual(floatformat("foo"), "") + self.assertEqual(floatformat(13.1031, "bar"), "13.1031") + self.assertEqual(floatformat(18.125, 2), "18.13") + self.assertEqual(floatformat("foo", "bar"), "") + self.assertEqual(floatformat("¿Cómo esta usted?"), "") + self.assertEqual(floatformat(None), "") + self.assertEqual( + floatformat(-1.323297138040798e35, 2), + "-132329713804079800000000000000000000.00", + ) + self.assertEqual( + floatformat(-1.323297138040798e35, -2), + "-132329713804079800000000000000000000", + ) + self.assertEqual(floatformat(1.5e-15, 20), "0.00000000000000150000") + self.assertEqual(floatformat(1.5e-15, -20), "0.00000000000000150000") + self.assertEqual(floatformat(1.00000000000000015, 16), "1.0000000000000002") def test_force_grouping(self): - with translation.override('en'): - self.assertEqual(floatformat(10000, 'g'), '10,000') - self.assertEqual(floatformat(66666.666, '1g'), '66,666.7') + with translation.override("en"): + self.assertEqual(floatformat(10000, "g"), "10,000") + self.assertEqual(floatformat(66666.666, "1g"), "66,666.7") # Invalid suffix. - self.assertEqual(floatformat(10000, 'g2'), '10000') - with translation.override('de', deactivate=True): - self.assertEqual(floatformat(10000, 'g'), '10.000') - self.assertEqual(floatformat(66666.666, '1g'), '66.666,7') + self.assertEqual(floatformat(10000, "g2"), "10000") + with translation.override("de", deactivate=True): + self.assertEqual(floatformat(10000, "g"), "10.000") + self.assertEqual(floatformat(66666.666, "1g"), "66.666,7") # Invalid suffix. - self.assertEqual(floatformat(10000, 'g2'), '10000') + self.assertEqual(floatformat(10000, "g2"), "10000") def test_unlocalize(self): - with translation.override('de', deactivate=True): - self.assertEqual(floatformat(66666.666, '2'), '66666,67') - self.assertEqual(floatformat(66666.666, '2u'), '66666.67') + with translation.override("de", deactivate=True): + self.assertEqual(floatformat(66666.666, "2"), "66666,67") + self.assertEqual(floatformat(66666.666, "2u"), "66666.67") with self.settings( USE_THOUSAND_SEPARATOR=True, NUMBER_GROUPING=3, - THOUSAND_SEPARATOR='!', + THOUSAND_SEPARATOR="!", ): - self.assertEqual(floatformat(66666.666, '2gu'), '66!666.67') - self.assertEqual(floatformat(66666.666, '2ug'), '66!666.67') + self.assertEqual(floatformat(66666.666, "2gu"), "66!666.67") + self.assertEqual(floatformat(66666.666, "2ug"), "66!666.67") # Invalid suffix. - self.assertEqual(floatformat(66666.666, 'u2'), '66666.666') + self.assertEqual(floatformat(66666.666, "u2"), "66666.666") def test_zero_values(self): - self.assertEqual(floatformat(0, 6), '0.000000') - self.assertEqual(floatformat(0, 7), '0.0000000') - self.assertEqual(floatformat(0, 10), '0.0000000000') - self.assertEqual(floatformat(0.000000000000000000015, 20), '0.00000000000000000002') + self.assertEqual(floatformat(0, 6), "0.000000") + self.assertEqual(floatformat(0, 7), "0.0000000") + self.assertEqual(floatformat(0, 10), "0.0000000000") + self.assertEqual( + floatformat(0.000000000000000000015, 20), "0.00000000000000000002" + ) def test_negative_zero_values(self): tests = [ - (-0.01, -1, '0.0'), - (-0.001, 2, '0.00'), - (-0.499, 0, '0'), + (-0.01, -1, "0.0"), + (-0.001, 2, "0.00"), + (-0.499, 0, "0"), ] for num, decimal_places, expected in tests: with self.subTest(num=num, decimal_places=decimal_places): @@ -104,9 +118,9 @@ class FunctionTests(SimpleTestCase): def test_infinity(self): pos_inf = float(1e30000) neg_inf = float(-1e30000) - self.assertEqual(floatformat(pos_inf), 'inf') - self.assertEqual(floatformat(neg_inf), '-inf') - self.assertEqual(floatformat(pos_inf / pos_inf), 'nan') + self.assertEqual(floatformat(pos_inf), "inf") + self.assertEqual(floatformat(neg_inf), "-inf") + self.assertEqual(floatformat(pos_inf / pos_inf), "nan") def test_float_dunder_method(self): class FloatWrapper: @@ -116,7 +130,7 @@ class FunctionTests(SimpleTestCase): def __float__(self): return self.value - self.assertEqual(floatformat(FloatWrapper(11.000001), -2), '11.00') + self.assertEqual(floatformat(FloatWrapper(11.000001), -2), "11.00") def test_low_decimal_precision(self): """ @@ -124,9 +138,9 @@ class FunctionTests(SimpleTestCase): """ with localcontext() as ctx: ctx.prec = 2 - self.assertEqual(floatformat(1.2345, 2), '1.23') - self.assertEqual(floatformat(15.2042, -3), '15.204') - self.assertEqual(floatformat(1.2345, '2'), '1.23') - self.assertEqual(floatformat(15.2042, '-3'), '15.204') - self.assertEqual(floatformat(Decimal('1.2345'), 2), '1.23') - self.assertEqual(floatformat(Decimal('15.2042'), -3), '15.204') + self.assertEqual(floatformat(1.2345, 2), "1.23") + self.assertEqual(floatformat(15.2042, -3), "15.204") + self.assertEqual(floatformat(1.2345, "2"), "1.23") + self.assertEqual(floatformat(15.2042, "-3"), "15.204") + self.assertEqual(floatformat(Decimal("1.2345"), 2), "1.23") + self.assertEqual(floatformat(Decimal("15.2042"), -3), "15.204") diff --git a/tests/template_tests/filter_tests/test_force_escape.py b/tests/template_tests/filter_tests/test_force_escape.py index 776dc8042d..7a34caee2b 100644 --- a/tests/template_tests/filter_tests/test_force_escape.py +++ b/tests/template_tests/filter_tests/test_force_escape.py @@ -11,58 +11,73 @@ class ForceEscapeTests(SimpleTestCase): double-escaping, for example. """ - @setup({'force-escape01': '{% autoescape off %}{{ a|force_escape }}{% endautoescape %}'}) + @setup( + { + "force-escape01": "{% autoescape off %}{{ a|force_escape }}{% endautoescape %}" + } + ) def test_force_escape01(self): - output = self.engine.render_to_string('force-escape01', {"a": "x&y"}) + output = self.engine.render_to_string("force-escape01", {"a": "x&y"}) self.assertEqual(output, "x&y") - @setup({'force-escape02': '{{ a|force_escape }}'}) + @setup({"force-escape02": "{{ a|force_escape }}"}) def test_force_escape02(self): - output = self.engine.render_to_string('force-escape02', {"a": "x&y"}) + output = self.engine.render_to_string("force-escape02", {"a": "x&y"}) self.assertEqual(output, "x&y") - @setup({'force-escape03': '{% autoescape off %}{{ a|force_escape|force_escape }}{% endautoescape %}'}) + @setup( + { + "force-escape03": "{% autoescape off %}{{ a|force_escape|force_escape }}{% endautoescape %}" + } + ) def test_force_escape03(self): - output = self.engine.render_to_string('force-escape03', {"a": "x&y"}) + output = self.engine.render_to_string("force-escape03", {"a": "x&y"}) self.assertEqual(output, "x&amp;y") - @setup({'force-escape04': '{{ a|force_escape|force_escape }}'}) + @setup({"force-escape04": "{{ a|force_escape|force_escape }}"}) def test_force_escape04(self): - output = self.engine.render_to_string('force-escape04', {"a": "x&y"}) + output = self.engine.render_to_string("force-escape04", {"a": "x&y"}) self.assertEqual(output, "x&amp;y") # Because the result of force_escape is "safe", an additional # escape filter has no effect. - @setup({'force-escape05': '{% autoescape off %}{{ a|force_escape|escape }}{% endautoescape %}'}) + @setup( + { + "force-escape05": "{% autoescape off %}{{ a|force_escape|escape }}{% endautoescape %}" + } + ) def test_force_escape05(self): - output = self.engine.render_to_string('force-escape05', {"a": "x&y"}) + output = self.engine.render_to_string("force-escape05", {"a": "x&y"}) self.assertEqual(output, "x&y") - @setup({'force-escape06': '{{ a|force_escape|escape }}'}) + @setup({"force-escape06": "{{ a|force_escape|escape }}"}) def test_force_escape06(self): - output = self.engine.render_to_string('force-escape06', {"a": "x&y"}) + output = self.engine.render_to_string("force-escape06", {"a": "x&y"}) self.assertEqual(output, "x&y") - @setup({'force-escape07': '{% autoescape off %}{{ a|escape|force_escape }}{% endautoescape %}'}) + @setup( + { + "force-escape07": "{% autoescape off %}{{ a|escape|force_escape }}{% endautoescape %}" + } + ) def test_force_escape07(self): - output = self.engine.render_to_string('force-escape07', {"a": "x&y"}) + output = self.engine.render_to_string("force-escape07", {"a": "x&y"}) self.assertEqual(output, "x&amp;y") - @setup({'force-escape08': '{{ a|escape|force_escape }}'}) + @setup({"force-escape08": "{{ a|escape|force_escape }}"}) def test_force_escape08(self): - output = self.engine.render_to_string('force-escape08', {"a": "x&y"}) + output = self.engine.render_to_string("force-escape08", {"a": "x&y"}) self.assertEqual(output, "x&amp;y") class FunctionTests(SimpleTestCase): - def test_escape(self): - escaped = force_escape(' here') - self.assertEqual(escaped, '<some html & special characters > here') + escaped = force_escape(" here") + self.assertEqual(escaped, "<some html & special characters > here") self.assertIsInstance(escaped, SafeData) def test_unicode(self): self.assertEqual( - force_escape(' here ĐÅ€£'), - '<some html & special characters > here \u0110\xc5\u20ac\xa3', + force_escape(" here ĐÅ€£"), + "<some html & special characters > here \u0110\xc5\u20ac\xa3", ) diff --git a/tests/template_tests/filter_tests/test_get_digit.py b/tests/template_tests/filter_tests/test_get_digit.py index 1382408715..4b10ca93ed 100644 --- a/tests/template_tests/filter_tests/test_get_digit.py +++ b/tests/template_tests/filter_tests/test_get_digit.py @@ -3,7 +3,6 @@ from django.test import SimpleTestCase class FunctionTests(SimpleTestCase): - def test_values(self): self.assertEqual(get_digit(123, 1), 3) self.assertEqual(get_digit(123, 2), 2) @@ -12,4 +11,4 @@ class FunctionTests(SimpleTestCase): self.assertEqual(get_digit(123, 0), 123) def test_string(self): - self.assertEqual(get_digit('xyz', 0), 'xyz') + self.assertEqual(get_digit("xyz", 0), "xyz") diff --git a/tests/template_tests/filter_tests/test_iriencode.py b/tests/template_tests/filter_tests/test_iriencode.py index 7d83b67f9d..31fce93949 100644 --- a/tests/template_tests/filter_tests/test_iriencode.py +++ b/tests/template_tests/filter_tests/test_iriencode.py @@ -10,31 +10,40 @@ class IriencodeTests(SimpleTestCase): Ensure iriencode keeps safe strings. """ - @setup({'iriencode01': '{{ url|iriencode }}'}) + @setup({"iriencode01": "{{ url|iriencode }}"}) def test_iriencode01(self): - output = self.engine.render_to_string('iriencode01', {'url': '?test=1&me=2'}) - self.assertEqual(output, '?test=1&me=2') + output = self.engine.render_to_string("iriencode01", {"url": "?test=1&me=2"}) + self.assertEqual(output, "?test=1&me=2") - @setup({'iriencode02': '{% autoescape off %}{{ url|iriencode }}{% endautoescape %}'}) + @setup( + {"iriencode02": "{% autoescape off %}{{ url|iriencode }}{% endautoescape %}"} + ) def test_iriencode02(self): - output = self.engine.render_to_string('iriencode02', {'url': '?test=1&me=2'}) - self.assertEqual(output, '?test=1&me=2') + output = self.engine.render_to_string("iriencode02", {"url": "?test=1&me=2"}) + self.assertEqual(output, "?test=1&me=2") - @setup({'iriencode03': '{{ url|iriencode }}'}) + @setup({"iriencode03": "{{ url|iriencode }}"}) def test_iriencode03(self): - output = self.engine.render_to_string('iriencode03', {'url': mark_safe('?test=1&me=2')}) - self.assertEqual(output, '?test=1&me=2') - - @setup({'iriencode04': '{% autoescape off %}{{ url|iriencode }}{% endautoescape %}'}) + output = self.engine.render_to_string( + "iriencode03", {"url": mark_safe("?test=1&me=2")} + ) + self.assertEqual(output, "?test=1&me=2") + + @setup( + {"iriencode04": "{% autoescape off %}{{ url|iriencode }}{% endautoescape %}"} + ) def test_iriencode04(self): - output = self.engine.render_to_string('iriencode04', {'url': mark_safe('?test=1&me=2')}) - self.assertEqual(output, '?test=1&me=2') + output = self.engine.render_to_string( + "iriencode04", {"url": mark_safe("?test=1&me=2")} + ) + self.assertEqual(output, "?test=1&me=2") class FunctionTests(SimpleTestCase): - def test_unicode(self): - self.assertEqual(iriencode('S\xf8r-Tr\xf8ndelag'), 'S%C3%B8r-Tr%C3%B8ndelag') + self.assertEqual(iriencode("S\xf8r-Tr\xf8ndelag"), "S%C3%B8r-Tr%C3%B8ndelag") def test_urlencoded(self): - self.assertEqual(iriencode(urlencode('fran\xe7ois & jill')), 'fran%C3%A7ois%20%26%20jill') + self.assertEqual( + iriencode(urlencode("fran\xe7ois & jill")), "fran%C3%A7ois%20%26%20jill" + ) diff --git a/tests/template_tests/filter_tests/test_join.py b/tests/template_tests/filter_tests/test_join.py index 43ac0da7c2..08f68537ee 100644 --- a/tests/template_tests/filter_tests/test_join.py +++ b/tests/template_tests/filter_tests/test_join.py @@ -6,70 +6,76 @@ from ..utils import setup class JoinTests(SimpleTestCase): - - @setup({'join01': '{{ a|join:", " }}'}) + @setup({"join01": '{{ a|join:", " }}'}) def test_join01(self): - output = self.engine.render_to_string('join01', {'a': ['alpha', 'beta & me']}) - self.assertEqual(output, 'alpha, beta & me') + output = self.engine.render_to_string("join01", {"a": ["alpha", "beta & me"]}) + self.assertEqual(output, "alpha, beta & me") - @setup({'join02': '{% autoescape off %}{{ a|join:", " }}{% endautoescape %}'}) + @setup({"join02": '{% autoescape off %}{{ a|join:", " }}{% endautoescape %}'}) def test_join02(self): - output = self.engine.render_to_string('join02', {'a': ['alpha', 'beta & me']}) - self.assertEqual(output, 'alpha, beta & me') + output = self.engine.render_to_string("join02", {"a": ["alpha", "beta & me"]}) + self.assertEqual(output, "alpha, beta & me") - @setup({'join03': '{{ a|join:" & " }}'}) + @setup({"join03": '{{ a|join:" & " }}'}) def test_join03(self): - output = self.engine.render_to_string('join03', {'a': ['alpha', 'beta & me']}) - self.assertEqual(output, 'alpha & beta & me') + output = self.engine.render_to_string("join03", {"a": ["alpha", "beta & me"]}) + self.assertEqual(output, "alpha & beta & me") - @setup({'join04': '{% autoescape off %}{{ a|join:" & " }}{% endautoescape %}'}) + @setup({"join04": '{% autoescape off %}{{ a|join:" & " }}{% endautoescape %}'}) def test_join04(self): - output = self.engine.render_to_string('join04', {'a': ['alpha', 'beta & me']}) - self.assertEqual(output, 'alpha & beta & me') + output = self.engine.render_to_string("join04", {"a": ["alpha", "beta & me"]}) + self.assertEqual(output, "alpha & beta & me") # Joining with unsafe joiners doesn't result in unsafe strings. - @setup({'join05': '{{ a|join:var }}'}) + @setup({"join05": "{{ a|join:var }}"}) def test_join05(self): - output = self.engine.render_to_string('join05', {'a': ['alpha', 'beta & me'], 'var': ' & '}) - self.assertEqual(output, 'alpha & beta & me') + output = self.engine.render_to_string( + "join05", {"a": ["alpha", "beta & me"], "var": " & "} + ) + self.assertEqual(output, "alpha & beta & me") - @setup({'join06': '{{ a|join:var }}'}) + @setup({"join06": "{{ a|join:var }}"}) def test_join06(self): - output = self.engine.render_to_string('join06', {'a': ['alpha', 'beta & me'], 'var': mark_safe(' & ')}) - self.assertEqual(output, 'alpha & beta & me') + output = self.engine.render_to_string( + "join06", {"a": ["alpha", "beta & me"], "var": mark_safe(" & ")} + ) + self.assertEqual(output, "alpha & beta & me") - @setup({'join07': '{{ a|join:var|lower }}'}) + @setup({"join07": "{{ a|join:var|lower }}"}) def test_join07(self): - output = self.engine.render_to_string('join07', {'a': ['Alpha', 'Beta & me'], 'var': ' & '}) - self.assertEqual(output, 'alpha & beta & me') + output = self.engine.render_to_string( + "join07", {"a": ["Alpha", "Beta & me"], "var": " & "} + ) + self.assertEqual(output, "alpha & beta & me") - @setup({'join08': '{{ a|join:var|lower }}'}) + @setup({"join08": "{{ a|join:var|lower }}"}) def test_join08(self): - output = self.engine.render_to_string('join08', {'a': ['Alpha', 'Beta & me'], 'var': mark_safe(' & ')}) - self.assertEqual(output, 'alpha & beta & me') + output = self.engine.render_to_string( + "join08", {"a": ["Alpha", "Beta & me"], "var": mark_safe(" & ")} + ) + self.assertEqual(output, "alpha & beta & me") class FunctionTests(SimpleTestCase): - def test_list(self): - self.assertEqual(join([0, 1, 2], 'glue'), '0glue1glue2') + self.assertEqual(join([0, 1, 2], "glue"), "0glue1glue2") def test_autoescape(self): self.assertEqual( - join(['', '', ''], '
'), - '<a><br><img><br></a>', + join(["", "", ""], "
"), + "<a><br><img><br></a>", ) def test_autoescape_off(self): self.assertEqual( - join(['', '', ''], '
', autoescape=False), - '<br><br>', + join(["", "", ""], "
", autoescape=False), + "<br><br>", ) def test_noniterable_arg(self): obj = object() - self.assertEqual(join(obj, '
'), obj) + self.assertEqual(join(obj, "
"), obj) def test_noniterable_arg_autoescape_off(self): obj = object() - self.assertEqual(join(obj, '
', autoescape=False), obj) + self.assertEqual(join(obj, "
", autoescape=False), obj) diff --git a/tests/template_tests/filter_tests/test_json_script.py b/tests/template_tests/filter_tests/test_json_script.py index 1d38f678e0..28a078effb 100644 --- a/tests/template_tests/filter_tests/test_json_script.py +++ b/tests/template_tests/filter_tests/test_json_script.py @@ -4,21 +4,19 @@ from ..utils import setup class JsonScriptTests(SimpleTestCase): - - @setup({'json-tag01': '{{ value|json_script:"test_id" }}'}) + @setup({"json-tag01": '{{ value|json_script:"test_id" }}'}) def test_basic(self): output = self.engine.render_to_string( - 'json-tag01', - {'value': {'a': 'testing\r\njson \'string" escaping'}} + "json-tag01", {"value": {"a": "testing\r\njson 'string\" escaping"}} ) self.assertEqual( output, '' + "", ) - @setup({'json-tag02': '{{ value|json_script }}'}) + @setup({"json-tag02": "{{ value|json_script }}"}) def test_without_id(self): - output = self.engine.render_to_string('json-tag02', {'value': {}}) + output = self.engine.render_to_string("json-tag02", {"value": {}}) self.assertEqual(output, '') diff --git a/tests/template_tests/filter_tests/test_last.py b/tests/template_tests/filter_tests/test_last.py index e03caa2382..6b8b8fcbbc 100644 --- a/tests/template_tests/filter_tests/test_last.py +++ b/tests/template_tests/filter_tests/test_last.py @@ -5,18 +5,23 @@ from ..utils import setup class LastTests(SimpleTestCase): - - @setup({'last01': '{{ a|last }} {{ b|last }}'}) + @setup({"last01": "{{ a|last }} {{ b|last }}"}) def test_last01(self): - output = self.engine.render_to_string('last01', {"a": ["x", "a&b"], "b": ["x", mark_safe("a&b")]}) + output = self.engine.render_to_string( + "last01", {"a": ["x", "a&b"], "b": ["x", mark_safe("a&b")]} + ) self.assertEqual(output, "a&b a&b") - @setup({'last02': '{% autoescape off %}{{ a|last }} {{ b|last }}{% endautoescape %}'}) + @setup( + {"last02": "{% autoescape off %}{{ a|last }} {{ b|last }}{% endautoescape %}"} + ) def test_last02(self): - output = self.engine.render_to_string('last02', {"a": ["x", "a&b"], "b": ["x", mark_safe("a&b")]}) + output = self.engine.render_to_string( + "last02", {"a": ["x", "a&b"], "b": ["x", mark_safe("a&b")]} + ) self.assertEqual(output, "a&b a&b") - @setup({'empty_list': '{% autoescape off %}{{ a|last }}{% endautoescape %}'}) + @setup({"empty_list": "{% autoescape off %}{{ a|last }}{% endautoescape %}"}) def test_empty_list(self): - output = self.engine.render_to_string('empty_list', {"a": []}) - self.assertEqual(output, '') + output = self.engine.render_to_string("empty_list", {"a": []}) + self.assertEqual(output, "") diff --git a/tests/template_tests/filter_tests/test_length.py b/tests/template_tests/filter_tests/test_length.py index 9ea90a1234..507cff124b 100644 --- a/tests/template_tests/filter_tests/test_length.py +++ b/tests/template_tests/filter_tests/test_length.py @@ -6,51 +6,53 @@ from ..utils import setup class LengthTests(SimpleTestCase): - - @setup({'length01': '{{ list|length }}'}) + @setup({"length01": "{{ list|length }}"}) def test_length01(self): - output = self.engine.render_to_string('length01', {'list': ['4', None, True, {}]}) - self.assertEqual(output, '4') + output = self.engine.render_to_string( + "length01", {"list": ["4", None, True, {}]} + ) + self.assertEqual(output, "4") - @setup({'length02': '{{ list|length }}'}) + @setup({"length02": "{{ list|length }}"}) def test_length02(self): - output = self.engine.render_to_string('length02', {'list': []}) - self.assertEqual(output, '0') + output = self.engine.render_to_string("length02", {"list": []}) + self.assertEqual(output, "0") - @setup({'length03': '{{ string|length }}'}) + @setup({"length03": "{{ string|length }}"}) def test_length03(self): - output = self.engine.render_to_string('length03', {'string': ''}) - self.assertEqual(output, '0') + output = self.engine.render_to_string("length03", {"string": ""}) + self.assertEqual(output, "0") - @setup({'length04': '{{ string|length }}'}) + @setup({"length04": "{{ string|length }}"}) def test_length04(self): - output = self.engine.render_to_string('length04', {'string': 'django'}) - self.assertEqual(output, '6') + output = self.engine.render_to_string("length04", {"string": "django"}) + self.assertEqual(output, "6") - @setup({'length05': '{% if string|length == 6 %}Pass{% endif %}'}) + @setup({"length05": "{% if string|length == 6 %}Pass{% endif %}"}) def test_length05(self): - output = self.engine.render_to_string('length05', {'string': mark_safe('django')}) - self.assertEqual(output, 'Pass') + output = self.engine.render_to_string( + "length05", {"string": mark_safe("django")} + ) + self.assertEqual(output, "Pass") # Invalid uses that should fail silently. - @setup({'length06': '{{ int|length }}'}) + @setup({"length06": "{{ int|length }}"}) def test_length06(self): - output = self.engine.render_to_string('length06', {'int': 7}) - self.assertEqual(output, '0') + output = self.engine.render_to_string("length06", {"int": 7}) + self.assertEqual(output, "0") - @setup({'length07': '{{ None|length }}'}) + @setup({"length07": "{{ None|length }}"}) def test_length07(self): - output = self.engine.render_to_string('length07', {'None': None}) - self.assertEqual(output, '0') + output = self.engine.render_to_string("length07", {"None": None}) + self.assertEqual(output, "0") class FunctionTests(SimpleTestCase): - def test_string(self): - self.assertEqual(length('1234'), 4) + self.assertEqual(length("1234"), 4) def test_safestring(self): - self.assertEqual(length(mark_safe('1234')), 4) + self.assertEqual(length(mark_safe("1234")), 4) def test_list(self): self.assertEqual(length([1, 2, 3, 4]), 4) diff --git a/tests/template_tests/filter_tests/test_length_is.py b/tests/template_tests/filter_tests/test_length_is.py index 471ef312e9..1cc760c8a2 100644 --- a/tests/template_tests/filter_tests/test_length_is.py +++ b/tests/template_tests/filter_tests/test_length_is.py @@ -5,71 +5,97 @@ from ..utils import setup class LengthIsTests(SimpleTestCase): - - @setup({'length_is01': '{% if some_list|length_is:"4" %}Four{% endif %}'}) + @setup({"length_is01": '{% if some_list|length_is:"4" %}Four{% endif %}'}) def test_length_is01(self): - output = self.engine.render_to_string('length_is01', {'some_list': ['4', None, True, {}]}) - self.assertEqual(output, 'Four') - - @setup({'length_is02': '{% if some_list|length_is:"4" %}Four{% else %}Not Four{% endif %}'}) + output = self.engine.render_to_string( + "length_is01", {"some_list": ["4", None, True, {}]} + ) + self.assertEqual(output, "Four") + + @setup( + { + "length_is02": '{% if some_list|length_is:"4" %}Four{% else %}Not Four{% endif %}' + } + ) def test_length_is02(self): - output = self.engine.render_to_string('length_is02', {'some_list': ['4', None, True, {}, 17]}) - self.assertEqual(output, 'Not Four') + output = self.engine.render_to_string( + "length_is02", {"some_list": ["4", None, True, {}, 17]} + ) + self.assertEqual(output, "Not Four") - @setup({'length_is03': '{% if mystring|length_is:"4" %}Four{% endif %}'}) + @setup({"length_is03": '{% if mystring|length_is:"4" %}Four{% endif %}'}) def test_length_is03(self): - output = self.engine.render_to_string('length_is03', {'mystring': 'word'}) - self.assertEqual(output, 'Four') - - @setup({'length_is04': '{% if mystring|length_is:"4" %}Four{% else %}Not Four{% endif %}'}) + output = self.engine.render_to_string("length_is03", {"mystring": "word"}) + self.assertEqual(output, "Four") + + @setup( + { + "length_is04": '{% if mystring|length_is:"4" %}Four{% else %}Not Four{% endif %}' + } + ) def test_length_is04(self): - output = self.engine.render_to_string('length_is04', {'mystring': 'Python'}) - self.assertEqual(output, 'Not Four') - - @setup({'length_is05': '{% if mystring|length_is:"4" %}Four{% else %}Not Four{% endif %}'}) + output = self.engine.render_to_string("length_is04", {"mystring": "Python"}) + self.assertEqual(output, "Not Four") + + @setup( + { + "length_is05": '{% if mystring|length_is:"4" %}Four{% else %}Not Four{% endif %}' + } + ) def test_length_is05(self): - output = self.engine.render_to_string('length_is05', {'mystring': ''}) - self.assertEqual(output, 'Not Four') - - @setup({'length_is06': '{% with var|length as my_length %}{{ my_length }}{% endwith %}'}) + output = self.engine.render_to_string("length_is05", {"mystring": ""}) + self.assertEqual(output, "Not Four") + + @setup( + { + "length_is06": "{% with var|length as my_length %}{{ my_length }}{% endwith %}" + } + ) def test_length_is06(self): - output = self.engine.render_to_string('length_is06', {'var': 'django'}) - self.assertEqual(output, '6') + output = self.engine.render_to_string("length_is06", {"var": "django"}) + self.assertEqual(output, "6") # Boolean return value from length_is should not be coerced to a string - @setup({'length_is07': '{% if "X"|length_is:0 %}Length is 0{% else %}Length not 0{% endif %}'}) + @setup( + { + "length_is07": '{% if "X"|length_is:0 %}Length is 0{% else %}Length not 0{% endif %}' + } + ) def test_length_is07(self): - output = self.engine.render_to_string('length_is07', {}) - self.assertEqual(output, 'Length not 0') - - @setup({'length_is08': '{% if "X"|length_is:1 %}Length is 1{% else %}Length not 1{% endif %}'}) + output = self.engine.render_to_string("length_is07", {}) + self.assertEqual(output, "Length not 0") + + @setup( + { + "length_is08": '{% if "X"|length_is:1 %}Length is 1{% else %}Length not 1{% endif %}' + } + ) def test_length_is08(self): - output = self.engine.render_to_string('length_is08', {}) - self.assertEqual(output, 'Length is 1') + output = self.engine.render_to_string("length_is08", {}) + self.assertEqual(output, "Length is 1") # Invalid uses that should fail silently. - @setup({'length_is09': '{{ var|length_is:"fish" }}'}) + @setup({"length_is09": '{{ var|length_is:"fish" }}'}) def test_length_is09(self): - output = self.engine.render_to_string('length_is09', {'var': 'django'}) - self.assertEqual(output, '') + output = self.engine.render_to_string("length_is09", {"var": "django"}) + self.assertEqual(output, "") - @setup({'length_is10': '{{ int|length_is:"1" }}'}) + @setup({"length_is10": '{{ int|length_is:"1" }}'}) def test_length_is10(self): - output = self.engine.render_to_string('length_is10', {'int': 7}) - self.assertEqual(output, '') + output = self.engine.render_to_string("length_is10", {"int": 7}) + self.assertEqual(output, "") - @setup({'length_is11': '{{ none|length_is:"1" }}'}) + @setup({"length_is11": '{{ none|length_is:"1" }}'}) def test_length_is11(self): - output = self.engine.render_to_string('length_is11', {'none': None}) - self.assertEqual(output, '') + output = self.engine.render_to_string("length_is11", {"none": None}) + self.assertEqual(output, "") class FunctionTests(SimpleTestCase): - def test_empty_list(self): self.assertIs(length_is([], 0), True) self.assertIs(length_is([], 1), False) def test_string(self): - self.assertIs(length_is('a', 1), True) - self.assertIs(length_is('a', 10), False) + self.assertIs(length_is("a", 1), True) + self.assertIs(length_is("a", 10), False) diff --git a/tests/template_tests/filter_tests/test_linebreaks.py b/tests/template_tests/filter_tests/test_linebreaks.py index 8fdb91f377..ce0f082466 100644 --- a/tests/template_tests/filter_tests/test_linebreaks.py +++ b/tests/template_tests/filter_tests/test_linebreaks.py @@ -12,49 +12,58 @@ class LinebreaksTests(SimpleTestCase): autoescape setting. """ - @setup({'linebreaks01': '{{ a|linebreaks }} {{ b|linebreaks }}'}) + @setup({"linebreaks01": "{{ a|linebreaks }} {{ b|linebreaks }}"}) def test_linebreaks01(self): - output = self.engine.render_to_string('linebreaks01', {"a": "x&\ny", "b": mark_safe("x&\ny")}) + output = self.engine.render_to_string( + "linebreaks01", {"a": "x&\ny", "b": mark_safe("x&\ny")} + ) self.assertEqual(output, "

x&
y

x&
y

") - @setup({'linebreaks02': '{% autoescape off %}{{ a|linebreaks }} {{ b|linebreaks }}{% endautoescape %}'}) + @setup( + { + "linebreaks02": "{% autoescape off %}{{ a|linebreaks }} {{ b|linebreaks }}{% endautoescape %}" + } + ) def test_linebreaks02(self): - output = self.engine.render_to_string('linebreaks02', {"a": "x&\ny", "b": mark_safe("x&\ny")}) + output = self.engine.render_to_string( + "linebreaks02", {"a": "x&\ny", "b": mark_safe("x&\ny")} + ) self.assertEqual(output, "

x&
y

x&
y

") class FunctionTests(SimpleTestCase): - def test_line(self): - self.assertEqual(linebreaks_filter('line 1'), '

line 1

') + self.assertEqual(linebreaks_filter("line 1"), "

line 1

") def test_newline(self): - self.assertEqual(linebreaks_filter('line 1\nline 2'), '

line 1
line 2

') + self.assertEqual(linebreaks_filter("line 1\nline 2"), "

line 1
line 2

") def test_carriage(self): - self.assertEqual(linebreaks_filter('line 1\rline 2'), '

line 1
line 2

') + self.assertEqual(linebreaks_filter("line 1\rline 2"), "

line 1
line 2

") def test_carriage_newline(self): - self.assertEqual(linebreaks_filter('line 1\r\nline 2'), '

line 1
line 2

') + self.assertEqual( + linebreaks_filter("line 1\r\nline 2"), "

line 1
line 2

" + ) def test_non_string_input(self): - self.assertEqual(linebreaks_filter(123), '

123

') + self.assertEqual(linebreaks_filter(123), "

123

") def test_autoescape(self): self.assertEqual( - linebreaks_filter('foo\nbar\nbuz'), - '

foo
<a>bar</a>
buz

', + linebreaks_filter("foo\nbar\nbuz"), + "

foo
<a>bar</a>
buz

", ) def test_autoescape_off(self): self.assertEqual( - linebreaks_filter('foo\nbar\nbuz', autoescape=False), - '

foo
bar
buz

', + linebreaks_filter("foo\nbar\nbuz", autoescape=False), + "

foo
bar
buz

", ) def test_lazy_string_input(self): - add_header = lazy(lambda string: 'Header\n\n' + string, str) + add_header = lazy(lambda string: "Header\n\n" + string, str) self.assertEqual( - linebreaks_filter(add_header('line 1\r\nline2')), - '

Header

\n\n

line 1
line2

' + linebreaks_filter(add_header("line 1\r\nline2")), + "

Header

\n\n

line 1
line2

", ) diff --git a/tests/template_tests/filter_tests/test_linebreaksbr.py b/tests/template_tests/filter_tests/test_linebreaksbr.py index f2583f0aaf..fa4cff209b 100644 --- a/tests/template_tests/filter_tests/test_linebreaksbr.py +++ b/tests/template_tests/filter_tests/test_linebreaksbr.py @@ -11,39 +11,46 @@ class LinebreaksbrTests(SimpleTestCase): autoescape setting. """ - @setup({'linebreaksbr01': '{{ a|linebreaksbr }} {{ b|linebreaksbr }}'}) + @setup({"linebreaksbr01": "{{ a|linebreaksbr }} {{ b|linebreaksbr }}"}) def test_linebreaksbr01(self): - output = self.engine.render_to_string('linebreaksbr01', {"a": "x&\ny", "b": mark_safe("x&\ny")}) + output = self.engine.render_to_string( + "linebreaksbr01", {"a": "x&\ny", "b": mark_safe("x&\ny")} + ) self.assertEqual(output, "x&
y x&
y") - @setup({'linebreaksbr02': '{% autoescape off %}{{ a|linebreaksbr }} {{ b|linebreaksbr }}{% endautoescape %}'}) + @setup( + { + "linebreaksbr02": "{% autoescape off %}{{ a|linebreaksbr }} {{ b|linebreaksbr }}{% endautoescape %}" + } + ) def test_linebreaksbr02(self): - output = self.engine.render_to_string('linebreaksbr02', {"a": "x&\ny", "b": mark_safe("x&\ny")}) + output = self.engine.render_to_string( + "linebreaksbr02", {"a": "x&\ny", "b": mark_safe("x&\ny")} + ) self.assertEqual(output, "x&
y x&
y") class FunctionTests(SimpleTestCase): - def test_newline(self): - self.assertEqual(linebreaksbr('line 1\nline 2'), 'line 1
line 2') + self.assertEqual(linebreaksbr("line 1\nline 2"), "line 1
line 2") def test_carriage(self): - self.assertEqual(linebreaksbr('line 1\rline 2'), 'line 1
line 2') + self.assertEqual(linebreaksbr("line 1\rline 2"), "line 1
line 2") def test_carriage_newline(self): - self.assertEqual(linebreaksbr('line 1\r\nline 2'), 'line 1
line 2') + self.assertEqual(linebreaksbr("line 1\r\nline 2"), "line 1
line 2") def test_non_string_input(self): - self.assertEqual(linebreaksbr(123), '123') + self.assertEqual(linebreaksbr(123), "123") def test_autoescape(self): self.assertEqual( - linebreaksbr('foo\nbar\nbuz'), - 'foo
<a>bar</a>
buz', + linebreaksbr("foo\nbar\nbuz"), + "foo
<a>bar</a>
buz", ) def test_autoescape_off(self): self.assertEqual( - linebreaksbr('foo\nbar\nbuz', autoescape=False), - 'foo
bar
buz', + linebreaksbr("foo\nbar\nbuz", autoescape=False), + "foo
bar
buz", ) diff --git a/tests/template_tests/filter_tests/test_linenumbers.py b/tests/template_tests/filter_tests/test_linenumbers.py index 2ded01f421..82fae4f889 100644 --- a/tests/template_tests/filter_tests/test_linenumbers.py +++ b/tests/template_tests/filter_tests/test_linenumbers.py @@ -11,45 +11,52 @@ class LinenumbersTests(SimpleTestCase): autoescape setting. """ - @setup({'linenumbers01': '{{ a|linenumbers }} {{ b|linenumbers }}'}) + @setup({"linenumbers01": "{{ a|linenumbers }} {{ b|linenumbers }}"}) def test_linenumbers01(self): output = self.engine.render_to_string( - 'linenumbers01', - {'a': 'one\n\nthree', 'b': mark_safe('one\n<two>\nthree')}, + "linenumbers01", + {"a": "one\n\nthree", "b": mark_safe("one\n<two>\nthree")}, + ) + self.assertEqual( + output, "1. one\n2. <two>\n3. three 1. one\n2. <two>\n3. three" ) - self.assertEqual(output, '1. one\n2. <two>\n3. three 1. one\n2. <two>\n3. three') - @setup({'linenumbers02': '{% autoescape off %}{{ a|linenumbers }} {{ b|linenumbers }}{% endautoescape %}'}) + @setup( + { + "linenumbers02": "{% autoescape off %}{{ a|linenumbers }} {{ b|linenumbers }}{% endautoescape %}" + } + ) def test_linenumbers02(self): output = self.engine.render_to_string( - 'linenumbers02', - {'a': 'one\n\nthree', 'b': mark_safe('one\n<two>\nthree')}, + "linenumbers02", + {"a": "one\n\nthree", "b": mark_safe("one\n<two>\nthree")}, + ) + self.assertEqual( + output, "1. one\n2. \n3. three 1. one\n2. <two>\n3. three" ) - self.assertEqual(output, '1. one\n2. \n3. three 1. one\n2. <two>\n3. three') class FunctionTests(SimpleTestCase): - def test_linenumbers(self): - self.assertEqual(linenumbers('line 1\nline 2'), '1. line 1\n2. line 2') + self.assertEqual(linenumbers("line 1\nline 2"), "1. line 1\n2. line 2") def test_linenumbers2(self): self.assertEqual( - linenumbers('\n'.join(['x'] * 10)), - '01. x\n02. x\n03. x\n04. x\n05. x\n06. x\n07. x\n08. x\n09. x\n10. x', + linenumbers("\n".join(["x"] * 10)), + "01. x\n02. x\n03. x\n04. x\n05. x\n06. x\n07. x\n08. x\n09. x\n10. x", ) def test_non_string_input(self): - self.assertEqual(linenumbers(123), '1. 123') + self.assertEqual(linenumbers(123), "1. 123") def test_autoescape(self): self.assertEqual( - linenumbers('foo\nbar\nbuz'), - '1. foo\n2. <a>bar</a>\n3. buz', + linenumbers("foo\nbar\nbuz"), + "1. foo\n2. <a>bar</a>\n3. buz", ) def test_autoescape_off(self): self.assertEqual( - linenumbers('foo\nbar\nbuz', autoescape=False), - '1. foo\n2. bar\n3. buz' + linenumbers("foo\nbar\nbuz", autoescape=False), + "1. foo\n2. bar\n3. buz", ) diff --git a/tests/template_tests/filter_tests/test_ljust.py b/tests/template_tests/filter_tests/test_ljust.py index 19f35f78f4..9ea5b23862 100644 --- a/tests/template_tests/filter_tests/test_ljust.py +++ b/tests/template_tests/filter_tests/test_ljust.py @@ -6,26 +6,32 @@ from ..utils import setup class LjustTests(SimpleTestCase): - - @setup({'ljust01': '{% autoescape off %}.{{ a|ljust:"5" }}. .{{ b|ljust:"5" }}.{% endautoescape %}'}) + @setup( + { + "ljust01": '{% autoescape off %}.{{ a|ljust:"5" }}. .{{ b|ljust:"5" }}.{% endautoescape %}' + } + ) def test_ljust01(self): - output = self.engine.render_to_string('ljust01', {"a": "a&b", "b": mark_safe("a&b")}) + output = self.engine.render_to_string( + "ljust01", {"a": "a&b", "b": mark_safe("a&b")} + ) self.assertEqual(output, ".a&b . .a&b .") - @setup({'ljust02': '.{{ a|ljust:"5" }}. .{{ b|ljust:"5" }}.'}) + @setup({"ljust02": '.{{ a|ljust:"5" }}. .{{ b|ljust:"5" }}.'}) def test_ljust02(self): - output = self.engine.render_to_string('ljust02', {"a": "a&b", "b": mark_safe("a&b")}) + output = self.engine.render_to_string( + "ljust02", {"a": "a&b", "b": mark_safe("a&b")} + ) self.assertEqual(output, ".a&b . .a&b .") class FunctionTests(SimpleTestCase): - def test_ljust(self): - self.assertEqual(ljust('test', 10), 'test ') - self.assertEqual(ljust('test', 3), 'test') + self.assertEqual(ljust("test", 10), "test ") + self.assertEqual(ljust("test", 3), "test") def test_less_than_string_length(self): - self.assertEqual(ljust('test', 3), 'test') + self.assertEqual(ljust("test", 3), "test") def test_non_string_input(self): - self.assertEqual(ljust(123, 4), '123 ') + self.assertEqual(ljust(123, 4), "123 ") diff --git a/tests/template_tests/filter_tests/test_lower.py b/tests/template_tests/filter_tests/test_lower.py index 1db934c5fa..29845663dd 100644 --- a/tests/template_tests/filter_tests/test_lower.py +++ b/tests/template_tests/filter_tests/test_lower.py @@ -6,26 +6,32 @@ from ..utils import setup class LowerTests(SimpleTestCase): - - @setup({'lower01': '{% autoescape off %}{{ a|lower }} {{ b|lower }}{% endautoescape %}'}) + @setup( + { + "lower01": "{% autoescape off %}{{ a|lower }} {{ b|lower }}{% endautoescape %}" + } + ) def test_lower01(self): - output = self.engine.render_to_string('lower01', {"a": "Apple & banana", "b": mark_safe("Apple & banana")}) + output = self.engine.render_to_string( + "lower01", {"a": "Apple & banana", "b": mark_safe("Apple & banana")} + ) self.assertEqual(output, "apple & banana apple & banana") - @setup({'lower02': '{{ a|lower }} {{ b|lower }}'}) + @setup({"lower02": "{{ a|lower }} {{ b|lower }}"}) def test_lower02(self): - output = self.engine.render_to_string('lower02', {"a": "Apple & banana", "b": mark_safe("Apple & banana")}) + output = self.engine.render_to_string( + "lower02", {"a": "Apple & banana", "b": mark_safe("Apple & banana")} + ) self.assertEqual(output, "apple & banana apple & banana") class FunctionTests(SimpleTestCase): - def test_lower(self): - self.assertEqual(lower('TEST'), 'test') + self.assertEqual(lower("TEST"), "test") def test_unicode(self): # uppercase E umlaut - self.assertEqual(lower('\xcb'), '\xeb') + self.assertEqual(lower("\xcb"), "\xeb") def test_non_string_input(self): - self.assertEqual(lower(123), '123') + self.assertEqual(lower(123), "123") diff --git a/tests/template_tests/filter_tests/test_make_list.py b/tests/template_tests/filter_tests/test_make_list.py index a3e8535ecb..34901d2ff2 100644 --- a/tests/template_tests/filter_tests/test_make_list.py +++ b/tests/template_tests/filter_tests/test_make_list.py @@ -11,31 +11,34 @@ class MakeListTests(SimpleTestCase): escaped. """ - @setup({'make_list01': '{% autoescape off %}{{ a|make_list }}{% endautoescape %}'}) + @setup({"make_list01": "{% autoescape off %}{{ a|make_list }}{% endautoescape %}"}) def test_make_list01(self): - output = self.engine.render_to_string('make_list01', {"a": mark_safe("&")}) + output = self.engine.render_to_string("make_list01", {"a": mark_safe("&")}) self.assertEqual(output, "['&']") - @setup({'make_list02': '{{ a|make_list }}'}) + @setup({"make_list02": "{{ a|make_list }}"}) def test_make_list02(self): - output = self.engine.render_to_string('make_list02', {"a": mark_safe("&")}) - self.assertEqual(output, '['&']') - - @setup({'make_list03': '{% autoescape off %}{{ a|make_list|stringformat:"s"|safe }}{% endautoescape %}'}) + output = self.engine.render_to_string("make_list02", {"a": mark_safe("&")}) + self.assertEqual(output, "['&']") + + @setup( + { + "make_list03": '{% autoescape off %}{{ a|make_list|stringformat:"s"|safe }}{% endautoescape %}' + } + ) def test_make_list03(self): - output = self.engine.render_to_string('make_list03', {"a": mark_safe("&")}) + output = self.engine.render_to_string("make_list03", {"a": mark_safe("&")}) self.assertEqual(output, "['&']") - @setup({'make_list04': '{{ a|make_list|stringformat:"s"|safe }}'}) + @setup({"make_list04": '{{ a|make_list|stringformat:"s"|safe }}'}) def test_make_list04(self): - output = self.engine.render_to_string('make_list04', {"a": mark_safe("&")}) + output = self.engine.render_to_string("make_list04", {"a": mark_safe("&")}) self.assertEqual(output, "['&']") class FunctionTests(SimpleTestCase): - def test_string(self): - self.assertEqual(make_list('abc'), ['a', 'b', 'c']) + self.assertEqual(make_list("abc"), ["a", "b", "c"]) def test_integer(self): - self.assertEqual(make_list(1234), ['1', '2', '3', '4']) + self.assertEqual(make_list(1234), ["1", "2", "3", "4"]) diff --git a/tests/template_tests/filter_tests/test_phone2numeric.py b/tests/template_tests/filter_tests/test_phone2numeric.py index 0c81a904ea..8165fba9da 100644 --- a/tests/template_tests/filter_tests/test_phone2numeric.py +++ b/tests/template_tests/filter_tests/test_phone2numeric.py @@ -6,36 +6,37 @@ from ..utils import setup class Phone2numericTests(SimpleTestCase): - - @setup({'phone2numeric01': '{{ a|phone2numeric }} {{ b|phone2numeric }}'}) + @setup({"phone2numeric01": "{{ a|phone2numeric }} {{ b|phone2numeric }}"}) def test_phone2numeric01(self): output = self.engine.render_to_string( - 'phone2numeric01', - {'a': '<1-800-call-me>', 'b': mark_safe('<1-800-call-me>')}, + "phone2numeric01", + {"a": "<1-800-call-me>", "b": mark_safe("<1-800-call-me>")}, ) - self.assertEqual(output, '<1-800-2255-63> <1-800-2255-63>') + self.assertEqual(output, "<1-800-2255-63> <1-800-2255-63>") - @setup({'phone2numeric02': '{% autoescape off %}{{ a|phone2numeric }} {{ b|phone2numeric }}{% endautoescape %}'}) + @setup( + { + "phone2numeric02": "{% autoescape off %}{{ a|phone2numeric }} {{ b|phone2numeric }}{% endautoescape %}" + } + ) def test_phone2numeric02(self): output = self.engine.render_to_string( - 'phone2numeric02', - {'a': '<1-800-call-me>', 'b': mark_safe('<1-800-call-me>')}, + "phone2numeric02", + {"a": "<1-800-call-me>", "b": mark_safe("<1-800-call-me>")}, ) - self.assertEqual(output, '<1-800-2255-63> <1-800-2255-63>') + self.assertEqual(output, "<1-800-2255-63> <1-800-2255-63>") - @setup({'phone2numeric03': '{{ a|phone2numeric }}'}) + @setup({"phone2numeric03": "{{ a|phone2numeric }}"}) def test_phone2numeric03(self): output = self.engine.render_to_string( - 'phone2numeric03', - {'a': 'How razorback-jumping frogs can level six piqued gymnasts!'}, + "phone2numeric03", + {"a": "How razorback-jumping frogs can level six piqued gymnasts!"}, ) self.assertEqual( - output, - '469 729672225-5867464 37647 226 53835 749 747833 49662787!' + output, "469 729672225-5867464 37647 226 53835 749 747833 49662787!" ) class FunctionTests(SimpleTestCase): - def test_phone2numeric(self): - self.assertEqual(phone2numeric_filter('0800 flowers'), '0800 3569377') + self.assertEqual(phone2numeric_filter("0800 flowers"), "0800 3569377") diff --git a/tests/template_tests/filter_tests/test_pluralize.py b/tests/template_tests/filter_tests/test_pluralize.py index 313981c6a8..c28718e101 100644 --- a/tests/template_tests/filter_tests/test_pluralize.py +++ b/tests/template_tests/filter_tests/test_pluralize.py @@ -7,60 +7,58 @@ from ..utils import setup class PluralizeTests(SimpleTestCase): - def check_values(self, *tests): for value, expected in tests: with self.subTest(value=value): - output = self.engine.render_to_string('t', {'value': value}) + output = self.engine.render_to_string("t", {"value": value}) self.assertEqual(output, expected) - @setup({'t': 'vote{{ value|pluralize }}'}) + @setup({"t": "vote{{ value|pluralize }}"}) def test_no_arguments(self): - self.check_values(('0', 'votes'), ('1', 'vote'), ('2', 'votes')) + self.check_values(("0", "votes"), ("1", "vote"), ("2", "votes")) - @setup({'t': 'class{{ value|pluralize:"es" }}'}) + @setup({"t": 'class{{ value|pluralize:"es" }}'}) def test_suffix(self): - self.check_values(('0', 'classes'), ('1', 'class'), ('2', 'classes')) + self.check_values(("0", "classes"), ("1", "class"), ("2", "classes")) - @setup({'t': 'cand{{ value|pluralize:"y,ies" }}'}) + @setup({"t": 'cand{{ value|pluralize:"y,ies" }}'}) def test_singular_and_plural_suffix(self): - self.check_values(('0', 'candies'), ('1', 'candy'), ('2', 'candies')) + self.check_values(("0", "candies"), ("1", "candy"), ("2", "candies")) class FunctionTests(SimpleTestCase): - def test_integers(self): - self.assertEqual(pluralize(1), '') - self.assertEqual(pluralize(0), 's') - self.assertEqual(pluralize(2), 's') + self.assertEqual(pluralize(1), "") + self.assertEqual(pluralize(0), "s") + self.assertEqual(pluralize(2), "s") def test_floats(self): - self.assertEqual(pluralize(0.5), 's') - self.assertEqual(pluralize(1.5), 's') + self.assertEqual(pluralize(0.5), "s") + self.assertEqual(pluralize(1.5), "s") def test_decimals(self): - self.assertEqual(pluralize(Decimal(1)), '') - self.assertEqual(pluralize(Decimal(0)), 's') - self.assertEqual(pluralize(Decimal(2)), 's') + self.assertEqual(pluralize(Decimal(1)), "") + self.assertEqual(pluralize(Decimal(0)), "s") + self.assertEqual(pluralize(Decimal(2)), "s") def test_lists(self): - self.assertEqual(pluralize([1]), '') - self.assertEqual(pluralize([]), 's') - self.assertEqual(pluralize([1, 2, 3]), 's') + self.assertEqual(pluralize([1]), "") + self.assertEqual(pluralize([]), "s") + self.assertEqual(pluralize([1, 2, 3]), "s") def test_suffixes(self): - self.assertEqual(pluralize(1, 'es'), '') - self.assertEqual(pluralize(0, 'es'), 'es') - self.assertEqual(pluralize(2, 'es'), 'es') - self.assertEqual(pluralize(1, 'y,ies'), 'y') - self.assertEqual(pluralize(0, 'y,ies'), 'ies') - self.assertEqual(pluralize(2, 'y,ies'), 'ies') - self.assertEqual(pluralize(0, 'y,ies,error'), '') + self.assertEqual(pluralize(1, "es"), "") + self.assertEqual(pluralize(0, "es"), "es") + self.assertEqual(pluralize(2, "es"), "es") + self.assertEqual(pluralize(1, "y,ies"), "y") + self.assertEqual(pluralize(0, "y,ies"), "ies") + self.assertEqual(pluralize(2, "y,ies"), "ies") + self.assertEqual(pluralize(0, "y,ies,error"), "") def test_no_len_type(self): - self.assertEqual(pluralize(object(), 'y,es'), '') - self.assertEqual(pluralize(object(), 'es'), '') + self.assertEqual(pluralize(object(), "y,es"), "") + self.assertEqual(pluralize(object(), "es"), "") def test_value_error(self): - self.assertEqual(pluralize('', 'y,es'), '') - self.assertEqual(pluralize('', 'es'), '') + self.assertEqual(pluralize("", "y,es"), "") + self.assertEqual(pluralize("", "es"), "") diff --git a/tests/template_tests/filter_tests/test_random.py b/tests/template_tests/filter_tests/test_random.py index acb8a82f1d..a419128971 100644 --- a/tests/template_tests/filter_tests/test_random.py +++ b/tests/template_tests/filter_tests/test_random.py @@ -5,17 +5,20 @@ from ..utils import setup class RandomTests(SimpleTestCase): - - @setup({'random01': '{{ a|random }} {{ b|random }}'}) + @setup({"random01": "{{ a|random }} {{ b|random }}"}) def test_random01(self): output = self.engine.render_to_string( - 'random01', {'a': ['a&b', 'a&b'], 'b': [mark_safe('a&b'), mark_safe('a&b')]} + "random01", {"a": ["a&b", "a&b"], "b": [mark_safe("a&b"), mark_safe("a&b")]} ) - self.assertEqual(output, 'a&b a&b') + self.assertEqual(output, "a&b a&b") - @setup({'random02': '{% autoescape off %}{{ a|random }} {{ b|random }}{% endautoescape %}'}) + @setup( + { + "random02": "{% autoescape off %}{{ a|random }} {{ b|random }}{% endautoescape %}" + } + ) def test_random02(self): output = self.engine.render_to_string( - 'random02', {'a': ['a&b', 'a&b'], 'b': [mark_safe('a&b'), mark_safe('a&b')]} + "random02", {"a": ["a&b", "a&b"], "b": [mark_safe("a&b"), mark_safe("a&b")]} ) - self.assertEqual(output, 'a&b a&b') + self.assertEqual(output, "a&b a&b") diff --git a/tests/template_tests/filter_tests/test_rjust.py b/tests/template_tests/filter_tests/test_rjust.py index 1926b49e38..b7dde7514a 100644 --- a/tests/template_tests/filter_tests/test_rjust.py +++ b/tests/template_tests/filter_tests/test_rjust.py @@ -6,25 +6,31 @@ from ..utils import setup class RjustTests(SimpleTestCase): - - @setup({'rjust01': '{% autoescape off %}.{{ a|rjust:"5" }}. .{{ b|rjust:"5" }}.{% endautoescape %}'}) + @setup( + { + "rjust01": '{% autoescape off %}.{{ a|rjust:"5" }}. .{{ b|rjust:"5" }}.{% endautoescape %}' + } + ) def test_rjust01(self): - output = self.engine.render_to_string('rjust01', {"a": "a&b", "b": mark_safe("a&b")}) + output = self.engine.render_to_string( + "rjust01", {"a": "a&b", "b": mark_safe("a&b")} + ) self.assertEqual(output, ". a&b. . a&b.") - @setup({'rjust02': '.{{ a|rjust:"5" }}. .{{ b|rjust:"5" }}.'}) + @setup({"rjust02": '.{{ a|rjust:"5" }}. .{{ b|rjust:"5" }}.'}) def test_rjust02(self): - output = self.engine.render_to_string('rjust02', {"a": "a&b", "b": mark_safe("a&b")}) + output = self.engine.render_to_string( + "rjust02", {"a": "a&b", "b": mark_safe("a&b")} + ) self.assertEqual(output, ". a&b. . a&b.") class FunctionTests(SimpleTestCase): - def test_rjust(self): - self.assertEqual(rjust('test', 10), ' test') + self.assertEqual(rjust("test", 10), " test") def test_less_than_string_length(self): - self.assertEqual(rjust('test', 3), 'test') + self.assertEqual(rjust("test", 3), "test") def test_non_string_input(self): - self.assertEqual(rjust(123, 4), ' 123') + self.assertEqual(rjust(123, 4), " 123") diff --git a/tests/template_tests/filter_tests/test_safe.py b/tests/template_tests/filter_tests/test_safe.py index c05387098d..ecde1c820c 100644 --- a/tests/template_tests/filter_tests/test_safe.py +++ b/tests/template_tests/filter_tests/test_safe.py @@ -4,13 +4,12 @@ from ..utils import setup class SafeTests(SimpleTestCase): - - @setup({'safe01': '{{ a }} -- {{ a|safe }}'}) + @setup({"safe01": "{{ a }} -- {{ a|safe }}"}) def test_safe01(self): - output = self.engine.render_to_string('safe01', {'a': 'hello'}) - self.assertEqual(output, '<b>hello</b> -- hello') + output = self.engine.render_to_string("safe01", {"a": "hello"}) + self.assertEqual(output, "<b>hello</b> -- hello") - @setup({'safe02': '{% autoescape off %}{{ a }} -- {{ a|safe }}{% endautoescape %}'}) + @setup({"safe02": "{% autoescape off %}{{ a }} -- {{ a|safe }}{% endautoescape %}"}) def test_safe02(self): - output = self.engine.render_to_string('safe02', {'a': 'hello'}) - self.assertEqual(output, 'hello -- hello') + output = self.engine.render_to_string("safe02", {"a": "hello"}) + self.assertEqual(output, "hello -- hello") diff --git a/tests/template_tests/filter_tests/test_safeseq.py b/tests/template_tests/filter_tests/test_safeseq.py index 38b1cd6078..4a537551f9 100644 --- a/tests/template_tests/filter_tests/test_safeseq.py +++ b/tests/template_tests/filter_tests/test_safeseq.py @@ -4,13 +4,16 @@ from ..utils import setup class SafeseqTests(SimpleTestCase): - - @setup({'safeseq01': '{{ a|join:", " }} -- {{ a|safeseq|join:", " }}'}) + @setup({"safeseq01": '{{ a|join:", " }} -- {{ a|safeseq|join:", " }}'}) def test_safeseq01(self): - output = self.engine.render_to_string('safeseq01', {'a': ['&', '<']}) - self.assertEqual(output, '&, < -- &, <') + output = self.engine.render_to_string("safeseq01", {"a": ["&", "<"]}) + self.assertEqual(output, "&, < -- &, <") - @setup({'safeseq02': '{% autoescape off %}{{ a|join:", " }} -- {{ a|safeseq|join:", " }}{% endautoescape %}'}) + @setup( + { + "safeseq02": '{% autoescape off %}{{ a|join:", " }} -- {{ a|safeseq|join:", " }}{% endautoescape %}' + } + ) def test_safeseq02(self): - output = self.engine.render_to_string('safeseq02', {'a': ['&', '<']}) - self.assertEqual(output, '&, < -- &, <') + output = self.engine.render_to_string("safeseq02", {"a": ["&", "<"]}) + self.assertEqual(output, "&, < -- &, <") diff --git a/tests/template_tests/filter_tests/test_slice.py b/tests/template_tests/filter_tests/test_slice.py index 1b92776707..f1c91a5008 100644 --- a/tests/template_tests/filter_tests/test_slice.py +++ b/tests/template_tests/filter_tests/test_slice.py @@ -6,41 +6,47 @@ from ..utils import setup class SliceTests(SimpleTestCase): - - @setup({'slice01': '{{ a|slice:"1:3" }} {{ b|slice:"1:3" }}'}) + @setup({"slice01": '{{ a|slice:"1:3" }} {{ b|slice:"1:3" }}'}) def test_slice01(self): - output = self.engine.render_to_string('slice01', {'a': 'a&b', 'b': mark_safe('a&b')}) - self.assertEqual(output, '&b &b') - - @setup({'slice02': '{% autoescape off %}{{ a|slice:"1:3" }} {{ b|slice:"1:3" }}{% endautoescape %}'}) + output = self.engine.render_to_string( + "slice01", {"a": "a&b", "b": mark_safe("a&b")} + ) + self.assertEqual(output, "&b &b") + + @setup( + { + "slice02": '{% autoescape off %}{{ a|slice:"1:3" }} {{ b|slice:"1:3" }}{% endautoescape %}' + } + ) def test_slice02(self): - output = self.engine.render_to_string('slice02', {'a': 'a&b', 'b': mark_safe('a&b')}) - self.assertEqual(output, '&b &b') + output = self.engine.render_to_string( + "slice02", {"a": "a&b", "b": mark_safe("a&b")} + ) + self.assertEqual(output, "&b &b") class FunctionTests(SimpleTestCase): - def test_zero_length(self): - self.assertEqual(slice_filter('abcdefg', '0'), '') + self.assertEqual(slice_filter("abcdefg", "0"), "") def test_index(self): - self.assertEqual(slice_filter('abcdefg', '1'), 'a') + self.assertEqual(slice_filter("abcdefg", "1"), "a") def test_index_integer(self): - self.assertEqual(slice_filter('abcdefg', 1), 'a') + self.assertEqual(slice_filter("abcdefg", 1), "a") def test_negative_index(self): - self.assertEqual(slice_filter('abcdefg', '-1'), 'abcdef') + self.assertEqual(slice_filter("abcdefg", "-1"), "abcdef") def test_range(self): - self.assertEqual(slice_filter('abcdefg', '1:2'), 'b') + self.assertEqual(slice_filter("abcdefg", "1:2"), "b") def test_range_multiple(self): - self.assertEqual(slice_filter('abcdefg', '1:3'), 'bc') + self.assertEqual(slice_filter("abcdefg", "1:3"), "bc") def test_range_step(self): - self.assertEqual(slice_filter('abcdefg', '0::2'), 'aceg') + self.assertEqual(slice_filter("abcdefg", "0::2"), "aceg") def test_fail_silently(self): obj = object() - self.assertEqual(slice_filter(obj, '0::2'), obj) + self.assertEqual(slice_filter(obj, "0::2"), obj) diff --git a/tests/template_tests/filter_tests/test_slugify.py b/tests/template_tests/filter_tests/test_slugify.py index b1d617f5bc..e0e8a52da9 100644 --- a/tests/template_tests/filter_tests/test_slugify.py +++ b/tests/template_tests/filter_tests/test_slugify.py @@ -12,37 +12,50 @@ class SlugifyTests(SimpleTestCase): but the result is still safe. """ - @setup({'slugify01': '{% autoescape off %}{{ a|slugify }} {{ b|slugify }}{% endautoescape %}'}) + @setup( + { + "slugify01": "{% autoescape off %}{{ a|slugify }} {{ b|slugify }}{% endautoescape %}" + } + ) def test_slugify01(self): - output = self.engine.render_to_string('slugify01', {'a': 'a & b', 'b': mark_safe('a & b')}) - self.assertEqual(output, 'a-b a-amp-b') + output = self.engine.render_to_string( + "slugify01", {"a": "a & b", "b": mark_safe("a & b")} + ) + self.assertEqual(output, "a-b a-amp-b") - @setup({'slugify02': '{{ a|slugify }} {{ b|slugify }}'}) + @setup({"slugify02": "{{ a|slugify }} {{ b|slugify }}"}) def test_slugify02(self): - output = self.engine.render_to_string('slugify02', {'a': 'a & b', 'b': mark_safe('a & b')}) - self.assertEqual(output, 'a-b a-amp-b') + output = self.engine.render_to_string( + "slugify02", {"a": "a & b", "b": mark_safe("a & b")} + ) + self.assertEqual(output, "a-b a-amp-b") class FunctionTests(SimpleTestCase): - def test_slugify(self): self.assertEqual( - slugify(' Jack & Jill like numbers 1,2,3 and 4 and silly characters ?%.$!/'), - 'jack-jill-like-numbers-123-and-4-and-silly-characters', + slugify( + " Jack & Jill like numbers 1,2,3 and 4 and silly characters ?%.$!/" + ), + "jack-jill-like-numbers-123-and-4-and-silly-characters", ) def test_unicode(self): self.assertEqual( slugify("Un \xe9l\xe9phant \xe0 l'or\xe9e du bois"), - 'un-elephant-a-loree-du-bois', + "un-elephant-a-loree-du-bois", ) def test_non_string_input(self): - self.assertEqual(slugify(123), '123') + self.assertEqual(slugify(123), "123") def test_slugify_lazy_string(self): lazy_str = lazy(lambda string: string, str) self.assertEqual( - slugify(lazy_str(' Jack & Jill like numbers 1,2,3 and 4 and silly characters ?%.$!/')), - 'jack-jill-like-numbers-123-and-4-and-silly-characters', + slugify( + lazy_str( + " Jack & Jill like numbers 1,2,3 and 4 and silly characters ?%.$!/" + ) + ), + "jack-jill-like-numbers-123-and-4-and-silly-characters", ) diff --git a/tests/template_tests/filter_tests/test_stringformat.py b/tests/template_tests/filter_tests/test_stringformat.py index 62ee19aef8..e8f06ac4a0 100644 --- a/tests/template_tests/filter_tests/test_stringformat.py +++ b/tests/template_tests/filter_tests/test_stringformat.py @@ -11,32 +11,38 @@ class StringformatTests(SimpleTestCase): formatting here only needs to deal with pre-escaped characters. """ - @setup({ - 'stringformat01': - '{% autoescape off %}.{{ a|stringformat:"5s" }}. .{{ b|stringformat:"5s" }}.{% endautoescape %}' - }) + @setup( + { + "stringformat01": '{% autoescape off %}.{{ a|stringformat:"5s" }}. .{{ b|stringformat:"5s" }}.{% endautoescape %}' + } + ) def test_stringformat01(self): - output = self.engine.render_to_string('stringformat01', {'a': 'ax

y

', - 'b': mark_safe('x

y

'), + "a": "x

y

", + "b": mark_safe("x

y

"), }, ) - self.assertEqual(output, 'x y x y') + self.assertEqual(output, "x y x y") - @setup({'striptags02': '{% autoescape off %}{{ a|striptags }} {{ b|striptags }}{% endautoescape %}'}) + @setup( + { + "striptags02": "{% autoescape off %}{{ a|striptags }} {{ b|striptags }}{% endautoescape %}" + } + ) def test_striptags02(self): output = self.engine.render_to_string( - 'striptags02', + "striptags02", { - 'a': 'x

y

', - 'b': mark_safe('x

y

'), + "a": "x

y

", + "b": mark_safe("x

y

"), }, ) - self.assertEqual(output, 'x y x y') + self.assertEqual(output, "x y x y") class FunctionTests(SimpleTestCase): - def test_strip(self): self.assertEqual( - striptags('some html with disallowed tags'), + striptags( + 'some html with disallowed tags' + ), 'some html with alert("You smell") disallowed tags', ) def test_non_string_input(self): - self.assertEqual(striptags(123), '123') + self.assertEqual(striptags(123), "123") def test_strip_lazy_string(self): self.assertEqual( - striptags(lazystr('some html with disallowed tags')), + striptags( + lazystr( + 'some html with disallowed tags' + ) + ), 'some html with alert("Hello") disallowed tags', ) diff --git a/tests/template_tests/filter_tests/test_time.py b/tests/template_tests/filter_tests/test_time.py index a848e74378..c8ab58b553 100644 --- a/tests/template_tests/filter_tests/test_time.py +++ b/tests/template_tests/filter_tests/test_time.py @@ -13,54 +13,55 @@ class TimeTests(TimezoneTestCase): #20693: Timezone support for the time template filter """ - @setup({'time00': '{{ dt|time }}'}) + @setup({"time00": "{{ dt|time }}"}) def test_time00(self): - output = self.engine.render_to_string('time00', {'dt': time(16, 25)}) - self.assertEqual(output, '4:25 p.m.') + output = self.engine.render_to_string("time00", {"dt": time(16, 25)}) + self.assertEqual(output, "4:25 p.m.") - @setup({'time00_l10n': '{{ dt|time }}'}) + @setup({"time00_l10n": "{{ dt|time }}"}) def test_time00_l10n(self): - with translation.override('fr'): - output = self.engine.render_to_string('time00_l10n', {'dt': time(16, 25)}) - self.assertEqual(output, '16:25') + with translation.override("fr"): + output = self.engine.render_to_string("time00_l10n", {"dt": time(16, 25)}) + self.assertEqual(output, "16:25") - @setup({'time01': '{{ dt|time:"e:O:T:Z" }}'}) + @setup({"time01": '{{ dt|time:"e:O:T:Z" }}'}) def test_time01(self): - output = self.engine.render_to_string('time01', {'dt': self.now_tz_i}) - self.assertEqual(output, '+0315:+0315:+0315:11700') + output = self.engine.render_to_string("time01", {"dt": self.now_tz_i}) + self.assertEqual(output, "+0315:+0315:+0315:11700") - @setup({'time02': '{{ dt|time:"e:T" }}'}) + @setup({"time02": '{{ dt|time:"e:T" }}'}) def test_time02(self): - output = self.engine.render_to_string('time02', {'dt': self.now}) - self.assertEqual(output, ':' + self.now_tz.tzinfo.tzname(self.now_tz)) + output = self.engine.render_to_string("time02", {"dt": self.now}) + self.assertEqual(output, ":" + self.now_tz.tzinfo.tzname(self.now_tz)) - @setup({'time03': '{{ t|time:"P:e:O:T:Z" }}'}) + @setup({"time03": '{{ t|time:"P:e:O:T:Z" }}'}) def test_time03(self): - output = self.engine.render_to_string('time03', {'t': time(4, 0, tzinfo=timezone.get_fixed_timezone(30))}) - self.assertEqual(output, '4 a.m.::::') + output = self.engine.render_to_string( + "time03", {"t": time(4, 0, tzinfo=timezone.get_fixed_timezone(30))} + ) + self.assertEqual(output, "4 a.m.::::") - @setup({'time04': '{{ t|time:"P:e:O:T:Z" }}'}) + @setup({"time04": '{{ t|time:"P:e:O:T:Z" }}'}) def test_time04(self): - output = self.engine.render_to_string('time04', {'t': time(4, 0)}) - self.assertEqual(output, '4 a.m.::::') + output = self.engine.render_to_string("time04", {"t": time(4, 0)}) + self.assertEqual(output, "4 a.m.::::") - @setup({'time05': '{{ d|time:"P:e:O:T:Z" }}'}) + @setup({"time05": '{{ d|time:"P:e:O:T:Z" }}'}) def test_time05(self): - output = self.engine.render_to_string('time05', {'d': self.today}) - self.assertEqual(output, '') + output = self.engine.render_to_string("time05", {"d": self.today}) + self.assertEqual(output, "") - @setup({'time06': '{{ obj|time:"P:e:O:T:Z" }}'}) + @setup({"time06": '{{ obj|time:"P:e:O:T:Z" }}'}) def test_time06(self): - output = self.engine.render_to_string('time06', {'obj': 'non-datetime-value'}) - self.assertEqual(output, '') + output = self.engine.render_to_string("time06", {"obj": "non-datetime-value"}) + self.assertEqual(output, "") class FunctionTests(SimpleTestCase): - def test_no_args(self): - self.assertEqual(time_filter(''), '') - self.assertEqual(time_filter(None), '') + self.assertEqual(time_filter(""), "") + self.assertEqual(time_filter(None), "") def test_inputs(self): - self.assertEqual(time_filter(time(13), 'h'), '01') - self.assertEqual(time_filter(time(0), 'h'), '12') + self.assertEqual(time_filter(time(13), "h"), "01") + self.assertEqual(time_filter(time(0), "h"), "12") diff --git a/tests/template_tests/filter_tests/test_timesince.py b/tests/template_tests/filter_tests/test_timesince.py index 7fe4831d61..10e4e51d89 100644 --- a/tests/template_tests/filter_tests/test_timesince.py +++ b/tests/template_tests/filter_tests/test_timesince.py @@ -14,125 +14,148 @@ class TimesinceTests(TimezoneTestCase): """ # Default compare with datetime.now() - @setup({'timesince01': '{{ a|timesince }}'}) + @setup({"timesince01": "{{ a|timesince }}"}) def test_timesince01(self): output = self.engine.render_to_string( - 'timesince01', {'a': datetime.now() + timedelta(minutes=-1, seconds=-10)} + "timesince01", {"a": datetime.now() + timedelta(minutes=-1, seconds=-10)} ) - self.assertEqual(output, '1\xa0minute') + self.assertEqual(output, "1\xa0minute") - @setup({'timesince02': '{{ a|timesince }}'}) + @setup({"timesince02": "{{ a|timesince }}"}) def test_timesince02(self): output = self.engine.render_to_string( - 'timesince02', {'a': datetime.now() - timedelta(days=1, minutes=1)} + "timesince02", {"a": datetime.now() - timedelta(days=1, minutes=1)} ) - self.assertEqual(output, '1\xa0day') + self.assertEqual(output, "1\xa0day") - @setup({'timesince03': '{{ a|timesince }}'}) + @setup({"timesince03": "{{ a|timesince }}"}) def test_timesince03(self): output = self.engine.render_to_string( - 'timesince03', {'a': datetime.now() - timedelta(hours=1, minutes=25, seconds=10)} + "timesince03", + {"a": datetime.now() - timedelta(hours=1, minutes=25, seconds=10)}, ) - self.assertEqual(output, '1\xa0hour, 25\xa0minutes') + self.assertEqual(output, "1\xa0hour, 25\xa0minutes") # Compare to a given parameter - @setup({'timesince04': '{{ a|timesince:b }}'}) + @setup({"timesince04": "{{ a|timesince:b }}"}) def test_timesince04(self): output = self.engine.render_to_string( - 'timesince04', - {'a': self.now - timedelta(days=2), 'b': self.now - timedelta(days=1)}, + "timesince04", + {"a": self.now - timedelta(days=2), "b": self.now - timedelta(days=1)}, ) - self.assertEqual(output, '1\xa0day') + self.assertEqual(output, "1\xa0day") - @setup({'timesince05': '{{ a|timesince:b }}'}) + @setup({"timesince05": "{{ a|timesince:b }}"}) def test_timesince05(self): output = self.engine.render_to_string( - 'timesince05', - {'a': self.now - timedelta(days=2, minutes=1), 'b': self.now - timedelta(days=2)}, + "timesince05", + { + "a": self.now - timedelta(days=2, minutes=1), + "b": self.now - timedelta(days=2), + }, ) - self.assertEqual(output, '1\xa0minute') + self.assertEqual(output, "1\xa0minute") # Timezone is respected - @setup({'timesince06': '{{ a|timesince:b }}'}) + @setup({"timesince06": "{{ a|timesince:b }}"}) def test_timesince06(self): - output = self.engine.render_to_string('timesince06', {'a': self.now_tz - timedelta(hours=8), 'b': self.now_tz}) - self.assertEqual(output, '8\xa0hours') + output = self.engine.render_to_string( + "timesince06", {"a": self.now_tz - timedelta(hours=8), "b": self.now_tz} + ) + self.assertEqual(output, "8\xa0hours") # Tests for #7443 - @setup({'timesince07': '{{ earlier|timesince }}'}) + @setup({"timesince07": "{{ earlier|timesince }}"}) def test_timesince07(self): - output = self.engine.render_to_string('timesince07', {'earlier': self.now - timedelta(days=7)}) - self.assertEqual(output, '1\xa0week') + output = self.engine.render_to_string( + "timesince07", {"earlier": self.now - timedelta(days=7)} + ) + self.assertEqual(output, "1\xa0week") - @setup({'timesince08': '{{ earlier|timesince:now }}'}) + @setup({"timesince08": "{{ earlier|timesince:now }}"}) def test_timesince08(self): output = self.engine.render_to_string( - 'timesince08', {'now': self.now, 'earlier': self.now - timedelta(days=7)} + "timesince08", {"now": self.now, "earlier": self.now - timedelta(days=7)} ) - self.assertEqual(output, '1\xa0week') + self.assertEqual(output, "1\xa0week") - @setup({'timesince09': '{{ later|timesince }}'}) + @setup({"timesince09": "{{ later|timesince }}"}) def test_timesince09(self): - output = self.engine.render_to_string('timesince09', {'later': self.now + timedelta(days=7)}) - self.assertEqual(output, '0\xa0minutes') + output = self.engine.render_to_string( + "timesince09", {"later": self.now + timedelta(days=7)} + ) + self.assertEqual(output, "0\xa0minutes") - @setup({'timesince10': '{{ later|timesince:now }}'}) + @setup({"timesince10": "{{ later|timesince:now }}"}) def test_timesince10(self): - output = self.engine.render_to_string('timesince10', {'now': self.now, 'later': self.now + timedelta(days=7)}) - self.assertEqual(output, '0\xa0minutes') + output = self.engine.render_to_string( + "timesince10", {"now": self.now, "later": self.now + timedelta(days=7)} + ) + self.assertEqual(output, "0\xa0minutes") # Differing timezones are calculated correctly. - @setup({'timesince11': '{{ a|timesince }}'}) + @setup({"timesince11": "{{ a|timesince }}"}) def test_timesince11(self): - output = self.engine.render_to_string('timesince11', {'a': self.now}) - self.assertEqual(output, '0\xa0minutes') + output = self.engine.render_to_string("timesince11", {"a": self.now}) + self.assertEqual(output, "0\xa0minutes") @requires_tz_support - @setup({'timesince12': '{{ a|timesince }}'}) + @setup({"timesince12": "{{ a|timesince }}"}) def test_timesince12(self): - output = self.engine.render_to_string('timesince12', {'a': self.now_tz}) - self.assertEqual(output, '0\xa0minutes') + output = self.engine.render_to_string("timesince12", {"a": self.now_tz}) + self.assertEqual(output, "0\xa0minutes") @requires_tz_support - @setup({'timesince13': '{{ a|timesince }}'}) + @setup({"timesince13": "{{ a|timesince }}"}) def test_timesince13(self): - output = self.engine.render_to_string('timesince13', {'a': self.now_tz_i}) - self.assertEqual(output, '0\xa0minutes') + output = self.engine.render_to_string("timesince13", {"a": self.now_tz_i}) + self.assertEqual(output, "0\xa0minutes") - @setup({'timesince14': '{{ a|timesince:b }}'}) + @setup({"timesince14": "{{ a|timesince:b }}"}) def test_timesince14(self): - output = self.engine.render_to_string('timesince14', {'a': self.now_tz, 'b': self.now_tz_i}) - self.assertEqual(output, '0\xa0minutes') + output = self.engine.render_to_string( + "timesince14", {"a": self.now_tz, "b": self.now_tz_i} + ) + self.assertEqual(output, "0\xa0minutes") - @setup({'timesince15': '{{ a|timesince:b }}'}) + @setup({"timesince15": "{{ a|timesince:b }}"}) def test_timesince15(self): - output = self.engine.render_to_string('timesince15', {'a': self.now, 'b': self.now_tz_i}) - self.assertEqual(output, '') + output = self.engine.render_to_string( + "timesince15", {"a": self.now, "b": self.now_tz_i} + ) + self.assertEqual(output, "") - @setup({'timesince16': '{{ a|timesince:b }}'}) + @setup({"timesince16": "{{ a|timesince:b }}"}) def test_timesince16(self): - output = self.engine.render_to_string('timesince16', {'a': self.now_tz_i, 'b': self.now}) - self.assertEqual(output, '') + output = self.engine.render_to_string( + "timesince16", {"a": self.now_tz_i, "b": self.now} + ) + self.assertEqual(output, "") # Tests for #9065 (two date objects). - @setup({'timesince17': '{{ a|timesince:b }}'}) + @setup({"timesince17": "{{ a|timesince:b }}"}) def test_timesince17(self): - output = self.engine.render_to_string('timesince17', {'a': self.today, 'b': self.today}) - self.assertEqual(output, '0\xa0minutes') + output = self.engine.render_to_string( + "timesince17", {"a": self.today, "b": self.today} + ) + self.assertEqual(output, "0\xa0minutes") - @setup({'timesince18': '{{ a|timesince:b }}'}) + @setup({"timesince18": "{{ a|timesince:b }}"}) def test_timesince18(self): - output = self.engine.render_to_string('timesince18', {'a': self.today, 'b': self.today + timedelta(hours=24)}) - self.assertEqual(output, '1\xa0day') + output = self.engine.render_to_string( + "timesince18", {"a": self.today, "b": self.today + timedelta(hours=24)} + ) + self.assertEqual(output, "1\xa0day") class FunctionTests(SimpleTestCase): - def test_since_now(self): - self.assertEqual(timesince_filter(datetime.now() - timedelta(1)), '1\xa0day') + self.assertEqual(timesince_filter(datetime.now() - timedelta(1)), "1\xa0day") def test_no_args(self): - self.assertEqual(timesince_filter(None), '') + self.assertEqual(timesince_filter(None), "") def test_explicit_date(self): - self.assertEqual(timesince_filter(datetime(2005, 12, 29), datetime(2005, 12, 30)), '1\xa0day') + self.assertEqual( + timesince_filter(datetime(2005, 12, 29), datetime(2005, 12, 30)), "1\xa0day" + ) diff --git a/tests/template_tests/filter_tests/test_timeuntil.py b/tests/template_tests/filter_tests/test_timeuntil.py index f3a211c626..1df5a24d15 100644 --- a/tests/template_tests/filter_tests/test_timeuntil.py +++ b/tests/template_tests/filter_tests/test_timeuntil.py @@ -11,110 +11,135 @@ from .timezone_utils import TimezoneTestCase class TimeuntilTests(TimezoneTestCase): # Default compare with datetime.now() - @setup({'timeuntil01': '{{ a|timeuntil }}'}) + @setup({"timeuntil01": "{{ a|timeuntil }}"}) def test_timeuntil01(self): - output = self.engine.render_to_string('timeuntil01', {'a': datetime.now() + timedelta(minutes=2, seconds=10)}) - self.assertEqual(output, '2\xa0minutes') + output = self.engine.render_to_string( + "timeuntil01", {"a": datetime.now() + timedelta(minutes=2, seconds=10)} + ) + self.assertEqual(output, "2\xa0minutes") - @setup({'timeuntil02': '{{ a|timeuntil }}'}) + @setup({"timeuntil02": "{{ a|timeuntil }}"}) def test_timeuntil02(self): - output = self.engine.render_to_string('timeuntil02', {'a': (datetime.now() + timedelta(days=1, seconds=10))}) - self.assertEqual(output, '1\xa0day') + output = self.engine.render_to_string( + "timeuntil02", {"a": (datetime.now() + timedelta(days=1, seconds=10))} + ) + self.assertEqual(output, "1\xa0day") - @setup({'timeuntil03': '{{ a|timeuntil }}'}) + @setup({"timeuntil03": "{{ a|timeuntil }}"}) def test_timeuntil03(self): output = self.engine.render_to_string( - 'timeuntil03', {'a': (datetime.now() + timedelta(hours=8, minutes=10, seconds=10))} + "timeuntil03", + {"a": (datetime.now() + timedelta(hours=8, minutes=10, seconds=10))}, ) - self.assertEqual(output, '8\xa0hours, 10\xa0minutes') + self.assertEqual(output, "8\xa0hours, 10\xa0minutes") # Compare to a given parameter - @setup({'timeuntil04': '{{ a|timeuntil:b }}'}) + @setup({"timeuntil04": "{{ a|timeuntil:b }}"}) def test_timeuntil04(self): output = self.engine.render_to_string( - 'timeuntil04', - {'a': self.now - timedelta(days=1), 'b': self.now - timedelta(days=2)}, + "timeuntil04", + {"a": self.now - timedelta(days=1), "b": self.now - timedelta(days=2)}, ) - self.assertEqual(output, '1\xa0day') + self.assertEqual(output, "1\xa0day") - @setup({'timeuntil05': '{{ a|timeuntil:b }}'}) + @setup({"timeuntil05": "{{ a|timeuntil:b }}"}) def test_timeuntil05(self): output = self.engine.render_to_string( - 'timeuntil05', - {'a': self.now - timedelta(days=2), 'b': self.now - timedelta(days=2, minutes=1)}, + "timeuntil05", + { + "a": self.now - timedelta(days=2), + "b": self.now - timedelta(days=2, minutes=1), + }, ) - self.assertEqual(output, '1\xa0minute') + self.assertEqual(output, "1\xa0minute") # Regression for #7443 - @setup({'timeuntil06': '{{ earlier|timeuntil }}'}) + @setup({"timeuntil06": "{{ earlier|timeuntil }}"}) def test_timeuntil06(self): - output = self.engine.render_to_string('timeuntil06', {'earlier': self.now - timedelta(days=7)}) - self.assertEqual(output, '0\xa0minutes') + output = self.engine.render_to_string( + "timeuntil06", {"earlier": self.now - timedelta(days=7)} + ) + self.assertEqual(output, "0\xa0minutes") - @setup({'timeuntil07': '{{ earlier|timeuntil:now }}'}) + @setup({"timeuntil07": "{{ earlier|timeuntil:now }}"}) def test_timeuntil07(self): output = self.engine.render_to_string( - 'timeuntil07', {'now': self.now, 'earlier': self.now - timedelta(days=7)} + "timeuntil07", {"now": self.now, "earlier": self.now - timedelta(days=7)} ) - self.assertEqual(output, '0\xa0minutes') + self.assertEqual(output, "0\xa0minutes") - @setup({'timeuntil08': '{{ later|timeuntil }}'}) + @setup({"timeuntil08": "{{ later|timeuntil }}"}) def test_timeuntil08(self): - output = self.engine.render_to_string('timeuntil08', {'later': self.now + timedelta(days=7, hours=1)}) - self.assertEqual(output, '1\xa0week') + output = self.engine.render_to_string( + "timeuntil08", {"later": self.now + timedelta(days=7, hours=1)} + ) + self.assertEqual(output, "1\xa0week") - @setup({'timeuntil09': '{{ later|timeuntil:now }}'}) + @setup({"timeuntil09": "{{ later|timeuntil:now }}"}) def test_timeuntil09(self): - output = self.engine.render_to_string('timeuntil09', {'now': self.now, 'later': self.now + timedelta(days=7)}) - self.assertEqual(output, '1\xa0week') + output = self.engine.render_to_string( + "timeuntil09", {"now": self.now, "later": self.now + timedelta(days=7)} + ) + self.assertEqual(output, "1\xa0week") # Differing timezones are calculated correctly. @requires_tz_support - @setup({'timeuntil10': '{{ a|timeuntil }}'}) + @setup({"timeuntil10": "{{ a|timeuntil }}"}) def test_timeuntil10(self): - output = self.engine.render_to_string('timeuntil10', {'a': self.now_tz}) - self.assertEqual(output, '0\xa0minutes') + output = self.engine.render_to_string("timeuntil10", {"a": self.now_tz}) + self.assertEqual(output, "0\xa0minutes") @requires_tz_support - @setup({'timeuntil11': '{{ a|timeuntil }}'}) + @setup({"timeuntil11": "{{ a|timeuntil }}"}) def test_timeuntil11(self): - output = self.engine.render_to_string('timeuntil11', {'a': self.now_tz_i}) - self.assertEqual(output, '0\xa0minutes') + output = self.engine.render_to_string("timeuntil11", {"a": self.now_tz_i}) + self.assertEqual(output, "0\xa0minutes") - @setup({'timeuntil12': '{{ a|timeuntil:b }}'}) + @setup({"timeuntil12": "{{ a|timeuntil:b }}"}) def test_timeuntil12(self): - output = self.engine.render_to_string('timeuntil12', {'a': self.now_tz_i, 'b': self.now_tz}) - self.assertEqual(output, '0\xa0minutes') + output = self.engine.render_to_string( + "timeuntil12", {"a": self.now_tz_i, "b": self.now_tz} + ) + self.assertEqual(output, "0\xa0minutes") # Regression for #9065 (two date objects). - @setup({'timeuntil13': '{{ a|timeuntil:b }}'}) + @setup({"timeuntil13": "{{ a|timeuntil:b }}"}) def test_timeuntil13(self): - output = self.engine.render_to_string('timeuntil13', {'a': self.today, 'b': self.today}) - self.assertEqual(output, '0\xa0minutes') + output = self.engine.render_to_string( + "timeuntil13", {"a": self.today, "b": self.today} + ) + self.assertEqual(output, "0\xa0minutes") - @setup({'timeuntil14': '{{ a|timeuntil:b }}'}) + @setup({"timeuntil14": "{{ a|timeuntil:b }}"}) def test_timeuntil14(self): - output = self.engine.render_to_string('timeuntil14', {'a': self.today, 'b': self.today - timedelta(hours=24)}) - self.assertEqual(output, '1\xa0day') + output = self.engine.render_to_string( + "timeuntil14", {"a": self.today, "b": self.today - timedelta(hours=24)} + ) + self.assertEqual(output, "1\xa0day") - @setup({'timeuntil15': '{{ a|timeuntil:b }}'}) + @setup({"timeuntil15": "{{ a|timeuntil:b }}"}) def test_naive_aware_type_error(self): - output = self.engine.render_to_string('timeuntil15', {'a': self.now, 'b': self.now_tz_i}) - self.assertEqual(output, '') + output = self.engine.render_to_string( + "timeuntil15", {"a": self.now, "b": self.now_tz_i} + ) + self.assertEqual(output, "") - @setup({'timeuntil16': '{{ a|timeuntil:b }}'}) + @setup({"timeuntil16": "{{ a|timeuntil:b }}"}) def test_aware_naive_type_error(self): - output = self.engine.render_to_string('timeuntil16', {'a': self.now_tz_i, 'b': self.now}) - self.assertEqual(output, '') + output = self.engine.render_to_string( + "timeuntil16", {"a": self.now_tz_i, "b": self.now} + ) + self.assertEqual(output, "") class FunctionTests(SimpleTestCase): - def test_until_now(self): - self.assertEqual(timeuntil_filter(datetime.now() + timedelta(1, 1)), '1\xa0day') + self.assertEqual(timeuntil_filter(datetime.now() + timedelta(1, 1)), "1\xa0day") def test_no_args(self): - self.assertEqual(timeuntil_filter(None), '') + self.assertEqual(timeuntil_filter(None), "") def test_explicit_date(self): - self.assertEqual(timeuntil_filter(datetime(2005, 12, 30), datetime(2005, 12, 29)), '1\xa0day') + self.assertEqual( + timeuntil_filter(datetime(2005, 12, 30), datetime(2005, 12, 29)), "1\xa0day" + ) diff --git a/tests/template_tests/filter_tests/test_title.py b/tests/template_tests/filter_tests/test_title.py index 2eaf4a0219..ad2c7c9b28 100644 --- a/tests/template_tests/filter_tests/test_title.py +++ b/tests/template_tests/filter_tests/test_title.py @@ -5,25 +5,23 @@ from ..utils import setup class TitleTests(SimpleTestCase): - - @setup({'title1': '{{ a|title }}'}) + @setup({"title1": "{{ a|title }}"}) def test_title1(self): - output = self.engine.render_to_string('title1', {'a': 'JOE\'S CRAB SHACK'}) - self.assertEqual(output, 'Joe's Crab Shack') + output = self.engine.render_to_string("title1", {"a": "JOE'S CRAB SHACK"}) + self.assertEqual(output, "Joe's Crab Shack") - @setup({'title2': '{{ a|title }}'}) + @setup({"title2": "{{ a|title }}"}) def test_title2(self): - output = self.engine.render_to_string('title2', {'a': '555 WEST 53RD STREET'}) - self.assertEqual(output, '555 West 53rd Street') + output = self.engine.render_to_string("title2", {"a": "555 WEST 53RD STREET"}) + self.assertEqual(output, "555 West 53rd Street") class FunctionTests(SimpleTestCase): - def test_title(self): - self.assertEqual(title('a nice title, isn\'t it?'), "A Nice Title, Isn't It?") + self.assertEqual(title("a nice title, isn't it?"), "A Nice Title, Isn't It?") def test_unicode(self): - self.assertEqual(title('discoth\xe8que'), 'Discoth\xe8que') + self.assertEqual(title("discoth\xe8que"), "Discoth\xe8que") def test_non_string_input(self): - self.assertEqual(title(123), '123') + self.assertEqual(title(123), "123") diff --git a/tests/template_tests/filter_tests/test_truncatechars.py b/tests/template_tests/filter_tests/test_truncatechars.py index 89d48fd1cf..a444125cf8 100644 --- a/tests/template_tests/filter_tests/test_truncatechars.py +++ b/tests/template_tests/filter_tests/test_truncatechars.py @@ -4,18 +4,21 @@ from ..utils import setup class TruncatecharsTests(SimpleTestCase): - - @setup({'truncatechars01': '{{ a|truncatechars:3 }}'}) + @setup({"truncatechars01": "{{ a|truncatechars:3 }}"}) def test_truncatechars01(self): - output = self.engine.render_to_string('truncatechars01', {'a': 'Testing, testing'}) - self.assertEqual(output, 'Te…') + output = self.engine.render_to_string( + "truncatechars01", {"a": "Testing, testing"} + ) + self.assertEqual(output, "Te…") - @setup({'truncatechars02': '{{ a|truncatechars:7 }}'}) + @setup({"truncatechars02": "{{ a|truncatechars:7 }}"}) def test_truncatechars02(self): - output = self.engine.render_to_string('truncatechars02', {'a': 'Testing'}) - self.assertEqual(output, 'Testing') + output = self.engine.render_to_string("truncatechars02", {"a": "Testing"}) + self.assertEqual(output, "Testing") - @setup({'truncatechars03': "{{ a|truncatechars:'e' }}"}) + @setup({"truncatechars03": "{{ a|truncatechars:'e' }}"}) def test_fail_silently_incorrect_arg(self): - output = self.engine.render_to_string('truncatechars03', {'a': 'Testing, testing'}) - self.assertEqual(output, 'Testing, testing') + output = self.engine.render_to_string( + "truncatechars03", {"a": "Testing, testing"} + ) + self.assertEqual(output, "Testing, testing") diff --git a/tests/template_tests/filter_tests/test_truncatechars_html.py b/tests/template_tests/filter_tests/test_truncatechars_html.py index 4948e6534e..6c5fc3c883 100644 --- a/tests/template_tests/filter_tests/test_truncatechars_html.py +++ b/tests/template_tests/filter_tests/test_truncatechars_html.py @@ -3,34 +3,46 @@ from django.test import SimpleTestCase class FunctionTests(SimpleTestCase): - def test_truncate_zero(self): - self.assertEqual(truncatechars_html('

one two - three
four five

', 0), '…') + self.assertEqual( + truncatechars_html( + '

one two - three
four five

', 0 + ), + "…", + ) def test_truncate(self): self.assertEqual( - truncatechars_html('

one two - three
four five

', 4), - '

one…

', + truncatechars_html( + '

one two - three
four five

', 4 + ), + "

one…

", ) def test_truncate2(self): self.assertEqual( - truncatechars_html('

one two - three
four five

', 9), + truncatechars_html( + '

one two - three
four five

', 9 + ), '

one two …

', ) def test_truncate3(self): self.assertEqual( - truncatechars_html('

one two - three
four five

', 100), + truncatechars_html( + '

one two - three
four five

', 100 + ), '

one two - three
four five

', ) def test_truncate_unicode(self): - self.assertEqual(truncatechars_html('\xc5ngstr\xf6m was here', 3), '\xc5n…') + self.assertEqual( + truncatechars_html("\xc5ngstr\xf6m was here", 3), "\xc5n…" + ) def test_truncate_something(self): - self.assertEqual(truncatechars_html('abc', 3), 'abc') + self.assertEqual(truncatechars_html("abc", 3), "abc") def test_invalid_arg(self): html = '

one two - three
four five

' - self.assertEqual(truncatechars_html(html, 'a'), html) + self.assertEqual(truncatechars_html(html, "a"), html) diff --git a/tests/template_tests/filter_tests/test_truncatewords.py b/tests/template_tests/filter_tests/test_truncatewords.py index 636cd55fd5..b3457205ac 100644 --- a/tests/template_tests/filter_tests/test_truncatewords.py +++ b/tests/template_tests/filter_tests/test_truncatewords.py @@ -6,46 +6,48 @@ from ..utils import setup class TruncatewordsTests(SimpleTestCase): - - @setup({ - 'truncatewords01': '{% autoescape off %}{{ a|truncatewords:"2" }} {{ b|truncatewords:"2"}}{% endautoescape %}' - }) + @setup( + { + "truncatewords01": '{% autoescape off %}{{ a|truncatewords:"2" }} {{ b|truncatewords:"2"}}{% endautoescape %}' + } + ) def test_truncatewords01(self): output = self.engine.render_to_string( - 'truncatewords01', {'a': 'alpha & bravo', 'b': mark_safe('alpha & bravo')} + "truncatewords01", + {"a": "alpha & bravo", "b": mark_safe("alpha & bravo")}, ) - self.assertEqual(output, 'alpha & … alpha & …') + self.assertEqual(output, "alpha & … alpha & …") - @setup({'truncatewords02': '{{ a|truncatewords:"2" }} {{ b|truncatewords:"2"}}'}) + @setup({"truncatewords02": '{{ a|truncatewords:"2" }} {{ b|truncatewords:"2"}}'}) def test_truncatewords02(self): output = self.engine.render_to_string( - 'truncatewords02', {'a': 'alpha & bravo', 'b': mark_safe('alpha & bravo')} + "truncatewords02", + {"a": "alpha & bravo", "b": mark_safe("alpha & bravo")}, ) - self.assertEqual(output, 'alpha & … alpha & …') + self.assertEqual(output, "alpha & … alpha & …") class FunctionTests(SimpleTestCase): - def test_truncate(self): - self.assertEqual(truncatewords('A sentence with a few words in it', 1), 'A …') + self.assertEqual(truncatewords("A sentence with a few words in it", 1), "A …") def test_truncate2(self): self.assertEqual( - truncatewords('A sentence with a few words in it', 5), - 'A sentence with a few …', + truncatewords("A sentence with a few words in it", 5), + "A sentence with a few …", ) def test_overtruncate(self): self.assertEqual( - truncatewords('A sentence with a few words in it', 100), - 'A sentence with a few words in it', + truncatewords("A sentence with a few words in it", 100), + "A sentence with a few words in it", ) def test_invalid_number(self): self.assertEqual( - truncatewords('A sentence with a few words in it', 'not a number'), - 'A sentence with a few words in it', + truncatewords("A sentence with a few words in it", "not a number"), + "A sentence with a few words in it", ) def test_non_string_input(self): - self.assertEqual(truncatewords(123, 2), '123') + self.assertEqual(truncatewords(123, 2), "123") diff --git a/tests/template_tests/filter_tests/test_truncatewords_html.py b/tests/template_tests/filter_tests/test_truncatewords_html.py index 6177fc875d..32b7c81a76 100644 --- a/tests/template_tests/filter_tests/test_truncatewords_html.py +++ b/tests/template_tests/filter_tests/test_truncatewords_html.py @@ -3,42 +3,58 @@ from django.test import SimpleTestCase class FunctionTests(SimpleTestCase): - def test_truncate_zero(self): - self.assertEqual(truncatewords_html('

one two - three
four five

', 0), '') + self.assertEqual( + truncatewords_html( + '

one two - three
four five

', 0 + ), + "", + ) def test_truncate(self): self.assertEqual( - truncatewords_html('

one two - three
four five

', 2), + truncatewords_html( + '

one two - three
four five

', 2 + ), '

one two …

', ) def test_truncate2(self): self.assertEqual( - truncatewords_html('

one two - three
four five

', 4), + truncatewords_html( + '

one two - three
four five

', 4 + ), '

one two - three …

', ) def test_truncate3(self): self.assertEqual( - truncatewords_html('

one two - three
four five

', 5), + truncatewords_html( + '

one two - three
four five

', 5 + ), '

one two - three
four …

', ) def test_truncate4(self): self.assertEqual( - truncatewords_html('

one two - three
four five

', 100), + truncatewords_html( + '

one two - three
four five

', 100 + ), '

one two - three
four five

', ) def test_truncate_unicode(self): - self.assertEqual(truncatewords_html('\xc5ngstr\xf6m was here', 1), '\xc5ngstr\xf6m …') + self.assertEqual( + truncatewords_html("\xc5ngstr\xf6m was here", 1), "\xc5ngstr\xf6m …" + ) def test_truncate_complex(self): self.assertEqual( - truncatewords_html('Buenos días! ¿Cómo está?', 3), - 'Buenos días! ¿Cómo …', + truncatewords_html( + "Buenos días! ¿Cómo está?", 3 + ), + "Buenos días! ¿Cómo …", ) def test_invalid_arg(self): - self.assertEqual(truncatewords_html('

string

', 'a'), '

string

') + self.assertEqual(truncatewords_html("

string

", "a"), "

string

") diff --git a/tests/template_tests/filter_tests/test_unordered_list.py b/tests/template_tests/filter_tests/test_unordered_list.py index 6a04664d99..1f08ea790d 100644 --- a/tests/template_tests/filter_tests/test_unordered_list.py +++ b/tests/template_tests/filter_tests/test_unordered_list.py @@ -7,90 +7,110 @@ from ..utils import setup class UnorderedListTests(SimpleTestCase): - - @setup({'unordered_list01': '{{ a|unordered_list }}'}) + @setup({"unordered_list01": "{{ a|unordered_list }}"}) def test_unordered_list01(self): - output = self.engine.render_to_string('unordered_list01', {'a': ['x>', ['x>\n\t
    \n\t\t
  • <y
    • \n\t
\n\t') + output = self.engine.render_to_string("unordered_list01", {"a": ["x>", ["x>\n\t
    \n\t\t
  • <y
    • \n\t
\n\t" + ) - @setup({'unordered_list02': '{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}'}) + @setup( + { + "unordered_list02": "{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}" + } + ) def test_unordered_list02(self): - output = self.engine.render_to_string('unordered_list02', {'a': ['x>', ['x>\n\t
    \n\t\t
  • \n\t
\n\t') + output = self.engine.render_to_string("unordered_list02", {"a": ["x>", ["x>\n\t
    \n\t\t
  • \n\t
\n\t") - @setup({'unordered_list03': '{{ a|unordered_list }}'}) + @setup({"unordered_list03": "{{ a|unordered_list }}"}) def test_unordered_list03(self): - output = self.engine.render_to_string('unordered_list03', {'a': ['x>', [mark_safe('x>\n\t
    \n\t\t
  • \n\t
\n\t') + output = self.engine.render_to_string( + "unordered_list03", {"a": ["x>", [mark_safe("x>\n\t
    \n\t\t
  • \n\t
\n\t" + ) - @setup({'unordered_list04': '{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}'}) + @setup( + { + "unordered_list04": "{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}" + } + ) def test_unordered_list04(self): - output = self.engine.render_to_string('unordered_list04', {'a': ['x>', [mark_safe('x>\n\t
    \n\t\t
  • \n\t
\n\t') + output = self.engine.render_to_string( + "unordered_list04", {"a": ["x>", [mark_safe("x>\n\t
    \n\t\t
  • \n\t
\n\t") - @setup({'unordered_list05': '{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}'}) + @setup( + { + "unordered_list05": "{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}" + } + ) def test_unordered_list05(self): - output = self.engine.render_to_string('unordered_list05', {'a': ['x>', ['x>\n\t
    \n\t\t
  • \n\t
\n\t') + output = self.engine.render_to_string("unordered_list05", {"a": ["x>", ["x>\n\t
    \n\t\t
  • \n\t
\n\t") class FunctionTests(SimpleTestCase): - def test_list(self): - self.assertEqual(unordered_list(['item 1', 'item 2']), '\t
  • item 1
    • \n\t
  • item 2
    • ') + self.assertEqual( + unordered_list(["item 1", "item 2"]), "\t
  • item 1
    • \n\t
  • item 2
    • " + ) def test_list_gettext(self): self.assertEqual( - unordered_list(['item 1', gettext_lazy('item 2')]), - '\t
  • item 1
    • \n\t
  • item 2
    • ' + unordered_list(["item 1", gettext_lazy("item 2")]), + "\t
  • item 1
    • \n\t
  • item 2
    • ", ) def test_nested(self): self.assertEqual( - unordered_list(['item 1', ['item 1.1']]), - '\t
  • item 1\n\t
      \n\t\t
    • item 1.1
      • \n\t
    \n\t
    • ', + unordered_list(["item 1", ["item 1.1"]]), + "\t
  • item 1\n\t
      \n\t\t
    • item 1.1
      • \n\t
    \n\t
    • ", ) def test_nested2(self): self.assertEqual( - unordered_list(['item 1', ['item 1.1', 'item1.2'], 'item 2']), - '\t
  • item 1\n\t
      \n\t\t
    • item 1.1
      • \n\t\t
    • item1.2' - '
      • \n\t
    \n\t
    • \n\t
  • item 2
    • ', + unordered_list(["item 1", ["item 1.1", "item1.2"], "item 2"]), + "\t
  • item 1\n\t
      \n\t\t
    • item 1.1
      • \n\t\t
    • item1.2" + "
      • \n\t
    \n\t
    • \n\t
  • item 2
    • ", ) def test_nested3(self): self.assertEqual( - unordered_list(['item 1', 'item 2', ['item 2.1']]), - '\t
  • item 1
    • \n\t
  • item 2\n\t
      \n\t\t
    • item 2.1' - '
      • \n\t
    \n\t
    • ', + unordered_list(["item 1", "item 2", ["item 2.1"]]), + "\t
  • item 1
    • \n\t
  • item 2\n\t
      \n\t\t
    • item 2.1" + "
      • \n\t
    \n\t
    • ", ) def test_nested_multiple(self): self.assertEqual( - unordered_list(['item 1', ['item 1.1', ['item 1.1.1', ['item 1.1.1.1']]]]), - '\t
  • item 1\n\t
      \n\t\t
    • item 1.1\n\t\t
        \n\t\t\t
      • ' - 'item 1.1.1\n\t\t\t
          \n\t\t\t\t
        • item 1.1.1.1
          • \n\t\t\t' - '
        \n\t\t\t
        • \n\t\t
      \n\t\t
      • \n\t
    \n\t
    • ', + unordered_list(["item 1", ["item 1.1", ["item 1.1.1", ["item 1.1.1.1"]]]]), + "\t
  • item 1\n\t
      \n\t\t
    • item 1.1\n\t\t
        \n\t\t\t
      • " + "item 1.1.1\n\t\t\t
          \n\t\t\t\t
        • item 1.1.1.1
          • \n\t\t\t" + "
        \n\t\t\t
        • \n\t\t
      \n\t\t
      • \n\t
    \n\t
    • ", ) def test_nested_multiple2(self): self.assertEqual( - unordered_list(['States', ['Kansas', ['Lawrence', 'Topeka'], 'Illinois']]), - '\t
  • States\n\t
      \n\t\t
    • Kansas\n\t\t
        \n\t\t\t
      • ' - 'Lawrence
        • \n\t\t\t
      • Topeka
        • \n\t\t
      \n\t\t
      • ' - '\n\t\t
    • Illinois
      • \n\t
    \n\t
    • ', + unordered_list(["States", ["Kansas", ["Lawrence", "Topeka"], "Illinois"]]), + "\t
  • States\n\t
      \n\t\t
    • Kansas\n\t\t
        \n\t\t\t
      • " + "Lawrence
        • \n\t\t\t
      • Topeka
        • \n\t\t
      \n\t\t
      • " + "\n\t\t
    • Illinois
      • \n\t
    \n\t
    • ", ) def test_autoescape(self): self.assertEqual( - unordered_list(['item 1', 'item 2']), - '\t
  • <a>item 1</a>
    • \n\t
  • item 2
    • ', + unordered_list(["item 1", "item 2"]), + "\t
  • <a>item 1</a>
    • \n\t
  • item 2
    • ", ) def test_autoescape_off(self): self.assertEqual( - unordered_list(['item 1', 'item 2'], autoescape=False), - '\t
  • item 1
    • \n\t
  • item 2
    • ', + unordered_list(["item 1", "item 2"], autoescape=False), + "\t
  • item 1
    • \n\t
  • item 2
    • ", ) def test_ulitem(self): @@ -99,14 +119,14 @@ class FunctionTests(SimpleTestCase): self.title = title def __str__(self): - return 'ulitem-%s' % str(self.title) + return "ulitem-%s" % str(self.title) - a = ULItem('a') - b = ULItem('b') - c = ULItem('c') + a = ULItem("a") + b = ULItem("b") + c = ULItem("c") self.assertEqual( unordered_list([a, b, c]), - '\t
  • ulitem-a
    • \n\t
  • ulitem-b
    • \n\t
  • ulitem-<a>c</a>
    • ', + "\t
  • ulitem-a
    • \n\t
  • ulitem-b
    • \n\t
  • ulitem-<a>c</a>
    • ", ) def item_generator(): @@ -114,21 +134,21 @@ class FunctionTests(SimpleTestCase): self.assertEqual( unordered_list(item_generator()), - '\t
  • ulitem-a
    • \n\t
  • ulitem-b
    • \n\t
  • ulitem-<a>c</a>
    • ', + "\t
  • ulitem-a
    • \n\t
  • ulitem-b
    • \n\t
  • ulitem-<a>c</a>
    • ", ) def test_nested_generators(self): def inner_generator(): - yield from ('B', 'C') + yield from ("B", "C") def item_generator(): - yield 'A' + yield "A" yield inner_generator() - yield 'D' + yield "D" self.assertEqual( unordered_list(item_generator()), - '\t
  • A\n\t
      \n\t\t
    • B
      • \n\t\t
    • C
      • \n\t
    \n\t
    • \n\t
  • D
    • ', + "\t
  • A\n\t
      \n\t\t
    • B
      • \n\t\t
    • C
      • \n\t
    \n\t
    • \n\t
  • D
    • ", ) def test_ulitem_autoescape_off(self): @@ -137,14 +157,14 @@ class FunctionTests(SimpleTestCase): self.title = title def __str__(self): - return 'ulitem-%s' % str(self.title) + return "ulitem-%s" % str(self.title) - a = ULItem('a') - b = ULItem('b') - c = ULItem('c') + a = ULItem("a") + b = ULItem("b") + c = ULItem("c") self.assertEqual( unordered_list([a, b, c], autoescape=False), - '\t
  • ulitem-a
    • \n\t
  • ulitem-b
    • \n\t
  • ulitem-c
    • ', + "\t
  • ulitem-a
    • \n\t
  • ulitem-b
    • \n\t
  • ulitem-c
    • ", ) def item_generator(): @@ -152,5 +172,5 @@ class FunctionTests(SimpleTestCase): self.assertEqual( unordered_list(item_generator(), autoescape=False), - '\t
  • ulitem-a
    • \n\t
  • ulitem-b
    • \n\t
  • ulitem-c
    • ', + "\t
  • ulitem-a
    • \n\t
  • ulitem-b
    • \n\t
  • ulitem-c
    • ", ) diff --git a/tests/template_tests/filter_tests/test_upper.py b/tests/template_tests/filter_tests/test_upper.py index a9efaf5322..01a2f306ae 100644 --- a/tests/template_tests/filter_tests/test_upper.py +++ b/tests/template_tests/filter_tests/test_upper.py @@ -11,25 +11,32 @@ class UpperTests(SimpleTestCase): so it's not safe for non-escaping purposes. """ - @setup({'upper01': '{% autoescape off %}{{ a|upper }} {{ b|upper }}{% endautoescape %}'}) + @setup( + { + "upper01": "{% autoescape off %}{{ a|upper }} {{ b|upper }}{% endautoescape %}" + } + ) def test_upper01(self): - output = self.engine.render_to_string('upper01', {'a': 'a & b', 'b': mark_safe('a & b')}) - self.assertEqual(output, 'A & B A & B') + output = self.engine.render_to_string( + "upper01", {"a": "a & b", "b": mark_safe("a & b")} + ) + self.assertEqual(output, "A & B A & B") - @setup({'upper02': '{{ a|upper }} {{ b|upper }}'}) + @setup({"upper02": "{{ a|upper }} {{ b|upper }}"}) def test_upper02(self): - output = self.engine.render_to_string('upper02', {'a': 'a & b', 'b': mark_safe('a & b')}) - self.assertEqual(output, 'A & B A &AMP; B') + output = self.engine.render_to_string( + "upper02", {"a": "a & b", "b": mark_safe("a & b")} + ) + self.assertEqual(output, "A & B A &AMP; B") class FunctionTests(SimpleTestCase): - def test_upper(self): - self.assertEqual(upper('Mixed case input'), 'MIXED CASE INPUT') + self.assertEqual(upper("Mixed case input"), "MIXED CASE INPUT") def test_unicode(self): # lowercase e umlaut - self.assertEqual(upper('\xeb'), '\xcb') + self.assertEqual(upper("\xeb"), "\xcb") def test_non_string_input(self): - self.assertEqual(upper(123), '123') + self.assertEqual(upper(123), "123") diff --git a/tests/template_tests/filter_tests/test_urlencode.py b/tests/template_tests/filter_tests/test_urlencode.py index d095bb8fae..d3c8d2931a 100644 --- a/tests/template_tests/filter_tests/test_urlencode.py +++ b/tests/template_tests/filter_tests/test_urlencode.py @@ -5,22 +5,20 @@ from ..utils import setup class UrlencodeTests(SimpleTestCase): - - @setup({'urlencode01': '{{ url|urlencode }}'}) + @setup({"urlencode01": "{{ url|urlencode }}"}) def test_urlencode01(self): - output = self.engine.render_to_string('urlencode01', {'url': '/test&"/me?/'}) - self.assertEqual(output, '/test%26%22/me%3F/') + output = self.engine.render_to_string("urlencode01", {"url": '/test&"/me?/'}) + self.assertEqual(output, "/test%26%22/me%3F/") - @setup({'urlencode02': '/test/{{ urlbit|urlencode:"" }}/'}) + @setup({"urlencode02": '/test/{{ urlbit|urlencode:"" }}/'}) def test_urlencode02(self): - output = self.engine.render_to_string('urlencode02', {'urlbit': 'escape/slash'}) - self.assertEqual(output, '/test/escape%2Fslash/') + output = self.engine.render_to_string("urlencode02", {"urlbit": "escape/slash"}) + self.assertEqual(output, "/test/escape%2Fslash/") class FunctionTests(SimpleTestCase): - def test_urlencode(self): - self.assertEqual(urlencode('fran\xe7ois & jill'), 'fran%C3%A7ois%20%26%20jill') + self.assertEqual(urlencode("fran\xe7ois & jill"), "fran%C3%A7ois%20%26%20jill") def test_non_string_input(self): - self.assertEqual(urlencode(1), '1') + self.assertEqual(urlencode(1), "1") diff --git a/tests/template_tests/filter_tests/test_urlize.py b/tests/template_tests/filter_tests/test_urlize.py index 7783ed7280..01e97b35fc 100644 --- a/tests/template_tests/filter_tests/test_urlize.py +++ b/tests/template_tests/filter_tests/test_urlize.py @@ -7,73 +7,92 @@ from ..utils import setup class UrlizeTests(SimpleTestCase): - - @setup({'urlize01': '{% autoescape off %}{{ a|urlize }} {{ b|urlize }}{% endautoescape %}'}) + @setup( + { + "urlize01": "{% autoescape off %}{{ a|urlize }} {{ b|urlize }}{% endautoescape %}" + } + ) def test_urlize01(self): output = self.engine.render_to_string( - 'urlize01', - {'a': 'http://example.com/?x=&y=', 'b': mark_safe('http://example.com?x=&y=<2>')}, + "urlize01", + { + "a": "http://example.com/?x=&y=", + "b": mark_safe("http://example.com?x=&y=<2>"), + }, ) self.assertEqual( output, 'http://example.com/?x=&y= ' - 'http://example.com?x=&y=<2>' + 'http://example.com?x=&y=<2>', ) - @setup({'urlize02': '{{ a|urlize }} {{ b|urlize }}'}) + @setup({"urlize02": "{{ a|urlize }} {{ b|urlize }}"}) def test_urlize02(self): output = self.engine.render_to_string( - 'urlize02', - {'a': "http://example.com/?x=&y=", 'b': mark_safe("http://example.com?x=&y=")}, + "urlize02", + { + "a": "http://example.com/?x=&y=", + "b": mark_safe("http://example.com?x=&y="), + }, ) self.assertEqual( output, 'http://example.com/?x=&y= ' - 'http://example.com?x=&y=' + 'http://example.com?x=&y=', ) - @setup({'urlize03': '{% autoescape off %}{{ a|urlize }}{% endautoescape %}'}) + @setup({"urlize03": "{% autoescape off %}{{ a|urlize }}{% endautoescape %}"}) def test_urlize03(self): - output = self.engine.render_to_string('urlize03', {'a': mark_safe("a & b")}) - self.assertEqual(output, 'a & b') + output = self.engine.render_to_string("urlize03", {"a": mark_safe("a & b")}) + self.assertEqual(output, "a & b") - @setup({'urlize04': '{{ a|urlize }}'}) + @setup({"urlize04": "{{ a|urlize }}"}) def test_urlize04(self): - output = self.engine.render_to_string('urlize04', {'a': mark_safe("a & b")}) - self.assertEqual(output, 'a & b') + output = self.engine.render_to_string("urlize04", {"a": mark_safe("a & b")}) + self.assertEqual(output, "a & b") # This will lead to a nonsense result, but at least it won't be # exploitable for XSS purposes when auto-escaping is on. - @setup({'urlize05': '{% autoescape off %}{{ a|urlize }}{% endautoescape %}'}) + @setup({"urlize05": "{% autoescape off %}{{ a|urlize }}{% endautoescape %}"}) def test_urlize05(self): - output = self.engine.render_to_string('urlize05', {'a': ""}) + output = self.engine.render_to_string( + "urlize05", {"a": ""} + ) self.assertEqual(output, "") - @setup({'urlize06': '{{ a|urlize }}'}) + @setup({"urlize06": "{{ a|urlize }}"}) def test_urlize06(self): - output = self.engine.render_to_string('urlize06', {'a': ""}) - self.assertEqual(output, '<script>alert('foo')</script>') + output = self.engine.render_to_string( + "urlize06", {"a": ""} + ) + self.assertEqual(output, "<script>alert('foo')</script>") # mailto: testing for urlize - @setup({'urlize07': '{{ a|urlize }}'}) + @setup({"urlize07": "{{ a|urlize }}"}) def test_urlize07(self): - output = self.engine.render_to_string('urlize07', {'a': "Email me at me@example.com"}) + output = self.engine.render_to_string( + "urlize07", {"a": "Email me at me@example.com"} + ) self.assertEqual( output, 'Email me at me@example.com', ) - @setup({'urlize08': '{{ a|urlize }}'}) + @setup({"urlize08": "{{ a|urlize }}"}) def test_urlize08(self): - output = self.engine.render_to_string('urlize08', {'a': "Email me at "}) + output = self.engine.render_to_string( + "urlize08", {"a": "Email me at "} + ) self.assertEqual( output, 'Email me at <me@example.com>', ) - @setup({'urlize09': '{% autoescape off %}{{ a|urlize }}{% endautoescape %}'}) + @setup({"urlize09": "{% autoescape off %}{{ a|urlize }}{% endautoescape %}"}) def test_urlize09(self): - output = self.engine.render_to_string('urlize09', {'a': "http://example.com/?x=&y=<2>"}) + output = self.engine.render_to_string( + "urlize09", {"a": "http://example.com/?x=&y=<2>"} + ) self.assertEqual( output, 'http://example.com/?x=&y=<2>', @@ -81,26 +100,25 @@ class UrlizeTests(SimpleTestCase): class FunctionTests(SimpleTestCase): - def test_urls(self): self.assertEqual( - urlize('http://google.com'), + urlize("http://google.com"), 'http://google.com', ) self.assertEqual( - urlize('http://google.com/'), + urlize("http://google.com/"), 'http://google.com/', ) self.assertEqual( - urlize('www.google.com'), + urlize("www.google.com"), 'www.google.com', ) self.assertEqual( - urlize('djangoproject.org'), + urlize("djangoproject.org"), 'djangoproject.org', ) self.assertEqual( - urlize('djangoproject.org/'), + urlize("djangoproject.org/"), 'djangoproject.org/', ) @@ -112,30 +130,30 @@ class FunctionTests(SimpleTestCase): 'www.server.com"abc', ) self.assertEqual( - urlize('www.server.com\'abc'), + urlize("www.server.com'abc"), 'www.server.com'abc', ) self.assertEqual( - urlize('www.server.comwww.server.com<abc', ) self.assertEqual( - urlize('www.server.com>abc'), + urlize("www.server.com>abc"), 'www.server.com>abc', ) def test_email(self): self.assertEqual( - urlize('info@djangoproject.org'), + urlize("info@djangoproject.org"), 'info@djangoproject.org', ) def test_word_with_dot(self): - self.assertEqual(urlize('some.organization'), 'some.organization'), + self.assertEqual(urlize("some.organization"), "some.organization"), def test_https(self): self.assertEqual( - urlize('https://google.com'), + urlize("https://google.com"), 'https://google.com', ) @@ -145,28 +163,28 @@ class FunctionTests(SimpleTestCase): teststring is the urlquoted version of 'http://hi.baidu.com/重新开始' """ self.assertEqual( - urlize('http://hi.baidu.com/%E9%87%8D%E6%96%B0%E5%BC%80%E5%A7%8B'), + urlize("http://hi.baidu.com/%E9%87%8D%E6%96%B0%E5%BC%80%E5%A7%8B"), '' - 'http://hi.baidu.com/%E9%87%8D%E6%96%B0%E5%BC%80%E5%A7%8B', + "http://hi.baidu.com/%E9%87%8D%E6%96%B0%E5%BC%80%E5%A7%8B", ) def test_urlencoded(self): self.assertEqual( - urlize('www.mystore.com/30%OffCoupons!'), + urlize("www.mystore.com/30%OffCoupons!"), '' - 'www.mystore.com/30%OffCoupons!', + "www.mystore.com/30%OffCoupons!", ) self.assertEqual( - urlize('https://en.wikipedia.org/wiki/Caf%C3%A9'), + urlize("https://en.wikipedia.org/wiki/Caf%C3%A9"), '' - 'https://en.wikipedia.org/wiki/Caf%C3%A9', + "https://en.wikipedia.org/wiki/Caf%C3%A9", ) def test_unicode(self): self.assertEqual( - urlize('https://en.wikipedia.org/wiki/Café'), + urlize("https://en.wikipedia.org/wiki/Café"), '' - 'https://en.wikipedia.org/wiki/Café', + "https://en.wikipedia.org/wiki/Café", ) def test_parenthesis(self): @@ -174,14 +192,14 @@ class FunctionTests(SimpleTestCase): #11911 - Check urlize keeps balanced parentheses """ self.assertEqual( - urlize('https://en.wikipedia.org/wiki/Django_(web_framework)'), + urlize("https://en.wikipedia.org/wiki/Django_(web_framework)"), '' - 'https://en.wikipedia.org/wiki/Django_(web_framework)', + "https://en.wikipedia.org/wiki/Django_(web_framework)", ) self.assertEqual( - urlize('(see https://en.wikipedia.org/wiki/Django_(web_framework))'), + urlize("(see https://en.wikipedia.org/wiki/Django_(web_framework))"), '(see ' - 'https://en.wikipedia.org/wiki/Django_(web_framework))', + "https://en.wikipedia.org/wiki/Django_(web_framework))", ) def test_nofollow(self): @@ -189,7 +207,7 @@ class FunctionTests(SimpleTestCase): #12183 - Check urlize adds nofollow properly - see #12183 """ self.assertEqual( - urlize('foo@bar.com or www.bar.com'), + urlize("foo@bar.com or www.bar.com"), 'foo@bar.com or ' 'www.bar.com', ) @@ -198,38 +216,50 @@ class FunctionTests(SimpleTestCase): """ #13704 - Check urlize handles IDN correctly """ - self.assertEqual(urlize('http://c✶.ws'), 'http://c✶.ws') - self.assertEqual(urlize('www.c✶.ws'), 'www.c✶.ws') - self.assertEqual(urlize('c✶.org'), 'c✶.org') - self.assertEqual(urlize('info@c✶.org'), 'info@c✶.org') + self.assertEqual( + urlize("http://c✶.ws"), + 'http://c✶.ws', + ) + self.assertEqual( + urlize("www.c✶.ws"), + 'www.c✶.ws', + ) + self.assertEqual( + urlize("c✶.org"), 'c✶.org' + ) + self.assertEqual( + urlize("info@c✶.org"), 'info@c✶.org' + ) def test_malformed(self): """ #16395 - Check urlize doesn't highlight malformed URIs """ - self.assertEqual(urlize('http:///www.google.com'), 'http:///www.google.com') - self.assertEqual(urlize('http://.google.com'), 'http://.google.com') - self.assertEqual(urlize('http://@foo.com'), 'http://@foo.com') + self.assertEqual(urlize("http:///www.google.com"), "http:///www.google.com") + self.assertEqual(urlize("http://.google.com"), "http://.google.com") + self.assertEqual(urlize("http://@foo.com"), "http://@foo.com") def test_tlds(self): """ #16656 - Check urlize accepts more TLDs """ - self.assertEqual(urlize('usa.gov'), 'usa.gov') + self.assertEqual( + urlize("usa.gov"), 'usa.gov' + ) def test_invalid_email(self): """ #17592 - Check urlize don't crash on invalid email with dot-starting domain """ - self.assertEqual(urlize('email@.stream.ru'), 'email@.stream.ru') + self.assertEqual(urlize("email@.stream.ru"), "email@.stream.ru") def test_uppercase(self): """ #18071 - Check urlize accepts uppercased URL schemes """ self.assertEqual( - urlize('HTTPS://github.com/'), + urlize("HTTPS://github.com/"), 'HTTPS://github.com/', ) @@ -238,26 +268,26 @@ class FunctionTests(SimpleTestCase): #18644 - Check urlize trims trailing period when followed by parenthesis """ self.assertEqual( - urlize('(Go to http://www.example.com/foo.)'), + urlize("(Go to http://www.example.com/foo.)"), '(Go to http://www.example.com/foo.)', ) def test_trailing_multiple_punctuation(self): self.assertEqual( - urlize('A test http://testing.com/example..'), - 'A test http://testing.com/example..' + urlize("A test http://testing.com/example.."), + 'A test http://testing.com/example..', ) self.assertEqual( - urlize('A test http://testing.com/example!!'), - 'A test http://testing.com/example!!' + urlize("A test http://testing.com/example!!"), + 'A test http://testing.com/example!!', ) self.assertEqual( - urlize('A test http://testing.com/example!!!'), - 'A test http://testing.com/example!!!' + urlize("A test http://testing.com/example!!!"), + 'A test http://testing.com/example!!!', ) self.assertEqual( urlize('A test http://testing.com/example.,:;)"!'), - 'A test http://testing.com/example.,:;)"!' + 'A test http://testing.com/example.,:;)"!', ) def test_brackets(self): @@ -265,46 +295,46 @@ class FunctionTests(SimpleTestCase): #19070 - Check urlize handles brackets properly """ self.assertEqual( - urlize('[see www.example.com]'), + urlize("[see www.example.com]"), '[see www.example.com]', ) self.assertEqual( - urlize('see test[at[example.com'), + urlize("see test[at[example.com"), 'see test[at[example.com', ) self.assertEqual( - urlize('[http://168.192.0.1](http://168.192.0.1)'), + urlize("[http://168.192.0.1](http://168.192.0.1)"), '[' - 'http://168.192.0.1](http://168.192.0.1)', + "http://168.192.0.1](http://168.192.0.1)", ) def test_wrapping_characters(self): wrapping_chars = ( - ('()', ('(', ')')), - ('<>', ('<', '>')), - ('[]', ('[', ']')), - ('""', ('"', '"')), - ("''", (''', ''')), + ("()", ("(", ")")), + ("<>", ("<", ">")), + ("[]", ("[", "]")), + ('""', (""", """)), + ("''", ("'", "'")), ) for wrapping_in, (start_out, end_out) in wrapping_chars: with self.subTest(wrapping_in=wrapping_in): start_in, end_in = wrapping_in self.assertEqual( - urlize(start_in + 'https://www.example.org/' + end_in), - start_out + - 'https://www.example.org/' + - end_out, + urlize(start_in + "https://www.example.org/" + end_in), + start_out + + 'https://www.example.org/' + + end_out, ) def test_ipv4(self): self.assertEqual( - urlize('http://192.168.0.15/api/9'), + urlize("http://192.168.0.15/api/9"), 'http://192.168.0.15/api/9', ) def test_ipv6(self): self.assertEqual( - urlize('http://[2001:db8:cafe::2]/api/9'), + urlize("http://[2001:db8:cafe::2]/api/9"), 'http://[2001:db8:cafe::2]/api/9', ) @@ -325,15 +355,15 @@ class FunctionTests(SimpleTestCase): 'before "hi@example.com afterward', ) self.assertEqual( - urlize('before \'hi@example.com\' afterward', autoescape=False), - 'before \'hi@example.com\' afterward', + urlize("before 'hi@example.com' afterward", autoescape=False), + "before 'hi@example.com' afterward", ) self.assertEqual( - urlize('before hi@example.com\' afterward', autoescape=False), + urlize("before hi@example.com' afterward", autoescape=False), 'before hi@example.com\' afterward', ) self.assertEqual( - urlize('before \'hi@example.com afterward', autoescape=False), + urlize("before 'hi@example.com afterward", autoescape=False), 'before \'hi@example.com afterward', ) @@ -342,7 +372,9 @@ class FunctionTests(SimpleTestCase): #20364 - Check urlize copes with commas following URLs in quotes """ self.assertEqual( - urlize('Email us at "hi@example.com", or phone us at +xx.yy', autoescape=False), + urlize( + 'Email us at "hi@example.com", or phone us at +xx.yy', autoescape=False + ), 'Email us at "hi@example.com", or phone us at +xx.yy', ) @@ -352,29 +384,29 @@ class FunctionTests(SimpleTestCase): or query string """ self.assertEqual( - urlize('Go to djangoproject.com! and enjoy.'), + urlize("Go to djangoproject.com! and enjoy."), 'Go to djangoproject.com! and enjoy.', ) self.assertEqual( - urlize('Search for google.com/?q=! and see.'), + urlize("Search for google.com/?q=! and see."), 'Search for google.com/?q=! and see.', ) self.assertEqual( - urlize('Search for google.com/?q=dj!`? and see.'), + urlize("Search for google.com/?q=dj!`? and see."), 'Search for google.com/?q=dj!`? and see.', ) self.assertEqual( - urlize('Search for google.com/?q=dj!`?! and see.'), + urlize("Search for google.com/?q=dj!`?! and see."), 'Search for google.com/?q=dj!`?! and see.', ) def test_non_string_input(self): - self.assertEqual(urlize(123), '123') + self.assertEqual(urlize(123), "123") def test_autoescape(self): self.assertEqual( urlize('foobarbuz'), - 'foo<a href=" google.com ">bar</a>buz' + 'foo<a href=" google.com ">bar</a>buz', ) def test_autoescape_off(self): @@ -384,8 +416,8 @@ class FunctionTests(SimpleTestCase): ) def test_lazystring(self): - prepend_www = lazy(lambda url: 'www.' + url, str) + prepend_www = lazy(lambda url: "www." + url, str) self.assertEqual( - urlize(prepend_www('google.com')), + urlize(prepend_www("google.com")), 'www.google.com', ) diff --git a/tests/template_tests/filter_tests/test_urlizetrunc.py b/tests/template_tests/filter_tests/test_urlizetrunc.py index 09bbe776cf..69e4ec4741 100644 --- a/tests/template_tests/filter_tests/test_urlizetrunc.py +++ b/tests/template_tests/filter_tests/test_urlizetrunc.py @@ -6,56 +6,56 @@ from ..utils import setup class UrlizetruncTests(SimpleTestCase): - - @setup({ - 'urlizetrunc01': '{% autoescape off %}{{ a|urlizetrunc:"8" }} {{ b|urlizetrunc:"8" }}{% endautoescape %}' - }) + @setup( + { + "urlizetrunc01": '{% autoescape off %}{{ a|urlizetrunc:"8" }} {{ b|urlizetrunc:"8" }}{% endautoescape %}' + } + ) def test_urlizetrunc01(self): output = self.engine.render_to_string( - 'urlizetrunc01', + "urlizetrunc01", { - 'a': '"Unsafe" http://example.com/x=&y=', - 'b': mark_safe('"Safe" http://example.com?x=&y='), + "a": '"Unsafe" http://example.com/x=&y=', + "b": mark_safe(""Safe" http://example.com?x=&y="), }, ) self.assertEqual( output, '"Unsafe" http://… ' - '"Safe" http://…' + '"Safe" http://…', ) - @setup({'urlizetrunc02': '{{ a|urlizetrunc:"8" }} {{ b|urlizetrunc:"8" }}'}) + @setup({"urlizetrunc02": '{{ a|urlizetrunc:"8" }} {{ b|urlizetrunc:"8" }}'}) def test_urlizetrunc02(self): output = self.engine.render_to_string( - 'urlizetrunc02', + "urlizetrunc02", { - 'a': '"Unsafe" http://example.com/x=&y=', - 'b': mark_safe('"Safe" http://example.com?x=&y='), + "a": '"Unsafe" http://example.com/x=&y=', + "b": mark_safe(""Safe" http://example.com?x=&y="), }, ) self.assertEqual( output, '"Unsafe" http://… ' - '"Safe" http://…' + '"Safe" http://…', ) class FunctionTests(SimpleTestCase): - def test_truncate(self): - uri = 'http://31characteruri.com/test/' + uri = "http://31characteruri.com/test/" self.assertEqual(len(uri), 31) self.assertEqual( urlizetrunc(uri, 31), '' - 'http://31characteruri.com/test/', + "http://31characteruri.com/test/", ) self.assertEqual( urlizetrunc(uri, 30), '' - 'http://31characteruri.com/tes…', + "http://31characteruri.com/tes…", ) self.assertEqual( @@ -65,24 +65,27 @@ class FunctionTests(SimpleTestCase): def test_overtruncate(self): self.assertEqual( - urlizetrunc('http://short.com/', 20), + urlizetrunc("http://short.com/", 20), 'http://short.com/', ) def test_query_string(self): self.assertEqual( - urlizetrunc('http://www.google.co.uk/search?hl=en&q=some+long+url&btnG=Search&meta=', 20), + urlizetrunc( + "http://www.google.co.uk/search?hl=en&q=some+long+url&btnG=Search&meta=", + 20, + ), 'http://www.google.c…', ) def test_non_string_input(self): - self.assertEqual(urlizetrunc(123, 1), '123') + self.assertEqual(urlizetrunc(123, 1), "123") def test_autoescape(self): self.assertEqual( urlizetrunc('foobarbuz', 10), - 'foo<a href=" google.com ">bar</a>buz' + 'foo<a href=" google.com ">bar</a>buz', ) def test_autoescape_off(self): diff --git a/tests/template_tests/filter_tests/test_wordcount.py b/tests/template_tests/filter_tests/test_wordcount.py index c49ebdf48b..d15447086f 100644 --- a/tests/template_tests/filter_tests/test_wordcount.py +++ b/tests/template_tests/filter_tests/test_wordcount.py @@ -6,28 +6,34 @@ from ..utils import setup class WordcountTests(SimpleTestCase): - - @setup({'wordcount01': '{% autoescape off %}{{ a|wordcount }} {{ b|wordcount }}{% endautoescape %}'}) + @setup( + { + "wordcount01": "{% autoescape off %}{{ a|wordcount }} {{ b|wordcount }}{% endautoescape %}" + } + ) def test_wordcount01(self): - output = self.engine.render_to_string('wordcount01', {'a': 'a & b', 'b': mark_safe('a & b')}) - self.assertEqual(output, '3 3') + output = self.engine.render_to_string( + "wordcount01", {"a": "a & b", "b": mark_safe("a & b")} + ) + self.assertEqual(output, "3 3") - @setup({'wordcount02': '{{ a|wordcount }} {{ b|wordcount }}'}) + @setup({"wordcount02": "{{ a|wordcount }} {{ b|wordcount }}"}) def test_wordcount02(self): - output = self.engine.render_to_string('wordcount02', {'a': 'a & b', 'b': mark_safe('a & b')}) - self.assertEqual(output, '3 3') + output = self.engine.render_to_string( + "wordcount02", {"a": "a & b", "b": mark_safe("a & b")} + ) + self.assertEqual(output, "3 3") class FunctionTests(SimpleTestCase): - def test_empty_string(self): - self.assertEqual(wordcount(''), 0) + self.assertEqual(wordcount(""), 0) def test_count_one(self): - self.assertEqual(wordcount('oneword'), 1) + self.assertEqual(wordcount("oneword"), 1) def test_count_multiple(self): - self.assertEqual(wordcount('lots of words'), 3) + self.assertEqual(wordcount("lots of words"), 3) def test_non_string_input(self): self.assertEqual(wordcount(123), 1) diff --git a/tests/template_tests/filter_tests/test_wordwrap.py b/tests/template_tests/filter_tests/test_wordwrap.py index 02f860582b..fb2bce5a90 100644 --- a/tests/template_tests/filter_tests/test_wordwrap.py +++ b/tests/template_tests/filter_tests/test_wordwrap.py @@ -7,47 +7,63 @@ from ..utils import setup class WordwrapTests(SimpleTestCase): - - @setup({ - 'wordwrap01': '{% autoescape off %}{{ a|wordwrap:"3" }} {{ b|wordwrap:"3" }}{% endautoescape %}' - }) + @setup( + { + "wordwrap01": '{% autoescape off %}{{ a|wordwrap:"3" }} {{ b|wordwrap:"3" }}{% endautoescape %}' + } + ) def test_wordwrap01(self): - output = self.engine.render_to_string('wordwrap01', {'a': 'a & b', 'b': mark_safe('a & b')}) - self.assertEqual(output, 'a &\nb a &\nb') + output = self.engine.render_to_string( + "wordwrap01", {"a": "a & b", "b": mark_safe("a & b")} + ) + self.assertEqual(output, "a &\nb a &\nb") - @setup({'wordwrap02': '{{ a|wordwrap:"3" }} {{ b|wordwrap:"3" }}'}) + @setup({"wordwrap02": '{{ a|wordwrap:"3" }} {{ b|wordwrap:"3" }}'}) def test_wordwrap02(self): - output = self.engine.render_to_string('wordwrap02', {'a': 'a & b', 'b': mark_safe('a & b')}) - self.assertEqual(output, 'a &\nb a &\nb') + output = self.engine.render_to_string( + "wordwrap02", {"a": "a & b", "b": mark_safe("a & b")} + ) + self.assertEqual(output, "a &\nb a &\nb") class FunctionTests(SimpleTestCase): - def test_wrap(self): self.assertEqual( - wordwrap('this is a long paragraph of text that really needs to be wrapped I\'m afraid', 14), - 'this is a long\nparagraph of\ntext that\nreally needs\nto be wrapped\nI\'m afraid', + wordwrap( + "this is a long paragraph of text that really needs to be wrapped I'm afraid", + 14, + ), + "this is a long\nparagraph of\ntext that\nreally needs\nto be wrapped\nI'm afraid", ) def test_indent(self): self.assertEqual( - wordwrap('this is a short paragraph of text.\n But this line should be indented', 14), - 'this is a\nshort\nparagraph of\ntext.\n But this\nline should be\nindented', + wordwrap( + "this is a short paragraph of text.\n But this line should be indented", + 14, + ), + "this is a\nshort\nparagraph of\ntext.\n But this\nline should be\nindented", ) def test_indent2(self): self.assertEqual( - wordwrap('this is a short paragraph of text.\n But this line should be indented', 15), - 'this is a short\nparagraph of\ntext.\n But this line\nshould be\nindented', + wordwrap( + "this is a short paragraph of text.\n But this line should be indented", + 15, + ), + "this is a short\nparagraph of\ntext.\n But this line\nshould be\nindented", ) def test_non_string_input(self): - self.assertEqual(wordwrap(123, 2), '123') + self.assertEqual(wordwrap(123, 2), "123") def test_wrap_lazy_string(self): self.assertEqual( - wordwrap(lazystr( - 'this is a long paragraph of text that really needs to be wrapped I\'m afraid' - ), 14), - 'this is a long\nparagraph of\ntext that\nreally needs\nto be wrapped\nI\'m afraid', + wordwrap( + lazystr( + "this is a long paragraph of text that really needs to be wrapped I'm afraid" + ), + 14, + ), + "this is a long\nparagraph of\ntext that\nreally needs\nto be wrapped\nI'm afraid", ) diff --git a/tests/template_tests/filter_tests/test_yesno.py b/tests/template_tests/filter_tests/test_yesno.py index 70b383a2b6..d26b2a7684 100644 --- a/tests/template_tests/filter_tests/test_yesno.py +++ b/tests/template_tests/filter_tests/test_yesno.py @@ -5,36 +5,37 @@ from ..utils import setup class YesNoTests(SimpleTestCase): - @setup({'t': '{{ var|yesno:"yup,nup,mup" }} {{ var|yesno }}'}) + @setup({"t": '{{ var|yesno:"yup,nup,mup" }} {{ var|yesno }}'}) def test_true(self): - output = self.engine.render_to_string('t', {'var': True}) - self.assertEqual(output, 'yup yes') + output = self.engine.render_to_string("t", {"var": True}) + self.assertEqual(output, "yup yes") class FunctionTests(SimpleTestCase): - def test_true(self): - self.assertEqual(yesno(True), 'yes') + self.assertEqual(yesno(True), "yes") def test_false(self): - self.assertEqual(yesno(False), 'no') + self.assertEqual(yesno(False), "no") def test_none(self): - self.assertEqual(yesno(None), 'maybe') + self.assertEqual(yesno(None), "maybe") def test_true_arguments(self): - self.assertEqual(yesno(True, 'certainly,get out of town,perhaps'), 'certainly') + self.assertEqual(yesno(True, "certainly,get out of town,perhaps"), "certainly") def test_false_arguments(self): - self.assertEqual(yesno(False, 'certainly,get out of town,perhaps'), 'get out of town') + self.assertEqual( + yesno(False, "certainly,get out of town,perhaps"), "get out of town" + ) def test_none_two_arguments(self): - self.assertEqual(yesno(None, 'certainly,get out of town'), 'get out of town') + self.assertEqual(yesno(None, "certainly,get out of town"), "get out of town") def test_none_three_arguments(self): - self.assertEqual(yesno(None, 'certainly,get out of town,perhaps'), 'perhaps') + self.assertEqual(yesno(None, "certainly,get out of town,perhaps"), "perhaps") def test_invalid_value(self): - self.assertIs(yesno(True, 'yes'), True) - self.assertIs(yesno(False, 'yes'), False) - self.assertIsNone(yesno(None, 'yes')) + self.assertIs(yesno(True, "yes"), True) + self.assertIs(yesno(False, "yes"), False) + self.assertIsNone(yesno(None, "yes")) diff --git a/tests/template_tests/filter_tests/timezone_utils.py b/tests/template_tests/filter_tests/timezone_utils.py index 874c634cfd..a990d164ae 100644 --- a/tests/template_tests/filter_tests/timezone_utils.py +++ b/tests/template_tests/filter_tests/timezone_utils.py @@ -5,13 +5,14 @@ from django.utils import timezone class TimezoneTestCase(SimpleTestCase): - def setUp(self): self.now = datetime.now() self.now_tz = timezone.make_aware( - self.now, timezone.get_default_timezone(), + self.now, + timezone.get_default_timezone(), ) self.now_tz_i = timezone.localtime( - self.now_tz, timezone.get_fixed_timezone(195), + self.now_tz, + timezone.get_fixed_timezone(195), ) self.today = date.today() diff --git a/tests/template_tests/syntax_tests/i18n/base.py b/tests/template_tests/syntax_tests/i18n/base.py index 61d2bbdb1c..6197179ee4 100644 --- a/tests/template_tests/syntax_tests/i18n/base.py +++ b/tests/template_tests/syntax_tests/i18n/base.py @@ -7,7 +7,7 @@ from django.utils.translation import activate, get_language here = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) pdir = os.path.split(os.path.split(os.path.abspath(here))[0])[0] extended_locale_paths = settings.LOCALE_PATHS + [ - os.path.join(pdir, 'i18n', 'other', 'locale'), + os.path.join(pdir, "i18n", "other", "locale"), ] diff --git a/tests/template_tests/syntax_tests/i18n/test_blocktranslate.py b/tests/template_tests/syntax_tests/i18n/test_blocktranslate.py index 114d4392c6..8ad004a899 100644 --- a/tests/template_tests/syntax_tests/i18n/test_blocktranslate.py +++ b/tests/template_tests/syntax_tests/i18n/test_blocktranslate.py @@ -18,18 +18,18 @@ from .base import MultipleLocaleActivationTestCase, extended_locale_paths, here def setup(templates, *args, **kwargs): blocktranslate_setup = base_setup(templates, *args, **kwargs) - blocktrans_setup = base_setup({ - name: template.replace( - '{% blocktranslate ', '{% blocktrans ' - ).replace( - '{% endblocktranslate %}', '{% endblocktrans %}' - ) - for name, template in templates.items() - }) + blocktrans_setup = base_setup( + { + name: template.replace("{% blocktranslate ", "{% blocktrans ").replace( + "{% endblocktranslate %}", "{% endblocktrans %}" + ) + for name, template in templates.items() + } + ) tags = { - 'blocktrans': blocktrans_setup, - 'blocktranslate': blocktranslate_setup, + "blocktrans": blocktrans_setup, + "blocktranslate": blocktranslate_setup, } def decorator(func): @@ -37,300 +37,459 @@ def setup(templates, *args, **kwargs): def inner(self, *args): signature = inspect.signature(func) for tag_name, setup_func in tags.items(): - if 'tag_name' in signature.parameters: + if "tag_name" in signature.parameters: setup_func(partial(func, tag_name=tag_name))(self) else: setup_func(func)(self) + return inner + return decorator class I18nBlockTransTagTests(SimpleTestCase): - libraries = {'i18n': 'django.templatetags.i18n'} + libraries = {"i18n": "django.templatetags.i18n"} - @setup({'i18n03': '{% load i18n %}{% blocktranslate %}{{ anton }}{% endblocktranslate %}'}) + @setup( + { + "i18n03": "{% load i18n %}{% blocktranslate %}{{ anton }}{% endblocktranslate %}" + } + ) def test_i18n03(self): """simple translation of a variable""" - output = self.engine.render_to_string('i18n03', {'anton': 'Å'}) - self.assertEqual(output, 'Å') - - @setup({'i18n04': '{% load i18n %}{% blocktranslate with berta=anton|lower %}{{ berta }}{% endblocktranslate %}'}) + output = self.engine.render_to_string("i18n03", {"anton": "Å"}) + self.assertEqual(output, "Å") + + @setup( + { + "i18n04": "{% load i18n %}{% blocktranslate with berta=anton|lower %}{{ berta }}{% endblocktranslate %}" + } + ) def test_i18n04(self): """simple translation of a variable and filter""" - output = self.engine.render_to_string('i18n04', {'anton': 'Å'}) - self.assertEqual(output, 'å') - - @setup({'legacyi18n04': '{% load i18n %}' - '{% blocktranslate with anton|lower as berta %}{{ berta }}{% endblocktranslate %}'}) + output = self.engine.render_to_string("i18n04", {"anton": "Å"}) + self.assertEqual(output, "å") + + @setup( + { + "legacyi18n04": "{% load i18n %}" + "{% blocktranslate with anton|lower as berta %}{{ berta }}{% endblocktranslate %}" + } + ) def test_legacyi18n04(self): """simple translation of a variable and filter""" - output = self.engine.render_to_string('legacyi18n04', {'anton': 'Å'}) - self.assertEqual(output, 'å') - - @setup({'i18n05': '{% load i18n %}{% blocktranslate %}xxx{{ anton }}xxx{% endblocktranslate %}'}) + output = self.engine.render_to_string("legacyi18n04", {"anton": "Å"}) + self.assertEqual(output, "å") + + @setup( + { + "i18n05": "{% load i18n %}{% blocktranslate %}xxx{{ anton }}xxx{% endblocktranslate %}" + } + ) def test_i18n05(self): """simple translation of a string with interpolation""" - output = self.engine.render_to_string('i18n05', {'anton': 'yyy'}) - self.assertEqual(output, 'xxxyyyxxx') - - @setup({'i18n07': '{% load i18n %}' - '{% blocktranslate count counter=number %}singular{% plural %}' - '{{ counter }} plural{% endblocktranslate %}'}) + output = self.engine.render_to_string("i18n05", {"anton": "yyy"}) + self.assertEqual(output, "xxxyyyxxx") + + @setup( + { + "i18n07": "{% load i18n %}" + "{% blocktranslate count counter=number %}singular{% plural %}" + "{{ counter }} plural{% endblocktranslate %}" + } + ) def test_i18n07(self): """translation of singular form""" - output = self.engine.render_to_string('i18n07', {'number': 1}) - self.assertEqual(output, 'singular') - - @setup({'legacyi18n07': '{% load i18n %}' - '{% blocktranslate count number as counter %}singular{% plural %}' - '{{ counter }} plural{% endblocktranslate %}'}) + output = self.engine.render_to_string("i18n07", {"number": 1}) + self.assertEqual(output, "singular") + + @setup( + { + "legacyi18n07": "{% load i18n %}" + "{% blocktranslate count number as counter %}singular{% plural %}" + "{{ counter }} plural{% endblocktranslate %}" + } + ) def test_legacyi18n07(self): """translation of singular form""" - output = self.engine.render_to_string('legacyi18n07', {'number': 1}) - self.assertEqual(output, 'singular') - - @setup({'i18n08': '{% load i18n %}' - '{% blocktranslate count number as counter %}singular{% plural %}' - '{{ counter }} plural{% endblocktranslate %}'}) + output = self.engine.render_to_string("legacyi18n07", {"number": 1}) + self.assertEqual(output, "singular") + + @setup( + { + "i18n08": "{% load i18n %}" + "{% blocktranslate count number as counter %}singular{% plural %}" + "{{ counter }} plural{% endblocktranslate %}" + } + ) def test_i18n08(self): """translation of plural form""" - output = self.engine.render_to_string('i18n08', {'number': 2}) - self.assertEqual(output, '2 plural') - - @setup({'legacyi18n08': '{% load i18n %}' - '{% blocktranslate count counter=number %}singular{% plural %}' - '{{ counter }} plural{% endblocktranslate %}'}) + output = self.engine.render_to_string("i18n08", {"number": 2}) + self.assertEqual(output, "2 plural") + + @setup( + { + "legacyi18n08": "{% load i18n %}" + "{% blocktranslate count counter=number %}singular{% plural %}" + "{{ counter }} plural{% endblocktranslate %}" + } + ) def test_legacyi18n08(self): """translation of plural form""" - output = self.engine.render_to_string('legacyi18n08', {'number': 2}) - self.assertEqual(output, '2 plural') - - @setup({'i18n17': '{% load i18n %}' - '{% blocktranslate with berta=anton|escape %}{{ berta }}{% endblocktranslate %}'}) + output = self.engine.render_to_string("legacyi18n08", {"number": 2}) + self.assertEqual(output, "2 plural") + + @setup( + { + "i18n17": "{% load i18n %}" + "{% blocktranslate with berta=anton|escape %}{{ berta }}{% endblocktranslate %}" + } + ) def test_i18n17(self): """ Escaping inside blocktranslate and translate works as if it was directly in the template. """ - output = self.engine.render_to_string('i18n17', {'anton': 'α & β'}) - self.assertEqual(output, 'α & β') - - @setup({'i18n18': '{% load i18n %}' - '{% blocktranslate with berta=anton|force_escape %}{{ berta }}{% endblocktranslate %}'}) + output = self.engine.render_to_string("i18n17", {"anton": "α & β"}) + self.assertEqual(output, "α & β") + + @setup( + { + "i18n18": "{% load i18n %}" + "{% blocktranslate with berta=anton|force_escape %}{{ berta }}{% endblocktranslate %}" + } + ) def test_i18n18(self): - output = self.engine.render_to_string('i18n18', {'anton': 'α & β'}) - self.assertEqual(output, 'α & β') - - @setup({'i18n19': '{% load i18n %}{% blocktranslate %}{{ andrew }}{% endblocktranslate %}'}) + output = self.engine.render_to_string("i18n18", {"anton": "α & β"}) + self.assertEqual(output, "α & β") + + @setup( + { + "i18n19": "{% load i18n %}{% blocktranslate %}{{ andrew }}{% endblocktranslate %}" + } + ) def test_i18n19(self): - output = self.engine.render_to_string('i18n19', {'andrew': 'a & b'}) - self.assertEqual(output, 'a & b') - - @setup({'i18n21': '{% load i18n %}{% blocktranslate %}{{ andrew }}{% endblocktranslate %}'}) + output = self.engine.render_to_string("i18n19", {"andrew": "a & b"}) + self.assertEqual(output, "a & b") + + @setup( + { + "i18n21": "{% load i18n %}{% blocktranslate %}{{ andrew }}{% endblocktranslate %}" + } + ) def test_i18n21(self): - output = self.engine.render_to_string('i18n21', {'andrew': mark_safe('a & b')}) - self.assertEqual(output, 'a & b') - - @setup({'legacyi18n17': '{% load i18n %}' - '{% blocktranslate with anton|escape as berta %}{{ berta }}{% endblocktranslate %}'}) + output = self.engine.render_to_string("i18n21", {"andrew": mark_safe("a & b")}) + self.assertEqual(output, "a & b") + + @setup( + { + "legacyi18n17": "{% load i18n %}" + "{% blocktranslate with anton|escape as berta %}{{ berta }}{% endblocktranslate %}" + } + ) def test_legacyi18n17(self): - output = self.engine.render_to_string('legacyi18n17', {'anton': 'α & β'}) - self.assertEqual(output, 'α & β') - - @setup({'legacyi18n18': '{% load i18n %}' - '{% blocktranslate with anton|force_escape as berta %}' - '{{ berta }}{% endblocktranslate %}'}) + output = self.engine.render_to_string("legacyi18n17", {"anton": "α & β"}) + self.assertEqual(output, "α & β") + + @setup( + { + "legacyi18n18": "{% load i18n %}" + "{% blocktranslate with anton|force_escape as berta %}" + "{{ berta }}{% endblocktranslate %}" + } + ) def test_legacyi18n18(self): - output = self.engine.render_to_string('legacyi18n18', {'anton': 'α & β'}) - self.assertEqual(output, 'α & β') - - @setup({'i18n26': '{% load i18n %}' - '{% blocktranslate with extra_field=myextra_field count counter=number %}' - 'singular {{ extra_field }}{% plural %}plural{% endblocktranslate %}'}) + output = self.engine.render_to_string("legacyi18n18", {"anton": "α & β"}) + self.assertEqual(output, "α & β") + + @setup( + { + "i18n26": "{% load i18n %}" + "{% blocktranslate with extra_field=myextra_field count counter=number %}" + "singular {{ extra_field }}{% plural %}plural{% endblocktranslate %}" + } + ) def test_i18n26(self): """ translation of plural form with extra field in singular form (#13568) """ - output = self.engine.render_to_string('i18n26', {'myextra_field': 'test', 'number': 1}) - self.assertEqual(output, 'singular test') - - @setup({'legacyi18n26': '{% load i18n %}' - '{% blocktranslate with myextra_field as extra_field count number as counter %}' - 'singular {{ extra_field }}{% plural %}plural{% endblocktranslate %}'}) + output = self.engine.render_to_string( + "i18n26", {"myextra_field": "test", "number": 1} + ) + self.assertEqual(output, "singular test") + + @setup( + { + "legacyi18n26": "{% load i18n %}" + "{% blocktranslate with myextra_field as extra_field count number as counter %}" + "singular {{ extra_field }}{% plural %}plural{% endblocktranslate %}" + } + ) def test_legacyi18n26(self): - output = self.engine.render_to_string('legacyi18n26', {'myextra_field': 'test', 'number': 1}) - self.assertEqual(output, 'singular test') - - @setup({'i18n27': '{% load i18n %}{% blocktranslate count counter=number %}' - '{{ counter }} result{% plural %}{{ counter }} results' - '{% endblocktranslate %}'}) + output = self.engine.render_to_string( + "legacyi18n26", {"myextra_field": "test", "number": 1} + ) + self.assertEqual(output, "singular test") + + @setup( + { + "i18n27": "{% load i18n %}{% blocktranslate count counter=number %}" + "{{ counter }} result{% plural %}{{ counter }} results" + "{% endblocktranslate %}" + } + ) def test_i18n27(self): """translation of singular form in Russian (#14126)""" - with translation.override('ru'): - output = self.engine.render_to_string('i18n27', {'number': 1}) - self.assertEqual(output, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442') + with translation.override("ru"): + output = self.engine.render_to_string("i18n27", {"number": 1}) + self.assertEqual( + output, "1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442" + ) - @setup({'legacyi18n27': '{% load i18n %}' - '{% blocktranslate count number as counter %}{{ counter }} result' - '{% plural %}{{ counter }} results{% endblocktranslate %}'}) + @setup( + { + "legacyi18n27": "{% load i18n %}" + "{% blocktranslate count number as counter %}{{ counter }} result" + "{% plural %}{{ counter }} results{% endblocktranslate %}" + } + ) def test_legacyi18n27(self): - with translation.override('ru'): - output = self.engine.render_to_string('legacyi18n27', {'number': 1}) - self.assertEqual(output, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442') + with translation.override("ru"): + output = self.engine.render_to_string("legacyi18n27", {"number": 1}) + self.assertEqual( + output, "1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442" + ) - @setup({'i18n28': '{% load i18n %}' - '{% blocktranslate with a=anton b=berta %}{{ a }} + {{ b }}{% endblocktranslate %}'}) + @setup( + { + "i18n28": "{% load i18n %}" + "{% blocktranslate with a=anton b=berta %}{{ a }} + {{ b }}{% endblocktranslate %}" + } + ) def test_i18n28(self): """simple translation of multiple variables""" - output = self.engine.render_to_string('i18n28', {'anton': 'α', 'berta': 'β'}) - self.assertEqual(output, 'α + β') - - @setup({'legacyi18n28': '{% load i18n %}' - '{% blocktranslate with anton as a and berta as b %}' - '{{ a }} + {{ b }}{% endblocktranslate %}'}) + output = self.engine.render_to_string("i18n28", {"anton": "α", "berta": "β"}) + self.assertEqual(output, "α + β") + + @setup( + { + "legacyi18n28": "{% load i18n %}" + "{% blocktranslate with anton as a and berta as b %}" + "{{ a }} + {{ b }}{% endblocktranslate %}" + } + ) def test_legacyi18n28(self): - output = self.engine.render_to_string('legacyi18n28', {'anton': 'α', 'berta': 'β'}) - self.assertEqual(output, 'α + β') + output = self.engine.render_to_string( + "legacyi18n28", {"anton": "α", "berta": "β"} + ) + self.assertEqual(output, "α + β") # blocktranslate handling of variables which are not in the context. # this should work as if blocktranslate was not there (#19915) - @setup({'i18n34': '{% load i18n %}{% blocktranslate %}{{ missing }}{% endblocktranslate %}'}) + @setup( + { + "i18n34": "{% load i18n %}{% blocktranslate %}{{ missing }}{% endblocktranslate %}" + } + ) def test_i18n34(self): - output = self.engine.render_to_string('i18n34') + output = self.engine.render_to_string("i18n34") if self.engine.string_if_invalid: - self.assertEqual(output, 'INVALID') + self.assertEqual(output, "INVALID") else: - self.assertEqual(output, '') + self.assertEqual(output, "") - @setup({'i18n34_2': '{% load i18n %}{% blocktranslate with a=\'α\' %}{{ missing }}{% endblocktranslate %}'}) + @setup( + { + "i18n34_2": "{% load i18n %}{% blocktranslate with a='α' %}{{ missing }}{% endblocktranslate %}" + } + ) def test_i18n34_2(self): - output = self.engine.render_to_string('i18n34_2') + output = self.engine.render_to_string("i18n34_2") if self.engine.string_if_invalid: - self.assertEqual(output, 'INVALID') + self.assertEqual(output, "INVALID") else: - self.assertEqual(output, '') + self.assertEqual(output, "") - @setup({'i18n34_3': '{% load i18n %}{% blocktranslate with a=anton %}{{ missing }}{% endblocktranslate %}'}) + @setup( + { + "i18n34_3": "{% load i18n %}{% blocktranslate with a=anton %}{{ missing }}{% endblocktranslate %}" + } + ) def test_i18n34_3(self): - output = self.engine.render_to_string( - 'i18n34_3', {'anton': '\xce\xb1'}) + output = self.engine.render_to_string("i18n34_3", {"anton": "\xce\xb1"}) if self.engine.string_if_invalid: - self.assertEqual(output, 'INVALID') + self.assertEqual(output, "INVALID") else: - self.assertEqual(output, '') - - @setup({'i18n37': '{% load i18n %}' - '{% translate "Page not found" as page_not_found %}' - '{% blocktranslate %}Error: {{ page_not_found }}{% endblocktranslate %}'}) + self.assertEqual(output, "") + + @setup( + { + "i18n37": "{% load i18n %}" + '{% translate "Page not found" as page_not_found %}' + "{% blocktranslate %}Error: {{ page_not_found }}{% endblocktranslate %}" + } + ) def test_i18n37(self): - with translation.override('de'): - output = self.engine.render_to_string('i18n37') - self.assertEqual(output, 'Error: Seite nicht gefunden') + with translation.override("de"): + output = self.engine.render_to_string("i18n37") + self.assertEqual(output, "Error: Seite nicht gefunden") # blocktranslate tag with asvar - @setup({'i18n39': '{% load i18n %}' - '{% blocktranslate asvar page_not_found %}Page not found{% endblocktranslate %}' - '>{{ page_not_found }}<'}) + @setup( + { + "i18n39": "{% load i18n %}" + "{% blocktranslate asvar page_not_found %}Page not found{% endblocktranslate %}" + ">{{ page_not_found }}<" + } + ) def test_i18n39(self): - with translation.override('de'): - output = self.engine.render_to_string('i18n39') - self.assertEqual(output, '>Seite nicht gefunden<') - - @setup({'i18n40': '{% load i18n %}' - '{% translate "Page not found" as pg_404 %}' - '{% blocktranslate with page_not_found=pg_404 asvar output %}' - 'Error: {{ page_not_found }}' - '{% endblocktranslate %}'}) + with translation.override("de"): + output = self.engine.render_to_string("i18n39") + self.assertEqual(output, ">Seite nicht gefunden<") + + @setup( + { + "i18n40": "{% load i18n %}" + '{% translate "Page not found" as pg_404 %}' + "{% blocktranslate with page_not_found=pg_404 asvar output %}" + "Error: {{ page_not_found }}" + "{% endblocktranslate %}" + } + ) def test_i18n40(self): - output = self.engine.render_to_string('i18n40') - self.assertEqual(output, '') - - @setup({'i18n41': '{% load i18n %}' - '{% translate "Page not found" as pg_404 %}' - '{% blocktranslate with page_not_found=pg_404 asvar output %}' - 'Error: {{ page_not_found }}' - '{% endblocktranslate %}' - '>{{ output }}<'}) + output = self.engine.render_to_string("i18n40") + self.assertEqual(output, "") + + @setup( + { + "i18n41": "{% load i18n %}" + '{% translate "Page not found" as pg_404 %}' + "{% blocktranslate with page_not_found=pg_404 asvar output %}" + "Error: {{ page_not_found }}" + "{% endblocktranslate %}" + ">{{ output }}<" + } + ) def test_i18n41(self): - with translation.override('de'): - output = self.engine.render_to_string('i18n41') - self.assertEqual(output, '>Error: Seite nicht gefunden<') - - @setup({'template': '{% load i18n %}{% blocktranslate asvar %}Yes{% endblocktranslate %}'}) + with translation.override("de"): + output = self.engine.render_to_string("i18n41") + self.assertEqual(output, ">Error: Seite nicht gefunden<") + + @setup( + { + "template": "{% load i18n %}{% blocktranslate asvar %}Yes{% endblocktranslate %}" + } + ) def test_blocktrans_syntax_error_missing_assignment(self, tag_name): - msg = "No argument provided to the '{}' tag for the asvar option.".format(tag_name) + msg = "No argument provided to the '{}' tag for the asvar option.".format( + tag_name + ) with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template') + self.engine.render_to_string("template") - @setup({'template': '{% load i18n %}{% blocktranslate %}%s{% endblocktranslate %}'}) + @setup({"template": "{% load i18n %}{% blocktranslate %}%s{% endblocktranslate %}"}) def test_blocktrans_tag_using_a_string_that_looks_like_str_fmt(self): - output = self.engine.render_to_string('template') - self.assertEqual(output, '%s') - - @setup({'template': '{% load i18n %}{% blocktranslate %}{% block b %} {% endblock %}{% endblocktranslate %}'}) + output = self.engine.render_to_string("template") + self.assertEqual(output, "%s") + + @setup( + { + "template": "{% load i18n %}{% blocktranslate %}{% block b %} {% endblock %}{% endblocktranslate %}" + } + ) def test_with_block(self, tag_name): - msg = "'{}' doesn't allow other block tags (seen 'block b') inside it".format(tag_name) + msg = "'{}' doesn't allow other block tags (seen 'block b') inside it".format( + tag_name + ) with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template') - - @setup({'template': ( - '{% load i18n %}' - '{% blocktranslate %}{% for b in [1, 2, 3] %} {% endfor %}' - '{% endblocktranslate %}' - )}) + self.engine.render_to_string("template") + + @setup( + { + "template": ( + "{% load i18n %}" + "{% blocktranslate %}{% for b in [1, 2, 3] %} {% endfor %}" + "{% endblocktranslate %}" + ) + } + ) def test_with_for(self, tag_name): - msg = "'{}' doesn't allow other block tags (seen 'for b in [1, 2, 3]') inside it".format(tag_name) + msg = "'{}' doesn't allow other block tags (seen 'for b in [1, 2, 3]') inside it".format( + tag_name + ) with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template') + self.engine.render_to_string("template") - @setup({'template': '{% load i18n %}{% blocktranslate with foo=bar with %}{{ foo }}{% endblocktranslate %}'}) + @setup( + { + "template": "{% load i18n %}{% blocktranslate with foo=bar with %}{{ foo }}{% endblocktranslate %}" + } + ) def test_variable_twice(self): - with self.assertRaisesMessage(TemplateSyntaxError, "The 'with' option was specified more than once"): - self.engine.render_to_string('template', {'foo': 'bar'}) - - @setup({'template': '{% load i18n %}{% blocktranslate with %}{% endblocktranslate %}'}) + with self.assertRaisesMessage( + TemplateSyntaxError, "The 'with' option was specified more than once" + ): + self.engine.render_to_string("template", {"foo": "bar"}) + + @setup( + {"template": "{% load i18n %}{% blocktranslate with %}{% endblocktranslate %}"} + ) def test_no_args_with(self, tag_name): - msg = '"with" in \'{}\' tag needs at least one keyword argument.'.format(tag_name) + msg = "\"with\" in '{}' tag needs at least one keyword argument.".format( + tag_name + ) with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template') + self.engine.render_to_string("template") - @setup({'template': '{% load i18n %}{% blocktranslate count a %}{% endblocktranslate %}'}) + @setup( + { + "template": "{% load i18n %}{% blocktranslate count a %}{% endblocktranslate %}" + } + ) def test_count(self, tag_name): - msg = '"count" in \'{}\' tag expected exactly one keyword argument.'.format(tag_name) + msg = "\"count\" in '{}' tag expected exactly one keyword argument.".format( + tag_name + ) with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template', {'a': [1, 2, 3]}) + self.engine.render_to_string("template", {"a": [1, 2, 3]}) - @setup({'template': ( - '{% load i18n %}{% blocktranslate count counter=num %}{{ counter }}' - '{% plural %}{{ counter }}{% endblocktranslate %}' - )}) + @setup( + { + "template": ( + "{% load i18n %}{% blocktranslate count counter=num %}{{ counter }}" + "{% plural %}{{ counter }}{% endblocktranslate %}" + ) + } + ) def test_count_not_number(self, tag_name): msg = "'counter' argument to '{}' tag must be a number.".format(tag_name) with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template', {'num': '1'}) - - @setup({'template': ( - '{% load i18n %}{% blocktranslate count count=var|length %}' - 'There is {{ count }} object. {% block a %} {% endblock %}' - '{% endblocktranslate %}' - )}) + self.engine.render_to_string("template", {"num": "1"}) + + @setup( + { + "template": ( + "{% load i18n %}{% blocktranslate count count=var|length %}" + "There is {{ count }} object. {% block a %} {% endblock %}" + "{% endblocktranslate %}" + ) + } + ) def test_plural_bad_syntax(self, tag_name): msg = "'{}' doesn't allow other block tags inside it".format(tag_name) with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template', {'var': [1, 2, 3]}) + self.engine.render_to_string("template", {"var": [1, 2, 3]}) class TranslationBlockTranslateTagTests(SimpleTestCase): - tag_name = 'blocktranslate' + tag_name = "blocktranslate" def get_template(self, template_string): return Template( template_string.replace( - '{{% blocktranslate ', - '{{% {}'.format(self.tag_name) + "{{% blocktranslate ", "{{% {}".format(self.tag_name) ).replace( - '{{% endblocktranslate %}}', - '{{% end{} %}}'.format(self.tag_name) + "{{% endblocktranslate %}}", "{{% end{} %}}".format(self.tag_name) ) ) @@ -339,108 +498,112 @@ class TranslationBlockTranslateTagTests(SimpleTestCase): """{% blocktranslate %} takes message contexts into account (#14806).""" trans_real._active = Local() trans_real._translations = {} - with translation.override('de'): + with translation.override("de"): # Nonexistent context t = self.get_template( '{% load i18n %}{% blocktranslate context "nonexistent" %}May' - '{% endblocktranslate %}' + "{% endblocktranslate %}" ) rendered = t.render(Context()) - self.assertEqual(rendered, 'May') + self.assertEqual(rendered, "May") # Existing context... using a literal - t = self.get_template('{% load i18n %}{% blocktranslate context "month name" %}May{% endblocktranslate %}') + t = self.get_template( + '{% load i18n %}{% blocktranslate context "month name" %}May{% endblocktranslate %}' + ) rendered = t.render(Context()) - self.assertEqual(rendered, 'Mai') - t = self.get_template('{% load i18n %}{% blocktranslate context "verb" %}May{% endblocktranslate %}') + self.assertEqual(rendered, "Mai") + t = self.get_template( + '{% load i18n %}{% blocktranslate context "verb" %}May{% endblocktranslate %}' + ) rendered = t.render(Context()) - self.assertEqual(rendered, 'Kann') + self.assertEqual(rendered, "Kann") # Using a variable t = self.get_template( - '{% load i18n %}{% blocktranslate context message_context %}' - 'May{% endblocktranslate %}' + "{% load i18n %}{% blocktranslate context message_context %}" + "May{% endblocktranslate %}" ) - rendered = t.render(Context({'message_context': 'month name'})) - self.assertEqual(rendered, 'Mai') + rendered = t.render(Context({"message_context": "month name"})) + self.assertEqual(rendered, "Mai") t = self.get_template( - '{% load i18n %}{% blocktranslate context message_context %}' - 'May{% endblocktranslate %}' + "{% load i18n %}{% blocktranslate context message_context %}" + "May{% endblocktranslate %}" ) - rendered = t.render(Context({'message_context': 'verb'})) - self.assertEqual(rendered, 'Kann') + rendered = t.render(Context({"message_context": "verb"})) + self.assertEqual(rendered, "Kann") # Using a filter t = self.get_template( - '{% load i18n %}{% blocktranslate context message_context|lower %}May{% endblocktranslate %}' + "{% load i18n %}{% blocktranslate context message_context|lower %}May{% endblocktranslate %}" ) - rendered = t.render(Context({'message_context': 'MONTH NAME'})) - self.assertEqual(rendered, 'Mai') + rendered = t.render(Context({"message_context": "MONTH NAME"})) + self.assertEqual(rendered, "Mai") t = self.get_template( - '{% load i18n %}{% blocktranslate context message_context|lower %}May{% endblocktranslate %}' + "{% load i18n %}{% blocktranslate context message_context|lower %}May{% endblocktranslate %}" ) - rendered = t.render(Context({'message_context': 'VERB'})) - self.assertEqual(rendered, 'Kann') + rendered = t.render(Context({"message_context": "VERB"})) + self.assertEqual(rendered, "Kann") # Using 'count' t = self.get_template( '{% load i18n %}{% blocktranslate count number=1 context "super search" %}' - '{{ number }} super result{% plural %}{{ number }} super results{% endblocktranslate %}' + "{{ number }} super result{% plural %}{{ number }} super results{% endblocktranslate %}" ) rendered = t.render(Context()) - self.assertEqual(rendered, '1 Super-Ergebnis') + self.assertEqual(rendered, "1 Super-Ergebnis") t = self.get_template( '{% load i18n %}{% blocktranslate count number=2 context "super search" %}{{ number }}' - ' super result{% plural %}{{ number }} super results{% endblocktranslate %}' + " super result{% plural %}{{ number }} super results{% endblocktranslate %}" ) rendered = t.render(Context()) - self.assertEqual(rendered, '2 Super-Ergebnisse') + self.assertEqual(rendered, "2 Super-Ergebnisse") t = self.get_template( '{% load i18n %}{% blocktranslate context "other super search" count number=1 %}' - '{{ number }} super result{% plural %}{{ number }} super results{% endblocktranslate %}' + "{{ number }} super result{% plural %}{{ number }} super results{% endblocktranslate %}" ) rendered = t.render(Context()) - self.assertEqual(rendered, '1 anderen Super-Ergebnis') + self.assertEqual(rendered, "1 anderen Super-Ergebnis") t = self.get_template( '{% load i18n %}{% blocktranslate context "other super search" count number=2 %}' - '{{ number }} super result{% plural %}{{ number }} super results{% endblocktranslate %}' + "{{ number }} super result{% plural %}{{ number }} super results{% endblocktranslate %}" ) rendered = t.render(Context()) - self.assertEqual(rendered, '2 andere Super-Ergebnisse') + self.assertEqual(rendered, "2 andere Super-Ergebnisse") # Using 'with' t = self.get_template( '{% load i18n %}{% blocktranslate with num_comments=5 context "comment count" %}' - 'There are {{ num_comments }} comments{% endblocktranslate %}' + "There are {{ num_comments }} comments{% endblocktranslate %}" ) rendered = t.render(Context()) - self.assertEqual(rendered, 'Es gibt 5 Kommentare') + self.assertEqual(rendered, "Es gibt 5 Kommentare") t = self.get_template( '{% load i18n %}{% blocktranslate with num_comments=5 context "other comment count" %}' - 'There are {{ num_comments }} comments{% endblocktranslate %}' + "There are {{ num_comments }} comments{% endblocktranslate %}" ) rendered = t.render(Context()) - self.assertEqual(rendered, 'Andere: Es gibt 5 Kommentare') + self.assertEqual(rendered, "Andere: Es gibt 5 Kommentare") # Using trimmed t = self.get_template( - '{% load i18n %}{% blocktranslate trimmed %}\n\nThere\n\t are 5 ' - '\n\n comments\n{% endblocktranslate %}' + "{% load i18n %}{% blocktranslate trimmed %}\n\nThere\n\t are 5 " + "\n\n comments\n{% endblocktranslate %}" ) rendered = t.render(Context()) - self.assertEqual(rendered, 'There are 5 comments') + self.assertEqual(rendered, "There are 5 comments") t = self.get_template( '{% load i18n %}{% blocktranslate with num_comments=5 context "comment count" trimmed %}\n\n' - 'There are \t\n \t {{ num_comments }} comments\n\n{% endblocktranslate %}' + "There are \t\n \t {{ num_comments }} comments\n\n{% endblocktranslate %}" ) rendered = t.render(Context()) - self.assertEqual(rendered, 'Es gibt 5 Kommentare') + self.assertEqual(rendered, "Es gibt 5 Kommentare") t = self.get_template( '{% load i18n %}{% blocktranslate context "other super search" count number=2 trimmed %}\n' - '{{ number }} super \n result{% plural %}{{ number }} super results{% endblocktranslate %}' + "{{ number }} super \n result{% plural %}{{ number }} super results{% endblocktranslate %}" ) rendered = t.render(Context()) - self.assertEqual(rendered, '2 andere Super-Ergebnisse') + self.assertEqual(rendered, "2 andere Super-Ergebnisse") # Misuses msg = "Unknown argument for 'blocktranslate' tag: %r." @@ -448,55 +611,61 @@ class TranslationBlockTranslateTagTests(SimpleTestCase): self.get_template( '{% load i18n %}{% blocktranslate context with month="May" %}{{ month }}{% endblocktranslate %}' ) - msg = '"context" in %r tag expected exactly one argument.' % 'blocktranslate' + msg = ( + '"context" in %r tag expected exactly one argument.' % "blocktranslate" + ) with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.get_template('{% load i18n %}{% blocktranslate context %}{% endblocktranslate %}') + self.get_template( + "{% load i18n %}{% blocktranslate context %}{% endblocktranslate %}" + ) with self.assertRaisesMessage(TemplateSyntaxError, msg): self.get_template( - '{% load i18n %}{% blocktranslate count number=2 context %}' - '{{ number }} super result{% plural %}{{ number }}' - ' super results{% endblocktranslate %}' + "{% load i18n %}{% blocktranslate count number=2 context %}" + "{{ number }} super result{% plural %}{{ number }}" + " super results{% endblocktranslate %}" ) - @override_settings(LOCALE_PATHS=[os.path.join(here, 'other', 'locale')]) + @override_settings(LOCALE_PATHS=[os.path.join(here, "other", "locale")]) def test_bad_placeholder_1(self): """ Error in translation file should not crash template rendering (#16516). (%(person)s is translated as %(personne)s in fr.po). """ - with translation.override('fr'): - t = Template('{% load i18n %}{% blocktranslate %}My name is {{ person }}.{% endblocktranslate %}') - rendered = t.render(Context({'person': 'James'})) - self.assertEqual(rendered, 'My name is James.') + with translation.override("fr"): + t = Template( + "{% load i18n %}{% blocktranslate %}My name is {{ person }}.{% endblocktranslate %}" + ) + rendered = t.render(Context({"person": "James"})) + self.assertEqual(rendered, "My name is James.") - @override_settings(LOCALE_PATHS=[os.path.join(here, 'other', 'locale')]) + @override_settings(LOCALE_PATHS=[os.path.join(here, "other", "locale")]) def test_bad_placeholder_2(self): """ Error in translation file should not crash template rendering (#18393). (%(person) misses a 's' in fr.po, causing the string formatting to fail) . """ - with translation.override('fr'): - t = Template('{% load i18n %}{% blocktranslate %}My other name is {{ person }}.{% endblocktranslate %}') - rendered = t.render(Context({'person': 'James'})) - self.assertEqual(rendered, 'My other name is James.') + with translation.override("fr"): + t = Template( + "{% load i18n %}{% blocktranslate %}My other name is {{ person }}.{% endblocktranslate %}" + ) + rendered = t.render(Context({"person": "James"})) + self.assertEqual(rendered, "My other name is James.") class TranslationBlockTransnTagTests(TranslationBlockTranslateTagTests): - tag_name = 'blocktrans' + tag_name = "blocktrans" class MultipleLocaleActivationBlockTranslateTests(MultipleLocaleActivationTestCase): - tag_name = 'blocktranslate' + tag_name = "blocktranslate" def get_template(self, template_string): return Template( template_string.replace( - '{{% blocktranslate ', - '{{% {}'.format(self.tag_name) + "{{% blocktranslate ", "{{% {}".format(self.tag_name) ).replace( - '{{% endblocktranslate %}}', - '{{% end{} %}}'.format(self.tag_name) + "{{% endblocktranslate %}}", "{{% end{} %}}".format(self.tag_name) ) ) @@ -505,46 +674,54 @@ class MultipleLocaleActivationBlockTranslateTests(MultipleLocaleActivationTestCa Simple baseline behavior with one locale for all the supported i18n constructs. """ - with translation.override('fr'): + with translation.override("fr"): self.assertEqual( - self.get_template("{% load i18n %}{% blocktranslate %}Yes{% endblocktranslate %}").render(Context({})), - 'Oui' + self.get_template( + "{% load i18n %}{% blocktranslate %}Yes{% endblocktranslate %}" + ).render(Context({})), + "Oui", ) def test_multiple_locale_btrans(self): - with translation.override('de'): - t = self.get_template("{% load i18n %}{% blocktranslate %}No{% endblocktranslate %}") - with translation.override(self._old_language), translation.override('nl'): - self.assertEqual(t.render(Context({})), 'Nee') + with translation.override("de"): + t = self.get_template( + "{% load i18n %}{% blocktranslate %}No{% endblocktranslate %}" + ) + with translation.override(self._old_language), translation.override("nl"): + self.assertEqual(t.render(Context({})), "Nee") def test_multiple_locale_deactivate_btrans(self): - with translation.override('de', deactivate=True): - t = self.get_template("{% load i18n %}{% blocktranslate %}No{% endblocktranslate %}") - with translation.override('nl'): - self.assertEqual(t.render(Context({})), 'Nee') + with translation.override("de", deactivate=True): + t = self.get_template( + "{% load i18n %}{% blocktranslate %}No{% endblocktranslate %}" + ) + with translation.override("nl"): + self.assertEqual(t.render(Context({})), "Nee") def test_multiple_locale_direct_switch_btrans(self): - with translation.override('de'): - t = self.get_template("{% load i18n %}{% blocktranslate %}No{% endblocktranslate %}") - with translation.override('nl'): - self.assertEqual(t.render(Context({})), 'Nee') + with translation.override("de"): + t = self.get_template( + "{% load i18n %}{% blocktranslate %}No{% endblocktranslate %}" + ) + with translation.override("nl"): + self.assertEqual(t.render(Context({})), "Nee") -class MultipleLocaleActivationBlockTransTests(MultipleLocaleActivationBlockTranslateTests): - tag_name = 'blocktrans' +class MultipleLocaleActivationBlockTransTests( + MultipleLocaleActivationBlockTranslateTests +): + tag_name = "blocktrans" class MiscTests(SimpleTestCase): - tag_name = 'blocktranslate' + tag_name = "blocktranslate" def get_template(self, template_string): return Template( template_string.replace( - '{{% blocktranslate ', - '{{% {}'.format(self.tag_name) + "{{% blocktranslate ", "{{% {}".format(self.tag_name) ).replace( - '{{% endblocktranslate %}}', - '{{% end{} %}}'.format(self.tag_name) + "{{% endblocktranslate %}}", "{{% end{} %}}".format(self.tag_name) ) ) @@ -558,10 +735,18 @@ class MiscTests(SimpleTestCase): "{{ percent }}% represents {{ num }} object{% plural %}" "{{ percent }}% represents {{ num }} objects{% endblocktranslate %}" ) - with translation.override('de'): - self.assertEqual(t_sing.render(Context({'percent': 42})), 'Das Ergebnis war 42%') - self.assertEqual(t_plur.render(Context({'percent': 42, 'num': 1})), '42% stellt 1 Objekt dar') - self.assertEqual(t_plur.render(Context({'percent': 42, 'num': 4})), '42% stellt 4 Objekte dar') + with translation.override("de"): + self.assertEqual( + t_sing.render(Context({"percent": 42})), "Das Ergebnis war 42%" + ) + self.assertEqual( + t_plur.render(Context({"percent": 42, "num": 1})), + "42% stellt 1 Objekt dar", + ) + self.assertEqual( + t_plur.render(Context({"percent": 42, "num": 4})), + "42% stellt 4 Objekte dar", + ) @override_settings(LOCALE_PATHS=extended_locale_paths) def test_percent_formatting_in_blocktranslate(self): @@ -577,26 +762,38 @@ class MiscTests(SimpleTestCase): "%(percent)s% represents {{ num }} object{% plural %}" "%(percent)s% represents {{ num }} objects{% endblocktranslate %}" ) - with translation.override('de'): + with translation.override("de"): # Strings won't get translated as they don't match after escaping % - self.assertEqual(t_sing.render(Context({'num_comments': 42})), 'There are %(num_comments)s comments') - self.assertEqual(t_plur.render(Context({'percent': 42, 'num': 1})), '%(percent)s% represents 1 object') - self.assertEqual(t_plur.render(Context({'percent': 42, 'num': 4})), '%(percent)s% represents 4 objects') + self.assertEqual( + t_sing.render(Context({"num_comments": 42})), + "There are %(num_comments)s comments", + ) + self.assertEqual( + t_plur.render(Context({"percent": 42, "num": 1})), + "%(percent)s% represents 1 object", + ) + self.assertEqual( + t_plur.render(Context({"percent": 42, "num": 4})), + "%(percent)s% represents 4 objects", + ) class MiscBlockTranslationTests(MiscTests): - tag_name = 'blocktrans' + tag_name = "blocktrans" class BlockTranslateNodeTests(SimpleTestCase): def test_repr(self): - block_translate_node = BlockTranslateNode(extra_context={}, singular=[ - Token(TokenType.TEXT, 'content'), - Token(TokenType.VAR, 'variable'), - ]) + block_translate_node = BlockTranslateNode( + extra_context={}, + singular=[ + Token(TokenType.TEXT, "content"), + Token(TokenType.VAR, "variable"), + ], + ) self.assertEqual( repr(block_translate_node), - ', ] ' - 'plural=None>', + "plural=None>", ) diff --git a/tests/template_tests/syntax_tests/i18n/test_filters.py b/tests/template_tests/syntax_tests/i18n/test_filters.py index cf8e4573c3..c78b8aca5f 100644 --- a/tests/template_tests/syntax_tests/i18n/test_filters.py +++ b/tests/template_tests/syntax_tests/i18n/test_filters.py @@ -6,42 +6,56 @@ from ...utils import setup class I18nFiltersTests(SimpleTestCase): libraries = { - 'custom': 'template_tests.templatetags.custom', - 'i18n': 'django.templatetags.i18n', + "custom": "template_tests.templatetags.custom", + "i18n": "django.templatetags.i18n", } - @setup({'i18n32': '{% load i18n %}{{ "hu"|language_name }} ' - '{{ "hu"|language_name_local }} {{ "hu"|language_bidi }} ' - '{{ "hu"|language_name_translated }}'}) + @setup( + { + "i18n32": '{% load i18n %}{{ "hu"|language_name }} ' + '{{ "hu"|language_name_local }} {{ "hu"|language_bidi }} ' + '{{ "hu"|language_name_translated }}' + } + ) def test_i18n32(self): - output = self.engine.render_to_string('i18n32') - self.assertEqual(output, 'Hungarian Magyar False Hungarian') - - with translation.override('cs'): - output = self.engine.render_to_string('i18n32') - self.assertEqual(output, 'Hungarian Magyar False maďarsky') - - @setup({'i18n33': '{% load i18n %}' - '{{ langcode|language_name }} {{ langcode|language_name_local }} ' - '{{ langcode|language_bidi }} {{ langcode|language_name_translated }}'}) + output = self.engine.render_to_string("i18n32") + self.assertEqual(output, "Hungarian Magyar False Hungarian") + + with translation.override("cs"): + output = self.engine.render_to_string("i18n32") + self.assertEqual(output, "Hungarian Magyar False maďarsky") + + @setup( + { + "i18n33": "{% load i18n %}" + "{{ langcode|language_name }} {{ langcode|language_name_local }} " + "{{ langcode|language_bidi }} {{ langcode|language_name_translated }}" + } + ) def test_i18n33(self): - output = self.engine.render_to_string('i18n33', {'langcode': 'nl'}) - self.assertEqual(output, 'Dutch Nederlands False Dutch') - - with translation.override('cs'): - output = self.engine.render_to_string('i18n33', {'langcode': 'nl'}) - self.assertEqual(output, 'Dutch Nederlands False nizozemsky') - - @setup({'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 }}/{{ l.name_translated }} ' - 'bidi={{ l.bidi }}; {% endfor %}'}) + output = self.engine.render_to_string("i18n33", {"langcode": "nl"}) + self.assertEqual(output, "Dutch Nederlands False Dutch") + + with translation.override("cs"): + output = self.engine.render_to_string("i18n33", {"langcode": "nl"}) + self.assertEqual(output, "Dutch Nederlands False nizozemsky") + + @setup( + { + "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 }}/{{ l.name_translated }} " + "bidi={{ l.bidi }}; {% endfor %}" + } + ) def test_i18n38_2(self): - with translation.override('cs'): - output = self.engine.render_to_string('i18n38_2', {'langcodes': ['it', 'fr']}) + with translation.override("cs"): + output = self.engine.render_to_string( + "i18n38_2", {"langcodes": ["it", "fr"]} + ) self.assertEqual( output, - 'it: Italian/italiano/italsky bidi=False; ' - 'fr: French/français/francouzsky bidi=False; ' + "it: Italian/italiano/italsky bidi=False; " + "fr: French/français/francouzsky bidi=False; ", ) diff --git a/tests/template_tests/syntax_tests/i18n/test_get_available_languages.py b/tests/template_tests/syntax_tests/i18n/test_get_available_languages.py index 5ac97a4f79..dce5a4de66 100644 --- a/tests/template_tests/syntax_tests/i18n/test_get_available_languages.py +++ b/tests/template_tests/syntax_tests/i18n/test_get_available_languages.py @@ -5,17 +5,21 @@ from ...utils import setup class GetAvailableLanguagesTagTests(SimpleTestCase): - libraries = {'i18n': 'django.templatetags.i18n'} + libraries = {"i18n": "django.templatetags.i18n"} - @setup({'i18n12': '{% load i18n %}' - '{% get_available_languages as langs %}{% for lang in langs %}' - '{% if lang.0 == "de" %}{{ lang.0 }}{% endif %}{% endfor %}'}) + @setup( + { + "i18n12": "{% load i18n %}" + "{% get_available_languages as langs %}{% for lang in langs %}" + '{% if lang.0 == "de" %}{{ lang.0 }}{% endif %}{% endfor %}' + } + ) def test_i18n12(self): - output = self.engine.render_to_string('i18n12') - self.assertEqual(output, 'de') + output = self.engine.render_to_string("i18n12") + self.assertEqual(output, "de") - @setup({'syntax_i18n': '{% load i18n %}{% get_available_languages a langs %}'}) + @setup({"syntax_i18n": "{% load i18n %}{% get_available_languages a langs %}"}) def test_no_as_var(self): msg = "'get_available_languages' requires 'as variable' (got ['get_available_languages', 'a', 'langs'])" with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('syntax_i18n') + self.engine.render_to_string("syntax_i18n") diff --git a/tests/template_tests/syntax_tests/i18n/test_get_current_language.py b/tests/template_tests/syntax_tests/i18n/test_get_current_language.py index f168b74f8e..8ed7f742c2 100644 --- a/tests/template_tests/syntax_tests/i18n/test_get_current_language.py +++ b/tests/template_tests/syntax_tests/i18n/test_get_current_language.py @@ -5,10 +5,10 @@ from django.test import SimpleTestCase class I18nGetCurrentLanguageTagTests(SimpleTestCase): - libraries = {'i18n': 'django.templatetags.i18n'} + libraries = {"i18n": "django.templatetags.i18n"} - @setup({'template': '{% load i18n %} {% get_current_language %}'}) + @setup({"template": "{% load i18n %} {% get_current_language %}"}) def test_no_as_var(self): msg = "'get_current_language' requires 'as variable' (got ['get_current_language'])" with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template') + self.engine.render_to_string("template") diff --git a/tests/template_tests/syntax_tests/i18n/test_get_current_language_bidi.py b/tests/template_tests/syntax_tests/i18n/test_get_current_language_bidi.py index 0ac408f78f..3f307471ae 100644 --- a/tests/template_tests/syntax_tests/i18n/test_get_current_language_bidi.py +++ b/tests/template_tests/syntax_tests/i18n/test_get_current_language_bidi.py @@ -5,10 +5,10 @@ from django.test import SimpleTestCase class I18nGetCurrentLanguageBidiTagTests(SimpleTestCase): - libraries = {'i18n': 'django.templatetags.i18n'} + libraries = {"i18n": "django.templatetags.i18n"} - @setup({'template': '{% load i18n %} {% get_current_language_bidi %}'}) + @setup({"template": "{% load i18n %} {% get_current_language_bidi %}"}) def test_no_as_var(self): msg = "'get_current_language_bidi' requires 'as variable' (got ['get_current_language_bidi'])" with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template') + self.engine.render_to_string("template") diff --git a/tests/template_tests/syntax_tests/i18n/test_get_language_info.py b/tests/template_tests/syntax_tests/i18n/test_get_language_info.py index 4ae8186af5..cf05df13db 100644 --- a/tests/template_tests/syntax_tests/i18n/test_get_language_info.py +++ b/tests/template_tests/syntax_tests/i18n/test_get_language_info.py @@ -7,37 +7,49 @@ from ...utils import setup class I18nGetLanguageInfoTagTests(SimpleTestCase): libraries = { - 'custom': 'template_tests.templatetags.custom', - 'i18n': 'django.templatetags.i18n', + "custom": "template_tests.templatetags.custom", + "i18n": "django.templatetags.i18n", } # retrieving language information - @setup({'i18n28_2': '{% load i18n %}' - '{% get_language_info for "de" as l %}' - '{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}'}) + @setup( + { + "i18n28_2": "{% load i18n %}" + '{% get_language_info for "de" as l %}' + "{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}" + } + ) def test_i18n28_2(self): - output = self.engine.render_to_string('i18n28_2') - self.assertEqual(output, 'de: German/Deutsch bidi=False') + output = self.engine.render_to_string("i18n28_2") + self.assertEqual(output, "de: German/Deutsch bidi=False") - @setup({'i18n29': '{% load i18n %}' - '{% get_language_info for LANGUAGE_CODE as l %}' - '{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}'}) + @setup( + { + "i18n29": "{% load i18n %}" + "{% get_language_info for LANGUAGE_CODE as l %}" + "{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}" + } + ) def test_i18n29(self): - output = self.engine.render_to_string('i18n29', {'LANGUAGE_CODE': 'fi'}) - self.assertEqual(output, 'fi: Finnish/suomi bidi=False') + output = self.engine.render_to_string("i18n29", {"LANGUAGE_CODE": "fi"}) + self.assertEqual(output, "fi: Finnish/suomi bidi=False") # Test whitespace in filter arguments - @setup({'i18n38': '{% load i18n custom %}' - '{% get_language_info for "de"|noop:"x y" as l %}' - '{{ l.code }}: {{ l.name }}/{{ l.name_local }}/' - '{{ l.name_translated }} bidi={{ l.bidi }}'}) + @setup( + { + "i18n38": "{% load i18n custom %}" + '{% get_language_info for "de"|noop:"x y" as l %}' + "{{ l.code }}: {{ l.name }}/{{ l.name_local }}/" + "{{ l.name_translated }} bidi={{ l.bidi }}" + } + ) def test_i18n38(self): - with translation.override('cs'): - output = self.engine.render_to_string('i18n38') - self.assertEqual(output, 'de: German/Deutsch/německy bidi=False') + with translation.override("cs"): + output = self.engine.render_to_string("i18n38") + self.assertEqual(output, "de: German/Deutsch/německy bidi=False") - @setup({'template': '{% load i18n %}{% get_language_info %}'}) + @setup({"template": "{% load i18n %}{% get_language_info %}"}) def test_no_for_as(self): msg = "'get_language_info' requires 'for string as variable' (got [])" with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template') + self.engine.render_to_string("template") diff --git a/tests/template_tests/syntax_tests/i18n/test_get_language_info_list.py b/tests/template_tests/syntax_tests/i18n/test_get_language_info_list.py index c2c7f8b9cb..93038daa2f 100644 --- a/tests/template_tests/syntax_tests/i18n/test_get_language_info_list.py +++ b/tests/template_tests/syntax_tests/i18n/test_get_language_info_list.py @@ -7,46 +7,64 @@ from ...utils import setup class GetLanguageInfoListTests(SimpleTestCase): libraries = { - 'custom': 'template_tests.templatetags.custom', - 'i18n': 'django.templatetags.i18n', + "custom": "template_tests.templatetags.custom", + "i18n": "django.templatetags.i18n", } - @setup({'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 %}'}) + @setup( + { + "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 %}" + } + ) def test_i18n30(self): - output = self.engine.render_to_string('i18n30', {'langcodes': ['it', 'no']}) - self.assertEqual(output, 'it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; ') + output = self.engine.render_to_string("i18n30", {"langcodes": ["it", "no"]}) + self.assertEqual( + output, "it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; " + ) - @setup({'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 %}'}) + @setup( + { + "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 %}" + } + ) def test_i18n31(self): - output = self.engine.render_to_string('i18n31', {'langcodes': (('sl', 'Slovenian'), ('fa', 'Persian'))}) + output = self.engine.render_to_string( + "i18n31", {"langcodes": (("sl", "Slovenian"), ("fa", "Persian"))} + ) self.assertEqual( output, - 'sl: Slovenian/Sloven\u0161\u010dina bidi=False; ' - 'fa: Persian/\u0641\u0627\u0631\u0633\u06cc bidi=True; ' + "sl: Slovenian/Sloven\u0161\u010dina bidi=False; " + "fa: Persian/\u0641\u0627\u0631\u0633\u06cc bidi=True; ", ) - @setup({'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 }}/{{ l.name_translated }} ' - 'bidi={{ l.bidi }}; {% endfor %}'}) + @setup( + { + "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 }}/{{ l.name_translated }} " + "bidi={{ l.bidi }}; {% endfor %}" + } + ) def test_i18n38_2(self): - with translation.override('cs'): - output = self.engine.render_to_string('i18n38_2', {'langcodes': ['it', 'fr']}) + with translation.override("cs"): + output = self.engine.render_to_string( + "i18n38_2", {"langcodes": ["it", "fr"]} + ) self.assertEqual( output, - 'it: Italian/italiano/italsky bidi=False; ' - 'fr: French/français/francouzsky bidi=False; ' + "it: Italian/italiano/italsky bidi=False; " + "fr: French/français/francouzsky bidi=False; ", ) - @setup({'i18n_syntax': '{% load i18n %} {% get_language_info_list error %}'}) + @setup({"i18n_syntax": "{% load i18n %} {% get_language_info_list error %}"}) def test_no_for_as(self): msg = "'get_language_info_list' requires 'for sequence as variable' (got ['error'])" with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('i18n_syntax') + self.engine.render_to_string("i18n_syntax") diff --git a/tests/template_tests/syntax_tests/i18n/test_language.py b/tests/template_tests/syntax_tests/i18n/test_language.py index 47797befae..57a3a53866 100644 --- a/tests/template_tests/syntax_tests/i18n/test_language.py +++ b/tests/template_tests/syntax_tests/i18n/test_language.py @@ -5,9 +5,11 @@ from django.test import SimpleTestCase class I18nLanguageTagTests(SimpleTestCase): - libraries = {'i18n': 'django.templatetags.i18n'} + libraries = {"i18n": "django.templatetags.i18n"} - @setup({'i18n_language': '{% load i18n %} {% language %} {% endlanguage %}'}) + @setup({"i18n_language": "{% load i18n %} {% language %} {% endlanguage %}"}) def test_no_arg(self): - with self.assertRaisesMessage(TemplateSyntaxError, "'language' takes one argument (language)"): - self.engine.render_to_string('i18n_language') + with self.assertRaisesMessage( + TemplateSyntaxError, "'language' takes one argument (language)" + ): + self.engine.render_to_string("i18n_language") diff --git a/tests/template_tests/syntax_tests/i18n/test_translate.py b/tests/template_tests/syntax_tests/i18n/test_translate.py index 55fdb92f7a..932b47a373 100644 --- a/tests/template_tests/syntax_tests/i18n/test_translate.py +++ b/tests/template_tests/syntax_tests/i18n/test_translate.py @@ -16,14 +16,16 @@ from .base import MultipleLocaleActivationTestCase, extended_locale_paths def setup(templates, *args, **kwargs): translate_setup = base_setup(templates, *args, **kwargs) - trans_setup = base_setup({ - name: template.replace('{% translate ', '{% trans ') - for name, template in templates.items() - }) + trans_setup = base_setup( + { + name: template.replace("{% translate ", "{% trans ") + for name, template in templates.items() + } + ) tags = { - 'trans': trans_setup, - 'translate': translate_setup, + "trans": trans_setup, + "translate": translate_setup, } def decorator(func): @@ -31,143 +33,162 @@ def setup(templates, *args, **kwargs): def inner(self, *args): signature = inspect.signature(func) for tag_name, setup_func in tags.items(): - if 'tag_name' in signature.parameters: + if "tag_name" in signature.parameters: setup_func(partial(func, tag_name=tag_name))(self) else: setup_func(func)(self) + return inner + return decorator class I18nTransTagTests(SimpleTestCase): - libraries = {'i18n': 'django.templatetags.i18n'} + libraries = {"i18n": "django.templatetags.i18n"} - @setup({'i18n01': '{% load i18n %}{% translate \'xxxyyyxxx\' %}'}) + @setup({"i18n01": "{% load i18n %}{% translate 'xxxyyyxxx' %}"}) def test_i18n01(self): """simple translation of a string delimited by '.""" - output = self.engine.render_to_string('i18n01') - self.assertEqual(output, 'xxxyyyxxx') + output = self.engine.render_to_string("i18n01") + self.assertEqual(output, "xxxyyyxxx") - @setup({'i18n02': '{% load i18n %}{% translate "xxxyyyxxx" %}'}) + @setup({"i18n02": '{% load i18n %}{% translate "xxxyyyxxx" %}'}) def test_i18n02(self): """simple translation of a string delimited by ".""" - output = self.engine.render_to_string('i18n02') - self.assertEqual(output, 'xxxyyyxxx') + output = self.engine.render_to_string("i18n02") + self.assertEqual(output, "xxxyyyxxx") - @setup({'i18n06': '{% load i18n %}{% translate "Page not found" %}'}) + @setup({"i18n06": '{% load i18n %}{% translate "Page not found" %}'}) def test_i18n06(self): """simple translation of a string to German""" - with translation.override('de'): - output = self.engine.render_to_string('i18n06') - self.assertEqual(output, 'Seite nicht gefunden') + with translation.override("de"): + output = self.engine.render_to_string("i18n06") + self.assertEqual(output, "Seite nicht gefunden") - @setup({'i18n09': '{% load i18n %}{% translate "Page not found" noop %}'}) + @setup({"i18n09": '{% load i18n %}{% translate "Page not found" noop %}'}) def test_i18n09(self): """simple non-translation (only marking) of a string to German""" - with translation.override('de'): - output = self.engine.render_to_string('i18n09') - self.assertEqual(output, 'Page not found') + with translation.override("de"): + output = self.engine.render_to_string("i18n09") + self.assertEqual(output, "Page not found") - @setup({'i18n20': '{% load i18n %}{% translate andrew %}'}) + @setup({"i18n20": "{% load i18n %}{% translate andrew %}"}) def test_i18n20(self): - output = self.engine.render_to_string('i18n20', {'andrew': 'a & b'}) - self.assertEqual(output, 'a & b') + output = self.engine.render_to_string("i18n20", {"andrew": "a & b"}) + self.assertEqual(output, "a & b") - @setup({'i18n22': '{% load i18n %}{% translate andrew %}'}) + @setup({"i18n22": "{% load i18n %}{% translate andrew %}"}) def test_i18n22(self): - output = self.engine.render_to_string('i18n22', {'andrew': mark_safe('a & b')}) - self.assertEqual(output, 'a & b') - - @setup({'i18n23': '{% load i18n %}{% translate "Page not found"|capfirst|slice:"6:" %}'}) + output = self.engine.render_to_string("i18n22", {"andrew": mark_safe("a & b")}) + self.assertEqual(output, "a & b") + + @setup( + { + "i18n23": '{% load i18n %}{% translate "Page not found"|capfirst|slice:"6:" %}' + } + ) def test_i18n23(self): """Using filters with the {% translate %} tag (#5972).""" - with translation.override('de'): - output = self.engine.render_to_string('i18n23') - self.assertEqual(output, 'nicht gefunden') + with translation.override("de"): + output = self.engine.render_to_string("i18n23") + self.assertEqual(output, "nicht gefunden") - @setup({'i18n24': '{% load i18n %}{% translate \'Page not found\'|upper %}'}) + @setup({"i18n24": "{% load i18n %}{% translate 'Page not found'|upper %}"}) def test_i18n24(self): - with translation.override('de'): - output = self.engine.render_to_string('i18n24') - self.assertEqual(output, 'SEITE NICHT GEFUNDEN') + with translation.override("de"): + output = self.engine.render_to_string("i18n24") + self.assertEqual(output, "SEITE NICHT GEFUNDEN") - @setup({'i18n25': '{% load i18n %}{% translate somevar|upper %}'}) + @setup({"i18n25": "{% load i18n %}{% translate somevar|upper %}"}) def test_i18n25(self): - with translation.override('de'): - output = self.engine.render_to_string('i18n25', {'somevar': 'Page not found'}) - self.assertEqual(output, 'SEITE NICHT GEFUNDEN') + with translation.override("de"): + output = self.engine.render_to_string( + "i18n25", {"somevar": "Page not found"} + ) + self.assertEqual(output, "SEITE NICHT GEFUNDEN") # trans tag with as var - @setup({'i18n35': '{% load i18n %}{% translate "Page not found" as page_not_found %}{{ page_not_found }}'}) + @setup( + { + "i18n35": '{% load i18n %}{% translate "Page not found" as page_not_found %}{{ page_not_found }}' + } + ) def test_i18n35(self): - with translation.override('de'): - output = self.engine.render_to_string('i18n35') - self.assertEqual(output, 'Seite nicht gefunden') - - @setup({'i18n36': '{% load i18n %}' - '{% translate "Page not found" noop as page_not_found %}{{ page_not_found }}'}) + with translation.override("de"): + output = self.engine.render_to_string("i18n35") + self.assertEqual(output, "Seite nicht gefunden") + + @setup( + { + "i18n36": "{% load i18n %}" + '{% translate "Page not found" noop as page_not_found %}{{ page_not_found }}' + } + ) def test_i18n36(self): - with translation.override('de'): - output = self.engine.render_to_string('i18n36') - self.assertEqual(output, 'Page not found') + with translation.override("de"): + output = self.engine.render_to_string("i18n36") + self.assertEqual(output, "Page not found") - @setup({'template': '{% load i18n %}{% translate %}A}'}) + @setup({"template": "{% load i18n %}{% translate %}A}"}) def test_syntax_error_no_arguments(self, tag_name): msg = "'{}' takes at least one argument".format(tag_name) with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template') + self.engine.render_to_string("template") - @setup({'template': '{% load i18n %}{% translate "Yes" badoption %}'}) + @setup({"template": '{% load i18n %}{% translate "Yes" badoption %}'}) def test_syntax_error_bad_option(self, tag_name): msg = "Unknown argument for '{}' tag: 'badoption'".format(tag_name) with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template') + self.engine.render_to_string("template") - @setup({'template': '{% load i18n %}{% translate "Yes" as %}'}) + @setup({"template": '{% load i18n %}{% translate "Yes" as %}'}) def test_syntax_error_missing_assignment(self, tag_name): msg = "No argument provided to the '{}' tag for the as option.".format(tag_name) with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template') + self.engine.render_to_string("template") - @setup({'template': '{% load i18n %}{% translate "Yes" as var context %}'}) + @setup({"template": '{% load i18n %}{% translate "Yes" as var context %}'}) def test_syntax_error_missing_context(self, tag_name): - msg = "No argument provided to the '{}' tag for the context option.".format(tag_name) + msg = "No argument provided to the '{}' tag for the context option.".format( + tag_name + ) with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template') + self.engine.render_to_string("template") - @setup({'template': '{% load i18n %}{% translate "Yes" context as var %}'}) + @setup({"template": '{% load i18n %}{% translate "Yes" context as var %}'}) def test_syntax_error_context_as(self, tag_name): - msg = "Invalid argument 'as' provided to the '{}' tag for the context option".format(tag_name) + msg = "Invalid argument 'as' provided to the '{}' tag for the context option".format( + tag_name + ) with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template') + self.engine.render_to_string("template") - @setup({'template': '{% load i18n %}{% translate "Yes" context noop %}'}) + @setup({"template": '{% load i18n %}{% translate "Yes" context noop %}'}) def test_syntax_error_context_noop(self, tag_name): - msg = "Invalid argument 'noop' provided to the '{}' tag for the context option".format(tag_name) + msg = "Invalid argument 'noop' provided to the '{}' tag for the context option".format( + tag_name + ) with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template') + self.engine.render_to_string("template") - @setup({'template': '{% load i18n %}{% translate "Yes" noop noop %}'}) + @setup({"template": '{% load i18n %}{% translate "Yes" noop noop %}'}) def test_syntax_error_duplicate_option(self): msg = "The 'noop' option was specified more than once." with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template') + self.engine.render_to_string("template") - @setup({'template': '{% load i18n %}{% translate "%s" %}'}) + @setup({"template": '{% load i18n %}{% translate "%s" %}'}) def test_trans_tag_using_a_string_that_looks_like_str_fmt(self): - output = self.engine.render_to_string('template') - self.assertEqual(output, '%s') + output = self.engine.render_to_string("template") + self.assertEqual(output, "%s") class TranslationTransTagTests(SimpleTestCase): - tag_name = 'trans' + tag_name = "trans" def get_template(self, template_string): return Template( - template_string.replace( - '{{% translate ', - '{{% {}'.format(self.tag_name) - ) + template_string.replace("{{% translate ", "{{% {}".format(self.tag_name)) ) @override_settings(LOCALE_PATHS=extended_locale_paths) @@ -175,58 +196,71 @@ class TranslationTransTagTests(SimpleTestCase): """{% translate %} takes message contexts into account (#14806).""" trans_real._active = Local() trans_real._translations = {} - with translation.override('de'): + with translation.override("de"): # Nonexistent context... - t = self.get_template('{% load i18n %}{% translate "May" context "nonexistent" %}') + t = self.get_template( + '{% load i18n %}{% translate "May" context "nonexistent" %}' + ) rendered = t.render(Context()) - self.assertEqual(rendered, 'May') + self.assertEqual(rendered, "May") # Existing context... using a literal - t = self.get_template('{% load i18n %}{% translate "May" context "month name" %}') + t = self.get_template( + '{% load i18n %}{% translate "May" context "month name" %}' + ) rendered = t.render(Context()) - self.assertEqual(rendered, 'Mai') + self.assertEqual(rendered, "Mai") t = self.get_template('{% load i18n %}{% translate "May" context "verb" %}') rendered = t.render(Context()) - self.assertEqual(rendered, 'Kann') + self.assertEqual(rendered, "Kann") # Using a variable - t = self.get_template('{% load i18n %}{% translate "May" context message_context %}') - rendered = t.render(Context({'message_context': 'month name'})) - self.assertEqual(rendered, 'Mai') - t = self.get_template('{% load i18n %}{% translate "May" context message_context %}') - rendered = t.render(Context({'message_context': 'verb'})) - self.assertEqual(rendered, 'Kann') + t = self.get_template( + '{% load i18n %}{% translate "May" context message_context %}' + ) + rendered = t.render(Context({"message_context": "month name"})) + self.assertEqual(rendered, "Mai") + t = self.get_template( + '{% load i18n %}{% translate "May" context message_context %}' + ) + rendered = t.render(Context({"message_context": "verb"})) + self.assertEqual(rendered, "Kann") # Using a filter - t = self.get_template('{% load i18n %}{% translate "May" context message_context|lower %}') - rendered = t.render(Context({'message_context': 'MONTH NAME'})) - self.assertEqual(rendered, 'Mai') - t = self.get_template('{% load i18n %}{% translate "May" context message_context|lower %}') - rendered = t.render(Context({'message_context': 'VERB'})) - self.assertEqual(rendered, 'Kann') + t = self.get_template( + '{% load i18n %}{% translate "May" context message_context|lower %}' + ) + rendered = t.render(Context({"message_context": "MONTH NAME"})) + self.assertEqual(rendered, "Mai") + t = self.get_template( + '{% load i18n %}{% translate "May" context message_context|lower %}' + ) + rendered = t.render(Context({"message_context": "VERB"})) + self.assertEqual(rendered, "Kann") # Using 'as' - t = self.get_template('{% load i18n %}{% translate "May" context "month name" as var %}Value: {{ var }}') + t = self.get_template( + '{% load i18n %}{% translate "May" context "month name" as var %}Value: {{ var }}' + ) rendered = t.render(Context()) - self.assertEqual(rendered, 'Value: Mai') - t = self.get_template('{% load i18n %}{% translate "May" as var context "verb" %}Value: {{ var }}') + self.assertEqual(rendered, "Value: Mai") + t = self.get_template( + '{% load i18n %}{% translate "May" as var context "verb" %}Value: {{ var }}' + ) rendered = t.render(Context()) - self.assertEqual(rendered, 'Value: Kann') + self.assertEqual(rendered, "Value: Kann") class TranslationTranslateTagTests(TranslationTransTagTests): - tag_name = 'translate' + tag_name = "translate" class MultipleLocaleActivationTransTagTests(MultipleLocaleActivationTestCase): - tag_name = 'trans' + tag_name = "trans" def get_template(self, template_string): return Template( - template_string.replace( - '{{% translate ', - '{{% {}'.format(self.tag_name) - ) + template_string.replace("{{% translate ", "{{% {}".format(self.tag_name)) ) def test_single_locale_activation(self): @@ -234,36 +268,38 @@ class MultipleLocaleActivationTransTagTests(MultipleLocaleActivationTestCase): Simple baseline behavior with one locale for all the supported i18n constructs. """ - with translation.override('fr'): + with translation.override("fr"): self.assertEqual( - self.get_template("{% load i18n %}{% translate 'Yes' %}").render(Context({})), - 'Oui' + self.get_template("{% load i18n %}{% translate 'Yes' %}").render( + Context({}) + ), + "Oui", ) def test_multiple_locale_trans(self): - with translation.override('de'): + with translation.override("de"): t = self.get_template("{% load i18n %}{% translate 'No' %}") - with translation.override(self._old_language), translation.override('nl'): - self.assertEqual(t.render(Context({})), 'Nee') + with translation.override(self._old_language), translation.override("nl"): + self.assertEqual(t.render(Context({})), "Nee") def test_multiple_locale_deactivate_trans(self): - with translation.override('de', deactivate=True): + with translation.override("de", deactivate=True): t = self.get_template("{% load i18n %}{% translate 'No' %}") - with translation.override('nl'): - self.assertEqual(t.render(Context({})), 'Nee') + with translation.override("nl"): + self.assertEqual(t.render(Context({})), "Nee") def test_multiple_locale_direct_switch_trans(self): - with translation.override('de'): + with translation.override("de"): t = self.get_template("{% load i18n %}{% translate 'No' %}") - with translation.override('nl'): - self.assertEqual(t.render(Context({})), 'Nee') + with translation.override("nl"): + self.assertEqual(t.render(Context({})), "Nee") class MultipleLocaleActivationTranslateTagTests(MultipleLocaleActivationTransTagTests): - tag_name = 'translate' + tag_name = "translate" class LocalizeNodeTests(SimpleTestCase): def test_repr(self): node = LocalizeNode(nodelist=[], use_l10n=True) - self.assertEqual(repr(node), '') + self.assertEqual(repr(node), "") diff --git a/tests/template_tests/syntax_tests/i18n/test_underscore_syntax.py b/tests/template_tests/syntax_tests/i18n/test_underscore_syntax.py index 38d929e214..dfb035999c 100644 --- a/tests/template_tests/syntax_tests/i18n/test_underscore_syntax.py +++ b/tests/template_tests/syntax_tests/i18n/test_underscore_syntax.py @@ -7,101 +7,105 @@ from .base import MultipleLocaleActivationTestCase class MultipleLocaleActivationTests(MultipleLocaleActivationTestCase): - def test_single_locale_activation(self): """ Simple baseline behavior with one locale for all the supported i18n constructs. """ - with translation.override('fr'): - self.assertEqual(Template("{{ _('Yes') }}").render(Context({})), 'Oui') + with translation.override("fr"): + self.assertEqual(Template("{{ _('Yes') }}").render(Context({})), "Oui") # Literal marked up with _() in a filter expression def test_multiple_locale_filter(self): - with translation.override('de'): + with translation.override("de"): t = Template("{% load i18n %}{{ 0|yesno:_('yes,no,maybe') }}") - with translation.override(self._old_language), translation.override('nl'): - self.assertEqual(t.render(Context({})), 'nee') + with translation.override(self._old_language), translation.override("nl"): + self.assertEqual(t.render(Context({})), "nee") def test_multiple_locale_filter_deactivate(self): - with translation.override('de', deactivate=True): + with translation.override("de", deactivate=True): t = Template("{% load i18n %}{{ 0|yesno:_('yes,no,maybe') }}") - with translation.override('nl'): - self.assertEqual(t.render(Context({})), 'nee') + with translation.override("nl"): + self.assertEqual(t.render(Context({})), "nee") def test_multiple_locale_filter_direct_switch(self): - with translation.override('de'): + with translation.override("de"): t = Template("{% load i18n %}{{ 0|yesno:_('yes,no,maybe') }}") - with translation.override('nl'): - self.assertEqual(t.render(Context({})), 'nee') + with translation.override("nl"): + self.assertEqual(t.render(Context({})), "nee") # Literal marked up with _() def test_multiple_locale(self): - with translation.override('de'): + with translation.override("de"): t = Template("{{ _('No') }}") - with translation.override(self._old_language), translation.override('nl'): - self.assertEqual(t.render(Context({})), 'Nee') + with translation.override(self._old_language), translation.override("nl"): + self.assertEqual(t.render(Context({})), "Nee") def test_multiple_locale_deactivate(self): - with translation.override('de', deactivate=True): + with translation.override("de", deactivate=True): t = Template("{{ _('No') }}") - with translation.override('nl'): - self.assertEqual(t.render(Context({})), 'Nee') + with translation.override("nl"): + self.assertEqual(t.render(Context({})), "Nee") def test_multiple_locale_direct_switch(self): - with translation.override('de'): + with translation.override("de"): t = Template("{{ _('No') }}") - with translation.override('nl'): - self.assertEqual(t.render(Context({})), 'Nee') + with translation.override("nl"): + self.assertEqual(t.render(Context({})), "Nee") # Literal marked up with _(), loading the i18n template tag library def test_multiple_locale_loadi18n(self): - with translation.override('de'): + with translation.override("de"): t = Template("{% load i18n %}{{ _('No') }}") - with translation.override(self._old_language), translation.override('nl'): - self.assertEqual(t.render(Context({})), 'Nee') + with translation.override(self._old_language), translation.override("nl"): + self.assertEqual(t.render(Context({})), "Nee") def test_multiple_locale_loadi18n_deactivate(self): - with translation.override('de', deactivate=True): + with translation.override("de", deactivate=True): t = Template("{% load i18n %}{{ _('No') }}") - with translation.override('nl'): - self.assertEqual(t.render(Context({})), 'Nee') + with translation.override("nl"): + self.assertEqual(t.render(Context({})), "Nee") def test_multiple_locale_loadi18n_direct_switch(self): - with translation.override('de'): + with translation.override("de"): t = Template("{% load i18n %}{{ _('No') }}") - with translation.override('nl'): - self.assertEqual(t.render(Context({})), 'Nee') + with translation.override("nl"): + self.assertEqual(t.render(Context({})), "Nee") class I18nStringLiteralTests(SimpleTestCase): """translation of constant strings""" - libraries = {'i18n': 'django.templatetags.i18n'} - @setup({'i18n13': '{{ _("Password") }}'}) + libraries = {"i18n": "django.templatetags.i18n"} + + @setup({"i18n13": '{{ _("Password") }}'}) def test_i18n13(self): - with translation.override('de'): - output = self.engine.render_to_string('i18n13') - self.assertEqual(output, 'Passwort') + with translation.override("de"): + output = self.engine.render_to_string("i18n13") + self.assertEqual(output, "Passwort") - @setup({'i18n14': '{% cycle "foo" _("Password") _(\'Password\') as c %} {% cycle c %} {% cycle c %}'}) + @setup( + { + "i18n14": '{% cycle "foo" _("Password") _(\'Password\') as c %} {% cycle c %} {% cycle c %}' + } + ) def test_i18n14(self): - with translation.override('de'): - output = self.engine.render_to_string('i18n14') - self.assertEqual(output, 'foo Passwort Passwort') + with translation.override("de"): + output = self.engine.render_to_string("i18n14") + self.assertEqual(output, "foo Passwort Passwort") - @setup({'i18n15': '{{ absent|default:_("Password") }}'}) + @setup({"i18n15": '{{ absent|default:_("Password") }}'}) def test_i18n15(self): - with translation.override('de'): - output = self.engine.render_to_string('i18n15', {'absent': ''}) - self.assertEqual(output, 'Passwort') + with translation.override("de"): + output = self.engine.render_to_string("i18n15", {"absent": ""}) + self.assertEqual(output, "Passwort") - @setup({'i18n16': '{{ _("<") }}'}) + @setup({"i18n16": '{{ _("<") }}'}) def test_i18n16(self): - with translation.override('de'): - output = self.engine.render_to_string('i18n16') - self.assertEqual(output, '<') + with translation.override("de"): + output = self.engine.render_to_string("i18n16") + self.assertEqual(output, "<") diff --git a/tests/template_tests/syntax_tests/test_autoescape.py b/tests/template_tests/syntax_tests/test_autoescape.py index 13968537a6..d3c5cb02da 100644 --- a/tests/template_tests/syntax_tests/test_autoescape.py +++ b/tests/template_tests/syntax_tests/test_autoescape.py @@ -6,72 +6,89 @@ from ..utils import SafeClass, UnsafeClass, setup class AutoescapeTagTests(SimpleTestCase): - - @setup({'autoescape-tag01': '{% autoescape off %}hello{% endautoescape %}'}) + @setup({"autoescape-tag01": "{% autoescape off %}hello{% endautoescape %}"}) def test_autoescape_tag01(self): - output = self.engine.render_to_string('autoescape-tag01') - self.assertEqual(output, 'hello') + output = self.engine.render_to_string("autoescape-tag01") + self.assertEqual(output, "hello") - @setup({'autoescape-tag02': '{% autoescape off %}{{ first }}{% endautoescape %}'}) + @setup({"autoescape-tag02": "{% autoescape off %}{{ first }}{% endautoescape %}"}) def test_autoescape_tag02(self): - output = self.engine.render_to_string('autoescape-tag02', {'first': 'hello'}) - self.assertEqual(output, 'hello') + output = self.engine.render_to_string( + "autoescape-tag02", {"first": "hello"} + ) + self.assertEqual(output, "hello") - @setup({'autoescape-tag03': '{% autoescape on %}{{ first }}{% endautoescape %}'}) + @setup({"autoescape-tag03": "{% autoescape on %}{{ first }}{% endautoescape %}"}) def test_autoescape_tag03(self): - output = self.engine.render_to_string('autoescape-tag03', {'first': 'hello'}) - self.assertEqual(output, '<b>hello</b>') + output = self.engine.render_to_string( + "autoescape-tag03", {"first": "hello"} + ) + self.assertEqual(output, "<b>hello</b>") # Autoescape disabling and enabling nest in a predictable way. - @setup({ - 'autoescape-tag04': - '{% autoescape off %}{{ first }} {% autoescape on %}{{ first }}{% endautoescape %}{% endautoescape %}' - }) + @setup( + { + "autoescape-tag04": "{% autoescape off %}{{ first }} {% autoescape on %}{{ first }}{% endautoescape %}{% endautoescape %}" + } + ) def test_autoescape_tag04(self): - output = self.engine.render_to_string('autoescape-tag04', {'first': ''}) - self.assertEqual(output, ' <a>') + output = self.engine.render_to_string("autoescape-tag04", {"first": ""}) + self.assertEqual(output, " <a>") - @setup({'autoescape-tag05': '{% autoescape on %}{{ first }}{% endautoescape %}'}) + @setup({"autoescape-tag05": "{% autoescape on %}{{ first }}{% endautoescape %}"}) def test_autoescape_tag05(self): - output = self.engine.render_to_string('autoescape-tag05', {'first': 'first'}) - self.assertEqual(output, '<b>first</b>') + output = self.engine.render_to_string( + "autoescape-tag05", {"first": "first"} + ) + self.assertEqual(output, "<b>first</b>") # Strings (ASCII or Unicode) already marked as "safe" are not # auto-escaped - @setup({'autoescape-tag06': '{{ first }}'}) + @setup({"autoescape-tag06": "{{ first }}"}) def test_autoescape_tag06(self): - output = self.engine.render_to_string('autoescape-tag06', {'first': mark_safe('first')}) - self.assertEqual(output, 'first') + output = self.engine.render_to_string( + "autoescape-tag06", {"first": mark_safe("first")} + ) + self.assertEqual(output, "first") - @setup({'autoescape-tag07': '{% autoescape on %}{{ first }}{% endautoescape %}'}) + @setup({"autoescape-tag07": "{% autoescape on %}{{ first }}{% endautoescape %}"}) def test_autoescape_tag07(self): - output = self.engine.render_to_string('autoescape-tag07', {'first': mark_safe('Apple')}) - self.assertEqual(output, 'Apple') - - @setup({ - 'autoescape-tag08': - r'{% autoescape on %}{{ var|default_if_none:" endquote\" hah" }}{% endautoescape %}' - }) + output = self.engine.render_to_string( + "autoescape-tag07", {"first": mark_safe("Apple")} + ) + self.assertEqual(output, "Apple") + + @setup( + { + "autoescape-tag08": r'{% autoescape on %}{{ var|default_if_none:" endquote\" hah" }}{% endautoescape %}' + } + ) def test_autoescape_tag08(self): """ Literal string arguments to filters, if used in the result, are safe. """ - output = self.engine.render_to_string('autoescape-tag08', {"var": None}) + output = self.engine.render_to_string("autoescape-tag08", {"var": None}) self.assertEqual(output, ' endquote" hah') # Objects which return safe strings as their __str__ method # won't get double-escaped. - @setup({'autoescape-tag09': r'{{ unsafe }}'}) + @setup({"autoescape-tag09": r"{{ unsafe }}"}) def test_autoescape_tag09(self): - output = self.engine.render_to_string('autoescape-tag09', {'unsafe': UnsafeClass()}) - self.assertEqual(output, 'you & me') + output = self.engine.render_to_string( + "autoescape-tag09", {"unsafe": UnsafeClass()} + ) + self.assertEqual(output, "you & me") - @setup({'autoescape-tag10': r'{{ safe }}'}) + @setup({"autoescape-tag10": r"{{ safe }}"}) def test_autoescape_tag10(self): - output = self.engine.render_to_string('autoescape-tag10', {'safe': SafeClass()}) - self.assertEqual(output, 'you > me') - - @setup({'autoescape-filtertag01': '{{ first }}{% filter safe %}{{ first }} x'}) + self.engine.render_to_string("autoescape-filtertag01", {"first": ""}) # Arguments to filters are 'safe' and manipulate their input unescaped. - @setup({'autoescape-filters01': '{{ var|cut:"&" }}'}) + @setup({"autoescape-filters01": '{{ var|cut:"&" }}'}) def test_autoescape_filters01(self): - output = self.engine.render_to_string('autoescape-filters01', {'var': 'this & that'}) - self.assertEqual(output, 'this that') + output = self.engine.render_to_string( + "autoescape-filters01", {"var": "this & that"} + ) + self.assertEqual(output, "this that") - @setup({'autoescape-filters02': '{{ var|join:" & " }}'}) + @setup({"autoescape-filters02": '{{ var|join:" & " }}'}) def test_autoescape_filters02(self): - output = self.engine.render_to_string('autoescape-filters02', {'var': ('Tom', 'Dick', 'Harry')}) - self.assertEqual(output, 'Tom & Dick & Harry') + output = self.engine.render_to_string( + "autoescape-filters02", {"var": ("Tom", "Dick", "Harry")} + ) + self.assertEqual(output, "Tom & Dick & Harry") - @setup({'autoescape-literals01': '{{ "this & that" }}'}) + @setup({"autoescape-literals01": '{{ "this & that" }}'}) def test_autoescape_literals01(self): """ Literal strings are safe. """ - output = self.engine.render_to_string('autoescape-literals01') - self.assertEqual(output, 'this & that') + output = self.engine.render_to_string("autoescape-literals01") + self.assertEqual(output, "this & that") - @setup({'autoescape-stringiterations01': '{% for l in var %}{{ l }},{% endfor %}'}) + @setup({"autoescape-stringiterations01": "{% for l in var %}{{ l }},{% endfor %}"}) def test_autoescape_stringiterations01(self): """ Iterating over strings outputs safe characters. """ - output = self.engine.render_to_string('autoescape-stringiterations01', {'var': 'K&R'}) - self.assertEqual(output, 'K,&,R,') + output = self.engine.render_to_string( + "autoescape-stringiterations01", {"var": "K&R"} + ) + self.assertEqual(output, "K,&,R,") - @setup({'autoescape-lookup01': '{{ var.key }}'}) + @setup({"autoescape-lookup01": "{{ var.key }}"}) def test_autoescape_lookup01(self): """ Escape requirement survives lookup. """ - output = self.engine.render_to_string('autoescape-lookup01', {'var': {'key': 'this & that'}}) - self.assertEqual(output, 'this & that') - - @setup({'autoescape-incorrect-arg': '{% autoescape true %}{{ var.key }}{% endautoescape %}'}) + output = self.engine.render_to_string( + "autoescape-lookup01", {"var": {"key": "this & that"}} + ) + self.assertEqual(output, "this & that") + + @setup( + { + "autoescape-incorrect-arg": "{% autoescape true %}{{ var.key }}{% endautoescape %}" + } + ) def test_invalid_arg(self): msg = "'autoescape' argument should be 'on' or 'off'" with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('autoescape-incorrect-arg', {'var': {'key': 'this & that'}}) + self.engine.render_to_string( + "autoescape-incorrect-arg", {"var": {"key": "this & that"}} + ) - @setup({'autoescape-incorrect-arg': '{% autoescape %}{{ var.key }}{% endautoescape %}'}) + @setup( + {"autoescape-incorrect-arg": "{% autoescape %}{{ var.key }}{% endautoescape %}"} + ) def test_no_arg(self): msg = "'autoescape' tag requires exactly one argument." with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('autoescape-incorrect-arg', {'var': {'key': 'this & that'}}) + self.engine.render_to_string( + "autoescape-incorrect-arg", {"var": {"key": "this & that"}} + ) diff --git a/tests/template_tests/syntax_tests/test_basic.py b/tests/template_tests/syntax_tests/test_basic.py index 011ce51229..20bf30d55c 100644 --- a/tests/template_tests/syntax_tests/test_basic.py +++ b/tests/template_tests/syntax_tests/test_basic.py @@ -6,20 +6,19 @@ from django.test import SimpleTestCase from ..utils import SilentAttrClass, SilentGetItemClass, SomeClass, setup basic_templates = { - 'basic-syntax01': 'something cool', - 'basic-syntax02': '{{ headline }}', - 'basic-syntax03': '{{ first }} --- {{ second }}', + "basic-syntax01": "something cool", + "basic-syntax02": "{{ headline }}", + "basic-syntax03": "{{ first }} --- {{ second }}", } class BasicSyntaxTests(SimpleTestCase): - @setup(basic_templates) def test_basic_syntax01(self): """ Plain text should go through the template parser untouched. """ - output = self.engine.render_to_string('basic-syntax01') + output = self.engine.render_to_string("basic-syntax01") self.assertEqual(output, "something cool") @setup(basic_templates) @@ -28,318 +27,330 @@ class BasicSyntaxTests(SimpleTestCase): Variables should be replaced with their value in the current context """ - output = self.engine.render_to_string('basic-syntax02', {'headline': 'Success'}) - self.assertEqual(output, 'Success') + output = self.engine.render_to_string("basic-syntax02", {"headline": "Success"}) + self.assertEqual(output, "Success") @setup(basic_templates) def test_basic_syntax03(self): """ More than one replacement variable is allowed in a template """ - output = self.engine.render_to_string('basic-syntax03', {"first": 1, "second": 2}) - self.assertEqual(output, '1 --- 2') + output = self.engine.render_to_string( + "basic-syntax03", {"first": 1, "second": 2} + ) + self.assertEqual(output, "1 --- 2") - @setup({'basic-syntax04': 'as{{ missing }}df'}) + @setup({"basic-syntax04": "as{{ missing }}df"}) def test_basic_syntax04(self): """ Fail silently when a variable is not found in the current context """ - output = self.engine.render_to_string('basic-syntax04') + output = self.engine.render_to_string("basic-syntax04") if self.engine.string_if_invalid: - self.assertEqual(output, 'asINVALIDdf') + self.assertEqual(output, "asINVALIDdf") else: - self.assertEqual(output, 'asdf') + self.assertEqual(output, "asdf") - @setup({'basic-syntax06': '{{ multi word variable }}'}) + @setup({"basic-syntax06": "{{ multi word variable }}"}) def test_basic_syntax06(self): """ A variable may not contain more than one word """ with self.assertRaises(TemplateSyntaxError): - self.engine.get_template('basic-syntax06') + self.engine.get_template("basic-syntax06") - @setup({'basic-syntax07': '{{ }}'}) + @setup({"basic-syntax07": "{{ }}"}) def test_basic_syntax07(self): """ Raise TemplateSyntaxError for empty variable tags. """ - with self.assertRaisesMessage(TemplateSyntaxError, 'Empty variable tag on line 1'): - self.engine.get_template('basic-syntax07') + with self.assertRaisesMessage( + TemplateSyntaxError, "Empty variable tag on line 1" + ): + self.engine.get_template("basic-syntax07") - @setup({'basic-syntax08': '{{ }}'}) + @setup({"basic-syntax08": "{{ }}"}) def test_basic_syntax08(self): """ Raise TemplateSyntaxError for empty variable tags. """ - with self.assertRaisesMessage(TemplateSyntaxError, 'Empty variable tag on line 1'): - self.engine.get_template('basic-syntax08') + with self.assertRaisesMessage( + TemplateSyntaxError, "Empty variable tag on line 1" + ): + self.engine.get_template("basic-syntax08") - @setup({'basic-syntax09': '{{ var.method }}'}) + @setup({"basic-syntax09": "{{ var.method }}"}) def test_basic_syntax09(self): """ Attribute syntax allows a template to call an object's attribute """ - output = self.engine.render_to_string('basic-syntax09', {'var': SomeClass()}) - self.assertEqual(output, 'SomeClass.method') + output = self.engine.render_to_string("basic-syntax09", {"var": SomeClass()}) + self.assertEqual(output, "SomeClass.method") - @setup({'basic-syntax10': '{{ var.otherclass.method }}'}) + @setup({"basic-syntax10": "{{ var.otherclass.method }}"}) def test_basic_syntax10(self): """ Multiple levels of attribute access are allowed. """ - output = self.engine.render_to_string('basic-syntax10', {'var': SomeClass()}) - self.assertEqual(output, 'OtherClass.method') + output = self.engine.render_to_string("basic-syntax10", {"var": SomeClass()}) + self.assertEqual(output, "OtherClass.method") - @setup({'basic-syntax11': '{{ var.blech }}'}) + @setup({"basic-syntax11": "{{ var.blech }}"}) def test_basic_syntax11(self): """ Fail silently when a variable's attribute isn't found. """ - output = self.engine.render_to_string('basic-syntax11', {'var': SomeClass()}) + output = self.engine.render_to_string("basic-syntax11", {"var": SomeClass()}) if self.engine.string_if_invalid: - self.assertEqual(output, 'INVALID') + self.assertEqual(output, "INVALID") else: - self.assertEqual(output, '') + self.assertEqual(output, "") - @setup({'basic-syntax12': '{{ var.__dict__ }}'}) + @setup({"basic-syntax12": "{{ var.__dict__ }}"}) def test_basic_syntax12(self): """ Raise TemplateSyntaxError when trying to access a variable beginning with an underscore. """ with self.assertRaises(TemplateSyntaxError): - self.engine.get_template('basic-syntax12') + self.engine.get_template("basic-syntax12") # Raise TemplateSyntaxError when trying to access a variable # containing an illegal character. - @setup({'basic-syntax13': "{{ va>r }}"}) + @setup({"basic-syntax13": "{{ va>r }}"}) def test_basic_syntax13(self): with self.assertRaises(TemplateSyntaxError): - self.engine.get_template('basic-syntax13') + self.engine.get_template("basic-syntax13") - @setup({'basic-syntax14': "{{ (var.r) }}"}) + @setup({"basic-syntax14": "{{ (var.r) }}"}) def test_basic_syntax14(self): with self.assertRaises(TemplateSyntaxError): - self.engine.get_template('basic-syntax14') + self.engine.get_template("basic-syntax14") - @setup({'basic-syntax15': "{{ sp%am }}"}) + @setup({"basic-syntax15": "{{ sp%am }}"}) def test_basic_syntax15(self): with self.assertRaises(TemplateSyntaxError): - self.engine.get_template('basic-syntax15') + self.engine.get_template("basic-syntax15") - @setup({'basic-syntax16': "{{ eggs! }}"}) + @setup({"basic-syntax16": "{{ eggs! }}"}) def test_basic_syntax16(self): with self.assertRaises(TemplateSyntaxError): - self.engine.get_template('basic-syntax16') + self.engine.get_template("basic-syntax16") - @setup({'basic-syntax17': "{{ moo? }}"}) + @setup({"basic-syntax17": "{{ moo? }}"}) def test_basic_syntax17(self): with self.assertRaises(TemplateSyntaxError): - self.engine.get_template('basic-syntax17') + self.engine.get_template("basic-syntax17") - @setup({'basic-syntax18': "{{ foo.bar }}"}) + @setup({"basic-syntax18": "{{ foo.bar }}"}) def test_basic_syntax18(self): """ Attribute syntax allows a template to call a dictionary key's value. """ - output = self.engine.render_to_string('basic-syntax18', {"foo": {"bar": "baz"}}) + output = self.engine.render_to_string("basic-syntax18", {"foo": {"bar": "baz"}}) self.assertEqual(output, "baz") - @setup({'basic-syntax19': "{{ foo.spam }}"}) + @setup({"basic-syntax19": "{{ foo.spam }}"}) def test_basic_syntax19(self): """ Fail silently when a variable's dictionary key isn't found. """ - output = self.engine.render_to_string('basic-syntax19', {"foo": {"bar": "baz"}}) + output = self.engine.render_to_string("basic-syntax19", {"foo": {"bar": "baz"}}) if self.engine.string_if_invalid: - self.assertEqual(output, 'INVALID') + self.assertEqual(output, "INVALID") else: - self.assertEqual(output, '') + self.assertEqual(output, "") - @setup({'basic-syntax20': "{{ var.method2 }}"}) + @setup({"basic-syntax20": "{{ var.method2 }}"}) def test_basic_syntax20(self): """ Fail silently when accessing a non-simple method """ - output = self.engine.render_to_string('basic-syntax20', {'var': SomeClass()}) + output = self.engine.render_to_string("basic-syntax20", {"var": SomeClass()}) if self.engine.string_if_invalid: - self.assertEqual(output, 'INVALID') + self.assertEqual(output, "INVALID") else: - self.assertEqual(output, '') + self.assertEqual(output, "") - @setup({'basic-syntax20b': "{{ var.method5 }}"}) + @setup({"basic-syntax20b": "{{ var.method5 }}"}) def test_basic_syntax20b(self): """ Don't silence a TypeError if it was raised inside a callable. """ - template = self.engine.get_template('basic-syntax20b') + template = self.engine.get_template("basic-syntax20b") with self.assertRaises(TypeError): - template.render(Context({'var': SomeClass()})) + template.render(Context({"var": SomeClass()})) # Don't get confused when parsing something that is almost, but not # quite, a template tag. - @setup({'basic-syntax21': "a {{ moo %} b"}) + @setup({"basic-syntax21": "a {{ moo %} b"}) def test_basic_syntax21(self): - output = self.engine.render_to_string('basic-syntax21') + output = self.engine.render_to_string("basic-syntax21") self.assertEqual(output, "a {{ moo %} b") - @setup({'basic-syntax22': "{{ moo #}"}) + @setup({"basic-syntax22": "{{ moo #}"}) def test_basic_syntax22(self): - output = self.engine.render_to_string('basic-syntax22') + output = self.engine.render_to_string("basic-syntax22") self.assertEqual(output, "{{ moo #}") - @setup({'basic-syntax23': "{{ moo #} {{ cow }}"}) + @setup({"basic-syntax23": "{{ moo #} {{ cow }}"}) def test_basic_syntax23(self): """ Treat "moo #} {{ cow" as the variable. Not ideal, but costly to work around, so this triggers an error. """ with self.assertRaises(TemplateSyntaxError): - self.engine.get_template('basic-syntax23') + self.engine.get_template("basic-syntax23") - @setup({'basic-syntax24': "{{ moo\n }}"}) + @setup({"basic-syntax24": "{{ moo\n }}"}) def test_basic_syntax24(self): """ Embedded newlines make it not-a-tag. """ - output = self.engine.render_to_string('basic-syntax24') + output = self.engine.render_to_string("basic-syntax24") self.assertEqual(output, "{{ moo\n }}") # Literal strings are permitted inside variables, mostly for i18n # purposes. - @setup({'basic-syntax25': '{{ "fred" }}'}) + @setup({"basic-syntax25": '{{ "fred" }}'}) def test_basic_syntax25(self): - output = self.engine.render_to_string('basic-syntax25') + output = self.engine.render_to_string("basic-syntax25") self.assertEqual(output, "fred") - @setup({'basic-syntax26': r'{{ "\"fred\"" }}'}) + @setup({"basic-syntax26": r'{{ "\"fred\"" }}'}) def test_basic_syntax26(self): - output = self.engine.render_to_string('basic-syntax26') - self.assertEqual(output, "\"fred\"") + output = self.engine.render_to_string("basic-syntax26") + self.assertEqual(output, '"fred"') - @setup({'basic-syntax27': r'{{ _("\"fred\"") }}'}) + @setup({"basic-syntax27": r'{{ _("\"fred\"") }}'}) def test_basic_syntax27(self): - output = self.engine.render_to_string('basic-syntax27') - self.assertEqual(output, "\"fred\"") + output = self.engine.render_to_string("basic-syntax27") + self.assertEqual(output, '"fred"') # #12554 -- Make sure a silent_variable_failure Exception is # suppressed on dictionary and attribute lookup. - @setup({'basic-syntax28': "{{ a.b }}"}) + @setup({"basic-syntax28": "{{ a.b }}"}) def test_basic_syntax28(self): - output = self.engine.render_to_string('basic-syntax28', {'a': SilentGetItemClass()}) + output = self.engine.render_to_string( + "basic-syntax28", {"a": SilentGetItemClass()} + ) if self.engine.string_if_invalid: - self.assertEqual(output, 'INVALID') + self.assertEqual(output, "INVALID") else: - self.assertEqual(output, '') + self.assertEqual(output, "") - @setup({'basic-syntax29': "{{ a.b }}"}) + @setup({"basic-syntax29": "{{ a.b }}"}) def test_basic_syntax29(self): - output = self.engine.render_to_string('basic-syntax29', {'a': SilentAttrClass()}) + output = self.engine.render_to_string( + "basic-syntax29", {"a": SilentAttrClass()} + ) if self.engine.string_if_invalid: - self.assertEqual(output, 'INVALID') + self.assertEqual(output, "INVALID") else: - self.assertEqual(output, '') + self.assertEqual(output, "") # Something that starts like a number but has an extra lookup works # as a lookup. - @setup({'basic-syntax30': "{{ 1.2.3 }}"}) + @setup({"basic-syntax30": "{{ 1.2.3 }}"}) def test_basic_syntax30(self): output = self.engine.render_to_string( - 'basic-syntax30', - {"1": {"2": {"3": "d"}}} + "basic-syntax30", {"1": {"2": {"3": "d"}}} ) - self.assertEqual(output, 'd') + self.assertEqual(output, "d") - @setup({'basic-syntax31': "{{ 1.2.3 }}"}) + @setup({"basic-syntax31": "{{ 1.2.3 }}"}) def test_basic_syntax31(self): output = self.engine.render_to_string( - 'basic-syntax31', + "basic-syntax31", {"1": {"2": ("a", "b", "c", "d")}}, ) - self.assertEqual(output, 'd') + self.assertEqual(output, "d") - @setup({'basic-syntax32': "{{ 1.2.3 }}"}) + @setup({"basic-syntax32": "{{ 1.2.3 }}"}) def test_basic_syntax32(self): output = self.engine.render_to_string( - 'basic-syntax32', + "basic-syntax32", {"1": (("x", "x", "x", "x"), ("y", "y", "y", "y"), ("a", "b", "c", "d"))}, ) - self.assertEqual(output, 'd') + self.assertEqual(output, "d") - @setup({'basic-syntax33': "{{ 1.2.3 }}"}) + @setup({"basic-syntax33": "{{ 1.2.3 }}"}) def test_basic_syntax33(self): output = self.engine.render_to_string( - 'basic-syntax33', + "basic-syntax33", {"1": ("xxxx", "yyyy", "abcd")}, ) - self.assertEqual(output, 'd') + self.assertEqual(output, "d") - @setup({'basic-syntax34': "{{ 1.2.3 }}"}) + @setup({"basic-syntax34": "{{ 1.2.3 }}"}) def test_basic_syntax34(self): output = self.engine.render_to_string( - 'basic-syntax34', - {"1": ({"x": "x"}, {"y": "y"}, {"z": "z", "3": "d"})} + "basic-syntax34", {"1": ({"x": "x"}, {"y": "y"}, {"z": "z", "3": "d"})} ) - self.assertEqual(output, 'd') + self.assertEqual(output, "d") # Numbers are numbers even if their digits are in the context. - @setup({'basic-syntax35': "{{ 1 }}"}) + @setup({"basic-syntax35": "{{ 1 }}"}) def test_basic_syntax35(self): - output = self.engine.render_to_string('basic-syntax35', {"1": "abc"}) - self.assertEqual(output, '1') + output = self.engine.render_to_string("basic-syntax35", {"1": "abc"}) + self.assertEqual(output, "1") - @setup({'basic-syntax36': "{{ 1.2 }}"}) + @setup({"basic-syntax36": "{{ 1.2 }}"}) def test_basic_syntax36(self): - output = self.engine.render_to_string('basic-syntax36', {"1": "abc"}) - self.assertEqual(output, '1.2') + output = self.engine.render_to_string("basic-syntax36", {"1": "abc"}) + self.assertEqual(output, "1.2") - @setup({'basic-syntax37': '{{ callable }}'}) + @setup({"basic-syntax37": "{{ callable }}"}) def test_basic_syntax37(self): """ Call methods in the top level of the context. """ - output = self.engine.render_to_string('basic-syntax37', {"callable": lambda: "foo bar"}) - self.assertEqual(output, 'foo bar') + output = self.engine.render_to_string( + "basic-syntax37", {"callable": lambda: "foo bar"} + ) + self.assertEqual(output, "foo bar") - @setup({'basic-syntax38': '{{ var.callable }}'}) + @setup({"basic-syntax38": "{{ var.callable }}"}) def test_basic_syntax38(self): """ Call methods returned from dictionary lookups. """ - output = self.engine.render_to_string('basic-syntax38', {"var": {"callable": lambda: "foo bar"}}) - self.assertEqual(output, 'foo bar') + output = self.engine.render_to_string( + "basic-syntax38", {"var": {"callable": lambda: "foo bar"}} + ) + self.assertEqual(output, "foo bar") - @setup({'template': '{% block content %}'}) + @setup({"template": "{% block content %}"}) def test_unclosed_block(self): msg = "Unclosed tag on line 1: 'block'. Looking for one of: endblock." with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template') + self.engine.render_to_string("template") - @setup({'template': '{% if a %}'}) + @setup({"template": "{% if a %}"}) def test_unclosed_block2(self): msg = "Unclosed tag on line 1: 'if'. Looking for one of: elif, else, endif." with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template') + self.engine.render_to_string("template") - @setup({'tpl-str': '%s', 'tpl-percent': '%%', 'tpl-weird-percent': '% %s'}) + @setup({"tpl-str": "%s", "tpl-percent": "%%", "tpl-weird-percent": "% %s"}) def test_ignores_strings_that_look_like_format_interpolation(self): - output = self.engine.render_to_string('tpl-str') - self.assertEqual(output, '%s') - output = self.engine.render_to_string('tpl-percent') - self.assertEqual(output, '%%') - output = self.engine.render_to_string('tpl-weird-percent') - self.assertEqual(output, '% %s') + output = self.engine.render_to_string("tpl-str") + self.assertEqual(output, "%s") + output = self.engine.render_to_string("tpl-percent") + self.assertEqual(output, "%%") + output = self.engine.render_to_string("tpl-weird-percent") + self.assertEqual(output, "% %s") class BlockContextTests(SimpleTestCase): def test_repr(self): block_context = BlockContext() - block_context.add_blocks({'content': BlockNode('content', [])}) + block_context.add_blocks({"content": BlockNode("content", [])}) self.assertEqual( repr(block_context), ", " diff --git a/tests/template_tests/syntax_tests/test_builtins.py b/tests/template_tests/syntax_tests/test_builtins.py index 8ade96c65a..6e81410556 100644 --- a/tests/template_tests/syntax_tests/test_builtins.py +++ b/tests/template_tests/syntax_tests/test_builtins.py @@ -4,18 +4,17 @@ from ..utils import setup class BuiltinsTests(SimpleTestCase): - - @setup({'builtins01': '{{ True }}'}) + @setup({"builtins01": "{{ True }}"}) def test_builtins01(self): - output = self.engine.render_to_string('builtins01') - self.assertEqual(output, 'True') + output = self.engine.render_to_string("builtins01") + self.assertEqual(output, "True") - @setup({'builtins02': '{{ False }}'}) + @setup({"builtins02": "{{ False }}"}) def test_builtins02(self): - output = self.engine.render_to_string('builtins02') - self.assertEqual(output, 'False') + output = self.engine.render_to_string("builtins02") + self.assertEqual(output, "False") - @setup({'builtins03': '{{ None }}'}) + @setup({"builtins03": "{{ None }}"}) def test_builtins03(self): - output = self.engine.render_to_string('builtins03') - self.assertEqual(output, 'None') + output = self.engine.render_to_string("builtins03") + self.assertEqual(output, "None") diff --git a/tests/template_tests/syntax_tests/test_cache.py b/tests/template_tests/syntax_tests/test_cache.py index 80af1c2bd6..a722420637 100644 --- a/tests/template_tests/syntax_tests/test_cache.py +++ b/tests/template_tests/syntax_tests/test_cache.py @@ -7,176 +7,203 @@ from ..utils import setup class CacheTagTests(SimpleTestCase): libraries = { - 'cache': 'django.templatetags.cache', - 'custom': 'template_tests.templatetags.custom', + "cache": "django.templatetags.cache", + "custom": "template_tests.templatetags.custom", } def tearDown(self): cache.clear() - @setup({'cache03': '{% load cache %}{% cache 2 test %}cache03{% endcache %}'}) + @setup({"cache03": "{% load cache %}{% cache 2 test %}cache03{% endcache %}"}) def test_cache03(self): - output = self.engine.render_to_string('cache03') - self.assertEqual(output, 'cache03') - - @setup({ - 'cache03': '{% load cache %}{% cache 2 test %}cache03{% endcache %}', - 'cache04': '{% load cache %}{% cache 2 test %}cache04{% endcache %}', - }) + output = self.engine.render_to_string("cache03") + self.assertEqual(output, "cache03") + + @setup( + { + "cache03": "{% load cache %}{% cache 2 test %}cache03{% endcache %}", + "cache04": "{% load cache %}{% cache 2 test %}cache04{% endcache %}", + } + ) def test_cache04(self): - self.engine.render_to_string('cache03') - output = self.engine.render_to_string('cache04') - self.assertEqual(output, 'cache03') + self.engine.render_to_string("cache03") + output = self.engine.render_to_string("cache04") + self.assertEqual(output, "cache03") - @setup({'cache05': '{% load cache %}{% cache 2 test foo %}cache05{% endcache %}'}) + @setup({"cache05": "{% load cache %}{% cache 2 test foo %}cache05{% endcache %}"}) def test_cache05(self): - output = self.engine.render_to_string('cache05', {'foo': 1}) - self.assertEqual(output, 'cache05') + output = self.engine.render_to_string("cache05", {"foo": 1}) + self.assertEqual(output, "cache05") - @setup({'cache06': '{% load cache %}{% cache 2 test foo %}cache06{% endcache %}'}) + @setup({"cache06": "{% load cache %}{% cache 2 test foo %}cache06{% endcache %}"}) def test_cache06(self): - output = self.engine.render_to_string('cache06', {'foo': 2}) - self.assertEqual(output, 'cache06') - - @setup({ - 'cache05': '{% load cache %}{% cache 2 test foo %}cache05{% endcache %}', - 'cache07': '{% load cache %}{% cache 2 test foo %}cache07{% endcache %}', - }) + output = self.engine.render_to_string("cache06", {"foo": 2}) + self.assertEqual(output, "cache06") + + @setup( + { + "cache05": "{% load cache %}{% cache 2 test foo %}cache05{% endcache %}", + "cache07": "{% load cache %}{% cache 2 test foo %}cache07{% endcache %}", + } + ) def test_cache07(self): - context = {'foo': 1} - self.engine.render_to_string('cache05', context) - output = self.engine.render_to_string('cache07', context) - self.assertEqual(output, 'cache05') - - @setup({ - 'cache06': '{% load cache %}{% cache 2 test foo %}cache06{% endcache %}', - 'cache08': '{% load cache %}{% cache time test foo %}cache08{% endcache %}', - }) + context = {"foo": 1} + self.engine.render_to_string("cache05", context) + output = self.engine.render_to_string("cache07", context) + self.assertEqual(output, "cache05") + + @setup( + { + "cache06": "{% load cache %}{% cache 2 test foo %}cache06{% endcache %}", + "cache08": "{% load cache %}{% cache time test foo %}cache08{% endcache %}", + } + ) def test_cache08(self): """ Allow first argument to be a variable. """ - context = {'foo': 2, 'time': 2} - self.engine.render_to_string('cache06', context) - output = self.engine.render_to_string('cache08', context) - self.assertEqual(output, 'cache06') + context = {"foo": 2, "time": 2} + self.engine.render_to_string("cache06", context) + output = self.engine.render_to_string("cache08", context) + self.assertEqual(output, "cache06") # Raise exception if we don't have at least 2 args, first one integer. - @setup({'cache11': '{% load cache %}{% cache %}{% endcache %}'}) + @setup({"cache11": "{% load cache %}{% cache %}{% endcache %}"}) def test_cache11(self): with self.assertRaises(TemplateSyntaxError): - self.engine.get_template('cache11') + self.engine.get_template("cache11") - @setup({'cache12': '{% load cache %}{% cache 1 %}{% endcache %}'}) + @setup({"cache12": "{% load cache %}{% cache 1 %}{% endcache %}"}) def test_cache12(self): with self.assertRaises(TemplateSyntaxError): - self.engine.get_template('cache12') + self.engine.get_template("cache12") - @setup({'cache13': '{% load cache %}{% cache foo bar %}{% endcache %}'}) + @setup({"cache13": "{% load cache %}{% cache foo bar %}{% endcache %}"}) def test_cache13(self): with self.assertRaises(TemplateSyntaxError): - self.engine.render_to_string('cache13') + self.engine.render_to_string("cache13") - @setup({'cache14': '{% load cache %}{% cache foo bar %}{% endcache %}'}) + @setup({"cache14": "{% load cache %}{% cache foo bar %}{% endcache %}"}) def test_cache14(self): with self.assertRaises(TemplateSyntaxError): - self.engine.render_to_string('cache14', {'foo': 'fail'}) + self.engine.render_to_string("cache14", {"foo": "fail"}) - @setup({'cache15': '{% load cache %}{% cache foo bar %}{% endcache %}'}) + @setup({"cache15": "{% load cache %}{% cache foo bar %}{% endcache %}"}) def test_cache15(self): with self.assertRaises(TemplateSyntaxError): - self.engine.render_to_string('cache15', {'foo': []}) + self.engine.render_to_string("cache15", {"foo": []}) - @setup({'cache16': '{% load cache %}{% cache 1 foo bar %}{% endcache %}'}) + @setup({"cache16": "{% load cache %}{% cache 1 foo bar %}{% endcache %}"}) def test_cache16(self): """ Regression test for #7460. """ - output = self.engine.render_to_string('cache16', {'foo': 'foo', 'bar': 'with spaces'}) - self.assertEqual(output, '') + output = self.engine.render_to_string( + "cache16", {"foo": "foo", "bar": "with spaces"} + ) + self.assertEqual(output, "") - @setup({'cache17': '{% load cache %}{% cache 10 long_cache_key poem %}Some Content{% endcache %}'}) + @setup( + { + "cache17": "{% load cache %}{% cache 10 long_cache_key poem %}Some Content{% endcache %}" + } + ) def test_cache17(self): """ Regression test for #11270. """ output = self.engine.render_to_string( - 'cache17', + "cache17", { - 'poem': ( - 'Oh freddled gruntbuggly/Thy micturations are to me/' - 'As plurdled gabbleblotchits/On a lurgid bee/' - 'That mordiously hath bitled out/Its earted jurtles/' - 'Into a rancid festering/Or else I shall rend thee in the gobberwarts' - 'with my blurglecruncheon/See if I don\'t.' + "poem": ( + "Oh freddled gruntbuggly/Thy micturations are to me/" + "As plurdled gabbleblotchits/On a lurgid bee/" + "That mordiously hath bitled out/Its earted jurtles/" + "Into a rancid festering/Or else I shall rend thee in the gobberwarts" + "with my blurglecruncheon/See if I don't." ), - } + }, ) - self.assertEqual(output, 'Some Content') + self.assertEqual(output, "Some Content") - @setup({'cache18': '{% load cache custom %}{% cache 2|noop:"x y" cache18 %}cache18{% endcache %}'}) + @setup( + { + "cache18": '{% load cache custom %}{% cache 2|noop:"x y" cache18 %}cache18{% endcache %}' + } + ) def test_cache18(self): """ Test whitespace in filter arguments """ - output = self.engine.render_to_string('cache18') - self.assertEqual(output, 'cache18') - - @setup({ - 'first': '{% load cache %}{% cache None fragment19 %}content{% endcache %}', - 'second': '{% load cache %}{% cache None fragment19 %}not rendered{% endcache %}' - }) + output = self.engine.render_to_string("cache18") + self.assertEqual(output, "cache18") + + @setup( + { + "first": "{% load cache %}{% cache None fragment19 %}content{% endcache %}", + "second": "{% load cache %}{% cache None fragment19 %}not rendered{% endcache %}", + } + ) def test_none_timeout(self): """A timeout of None means "cache forever".""" - output = self.engine.render_to_string('first') - self.assertEqual(output, 'content') - output = self.engine.render_to_string('second') - self.assertEqual(output, 'content') + output = self.engine.render_to_string("first") + self.assertEqual(output, "content") + output = self.engine.render_to_string("second") + self.assertEqual(output, "content") class CacheTests(SimpleTestCase): - @classmethod def setUpClass(cls): - cls.engine = Engine(libraries={'cache': 'django.templatetags.cache'}) + cls.engine = Engine(libraries={"cache": "django.templatetags.cache"}) super().setUpClass() def test_cache_regression_20130(self): - t = self.engine.from_string('{% load cache %}{% cache 1 regression_20130 %}foo{% endcache %}') + t = self.engine.from_string( + "{% load cache %}{% cache 1 regression_20130 %}foo{% endcache %}" + ) cachenode = t.nodelist[1] - self.assertEqual(cachenode.fragment_name, 'regression_20130') - - @override_settings(CACHES={ - 'default': { - 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', - 'LOCATION': 'default', - }, - 'template_fragments': { - 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', - 'LOCATION': 'fragments', - }, - }) + self.assertEqual(cachenode.fragment_name, "regression_20130") + + @override_settings( + CACHES={ + "default": { + "BACKEND": "django.core.cache.backends.locmem.LocMemCache", + "LOCATION": "default", + }, + "template_fragments": { + "BACKEND": "django.core.cache.backends.locmem.LocMemCache", + "LOCATION": "fragments", + }, + } + ) def test_cache_fragment_cache(self): """ When a cache called "template_fragments" is present, the cache tag will use it in preference to 'default' """ - t1 = self.engine.from_string('{% load cache %}{% cache 1 fragment %}foo{% endcache %}') - t2 = self.engine.from_string('{% load cache %}{% cache 1 fragment using="default" %}bar{% endcache %}') + t1 = self.engine.from_string( + "{% load cache %}{% cache 1 fragment %}foo{% endcache %}" + ) + t2 = self.engine.from_string( + '{% load cache %}{% cache 1 fragment using="default" %}bar{% endcache %}' + ) ctx = Context() o1 = t1.render(ctx) o2 = t2.render(ctx) - self.assertEqual(o1, 'foo') - self.assertEqual(o2, 'bar') + self.assertEqual(o1, "foo") + self.assertEqual(o2, "bar") def test_cache_missing_backend(self): """ When a cache that doesn't exist is specified, the cache tag will raise a TemplateSyntaxError '""" - t = self.engine.from_string('{% load cache %}{% cache 1 backend using="unknown" %}bar{% endcache %}') + t = self.engine.from_string( + '{% load cache %}{% cache 1 backend using="unknown" %}bar{% endcache %}' + ) ctx = Context() with self.assertRaises(TemplateSyntaxError): diff --git a/tests/template_tests/syntax_tests/test_comment.py b/tests/template_tests/syntax_tests/test_comment.py index d1b4dcf147..58dbe88b36 100644 --- a/tests/template_tests/syntax_tests/test_comment.py +++ b/tests/template_tests/syntax_tests/test_comment.py @@ -4,89 +4,92 @@ from ..utils import setup class CommentSyntaxTests(SimpleTestCase): - - @setup({'comment-syntax01': '{# this is hidden #}hello'}) + @setup({"comment-syntax01": "{# this is hidden #}hello"}) def test_comment_syntax01(self): - output = self.engine.render_to_string('comment-syntax01') - self.assertEqual(output, 'hello') + output = self.engine.render_to_string("comment-syntax01") + self.assertEqual(output, "hello") - @setup({'comment-syntax02': '{# this is hidden #}hello{# foo #}'}) + @setup({"comment-syntax02": "{# this is hidden #}hello{# foo #}"}) def test_comment_syntax02(self): - output = self.engine.render_to_string('comment-syntax02') - self.assertEqual(output, 'hello') + output = self.engine.render_to_string("comment-syntax02") + self.assertEqual(output, "hello") - @setup({'comment-syntax03': 'foo{# {% if %} #}'}) + @setup({"comment-syntax03": "foo{# {% if %} #}"}) def test_comment_syntax03(self): - output = self.engine.render_to_string('comment-syntax03') - self.assertEqual(output, 'foo') + output = self.engine.render_to_string("comment-syntax03") + self.assertEqual(output, "foo") - @setup({'comment-syntax04': 'foo{# {% endblock %} #}'}) + @setup({"comment-syntax04": "foo{# {% endblock %} #}"}) def test_comment_syntax04(self): - output = self.engine.render_to_string('comment-syntax04') - self.assertEqual(output, 'foo') + output = self.engine.render_to_string("comment-syntax04") + self.assertEqual(output, "foo") - @setup({'comment-syntax05': 'foo{# {% somerandomtag %} #}'}) + @setup({"comment-syntax05": "foo{# {% somerandomtag %} #}"}) def test_comment_syntax05(self): - output = self.engine.render_to_string('comment-syntax05') - self.assertEqual(output, 'foo') + output = self.engine.render_to_string("comment-syntax05") + self.assertEqual(output, "foo") - @setup({'comment-syntax06': 'foo{# {% #}'}) + @setup({"comment-syntax06": "foo{# {% #}"}) def test_comment_syntax06(self): - output = self.engine.render_to_string('comment-syntax06') - self.assertEqual(output, 'foo') + output = self.engine.render_to_string("comment-syntax06") + self.assertEqual(output, "foo") - @setup({'comment-syntax07': 'foo{# %} #}'}) + @setup({"comment-syntax07": "foo{# %} #}"}) def test_comment_syntax07(self): - output = self.engine.render_to_string('comment-syntax07') - self.assertEqual(output, 'foo') + output = self.engine.render_to_string("comment-syntax07") + self.assertEqual(output, "foo") - @setup({'comment-syntax08': 'foo{# %} #}bar'}) + @setup({"comment-syntax08": "foo{# %} #}bar"}) def test_comment_syntax08(self): - output = self.engine.render_to_string('comment-syntax08') - self.assertEqual(output, 'foobar') + output = self.engine.render_to_string("comment-syntax08") + self.assertEqual(output, "foobar") - @setup({'comment-syntax09': 'foo{# {{ #}'}) + @setup({"comment-syntax09": "foo{# {{ #}"}) def test_comment_syntax09(self): - output = self.engine.render_to_string('comment-syntax09') - self.assertEqual(output, 'foo') + output = self.engine.render_to_string("comment-syntax09") + self.assertEqual(output, "foo") - @setup({'comment-syntax10': 'foo{# }} #}'}) + @setup({"comment-syntax10": "foo{# }} #}"}) def test_comment_syntax10(self): - output = self.engine.render_to_string('comment-syntax10') - self.assertEqual(output, 'foo') + output = self.engine.render_to_string("comment-syntax10") + self.assertEqual(output, "foo") - @setup({'comment-syntax11': 'foo{# { #}'}) + @setup({"comment-syntax11": "foo{# { #}"}) def test_comment_syntax11(self): - output = self.engine.render_to_string('comment-syntax11') - self.assertEqual(output, 'foo') + output = self.engine.render_to_string("comment-syntax11") + self.assertEqual(output, "foo") - @setup({'comment-syntax12': 'foo{# } #}'}) + @setup({"comment-syntax12": "foo{# } #}"}) def test_comment_syntax12(self): - output = self.engine.render_to_string('comment-syntax12') - self.assertEqual(output, 'foo') + output = self.engine.render_to_string("comment-syntax12") + self.assertEqual(output, "foo") - @setup({'comment-tag01': '{% comment %}this is hidden{% endcomment %}hello'}) + @setup({"comment-tag01": "{% comment %}this is hidden{% endcomment %}hello"}) def test_comment_tag01(self): - output = self.engine.render_to_string('comment-tag01') - self.assertEqual(output, 'hello') - - @setup({'comment-tag02': '{% comment %}this is hidden{% endcomment %}' - 'hello{% comment %}foo{% endcomment %}'}) + output = self.engine.render_to_string("comment-tag01") + self.assertEqual(output, "hello") + + @setup( + { + "comment-tag02": "{% comment %}this is hidden{% endcomment %}" + "hello{% comment %}foo{% endcomment %}" + } + ) def test_comment_tag02(self): - output = self.engine.render_to_string('comment-tag02') - self.assertEqual(output, 'hello') + output = self.engine.render_to_string("comment-tag02") + self.assertEqual(output, "hello") - @setup({'comment-tag03': 'foo{% comment %} {% if %} {% endcomment %}'}) + @setup({"comment-tag03": "foo{% comment %} {% if %} {% endcomment %}"}) def test_comment_tag03(self): - output = self.engine.render_to_string('comment-tag03') - self.assertEqual(output, 'foo') + output = self.engine.render_to_string("comment-tag03") + self.assertEqual(output, "foo") - @setup({'comment-tag04': 'foo{% comment %} {% endblock %} {% endcomment %}'}) + @setup({"comment-tag04": "foo{% comment %} {% endblock %} {% endcomment %}"}) def test_comment_tag04(self): - output = self.engine.render_to_string('comment-tag04') - self.assertEqual(output, 'foo') + output = self.engine.render_to_string("comment-tag04") + self.assertEqual(output, "foo") - @setup({'comment-tag05': 'foo{% comment %} {% somerandomtag %} {% endcomment %}'}) + @setup({"comment-tag05": "foo{% comment %} {% somerandomtag %} {% endcomment %}"}) def test_comment_tag05(self): - output = self.engine.render_to_string('comment-tag05') - self.assertEqual(output, 'foo') + output = self.engine.render_to_string("comment-tag05") + self.assertEqual(output, "foo") diff --git a/tests/template_tests/syntax_tests/test_cycle.py b/tests/template_tests/syntax_tests/test_cycle.py index 12bf66e117..d4233fac3e 100644 --- a/tests/template_tests/syntax_tests/test_cycle.py +++ b/tests/template_tests/syntax_tests/test_cycle.py @@ -5,175 +5,214 @@ from ..utils import setup class CycleTagTests(SimpleTestCase): - - @setup({'cycle01': '{% cycle a %}'}) + @setup({"cycle01": "{% cycle a %}"}) def test_cycle01(self): msg = "No named cycles in template. 'a' is not defined" with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.get_template('cycle01') + self.engine.get_template("cycle01") - @setup({'cycle05': '{% cycle %}'}) + @setup({"cycle05": "{% cycle %}"}) def test_cycle05(self): msg = "'cycle' tag requires at least two arguments" with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.get_template('cycle05') + self.engine.get_template("cycle05") - @setup({'cycle07': '{% cycle a,b,c as foo %}{% cycle bar %}'}) + @setup({"cycle07": "{% cycle a,b,c as foo %}{% cycle bar %}"}) def test_cycle07(self): msg = "Could not parse the remainder: ',b,c' from 'a,b,c'" with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.get_template('cycle07') + self.engine.get_template("cycle07") - @setup({'cycle10': "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}"}) + @setup({"cycle10": "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}"}) def test_cycle10(self): - output = self.engine.render_to_string('cycle10') - self.assertEqual(output, 'ab') + output = self.engine.render_to_string("cycle10") + self.assertEqual(output, "ab") - @setup({'cycle11': "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}"}) + @setup({"cycle11": "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}"}) def test_cycle11(self): - output = self.engine.render_to_string('cycle11') - self.assertEqual(output, 'abc') - - @setup({'cycle12': "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"}) + output = self.engine.render_to_string("cycle11") + self.assertEqual(output, "abc") + + @setup( + { + "cycle12": "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}" + } + ) def test_cycle12(self): - output = self.engine.render_to_string('cycle12') - self.assertEqual(output, 'abca') + output = self.engine.render_to_string("cycle12") + self.assertEqual(output, "abca") - @setup({'cycle13': "{% for i in test %}{% cycle 'a' 'b' %}{{ i }},{% endfor %}"}) + @setup({"cycle13": "{% for i in test %}{% cycle 'a' 'b' %}{{ i }},{% endfor %}"}) def test_cycle13(self): - output = self.engine.render_to_string('cycle13', {'test': list(range(5))}) - self.assertEqual(output, 'a0,b1,a2,b3,a4,') + output = self.engine.render_to_string("cycle13", {"test": list(range(5))}) + self.assertEqual(output, "a0,b1,a2,b3,a4,") - @setup({'cycle14': '{% cycle one two as foo %}{% cycle foo %}'}) + @setup({"cycle14": "{% cycle one two as foo %}{% cycle foo %}"}) def test_cycle14(self): - output = self.engine.render_to_string('cycle14', {'one': '1', 'two': '2'}) - self.assertEqual(output, '12') + output = self.engine.render_to_string("cycle14", {"one": "1", "two": "2"}) + self.assertEqual(output, "12") - @setup({'cycle15': '{% for i in test %}{% cycle aye bee %}{{ i }},{% endfor %}'}) + @setup({"cycle15": "{% for i in test %}{% cycle aye bee %}{{ i }},{% endfor %}"}) def test_cycle15(self): - output = self.engine.render_to_string('cycle15', {'test': list(range(5)), 'aye': 'a', 'bee': 'b'}) - self.assertEqual(output, 'a0,b1,a2,b3,a4,') + output = self.engine.render_to_string( + "cycle15", {"test": list(range(5)), "aye": "a", "bee": "b"} + ) + self.assertEqual(output, "a0,b1,a2,b3,a4,") - @setup({'cycle16': '{% cycle one|lower two as foo %}{% cycle foo %}'}) + @setup({"cycle16": "{% cycle one|lower two as foo %}{% cycle foo %}"}) def test_cycle16(self): - output = self.engine.render_to_string('cycle16', {'one': 'A', 'two': '2'}) - self.assertEqual(output, 'a2') - - @setup({'cycle17': "{% cycle 'a' 'b' 'c' as abc silent %}" - "{% cycle abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"}) + output = self.engine.render_to_string("cycle16", {"one": "A", "two": "2"}) + self.assertEqual(output, "a2") + + @setup( + { + "cycle17": "{% cycle 'a' 'b' 'c' as abc silent %}" + "{% cycle abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}" + } + ) def test_cycle17(self): - output = self.engine.render_to_string('cycle17') - self.assertEqual(output, '') + output = self.engine.render_to_string("cycle17") + self.assertEqual(output, "") - @setup({'cycle18': "{% cycle 'a' 'b' 'c' as foo invalid_flag %}"}) + @setup({"cycle18": "{% cycle 'a' 'b' 'c' as foo invalid_flag %}"}) def test_cycle18(self): msg = "Only 'silent' flag is allowed after cycle's name, not 'invalid_flag'." with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.get_template('cycle18') + self.engine.get_template("cycle18") - @setup({'cycle19': "{% cycle 'a' 'b' as silent %}{% cycle silent %}"}) + @setup({"cycle19": "{% cycle 'a' 'b' as silent %}{% cycle silent %}"}) def test_cycle19(self): - output = self.engine.render_to_string('cycle19') - self.assertEqual(output, 'ab') + output = self.engine.render_to_string("cycle19") + self.assertEqual(output, "ab") - @setup({'cycle20': '{% cycle one two as foo %} & {% cycle foo %}'}) + @setup({"cycle20": "{% cycle one two as foo %} & {% cycle foo %}"}) def test_cycle20(self): - output = self.engine.render_to_string('cycle20', {'two': 'C & D', 'one': 'A & B'}) - self.assertEqual(output, 'A & B & C & D') - - @setup({'cycle21': '{% filter force_escape %}' - '{% cycle one two as foo %} & {% cycle foo %}{% endfilter %}'}) + output = self.engine.render_to_string( + "cycle20", {"two": "C & D", "one": "A & B"} + ) + self.assertEqual(output, "A & B & C & D") + + @setup( + { + "cycle21": "{% filter force_escape %}" + "{% cycle one two as foo %} & {% cycle foo %}{% endfilter %}" + } + ) def test_cycle21(self): - output = self.engine.render_to_string('cycle21', {'two': 'C & D', 'one': 'A & B'}) - self.assertEqual(output, 'A &amp; B & C &amp; D') - - @setup({'cycle22': "{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ x }}{% endfor %}"}) + output = self.engine.render_to_string( + "cycle21", {"two": "C & D", "one": "A & B"} + ) + self.assertEqual(output, "A &amp; B & C &amp; D") + + @setup( + { + "cycle22": "{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ x }}{% endfor %}" + } + ) def test_cycle22(self): - output = self.engine.render_to_string('cycle22', {'values': [1, 2, 3, 4]}) - self.assertEqual(output, '1234') - - @setup({'cycle23': "{% for x in values %}" - "{% cycle 'a' 'b' 'c' as abc silent %}{{ abc }}{{ x }}{% endfor %}"}) + output = self.engine.render_to_string("cycle22", {"values": [1, 2, 3, 4]}) + self.assertEqual(output, "1234") + + @setup( + { + "cycle23": "{% for x in values %}" + "{% cycle 'a' 'b' 'c' as abc silent %}{{ abc }}{{ x }}{% endfor %}" + } + ) def test_cycle23(self): - output = self.engine.render_to_string('cycle23', {'values': [1, 2, 3, 4]}) - self.assertEqual(output, 'a1b2c3a4') - - @setup({ - 'cycle24': "{% for x in values %}" - "{% cycle 'a' 'b' 'c' as abc silent %}{% include 'included-cycle' %}{% endfor %}", - 'included-cycle': '{{ abc }}', - }) + output = self.engine.render_to_string("cycle23", {"values": [1, 2, 3, 4]}) + self.assertEqual(output, "a1b2c3a4") + + @setup( + { + "cycle24": "{% for x in values %}" + "{% cycle 'a' 'b' 'c' as abc silent %}{% include 'included-cycle' %}{% endfor %}", + "included-cycle": "{{ abc }}", + } + ) def test_cycle24(self): - output = self.engine.render_to_string('cycle24', {'values': [1, 2, 3, 4]}) - self.assertEqual(output, 'abca') + output = self.engine.render_to_string("cycle24", {"values": [1, 2, 3, 4]}) + self.assertEqual(output, "abca") - @setup({'cycle25': '{% cycle a as abc %}'}) + @setup({"cycle25": "{% cycle a as abc %}"}) def test_cycle25(self): - output = self.engine.render_to_string('cycle25', {'a': '<'}) - self.assertEqual(output, '<') + output = self.engine.render_to_string("cycle25", {"a": "<"}) + self.assertEqual(output, "<") - @setup({'cycle26': '{% cycle a b as ab %}{% cycle ab %}'}) + @setup({"cycle26": "{% cycle a b as ab %}{% cycle ab %}"}) def test_cycle26(self): - output = self.engine.render_to_string('cycle26', {'a': '<', 'b': '>'}) - self.assertEqual(output, '<>') - - @setup({'cycle27': '{% autoescape off %}{% cycle a b as ab %}{% cycle ab %}{% endautoescape %}'}) + output = self.engine.render_to_string("cycle26", {"a": "<", "b": ">"}) + self.assertEqual(output, "<>") + + @setup( + { + "cycle27": "{% autoescape off %}{% cycle a b as ab %}{% cycle ab %}{% endautoescape %}" + } + ) def test_cycle27(self): - output = self.engine.render_to_string('cycle27', {'a': '<', 'b': '>'}) - self.assertEqual(output, '<>') + output = self.engine.render_to_string("cycle27", {"a": "<", "b": ">"}) + self.assertEqual(output, "<>") - @setup({'cycle28': '{% cycle a|safe b as ab %}{% cycle ab %}'}) + @setup({"cycle28": "{% cycle a|safe b as ab %}{% cycle ab %}"}) def test_cycle28(self): - output = self.engine.render_to_string('cycle28', {'a': '<', 'b': '>'}) - self.assertEqual(output, '<>') - - @setup({ - 'cycle29': "{% cycle 'a' 'b' 'c' as cycler silent %}" - "{% for x in values %}" - "{% ifchanged x %}" - "{% cycle cycler %}{{ cycler }}" - "{% else %}" - "{{ cycler }}" - "{% endifchanged %}" - "{% endfor %}" - }) + output = self.engine.render_to_string("cycle28", {"a": "<", "b": ">"}) + self.assertEqual(output, "<>") + + @setup( + { + "cycle29": "{% cycle 'a' 'b' 'c' as cycler silent %}" + "{% for x in values %}" + "{% ifchanged x %}" + "{% cycle cycler %}{{ cycler }}" + "{% else %}" + "{{ cycler }}" + "{% endifchanged %}" + "{% endfor %}" + } + ) def test_cycle29(self): """ A named {% cycle %} tag works inside an {% ifchanged %} block and a {% for %} loop. """ - output = self.engine.render_to_string('cycle29', {'values': [1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 9, 9]}) - self.assertEqual(output, 'bcabcabcccaa') - - @setup({ - 'cycle30': "{% cycle 'a' 'b' 'c' as cycler silent %}" - "{% for x in values %}" - "{% with doesnothing=irrelevant %}" - "{% ifchanged x %}" - "{% cycle cycler %}{{ cycler }}" - "{% else %}" - "{{ cycler }}" - "{% endifchanged %}" - "{% endwith %}" - "{% endfor %}"}) + output = self.engine.render_to_string( + "cycle29", {"values": [1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 9, 9]} + ) + self.assertEqual(output, "bcabcabcccaa") + + @setup( + { + "cycle30": "{% cycle 'a' 'b' 'c' as cycler silent %}" + "{% for x in values %}" + "{% with doesnothing=irrelevant %}" + "{% ifchanged x %}" + "{% cycle cycler %}{{ cycler }}" + "{% else %}" + "{{ cycler }}" + "{% endifchanged %}" + "{% endwith %}" + "{% endfor %}" + } + ) def test_cycle30(self): """ A {% with %} tag shouldn't reset the {% cycle %} variable. """ output = self.engine.render_to_string( - 'cycle30', { - 'irrelevant': 1, - 'values': [1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 9, 9] - }) - self.assertEqual(output, 'bcabcabcccaa') - - @setup({ - 'undefined_cycle': - "{% cycle 'a' 'b' 'c' as cycler silent %}" + "cycle30", {"irrelevant": 1, "values": [1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 9, 9]} + ) + self.assertEqual(output, "bcabcabcccaa") + + @setup( + { + "undefined_cycle": "{% cycle 'a' 'b' 'c' as cycler silent %}" "{% for x in values %}" "{% cycle undefined %}{{ cycler }}" "{% endfor %}" - }) + } + ) def test_cycle_undefined(self): - with self.assertRaisesMessage(TemplateSyntaxError, "Named cycle 'undefined' does not exist"): - self.engine.render_to_string('undefined_cycle') + with self.assertRaisesMessage( + TemplateSyntaxError, "Named cycle 'undefined' does not exist" + ): + self.engine.render_to_string("undefined_cycle") diff --git a/tests/template_tests/syntax_tests/test_debug.py b/tests/template_tests/syntax_tests/test_debug.py index 2f527b44ae..cbd71fa51a 100644 --- a/tests/template_tests/syntax_tests/test_debug.py +++ b/tests/template_tests/syntax_tests/test_debug.py @@ -6,41 +6,40 @@ from ..utils import setup @override_settings(DEBUG=True) class DebugTests(SimpleTestCase): - @override_settings(DEBUG=False) - @setup({'non_debug': '{% debug %}'}) + @setup({"non_debug": "{% debug %}"}) def test_non_debug(self): - output = self.engine.render_to_string('non_debug', {}) - self.assertEqual(output, '') + output = self.engine.render_to_string("non_debug", {}) + self.assertEqual(output, "") - @setup({'modules': '{% debug %}'}) + @setup({"modules": "{% debug %}"}) def test_modules(self): - output = self.engine.render_to_string('modules', {}) + output = self.engine.render_to_string("modules", {}) self.assertIn( - ''django': <module 'django' ', + "'django': <module 'django' ", output, ) - @setup({'plain': '{% debug %}'}) + @setup({"plain": "{% debug %}"}) def test_plain(self): - output = self.engine.render_to_string('plain', {'a': 1}) - self.assertTrue(output.startswith( - '{'a': 1}' - '{'False': False, 'None': None, ' - ''True': True}\n\n{' - )) + output = self.engine.render_to_string("plain", {"a": 1}) + self.assertTrue( + output.startswith( + "{'a': 1}" + "{'False': False, 'None': None, " + "'True': True}\n\n{" + ) + ) - @setup({'non_ascii': '{% debug %}'}) + @setup({"non_ascii": "{% debug %}"}) def test_non_ascii(self): group = Group(name="清風") - output = self.engine.render_to_string('non_ascii', {'group': group}) - self.assertTrue(output.startswith( - '{'group': <Group: 清風>}' - )) + output = self.engine.render_to_string("non_ascii", {"group": group}) + self.assertTrue(output.startswith("{'group': <Group: 清風>}")) - @setup({'script': '{% debug %}'}) + @setup({"script": "{% debug %}"}) def test_script(self): - output = self.engine.render_to_string('script', {'frag': '