diff --git a/tests/i18n/tests.py b/tests/i18n/tests.py index ed267ef1d6f..6e2269da4c6 100644 --- a/tests/i18n/tests.py +++ b/tests/i18n/tests.py @@ -14,27 +14,25 @@ from unittest import skipUnless from django import forms from django.conf import settings from django.conf.urls.i18n import i18n_patterns -from django.template import Context, Template, TemplateSyntaxError +from django.template import Context, Template from django.test import ( - RequestFactory, SimpleTestCase, TestCase, ignore_warnings, - override_settings, + RequestFactory, SimpleTestCase, TestCase, override_settings, ) from django.utils import six, translation from django.utils._os import upath -from django.utils.deprecation import RemovedInDjango21Warning from django.utils.formats import ( date_format, get_format, get_format_modules, iter_format_modules, localize, localize_input, reset_format_cache, sanitize_separators, time_format, ) from django.utils.numberformat import format as nformat -from django.utils.safestring import SafeBytes, SafeString, SafeText, mark_safe +from django.utils.safestring import SafeBytes, SafeText from django.utils.six import PY3 from django.utils.translation import ( LANGUAGE_SESSION_KEY, activate, check_for_language, deactivate, - get_language, get_language_bidi, get_language_from_request, - get_language_info, gettext, gettext_lazy, ngettext_lazy, npgettext, - npgettext_lazy, pgettext, pgettext_lazy, string_concat, to_locale, - trans_real, ugettext, ugettext_lazy, ungettext, ungettext_lazy, + get_language, get_language_from_request, get_language_info, gettext, + gettext_lazy, ngettext_lazy, npgettext, npgettext_lazy, pgettext, + pgettext_lazy, trans_real, ugettext, ugettext_lazy, ungettext, + ungettext_lazy, ) from .forms import CompanyForm, I18nForm, SelectDateForm @@ -264,247 +262,6 @@ class TranslationTests(SimpleTestCase): self.assertEqual(pgettext("verb", "May"), "Kann") self.assertEqual(npgettext("search", "%d result", "%d results", 4) % 4, "4 Resultate") - @override_settings(LOCALE_PATHS=extended_locale_paths) - def test_template_tags_pgettext(self): - """ - Message contexts are taken into account the {% trans %} and - {% blocktrans %} template tags (#14806). - """ - trans_real._active = local() - trans_real._translations = {} - with translation.override('de'): - - # {% trans %} ----------------------------------- - - # Inexisting context... - t = Template('{% load i18n %}{% trans "May" context "unexisting" %}') - rendered = t.render(Context()) - self.assertEqual(rendered, 'May') - - # Existing context... - # Using a literal - t = Template('{% load i18n %}{% trans "May" context "month name" %}') - rendered = t.render(Context()) - self.assertEqual(rendered, 'Mai') - t = Template('{% load i18n %}{% trans "May" context "verb" %}') - rendered = t.render(Context()) - self.assertEqual(rendered, 'Kann') - - # Using a variable - t = Template('{% load i18n %}{% trans "May" context message_context %}') - rendered = t.render(Context({'message_context': 'month name'})) - self.assertEqual(rendered, 'Mai') - t = Template('{% load i18n %}{% trans "May" context message_context %}') - rendered = t.render(Context({'message_context': 'verb'})) - self.assertEqual(rendered, 'Kann') - - # Using a filter - t = Template('{% load i18n %}{% trans "May" context message_context|lower %}') - rendered = t.render(Context({'message_context': 'MONTH NAME'})) - self.assertEqual(rendered, 'Mai') - t = Template('{% load i18n %}{% trans "May" context message_context|lower %}') - rendered = t.render(Context({'message_context': 'VERB'})) - self.assertEqual(rendered, 'Kann') - - # Using 'as' - t = Template('{% load i18n %}{% trans "May" context "month name" as var %}Value: {{ var }}') - rendered = t.render(Context()) - self.assertEqual(rendered, 'Value: Mai') - t = Template('{% load i18n %}{% trans "May" as var context "verb" %}Value: {{ var }}') - rendered = t.render(Context()) - self.assertEqual(rendered, 'Value: Kann') - - # {% blocktrans %} ------------------------------ - - # Inexisting context... - t = Template('{% load i18n %}{% blocktrans context "unexisting" %}May{% endblocktrans %}') - rendered = t.render(Context()) - self.assertEqual(rendered, 'May') - - # Existing context... - # Using a literal - t = Template('{% load i18n %}{% blocktrans context "month name" %}May{% endblocktrans %}') - rendered = t.render(Context()) - self.assertEqual(rendered, 'Mai') - t = Template('{% load i18n %}{% blocktrans context "verb" %}May{% endblocktrans %}') - rendered = t.render(Context()) - self.assertEqual(rendered, 'Kann') - - # Using a variable - t = Template('{% load i18n %}{% blocktrans context message_context %}May{% endblocktrans %}') - rendered = t.render(Context({'message_context': 'month name'})) - self.assertEqual(rendered, 'Mai') - t = Template('{% load i18n %}{% blocktrans context message_context %}May{% endblocktrans %}') - rendered = t.render(Context({'message_context': 'verb'})) - self.assertEqual(rendered, 'Kann') - - # Using a filter - t = Template('{% load i18n %}{% blocktrans context message_context|lower %}May{% endblocktrans %}') - rendered = t.render(Context({'message_context': 'MONTH NAME'})) - self.assertEqual(rendered, 'Mai') - t = Template('{% load i18n %}{% blocktrans context message_context|lower %}May{% endblocktrans %}') - rendered = t.render(Context({'message_context': 'VERB'})) - self.assertEqual(rendered, 'Kann') - - # Using 'count' - t = Template( - '{% load i18n %}{% blocktrans count number=1 context "super search" %}' - '{{ number }} super result{% plural %}{{ number }} super results{% endblocktrans %}' - ) - rendered = t.render(Context()) - self.assertEqual(rendered, '1 Super-Ergebnis') - t = Template( - '{% load i18n %}{% blocktrans count number=2 context "super search" %}{{ number }}' - ' super result{% plural %}{{ number }} super results{% endblocktrans %}' - ) - rendered = t.render(Context()) - self.assertEqual(rendered, '2 Super-Ergebnisse') - t = Template( - '{% load i18n %}{% blocktrans context "other super search" count number=1 %}' - '{{ number }} super result{% plural %}{{ number }} super results{% endblocktrans %}' - ) - rendered = t.render(Context()) - self.assertEqual(rendered, '1 anderen Super-Ergebnis') - t = Template( - '{% load i18n %}{% blocktrans context "other super search" count number=2 %}' - '{{ number }} super result{% plural %}{{ number }} super results{% endblocktrans %}' - ) - rendered = t.render(Context()) - self.assertEqual(rendered, '2 andere Super-Ergebnisse') - - # Using 'with' - t = Template( - '{% load i18n %}{% blocktrans with num_comments=5 context "comment count" %}' - 'There are {{ num_comments }} comments{% endblocktrans %}' - ) - rendered = t.render(Context()) - self.assertEqual(rendered, 'Es gibt 5 Kommentare') - t = Template( - '{% load i18n %}{% blocktrans with num_comments=5 context "other comment count" %}' - 'There are {{ num_comments }} comments{% endblocktrans %}' - ) - rendered = t.render(Context()) - self.assertEqual(rendered, 'Andere: Es gibt 5 Kommentare') - - # Using trimmed - t = Template( - '{% load i18n %}{% blocktrans trimmed %}\n\nThere\n\t are 5 ' - '\n\n comments\n{% endblocktrans %}' - ) - rendered = t.render(Context()) - self.assertEqual(rendered, 'There are 5 comments') - t = Template( - '{% load i18n %}{% blocktrans with num_comments=5 context "comment count" trimmed %}\n\n' - 'There are \t\n \t {{ num_comments }} comments\n\n{% endblocktrans %}' - ) - rendered = t.render(Context()) - self.assertEqual(rendered, 'Es gibt 5 Kommentare') - t = Template( - '{% load i18n %}{% blocktrans context "other super search" count number=2 trimmed %}\n' - '{{ number }} super \n result{% plural %}{{ number }} super results{% endblocktrans %}' - ) - rendered = t.render(Context()) - self.assertEqual(rendered, '2 andere Super-Ergebnisse') - - # Mis-uses - with self.assertRaises(TemplateSyntaxError): - Template('{% load i18n %}{% blocktrans context with month="May" %}{{ month }}{% endblocktrans %}') - with self.assertRaises(TemplateSyntaxError): - Template('{% load i18n %}{% blocktrans context %}{% endblocktrans %}') - with self.assertRaises(TemplateSyntaxError): - Template( - '{% load i18n %}{% blocktrans count number=2 context %}' - '{{ number }} super result{% plural %}{{ number }}' - ' super results{% endblocktrans %}' - ) - - @ignore_warnings(category=RemovedInDjango21Warning) - def test_string_concat(self): - """ - six.text_type(string_concat(...)) should not raise a TypeError - #4796 - """ - self.assertEqual('django', six.text_type(string_concat("dja", "ngo"))) - - def test_empty_value(self): - """ - Empty value must stay empty after being translated (#23196). - """ - with translation.override('de'): - self.assertEqual("", ugettext("")) - self.assertEqual(str(""), gettext(str(""))) - s = mark_safe("") - self.assertEqual(s, ugettext(s)) - - def test_safe_status(self): - """ - Translating a string requiring no auto-escaping shouldn't change the "safe" status. - """ - s = mark_safe(str('Password')) - self.assertEqual(SafeString, type(s)) - with translation.override('de', deactivate=True): - self.assertEqual(SafeText, type(ugettext(s))) - self.assertEqual('aPassword', SafeText('a') + s) - self.assertEqual('Passworda', s + SafeText('a')) - self.assertEqual('Passworda', s + mark_safe('a')) - self.assertEqual('aPassword', mark_safe('a') + s) - self.assertEqual('as', mark_safe('a') + mark_safe('s')) - - def test_maclines(self): - """ - Translations on files with mac or dos end of lines will be converted - to unix eof in .po catalogs, and they have to match when retrieved - """ - ca_translation = trans_real.translation('ca') - ca_translation._catalog['Mac\nEOF\n'] = 'Catalan Mac\nEOF\n' - ca_translation._catalog['Win\nEOF\n'] = 'Catalan Win\nEOF\n' - with translation.override('ca', deactivate=True): - self.assertEqual('Catalan Mac\nEOF\n', ugettext('Mac\rEOF\r')) - self.assertEqual('Catalan Win\nEOF\n', ugettext('Win\r\nEOF\r\n')) - - def test_to_locale(self): - """ - Tests the to_locale function and the special case of Serbian Latin - (refs #12230 and r11299) - """ - self.assertEqual(to_locale('en-us'), 'en_US') - self.assertEqual(to_locale('sr-lat'), 'sr_Lat') - - def test_to_language(self): - """ - Test the to_language function - """ - self.assertEqual(trans_real.to_language('en_US'), 'en-us') - self.assertEqual(trans_real.to_language('sr_Lat'), 'sr-lat') - - def test_language_bidi(self): - self.assertIs(get_language_bidi(), False) - with translation.override(None): - self.assertIs(get_language_bidi(), False) - - @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 - (%(person)s is translated as %(personne)s in fr.po) - Refs #16516. - """ - with translation.override('fr'): - t = Template('{% load i18n %}{% blocktrans %}My name is {{ person }}.{% endblocktrans %}') - rendered = t.render(Context({'person': 'James'})) - self.assertEqual(rendered, 'My name is James.') - - @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 - (%(person) misses a 's' in fr.po, causing the string formatting to fail) - Refs #18393. - """ - with translation.override('fr'): - t = Template('{% load i18n %}{% blocktrans %}My other name is {{ person }}.{% endblocktrans %}') - rendered = t.render(Context({'person': 'James'})) - self.assertEqual(rendered, 'My other name is James.') - class TranslationThreadSafetyTests(SimpleTestCase): @@ -1497,37 +1254,6 @@ class MiscTests(SimpleTestCase): self.assertIsNone(g('/pl')) self.assertIsNone(g('/xyz/')) - @override_settings(LOCALE_PATHS=extended_locale_paths) - def test_percent_in_translatable_block(self): - t_sing = Template("{% load i18n %}{% blocktrans %}The result was {{ percent }}%{% endblocktrans %}") - t_plur = Template( - "{% load i18n %}{% blocktrans count num as number %}" - "{{ percent }}% represents {{ num }} object{% plural %}" - "{{ percent }}% represents {{ num }} objects{% endblocktrans %}" - ) - 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_blocktrans(self): - """ - Python's %-formatting is properly escaped in blocktrans, singular or - plural. - """ - t_sing = Template("{% load i18n %}{% blocktrans %}There are %(num_comments)s comments{% endblocktrans %}") - t_plur = Template( - "{% load i18n %}{% blocktrans count num as number %}" - "%(percent)s% represents {{ num }} object{% plural %}" - "%(percent)s% represents {{ num }} objects{% endblocktrans %}" - ) - 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') - def test_cache_resetting(self): """ After setting LANGUAGE, the cache should be cleared and languages @@ -1658,132 +1384,6 @@ class TestLanguageInfo(SimpleTestCase): self.assertEqual(li['code'], 'zh-hans') -class MultipleLocaleActivationTests(SimpleTestCase): - """ - Tests for template rendering behavior when multiple locales are activated - during the lifetime of the same process. - """ - def setUp(self): - super(MultipleLocaleActivationTests, self).setUp() - self._old_language = get_language() - - def tearDown(self): - super(MultipleLocaleActivationTests, self).tearDown() - activate(self._old_language) - - 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') - self.assertEqual(Template("{% load i18n %}{% trans 'Yes' %}").render(Context({})), 'Oui') - self.assertEqual( - Template("{% load i18n %}{% blocktrans %}Yes{% endblocktrans %}").render(Context({})), - 'Oui' - ) - - # Literal marked up with _() in a filter expression - - def test_multiple_locale_filter(self): - 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') - - def test_multiple_locale_filter_deactivate(self): - 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') - - def test_multiple_locale_filter_direct_switch(self): - with translation.override('de'): - t = Template("{% load i18n %}{{ 0|yesno:_('yes,no,maybe') }}") - with translation.override('nl'): - self.assertEqual(t.render(Context({})), 'nee') - - # Literal marked up with _() - - def test_multiple_locale(self): - with translation.override('de'): - t = Template("{{ _('No') }}") - 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): - t = Template("{{ _('No') }}") - with translation.override('nl'): - self.assertEqual(t.render(Context({})), 'Nee') - - def test_multiple_locale_direct_switch(self): - with translation.override('de'): - t = Template("{{ _('No') }}") - 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'): - t = Template("{% load i18n %}{{ _('No') }}") - 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): - t = Template("{% load i18n %}{{ _('No') }}") - with translation.override('nl'): - self.assertEqual(t.render(Context({})), 'Nee') - - def test_multiple_locale_loadi18n_direct_switch(self): - with translation.override('de'): - t = Template("{% load i18n %}{{ _('No') }}") - with translation.override('nl'): - self.assertEqual(t.render(Context({})), 'Nee') - - # trans i18n tag - - def test_multiple_locale_trans(self): - with translation.override('de'): - t = Template("{% load i18n %}{% trans 'No' %}") - 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): - t = Template("{% load i18n %}{% trans 'No' %}") - with translation.override('nl'): - self.assertEqual(t.render(Context({})), 'Nee') - - def test_multiple_locale_direct_switch_trans(self): - with translation.override('de'): - t = Template("{% load i18n %}{% trans 'No' %}") - with translation.override('nl'): - self.assertEqual(t.render(Context({})), 'Nee') - - # blocktrans i18n tag - - def test_multiple_locale_btrans(self): - with translation.override('de'): - t = Template("{% load i18n %}{% blocktrans %}No{% endblocktrans %}") - 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 = Template("{% load i18n %}{% blocktrans %}No{% endblocktrans %}") - with translation.override('nl'): - self.assertEqual(t.render(Context({})), 'Nee') - - def test_multiple_locale_direct_switch_btrans(self): - with translation.override('de'): - t = Template("{% load i18n %}{% blocktrans %}No{% endblocktrans %}") - with translation.override('nl'): - self.assertEqual(t.render(Context({})), 'Nee') - - @override_settings( USE_I18N=True, LANGUAGES=[ diff --git a/tests/template_tests/syntax_tests/i18n/__init__.py b/tests/template_tests/syntax_tests/i18n/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/tests/template_tests/syntax_tests/i18n/base.py b/tests/template_tests/syntax_tests/i18n/base.py new file mode 100644 index 00000000000..b8c083d5368 --- /dev/null +++ b/tests/template_tests/syntax_tests/i18n/base.py @@ -0,0 +1,27 @@ +from __future__ import unicode_literals + +import os + +from django.conf import settings +from django.test import SimpleTestCase +from django.utils._os import upath +from django.utils.translation import activate, get_language + +here = os.path.dirname(os.path.dirname(os.path.abspath(upath(__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'), +] + + +class MultipleLocaleActivationTestCase(SimpleTestCase): + """ + Tests for template rendering when multiple locales are activated during the + lifetime of the same process. + """ + + def setUp(self): + self._old_language = get_language() + + def tearDown(self): + activate(self._old_language) diff --git a/tests/template_tests/syntax_tests/i18n/test_blocktrans.py b/tests/template_tests/syntax_tests/i18n/test_blocktrans.py new file mode 100644 index 00000000000..552c08b0381 --- /dev/null +++ b/tests/template_tests/syntax_tests/i18n/test_blocktrans.py @@ -0,0 +1,436 @@ +# -*- coding: utf-8 -*- +from __future__ import unicode_literals + +import os +from threading import local + +from django.template import Context, Template, TemplateSyntaxError +from django.test import SimpleTestCase, override_settings +from django.utils import translation +from django.utils.safestring import mark_safe +from django.utils.translation import trans_real + +from ...utils import setup +from .base import MultipleLocaleActivationTestCase, extended_locale_paths, here + + +class I18nBlockTransTagTests(SimpleTestCase): + libraries = {'i18n': 'django.templatetags.i18n'} + + @setup({'i18n03': '{% load i18n %}{% blocktrans %}{{ anton }}{% endblocktrans %}'}) + def test_i18n03(self): + """simple translation of a variable""" + output = self.engine.render_to_string('i18n03', {'anton': b'\xc3\x85'}) + self.assertEqual(output, 'Å') + + @setup({'i18n04': '{% load i18n %}{% blocktrans with berta=anton|lower %}{{ berta }}{% endblocktrans %}'}) + def test_i18n04(self): + """simple translation of a variable and filter""" + output = self.engine.render_to_string('i18n04', {'anton': b'\xc3\x85'}) + self.assertEqual(output, 'å') + + @setup({'legacyi18n04': '{% load i18n %}' + '{% blocktrans with anton|lower as berta %}{{ berta }}{% endblocktrans %}'}) + def test_legacyi18n04(self): + """simple translation of a variable and filter""" + output = self.engine.render_to_string('legacyi18n04', {'anton': b'\xc3\x85'}) + self.assertEqual(output, 'å') + + @setup({'i18n05': '{% load i18n %}{% blocktrans %}xxx{{ anton }}xxx{% endblocktrans %}'}) + 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 %}' + '{% blocktrans count counter=number %}singular{% plural %}' + '{{ counter }} plural{% endblocktrans %}'}) + 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 %}' + '{% blocktrans count number as counter %}singular{% plural %}' + '{{ counter }} plural{% endblocktrans %}'}) + 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 %}' + '{% blocktrans count number as counter %}singular{% plural %}' + '{{ counter }} plural{% endblocktrans %}'}) + 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 %}' + '{% blocktrans count counter=number %}singular{% plural %}' + '{{ counter }} plural{% endblocktrans %}'}) + 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 %}' + '{% blocktrans with berta=anton|escape %}{{ berta }}{% endblocktrans %}'}) + def test_i18n17(self): + """ + Escaping inside blocktrans and trans works as if it was directly in the + template. + """ + output = self.engine.render_to_string('i18n17', {'anton': 'α & β'}) + self.assertEqual(output, 'α & β') + + @setup({'i18n18': '{% load i18n %}' + '{% blocktrans with berta=anton|force_escape %}{{ berta }}{% endblocktrans %}'}) + def test_i18n18(self): + output = self.engine.render_to_string('i18n18', {'anton': 'α & β'}) + self.assertEqual(output, 'α & β') + + @setup({'i18n19': '{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}'}) + def test_i18n19(self): + output = self.engine.render_to_string('i18n19', {'andrew': 'a & b'}) + self.assertEqual(output, 'a & b') + + @setup({'i18n21': '{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}'}) + 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 %}' + '{% blocktrans with anton|escape as berta %}{{ berta }}{% endblocktrans %}'}) + def test_legacyi18n17(self): + output = self.engine.render_to_string('legacyi18n17', {'anton': 'α & β'}) + self.assertEqual(output, 'α & β') + + @setup({'legacyi18n18': '{% load i18n %}' + '{% blocktrans with anton|force_escape as berta %}' + '{{ berta }}{% endblocktrans %}'}) + def test_legacyi18n18(self): + output = self.engine.render_to_string('legacyi18n18', {'anton': 'α & β'}) + self.assertEqual(output, 'α & β') + + @setup({'i18n26': '{% load i18n %}' + '{% blocktrans with extra_field=myextra_field count counter=number %}' + 'singular {{ extra_field }}{% plural %}plural{% endblocktrans %}'}) + 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 %}' + '{% blocktrans with myextra_field as extra_field count number as counter %}' + 'singular {{ extra_field }}{% plural %}plural{% endblocktrans %}'}) + 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 %}{% blocktrans count counter=number %}' + '{{ counter }} result{% plural %}{{ counter }} results' + '{% endblocktrans %}'}) + 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') + + @setup({'legacyi18n27': '{% load i18n %}' + '{% blocktrans count number as counter %}{{ counter }} result' + '{% plural %}{{ counter }} results{% endblocktrans %}'}) + 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') + + @setup({'i18n28': '{% load i18n %}' + '{% blocktrans with a=anton b=berta %}{{ a }} + {{ b }}{% endblocktrans %}'}) + 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 %}' + '{% blocktrans with anton as a and berta as b %}' + '{{ a }} + {{ b }}{% endblocktrans %}'}) + def test_legacyi18n28(self): + output = self.engine.render_to_string('legacyi18n28', {'anton': 'α', 'berta': 'β'}) + self.assertEqual(output, 'α + β') + + # blocktrans handling of variables which are not in the context. + # this should work as if blocktrans was not there (#19915) + @setup({'i18n34': '{% load i18n %}{% blocktrans %}{{ missing }}{% endblocktrans %}'}) + def test_i18n34(self): + output = self.engine.render_to_string('i18n34') + if self.engine.string_if_invalid: + self.assertEqual(output, 'INVALID') + else: + self.assertEqual(output, '') + + @setup({'i18n34_2': '{% load i18n %}{% blocktrans with a=\'α\' %}{{ missing }}{% endblocktrans %}'}) + def test_i18n34_2(self): + output = self.engine.render_to_string('i18n34_2') + if self.engine.string_if_invalid: + self.assertEqual(output, 'INVALID') + else: + self.assertEqual(output, '') + + @setup({'i18n34_3': '{% load i18n %}{% blocktrans with a=anton %}{{ missing }}{% endblocktrans %}'}) + def test_i18n34_3(self): + output = self.engine.render_to_string( + 'i18n34_3', {'anton': '\xce\xb1'}) + if self.engine.string_if_invalid: + self.assertEqual(output, 'INVALID') + else: + self.assertEqual(output, '') + + @setup({'i18n37': '{% load i18n %}' + '{% trans "Page not found" as page_not_found %}' + '{% blocktrans %}Error: {{ page_not_found }}{% endblocktrans %}'}) + def test_i18n37(self): + with translation.override('de'): + output = self.engine.render_to_string('i18n37') + self.assertEqual(output, 'Error: Seite nicht gefunden') + + # blocktrans tag with asvar + @setup({'i18n39': '{% load i18n %}' + '{% blocktrans asvar page_not_found %}Page not found{% endblocktrans %}' + '>{{ 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 %}' + '{% trans "Page not found" as pg_404 %}' + '{% blocktrans with page_not_found=pg_404 asvar output %}' + 'Error: {{ page_not_found }}' + '{% endblocktrans %}'}) + def test_i18n40(self): + output = self.engine.render_to_string('i18n40') + self.assertEqual(output, '') + + @setup({'i18n41': '{% load i18n %}' + '{% trans "Page not found" as pg_404 %}' + '{% blocktrans with page_not_found=pg_404 asvar output %}' + 'Error: {{ page_not_found }}' + '{% endblocktrans %}' + '>{{ 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 %}{% blocktrans asvar %}Yes{% endblocktrans %}'}) + def test_blocktrans_syntax_error_missing_assignment(self): + msg = "No argument provided to the 'blocktrans' tag for the asvar option." + with self.assertRaisesMessage(TemplateSyntaxError, msg): + self.engine.render_to_string('template') + + @setup({'template': '{% load i18n %}{% blocktrans %}%s{% endblocktrans %}'}) + def test_blocktrans_tag_using_a_string_that_looks_like_str_fmt(self): + output = self.engine.render_to_string('template') + self.assertEqual(output, '%s') + + +class TranslationBlockTransTagTests(SimpleTestCase): + + @override_settings(LOCALE_PATHS=extended_locale_paths) + def test_template_tags_pgettext(self): + """{% blocktrans %} takes message contexts into account (#14806).""" + trans_real._active = local() + trans_real._translations = {} + with translation.override('de'): + # Nonexistent context + t = Template('{% load i18n %}{% blocktrans context "nonexistent" %}May{% endblocktrans %}') + rendered = t.render(Context()) + self.assertEqual(rendered, 'May') + + # Existing context... using a literal + t = Template('{% load i18n %}{% blocktrans context "month name" %}May{% endblocktrans %}') + rendered = t.render(Context()) + self.assertEqual(rendered, 'Mai') + t = Template('{% load i18n %}{% blocktrans context "verb" %}May{% endblocktrans %}') + rendered = t.render(Context()) + self.assertEqual(rendered, 'Kann') + + # Using a variable + t = Template('{% load i18n %}{% blocktrans context message_context %}May{% endblocktrans %}') + rendered = t.render(Context({'message_context': 'month name'})) + self.assertEqual(rendered, 'Mai') + t = Template('{% load i18n %}{% blocktrans context message_context %}May{% endblocktrans %}') + rendered = t.render(Context({'message_context': 'verb'})) + self.assertEqual(rendered, 'Kann') + + # Using a filter + t = Template('{% load i18n %}{% blocktrans context message_context|lower %}May{% endblocktrans %}') + rendered = t.render(Context({'message_context': 'MONTH NAME'})) + self.assertEqual(rendered, 'Mai') + t = Template('{% load i18n %}{% blocktrans context message_context|lower %}May{% endblocktrans %}') + rendered = t.render(Context({'message_context': 'VERB'})) + self.assertEqual(rendered, 'Kann') + + # Using 'count' + t = Template( + '{% load i18n %}{% blocktrans count number=1 context "super search" %}' + '{{ number }} super result{% plural %}{{ number }} super results{% endblocktrans %}' + ) + rendered = t.render(Context()) + self.assertEqual(rendered, '1 Super-Ergebnis') + t = Template( + '{% load i18n %}{% blocktrans count number=2 context "super search" %}{{ number }}' + ' super result{% plural %}{{ number }} super results{% endblocktrans %}' + ) + rendered = t.render(Context()) + self.assertEqual(rendered, '2 Super-Ergebnisse') + t = Template( + '{% load i18n %}{% blocktrans context "other super search" count number=1 %}' + '{{ number }} super result{% plural %}{{ number }} super results{% endblocktrans %}' + ) + rendered = t.render(Context()) + self.assertEqual(rendered, '1 anderen Super-Ergebnis') + t = Template( + '{% load i18n %}{% blocktrans context "other super search" count number=2 %}' + '{{ number }} super result{% plural %}{{ number }} super results{% endblocktrans %}' + ) + rendered = t.render(Context()) + self.assertEqual(rendered, '2 andere Super-Ergebnisse') + + # Using 'with' + t = Template( + '{% load i18n %}{% blocktrans with num_comments=5 context "comment count" %}' + 'There are {{ num_comments }} comments{% endblocktrans %}' + ) + rendered = t.render(Context()) + self.assertEqual(rendered, 'Es gibt 5 Kommentare') + t = Template( + '{% load i18n %}{% blocktrans with num_comments=5 context "other comment count" %}' + 'There are {{ num_comments }} comments{% endblocktrans %}' + ) + rendered = t.render(Context()) + self.assertEqual(rendered, 'Andere: Es gibt 5 Kommentare') + + # Using trimmed + t = Template( + '{% load i18n %}{% blocktrans trimmed %}\n\nThere\n\t are 5 ' + '\n\n comments\n{% endblocktrans %}' + ) + rendered = t.render(Context()) + self.assertEqual(rendered, 'There are 5 comments') + t = Template( + '{% load i18n %}{% blocktrans with num_comments=5 context "comment count" trimmed %}\n\n' + 'There are \t\n \t {{ num_comments }} comments\n\n{% endblocktrans %}' + ) + rendered = t.render(Context()) + self.assertEqual(rendered, 'Es gibt 5 Kommentare') + t = Template( + '{% load i18n %}{% blocktrans context "other super search" count number=2 trimmed %}\n' + '{{ number }} super \n result{% plural %}{{ number }} super results{% endblocktrans %}' + ) + rendered = t.render(Context()) + self.assertEqual(rendered, '2 andere Super-Ergebnisse') + + # Misuses + with self.assertRaises(TemplateSyntaxError): + Template('{% load i18n %}{% blocktrans context with month="May" %}{{ month }}{% endblocktrans %}') + with self.assertRaises(TemplateSyntaxError): + Template('{% load i18n %}{% blocktrans context %}{% endblocktrans %}') + with self.assertRaises(TemplateSyntaxError): + Template( + '{% load i18n %}{% blocktrans count number=2 context %}' + '{{ number }} super result{% plural %}{{ number }}' + ' super results{% endblocktrans %}' + ) + + @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 %}{% blocktrans %}My name is {{ person }}.{% endblocktrans %}') + rendered = t.render(Context({'person': 'James'})) + self.assertEqual(rendered, 'My name is James.') + + @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 %}{% blocktrans %}My other name is {{ person }}.{% endblocktrans %}') + rendered = t.render(Context({'person': 'James'})) + self.assertEqual(rendered, 'My other name is James.') + + +class MultipleLocaleActivationBlockTransTests(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("{% load i18n %}{% blocktrans %}Yes{% endblocktrans %}").render(Context({})), + 'Oui' + ) + + def test_multiple_locale_btrans(self): + with translation.override('de'): + t = Template("{% load i18n %}{% blocktrans %}No{% endblocktrans %}") + 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 = Template("{% load i18n %}{% blocktrans %}No{% endblocktrans %}") + with translation.override('nl'): + self.assertEqual(t.render(Context({})), 'Nee') + + def test_multiple_locale_direct_switch_btrans(self): + with translation.override('de'): + t = Template("{% load i18n %}{% blocktrans %}No{% endblocktrans %}") + with translation.override('nl'): + self.assertEqual(t.render(Context({})), 'Nee') + + +class MiscTests(SimpleTestCase): + + @override_settings(LOCALE_PATHS=extended_locale_paths) + def test_percent_in_translatable_block(self): + t_sing = Template("{% load i18n %}{% blocktrans %}The result was {{ percent }}%{% endblocktrans %}") + t_plur = Template( + "{% load i18n %}{% blocktrans count num as number %}" + "{{ percent }}% represents {{ num }} object{% plural %}" + "{{ percent }}% represents {{ num }} objects{% endblocktrans %}" + ) + 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_blocktrans(self): + """ + Python's %-formatting is properly escaped in blocktrans, singular, or + plural. + """ + t_sing = Template("{% load i18n %}{% blocktrans %}There are %(num_comments)s comments{% endblocktrans %}") + t_plur = Template( + "{% load i18n %}{% blocktrans count num as number %}" + "%(percent)s% represents {{ num }} object{% plural %}" + "%(percent)s% represents {{ num }} objects{% endblocktrans %}" + ) + 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') diff --git a/tests/template_tests/syntax_tests/i18n/test_filters.py b/tests/template_tests/syntax_tests/i18n/test_filters.py new file mode 100644 index 00000000000..6a5a3fd1d52 --- /dev/null +++ b/tests/template_tests/syntax_tests/i18n/test_filters.py @@ -0,0 +1,50 @@ +# -*- coding: utf-8 -*- +from __future__ import unicode_literals + +from django.test import SimpleTestCase +from django.utils import translation + +from ...utils import setup + + +class I18nFiltersTests(SimpleTestCase): + libraries = { + '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 }}'}) + 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 }}'}) + 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 %}'}) + def test_i18n38_2(self): + 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; ' + ) 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 new file mode 100644 index 00000000000..187aa4e7aba --- /dev/null +++ b/tests/template_tests/syntax_tests/i18n/test_get_available_languages.py @@ -0,0 +1,16 @@ +from __future__ import unicode_literals + +from django.test import SimpleTestCase + +from ...utils import setup + + +class GetAvailableLanguagesTagTests(SimpleTestCase): + 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 %}'}) + def test_i18n12(self): + output = self.engine.render_to_string('i18n12') + self.assertEqual(output, 'de') 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 new file mode 100644 index 00000000000..f555f67b7a8 --- /dev/null +++ b/tests/template_tests/syntax_tests/i18n/test_get_language_info.py @@ -0,0 +1,39 @@ +# -*- coding: utf-8 -*- +from __future__ import unicode_literals + +from django.test import SimpleTestCase +from django.utils import translation + +from ...utils import setup + + +class I18nGetLanguageInfoTagTests(SimpleTestCase): + libraries = { + '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 }}'}) + def test_i18n28_2(self): + 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 }}'}) + def test_i18n29(self): + 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 }}'}) + 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') 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 new file mode 100644 index 00000000000..4b782c94d69 --- /dev/null +++ b/tests/template_tests/syntax_tests/i18n/test_get_language_info_list.py @@ -0,0 +1,48 @@ +# -*- coding: utf-8 -*- +from __future__ import unicode_literals + +from django.test import SimpleTestCase +from django.utils import translation + +from ...utils import setup + + +class GetLanguageInfoListTests(SimpleTestCase): + libraries = { + '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 %}'}) + 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; ') + + @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'))}) + self.assertEqual( + output, + '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 %}'}) + def test_i18n38_2(self): + 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; ' + ) diff --git a/tests/template_tests/syntax_tests/i18n/test_trans.py b/tests/template_tests/syntax_tests/i18n/test_trans.py new file mode 100644 index 00000000000..dd386081755 --- /dev/null +++ b/tests/template_tests/syntax_tests/i18n/test_trans.py @@ -0,0 +1,207 @@ +from __future__ import unicode_literals + +from threading import local + +from django.template import Context, Template, TemplateSyntaxError +from django.test import SimpleTestCase, override_settings +from django.utils import translation +from django.utils.safestring import mark_safe +from django.utils.translation import trans_real + +from ...utils import setup +from .base import MultipleLocaleActivationTestCase, extended_locale_paths + + +class I18nTransTagTests(SimpleTestCase): + libraries = {'i18n': 'django.templatetags.i18n'} + + @setup({'i18n01': '{% load i18n %}{% trans \'xxxyyyxxx\' %}'}) + def test_i18n01(self): + """simple translation of a string delimited by '.""" + output = self.engine.render_to_string('i18n01') + self.assertEqual(output, 'xxxyyyxxx') + + @setup({'i18n02': '{% load i18n %}{% trans "xxxyyyxxx" %}'}) + def test_i18n02(self): + """simple translation of a string delimited by ".""" + output = self.engine.render_to_string('i18n02') + self.assertEqual(output, 'xxxyyyxxx') + + @setup({'i18n06': '{% load i18n %}{% trans "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') + + @setup({'i18n09': '{% load i18n %}{% trans "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') + + @setup({'i18n20': '{% load i18n %}{% trans andrew %}'}) + def test_i18n20(self): + output = self.engine.render_to_string('i18n20', {'andrew': 'a & b'}) + self.assertEqual(output, 'a & b') + + @setup({'i18n22': '{% load i18n %}{% trans 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 %}{% trans "Page not found"|capfirst|slice:"6:" %}'}) + def test_i18n23(self): + """Using filters with the {% trans %} tag (#5972).""" + with translation.override('de'): + output = self.engine.render_to_string('i18n23') + self.assertEqual(output, 'nicht gefunden') + + @setup({'i18n24': '{% load i18n %}{% trans \'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') + + @setup({'i18n25': '{% load i18n %}{% trans 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') + + # trans tag with as var + @setup({'i18n35': '{% load i18n %}{% trans "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 %}' + '{% trans "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') + + @setup({'template': '{% load i18n %}{% trans %}A}'}) + def test_syntax_error_no_arguments(self): + msg = "'trans' takes at least one argument" + with self.assertRaisesMessage(TemplateSyntaxError, msg): + self.engine.render_to_string('template') + + @setup({'template': '{% load i18n %}{% trans "Yes" badoption %}'}) + def test_syntax_error_bad_option(self): + msg = "Unknown argument for 'trans' tag: 'badoption'" + with self.assertRaisesMessage(TemplateSyntaxError, msg): + self.engine.render_to_string('template') + + @setup({'template': '{% load i18n %}{% trans "Yes" as %}'}) + def test_syntax_error_missing_assignment(self): + msg = "No argument provided to the 'trans' tag for the as option." + with self.assertRaisesMessage(TemplateSyntaxError, msg): + self.engine.render_to_string('template') + + @setup({'template': '{% load i18n %}{% trans "Yes" as var context %}'}) + def test_syntax_error_missing_context(self): + msg = "No argument provided to the 'trans' tag for the context option." + with self.assertRaisesMessage(TemplateSyntaxError, msg): + self.engine.render_to_string('template') + + @setup({'template': '{% load i18n %}{% trans "Yes" context as var %}'}) + def test_syntax_error_context_as(self): + msg = "Invalid argument 'as' provided to the 'trans' tag for the context option" + with self.assertRaisesMessage(TemplateSyntaxError, msg): + self.engine.render_to_string('template') + + @setup({'template': '{% load i18n %}{% trans "Yes" context noop %}'}) + def test_syntax_error_context_noop(self): + msg = "Invalid argument 'noop' provided to the 'trans' tag for the context option" + with self.assertRaisesMessage(TemplateSyntaxError, msg): + self.engine.render_to_string('template') + + @setup({'template': '{% load i18n %}{% trans "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') + + @setup({'template': '{% load i18n %}{% trans "%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') + + +class TranslationTransTagTests(SimpleTestCase): + + @override_settings(LOCALE_PATHS=extended_locale_paths) + def test_template_tags_pgettext(self): + """{% trans %} takes message contexts into account (#14806).""" + trans_real._active = local() + trans_real._translations = {} + with translation.override('de'): + # Nonexistent context... + t = Template('{% load i18n %}{% trans "May" context "nonexistent" %}') + rendered = t.render(Context()) + self.assertEqual(rendered, 'May') + + # Existing context... using a literal + t = Template('{% load i18n %}{% trans "May" context "month name" %}') + rendered = t.render(Context()) + self.assertEqual(rendered, 'Mai') + t = Template('{% load i18n %}{% trans "May" context "verb" %}') + rendered = t.render(Context()) + self.assertEqual(rendered, 'Kann') + + # Using a variable + t = Template('{% load i18n %}{% trans "May" context message_context %}') + rendered = t.render(Context({'message_context': 'month name'})) + self.assertEqual(rendered, 'Mai') + t = Template('{% load i18n %}{% trans "May" context message_context %}') + rendered = t.render(Context({'message_context': 'verb'})) + self.assertEqual(rendered, 'Kann') + + # Using a filter + t = Template('{% load i18n %}{% trans "May" context message_context|lower %}') + rendered = t.render(Context({'message_context': 'MONTH NAME'})) + self.assertEqual(rendered, 'Mai') + t = Template('{% load i18n %}{% trans "May" context message_context|lower %}') + rendered = t.render(Context({'message_context': 'VERB'})) + self.assertEqual(rendered, 'Kann') + + # Using 'as' + t = Template('{% load i18n %}{% trans "May" context "month name" as var %}Value: {{ var }}') + rendered = t.render(Context()) + self.assertEqual(rendered, 'Value: Mai') + t = Template('{% load i18n %}{% trans "May" as var context "verb" %}Value: {{ var }}') + rendered = t.render(Context()) + self.assertEqual(rendered, 'Value: Kann') + + +class MultipleLocaleActivationTransTagTests(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("{% load i18n %}{% trans 'Yes' %}").render(Context({})), 'Oui') + + def test_multiple_locale_trans(self): + with translation.override('de'): + t = Template("{% load i18n %}{% trans 'No' %}") + 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): + t = Template("{% load i18n %}{% trans 'No' %}") + with translation.override('nl'): + self.assertEqual(t.render(Context({})), 'Nee') + + def test_multiple_locale_direct_switch_trans(self): + with translation.override('de'): + t = Template("{% load i18n %}{% trans 'No' %}") + with translation.override('nl'): + self.assertEqual(t.render(Context({})), 'Nee') diff --git a/tests/template_tests/syntax_tests/i18n/test_underscore_syntax.py b/tests/template_tests/syntax_tests/i18n/test_underscore_syntax.py new file mode 100644 index 00000000000..aed204d63b1 --- /dev/null +++ b/tests/template_tests/syntax_tests/i18n/test_underscore_syntax.py @@ -0,0 +1,109 @@ +from __future__ import unicode_literals + +from django.template import Context, Template +from django.test import SimpleTestCase +from django.utils import translation + +from ...utils import setup +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') + + # Literal marked up with _() in a filter expression + + def test_multiple_locale_filter(self): + 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') + + def test_multiple_locale_filter_deactivate(self): + 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') + + def test_multiple_locale_filter_direct_switch(self): + with translation.override('de'): + t = Template("{% load i18n %}{{ 0|yesno:_('yes,no,maybe') }}") + with translation.override('nl'): + self.assertEqual(t.render(Context({})), 'nee') + + # Literal marked up with _() + + def test_multiple_locale(self): + with translation.override('de'): + t = Template("{{ _('No') }}") + 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): + t = Template("{{ _('No') }}") + with translation.override('nl'): + self.assertEqual(t.render(Context({})), 'Nee') + + def test_multiple_locale_direct_switch(self): + with translation.override('de'): + t = Template("{{ _('No') }}") + 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'): + t = Template("{% load i18n %}{{ _('No') }}") + 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): + t = Template("{% load i18n %}{{ _('No') }}") + with translation.override('nl'): + self.assertEqual(t.render(Context({})), 'Nee') + + def test_multiple_locale_loadi18n_direct_switch(self): + with translation.override('de'): + t = Template("{% load i18n %}{{ _('No') }}") + 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") }}'}) + def test_i18n13(self): + + 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 %}'}) + def test_i18n14(self): + with translation.override('de'): + output = self.engine.render_to_string('i18n14') + self.assertEqual(output, 'foo Passwort Passwort') + + @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') + + @setup({'i18n16': '{{ _("<") }}'}) + def test_i18n16(self): + with translation.override('de'): + output = self.engine.render_to_string('i18n16') + self.assertEqual(output, '<') diff --git a/tests/template_tests/syntax_tests/test_i18n.py b/tests/template_tests/syntax_tests/test_i18n.py deleted file mode 100644 index 4fbbfffd780..00000000000 --- a/tests/template_tests/syntax_tests/test_i18n.py +++ /dev/null @@ -1,523 +0,0 @@ -# coding: utf-8 -from __future__ import unicode_literals - -from django.template import TemplateSyntaxError -from django.test import SimpleTestCase -from django.utils import translation -from django.utils.safestring import mark_safe - -from ..utils import setup - - -class I18nTagTests(SimpleTestCase): - libraries = { - 'custom': 'template_tests.templatetags.custom', - 'i18n': 'django.templatetags.i18n', - } - - @setup({'i18n01': '{% load i18n %}{% trans \'xxxyyyxxx\' %}'}) - def test_i18n01(self): - """ - simple translation of a string delimited by ' - """ - output = self.engine.render_to_string('i18n01') - self.assertEqual(output, 'xxxyyyxxx') - - @setup({'i18n02': '{% load i18n %}{% trans "xxxyyyxxx" %}'}) - def test_i18n02(self): - """ - simple translation of a string delimited by " - """ - output = self.engine.render_to_string('i18n02') - self.assertEqual(output, 'xxxyyyxxx') - - @setup({'i18n03': '{% load i18n %}{% blocktrans %}{{ anton }}{% endblocktrans %}'}) - def test_i18n03(self): - """ - simple translation of a variable - """ - output = self.engine.render_to_string('i18n03', {'anton': b'\xc3\x85'}) - self.assertEqual(output, 'Å') - - @setup({'i18n04': '{% load i18n %}{% blocktrans with berta=anton|lower %}{{ berta }}{% endblocktrans %}'}) - def test_i18n04(self): - """ - simple translation of a variable and filter - """ - output = self.engine.render_to_string('i18n04', {'anton': b'\xc3\x85'}) - self.assertEqual(output, 'å') - - @setup({'legacyi18n04': '{% load i18n %}' - '{% blocktrans with anton|lower as berta %}{{ berta }}{% endblocktrans %}'}) - def test_legacyi18n04(self): - """ - simple translation of a variable and filter - """ - output = self.engine.render_to_string('legacyi18n04', {'anton': b'\xc3\x85'}) - self.assertEqual(output, 'å') - - @setup({'i18n05': '{% load i18n %}{% blocktrans %}xxx{{ anton }}xxx{% endblocktrans %}'}) - 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({'i18n06': '{% load i18n %}{% trans "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') - - @setup({'i18n07': '{% load i18n %}' - '{% blocktrans count counter=number %}singular{% plural %}' - '{{ counter }} plural{% endblocktrans %}'}) - 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 %}' - '{% blocktrans count number as counter %}singular{% plural %}' - '{{ counter }} plural{% endblocktrans %}'}) - 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 %}' - '{% blocktrans count number as counter %}singular{% plural %}' - '{{ counter }} plural{% endblocktrans %}'}) - 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 %}' - '{% blocktrans count counter=number %}singular{% plural %}' - '{{ counter }} plural{% endblocktrans %}'}) - def test_legacyi18n08(self): - """ - translation of plural form - """ - output = self.engine.render_to_string('legacyi18n08', {'number': 2}) - self.assertEqual(output, '2 plural') - - @setup({'i18n09': '{% load i18n %}{% trans "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') - - @setup({'i18n10': '{{ bool|yesno:_("yes,no,maybe") }}'}) - def test_i18n10(self): - """ - translation of a variable with a translated filter - """ - with translation.override('de'): - output = self.engine.render_to_string('i18n10', {'bool': True}) - self.assertEqual(output, 'Ja') - - @setup({'i18n11': '{{ bool|yesno:"ja,nein" }}'}) - def test_i18n11(self): - """ - translation of a variable with a non-translated filter - """ - output = self.engine.render_to_string('i18n11', {'bool': True}) - self.assertEqual(output, 'ja') - - @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): - """ - usage of the get_available_languages tag - """ - output = self.engine.render_to_string('i18n12') - self.assertEqual(output, 'de') - - @setup({'i18n13': '{{ _("Password") }}'}) - def test_i18n13(self): - """ - translation of constant strings - """ - 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 %}'}) - def test_i18n14(self): - """ - translation of constant strings - """ - with translation.override('de'): - output = self.engine.render_to_string('i18n14') - self.assertEqual(output, 'foo Passwort Passwort') - - @setup({'i18n15': '{{ absent|default:_("Password") }}'}) - def test_i18n15(self): - """ - translation of constant strings - """ - with translation.override('de'): - output = self.engine.render_to_string('i18n15', {'absent': ''}) - self.assertEqual(output, 'Passwort') - - @setup({'i18n16': '{{ _("<") }}'}) - def test_i18n16(self): - """ - translation of constant strings - """ - with translation.override('de'): - output = self.engine.render_to_string('i18n16') - self.assertEqual(output, '<') - - @setup({'i18n17': '{% load i18n %}' - '{% blocktrans with berta=anton|escape %}{{ berta }}{% endblocktrans %}'}) - def test_i18n17(self): - """ - Escaping inside blocktrans and trans works as if it was directly in the template. - """ - output = self.engine.render_to_string('i18n17', {'anton': 'α & β'}) - self.assertEqual(output, 'α & β') - - @setup({'i18n18': '{% load i18n %}' - '{% blocktrans with berta=anton|force_escape %}{{ berta }}{% endblocktrans %}'}) - def test_i18n18(self): - output = self.engine.render_to_string('i18n18', {'anton': 'α & β'}) - self.assertEqual(output, 'α & β') - - @setup({'i18n19': '{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}'}) - def test_i18n19(self): - output = self.engine.render_to_string('i18n19', {'andrew': 'a & b'}) - self.assertEqual(output, 'a & b') - - @setup({'i18n20': '{% load i18n %}{% trans andrew %}'}) - def test_i18n20(self): - output = self.engine.render_to_string('i18n20', {'andrew': 'a & b'}) - self.assertEqual(output, 'a & b') - - @setup({'i18n21': '{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}'}) - def test_i18n21(self): - output = self.engine.render_to_string('i18n21', {'andrew': mark_safe('a & b')}) - self.assertEqual(output, 'a & b') - - @setup({'i18n22': '{% load i18n %}{% trans andrew %}'}) - def test_i18n22(self): - output = self.engine.render_to_string('i18n22', {'andrew': mark_safe('a & b')}) - self.assertEqual(output, 'a & b') - - @setup({'legacyi18n17': '{% load i18n %}' - '{% blocktrans with anton|escape as berta %}{{ berta }}{% endblocktrans %}'}) - def test_legacyi18n17(self): - output = self.engine.render_to_string('legacyi18n17', {'anton': 'α & β'}) - self.assertEqual(output, 'α & β') - - @setup({'legacyi18n18': '{% load i18n %}' - '{% blocktrans with anton|force_escape as berta %}' - '{{ berta }}{% endblocktrans %}'}) - def test_legacyi18n18(self): - output = self.engine.render_to_string('legacyi18n18', {'anton': 'α & β'}) - self.assertEqual(output, 'α & β') - - @setup({'i18n23': '{% load i18n %}{% trans "Page not found"|capfirst|slice:"6:" %}'}) - def test_i18n23(self): - """ - #5972 - Use filters with the {% trans %} tag - """ - with translation.override('de'): - output = self.engine.render_to_string('i18n23') - self.assertEqual(output, 'nicht gefunden') - - @setup({'i18n24': '{% load i18n %}{% trans \'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') - - @setup({'i18n25': '{% load i18n %}{% trans 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') - - @setup({'i18n26': '{% load i18n %}' - '{% blocktrans with extra_field=myextra_field count counter=number %}' - 'singular {{ extra_field }}{% plural %}plural{% endblocktrans %}'}) - 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 %}' - '{% blocktrans with myextra_field as extra_field count number as counter %}' - 'singular {{ extra_field }}{% plural %}plural{% endblocktrans %}'}) - 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 %}{% blocktrans count counter=number %}' - '{{ counter }} result{% plural %}{{ counter }} results' - '{% endblocktrans %}'}) - 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') - - @setup({'legacyi18n27': '{% load i18n %}' - '{% blocktrans count number as counter %}{{ counter }} result' - '{% plural %}{{ counter }} results{% endblocktrans %}'}) - 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') - - @setup({'i18n28': '{% load i18n %}' - '{% blocktrans with a=anton b=berta %}{{ a }} + {{ b }}{% endblocktrans %}'}) - 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 %}' - '{% blocktrans with anton as a and berta as b %}' - '{{ a }} + {{ b }}{% endblocktrans %}'}) - def test_legacyi18n28(self): - output = self.engine.render_to_string('legacyi18n28', {'anton': 'α', 'berta': 'β'}) - self.assertEqual(output, 'α + β') - - # 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 }}'}) - def test_i18n28_2(self): - 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 }}'}) - def test_i18n29(self): - output = self.engine.render_to_string('i18n29', {'LANGUAGE_CODE': 'fi'}) - self.assertEqual(output, 'fi: Finnish/suomi bidi=False') - - @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; ') - - @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'))}) - self.assertEqual( - output, - 'sl: Slovenian/Sloven\u0161\u010dina bidi=False; ' - 'fa: Persian/\u0641\u0627\u0631\u0633\u06cc bidi=True; ' - ) - - @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 }}'}) - 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') - - # blocktrans handling of variables which are not in the context. - # this should work as if blocktrans was not there (#19915) - @setup({'i18n34': '{% load i18n %}{% blocktrans %}{{ missing }}{% endblocktrans %}'}) - def test_i18n34(self): - output = self.engine.render_to_string('i18n34') - if self.engine.string_if_invalid: - self.assertEqual(output, 'INVALID') - else: - self.assertEqual(output, '') - - @setup({'i18n34_2': '{% load i18n %}{% blocktrans with a=\'α\' %}{{ missing }}{% endblocktrans %}'}) - def test_i18n34_2(self): - output = self.engine.render_to_string('i18n34_2') - if self.engine.string_if_invalid: - self.assertEqual(output, 'INVALID') - else: - self.assertEqual(output, '') - - @setup({'i18n34_3': '{% load i18n %}{% blocktrans with a=anton %}{{ missing }}{% endblocktrans %}'}) - def test_i18n34_3(self): - output = self.engine.render_to_string('i18n34_3', {'anton': '\xce\xb1'}) - if self.engine.string_if_invalid: - self.assertEqual(output, 'INVALID') - else: - self.assertEqual(output, '') - - # trans tag with as var - @setup({'i18n35': '{% load i18n %}{% trans "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 %}' - '{% trans "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') - - @setup({'i18n37': '{% load i18n %}' - '{% trans "Page not found" as page_not_found %}' - '{% blocktrans %}Error: {{ page_not_found }}{% endblocktrans %}'}) - def test_i18n37(self): - with translation.override('de'): - output = self.engine.render_to_string('i18n37') - self.assertEqual(output, 'Error: Seite nicht gefunden') - - # 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 }}'}) - 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') - - @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']}) - self.assertEqual( - output, - 'it: Italian/italiano/italsky bidi=False; ' - 'fr: French/français/francouzsky bidi=False; ' - ) - - # blocktrans tag with asvar - @setup({'i18n39': '{% load i18n %}' - '{% blocktrans asvar page_not_found %}Page not found{% endblocktrans %}' - '>{{ 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 %}' - '{% trans "Page not found" as pg_404 %}' - '{% blocktrans with page_not_found=pg_404 asvar output %}' - 'Error: {{ page_not_found }}' - '{% endblocktrans %}'}) - def test_i18n40(self): - output = self.engine.render_to_string('i18n40') - self.assertEqual(output, '') - - @setup({'i18n41': '{% load i18n %}' - '{% trans "Page not found" as pg_404 %}' - '{% blocktrans with page_not_found=pg_404 asvar output %}' - 'Error: {{ page_not_found }}' - '{% endblocktrans %}' - '>{{ 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 %}{% trans %}A}'}) - def test_syntax_error_no_arguments(self): - msg = "'trans' takes at least one argument" - with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template') - - @setup({'template': '{% load i18n %}{% trans "Yes" badoption %}'}) - def test_syntax_error_bad_option(self): - msg = "Unknown argument for 'trans' tag: 'badoption'" - with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template') - - @setup({'template': '{% load i18n %}{% trans "Yes" as %}'}) - def test_syntax_error_missing_assignment(self): - msg = "No argument provided to the 'trans' tag for the as option." - with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template') - - @setup({'template': '{% load i18n %}{% blocktrans asvar %}Yes{% endblocktrans %}'}) - def test_blocktrans_syntax_error_missing_assignment(self): - msg = "No argument provided to the 'blocktrans' tag for the asvar option." - with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template') - - @setup({'template': '{% load i18n %}{% trans "Yes" as var context %}'}) - def test_syntax_error_missing_context(self): - msg = "No argument provided to the 'trans' tag for the context option." - with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template') - - @setup({'template': '{% load i18n %}{% trans "Yes" context as var %}'}) - def test_syntax_error_context_as(self): - msg = "Invalid argument 'as' provided to the 'trans' tag for the context option" - with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template') - - @setup({'template': '{% load i18n %}{% trans "Yes" context noop %}'}) - def test_syntax_error_context_noop(self): - msg = "Invalid argument 'noop' provided to the 'trans' tag for the context option" - with self.assertRaisesMessage(TemplateSyntaxError, msg): - self.engine.render_to_string('template') - - @setup({'template': '{% load i18n %}{% trans "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') - - @setup({'template': '{% load i18n %}{% trans "%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') - - @setup({'template': '{% load i18n %}{% blocktrans %}%s{% endblocktrans %}'}) - def test_blocktrans_tag_using_a_string_that_looks_like_str_fmt(self): - output = self.engine.render_to_string('template') - self.assertEqual(output, '%s')