| # -*- encoding: utf-8 -*- |
| from __future__ import with_statement, absolute_import |
| |
| import datetime |
| import decimal |
| import os |
| import pickle |
| from threading import local |
| |
| from django.conf import settings |
| from django.template import Template, Context |
| from django.template.base import TemplateSyntaxError |
| from django.test import TestCase, RequestFactory |
| from django.test.utils import override_settings |
| from django.utils import translation |
| from django.utils.formats import (get_format, date_format, time_format, |
| localize, localize_input, iter_format_modules, get_format_modules, |
| number_format) |
| from django.utils.importlib import import_module |
| from django.utils.numberformat import format as nformat |
| from django.utils.safestring import mark_safe, SafeString, SafeUnicode |
| from django.utils.translation import (ugettext, ugettext_lazy, activate, |
| deactivate, gettext_lazy, pgettext, npgettext, to_locale, |
| get_language_info, get_language, get_language_from_request) |
| |
| |
| from .commands.tests import can_run_extraction_tests, can_run_compilation_tests |
| if can_run_extraction_tests: |
| from .commands.extraction import (ExtractorTests, BasicExtractorTests, |
| JavascriptExtractorTests, IgnoredExtractorTests, SymlinkExtractorTests, |
| CopyPluralFormsExtractorTests, NoWrapExtractorTests, |
| NoLocationExtractorTests) |
| if can_run_compilation_tests: |
| from .commands.compilation import (PoFileTests, PoFileContentsTests, |
| PercentRenderingTests) |
| from .contenttypes.tests import ContentTypeTests |
| from .forms import I18nForm, SelectDateForm, SelectDateWidget, CompanyForm |
| from .models import Company, TestModel |
| from .patterns.tests import (URLRedirectWithoutTrailingSlashTests, |
| URLTranslationTests, URLDisabledTests, URLTagTests, URLTestCaseBase, |
| URLRedirectWithoutTrailingSlashSettingTests, URLNamespaceTests, |
| URLPrefixTests, URLResponseTests, URLRedirectTests, PathUnusedTests) |
| from .test_warnings import DeprecationWarningTests |
| |
| |
| here = os.path.dirname(os.path.abspath(__file__)) |
| |
| class TranslationTests(TestCase): |
| |
| def test_override(self): |
| activate('de') |
| with translation.override('pl'): |
| self.assertEqual(get_language(), 'pl') |
| self.assertEqual(get_language(), 'de') |
| with translation.override(None): |
| self.assertEqual(get_language(), settings.LANGUAGE_CODE) |
| self.assertEqual(get_language(), 'de') |
| deactivate() |
| |
| def test_lazy_objects(self): |
| """ |
| Format string interpolation should work with *_lazy objects. |
| """ |
| s = ugettext_lazy('Add %(name)s') |
| d = {'name': 'Ringo'} |
| self.assertEqual(u'Add Ringo', s % d) |
| with translation.override('de', deactivate=True): |
| self.assertEqual(u'Ringo hinzuf\xfcgen', s % d) |
| with translation.override('pl'): |
| self.assertEqual(u'Dodaj Ringo', s % d) |
| |
| # It should be possible to compare *_lazy objects. |
| s1 = ugettext_lazy('Add %(name)s') |
| self.assertEqual(True, s == s1) |
| s2 = gettext_lazy('Add %(name)s') |
| s3 = gettext_lazy('Add %(name)s') |
| self.assertEqual(True, s2 == s3) |
| self.assertEqual(True, s == s2) |
| s4 = ugettext_lazy('Some other string') |
| self.assertEqual(False, s == s4) |
| |
| def test_lazy_pickle(self): |
| s1 = ugettext_lazy("test") |
| self.assertEqual(unicode(s1), "test") |
| s2 = pickle.loads(pickle.dumps(s1)) |
| self.assertEqual(unicode(s2), "test") |
| |
| def test_pgettext(self): |
| # Reset translation catalog to include other/locale/de |
| extended_locale_paths = settings.LOCALE_PATHS + ( |
| os.path.join(here, 'other', 'locale'), |
| ) |
| with self.settings(LOCALE_PATHS=extended_locale_paths): |
| from django.utils.translation import trans_real |
| trans_real._active = local() |
| trans_real._translations = {} |
| with translation.override('de'): |
| self.assertEqual(pgettext("unexisting", "May"), u"May") |
| self.assertEqual(pgettext("month name", "May"), u"Mai") |
| self.assertEqual(pgettext("verb", "May"), u"Kann") |
| self.assertEqual(npgettext("search", "%d result", "%d results", 4) % 4, u"4 Resultate") |
| |
| def test_template_tags_pgettext(self): |
| """ |
| Ensure that message contexts are taken into account the {% trans %} and |
| {% blocktrans %} template tags. |
| Refs #14806. |
| """ |
| # Reset translation catalog to include other/locale/de |
| extended_locale_paths = settings.LOCALE_PATHS + ( |
| os.path.join(here, 'other', 'locale'), |
| ) |
| with self.settings(LOCALE_PATHS=extended_locale_paths): |
| from django.utils.translation import trans_real |
| 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') |
| |
| # Mis-uses |
| self.assertRaises(TemplateSyntaxError, Template, '{% load i18n %}{% trans "May" context as var %}{{ var }}') |
| self.assertRaises(TemplateSyntaxError, Template, '{% load i18n %}{% trans "May" as var context %}{{ var }}') |
| |
| # {% 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') |
| |
| # Mis-uses |
| self.assertRaises(TemplateSyntaxError, Template, '{% load i18n %}{% blocktrans context with month="May" %}{{ month }}{% endblocktrans %}') |
| self.assertRaises(TemplateSyntaxError, Template, '{% load i18n %}{% blocktrans context %}{% endblocktrans %}') |
| self.assertRaises(TemplateSyntaxError, Template, '{% load i18n %}{% blocktrans count number=2 context %}{{ number }} super result{% plural %}{{ number }} super results{% endblocktrans %}') |
| |
| |
| def test_string_concat(self): |
| """ |
| unicode(string_concat(...)) should not raise a TypeError - #4796 |
| """ |
| import django.utils.translation |
| self.assertEqual(u'django', unicode(django.utils.translation.string_concat("dja", "ngo"))) |
| |
| def test_safe_status(self): |
| """ |
| Translating a string requiring no auto-escaping shouldn't change the "safe" status. |
| """ |
| s = mark_safe('Password') |
| self.assertEqual(SafeString, type(s)) |
| with translation.override('de', deactivate=True): |
| self.assertEqual(SafeUnicode, type(ugettext(s))) |
| self.assertEqual('aPassword', SafeString('a') + s) |
| self.assertEqual('Passworda', s + SafeString('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 |
| """ |
| from django.utils.translation.trans_real import translation as Trans |
| ca_translation = Trans('ca') |
| ca_translation._catalog[u'Mac\nEOF\n'] = u'Catalan Mac\nEOF\n' |
| ca_translation._catalog[u'Win\nEOF\n'] = u'Catalan Win\nEOF\n' |
| with translation.override('ca', deactivate=True): |
| self.assertEqual(u'Catalan Mac\nEOF\n', ugettext(u'Mac\rEOF\r')) |
| self.assertEqual(u'Catalan Win\nEOF\n', ugettext(u'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 |
| """ |
| from django.utils.translation.trans_real import to_language |
| self.assertEqual(to_language('en_US'), 'en-us') |
| self.assertEqual(to_language('sr_Lat'), 'sr-lat') |
| |
| @override_settings(LOCALE_PATHS=(os.path.join(here, 'other', 'locale'),)) |
| def test_bad_placeholder(self): |
| """ |
| Error in translation file should not crash template rendering |
| (%(person)s is translated as %(personne)s in fr.po) |
| """ |
| from django.template import Template, Context |
| 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.') |
| |
| |
| class FormattingTests(TestCase): |
| |
| def setUp(self): |
| self.use_i18n = settings.USE_I18N |
| self.use_l10n = settings.USE_L10N |
| self.use_thousand_separator = settings.USE_THOUSAND_SEPARATOR |
| self.thousand_separator = settings.THOUSAND_SEPARATOR |
| self.number_grouping = settings.NUMBER_GROUPING |
| self.n = decimal.Decimal('66666.666') |
| self.f = 99999.999 |
| self.d = datetime.date(2009, 12, 31) |
| self.dt = datetime.datetime(2009, 12, 31, 20, 50) |
| self.t = datetime.time(10, 15, 48) |
| self.l = 10000L |
| self.ctxt = Context({ |
| 'n': self.n, |
| 't': self.t, |
| 'd': self.d, |
| 'dt': self.dt, |
| 'f': self.f, |
| 'l': self.l, |
| }) |
| |
| def tearDown(self): |
| # Restore defaults |
| settings.USE_I18N = self.use_i18n |
| settings.USE_L10N = self.use_l10n |
| settings.USE_THOUSAND_SEPARATOR = self.use_thousand_separator |
| settings.THOUSAND_SEPARATOR = self.thousand_separator |
| settings.NUMBER_GROUPING = self.number_grouping |
| |
| def test_locale_independent(self): |
| """ |
| Localization of numbers |
| """ |
| with self.settings(USE_L10N=True, USE_THOUSAND_SEPARATOR=False): |
| self.assertEqual(u'66666.66', nformat(self.n, decimal_sep='.', decimal_pos=2, grouping=3, thousand_sep=',')) |
| self.assertEqual(u'66666A6', nformat(self.n, decimal_sep='A', decimal_pos=1, grouping=1, thousand_sep='B')) |
| self.assertEqual(u'66666', nformat(self.n, decimal_sep='X', decimal_pos=0, grouping=1, thousand_sep='Y')) |
| |
| with self.settings(USE_L10N=True, USE_THOUSAND_SEPARATOR=True): |
| self.assertEqual(u'66,666.66', nformat(self.n, decimal_sep='.', decimal_pos=2, grouping=3, thousand_sep=',')) |
| self.assertEqual(u'6B6B6B6B6A6', nformat(self.n, decimal_sep='A', decimal_pos=1, grouping=1, thousand_sep='B')) |
| self.assertEqual(u'-66666.6', nformat(-66666.666, decimal_sep='.', decimal_pos=1)) |
| self.assertEqual(u'-66666.0', nformat(int('-66666'), decimal_sep='.', decimal_pos=1)) |
| self.assertEqual(u'10000.0', nformat(self.l, decimal_sep='.', decimal_pos=1)) |
| # This unusual grouping/force_grouping combination may be triggered by the intcomma filter (#17414) |
| self.assertEqual(u'10000', nformat(self.l, decimal_sep='.', decimal_pos=0, grouping=0, force_grouping=True)) |
| |
| # date filter |
| self.assertEqual(u'31.12.2009 в 20:50', Template('{{ dt|date:"d.m.Y в H:i" }}').render(self.ctxt)) |
| self.assertEqual(u'⌚ 10:15', Template('{{ t|time:"⌚ H:i" }}').render(self.ctxt)) |
| |
| def test_l10n_disabled(self): |
| """ |
| Catalan locale with format i18n disabled translations will be used, |
| but not formats |
| """ |
| settings.USE_L10N = False |
| with translation.override('ca', deactivate=True): |
| self.assertEqual(u'N j, Y', get_format('DATE_FORMAT')) |
| self.assertEqual(0, get_format('FIRST_DAY_OF_WEEK')) |
| self.assertEqual(u'.', get_format('DECIMAL_SEPARATOR')) |
| self.assertEqual(u'10:15 a.m.', time_format(self.t)) |
| self.assertEqual(u'des. 31, 2009', date_format(self.d)) |
| self.assertEqual(u'desembre 2009', date_format(self.d, 'YEAR_MONTH_FORMAT')) |
| self.assertEqual(u'12/31/2009 8:50 p.m.', date_format(self.dt, 'SHORT_DATETIME_FORMAT')) |
| self.assertEqual(u'No localizable', localize('No localizable')) |
| self.assertEqual(u'66666.666', localize(self.n)) |
| self.assertEqual(u'99999.999', localize(self.f)) |
| self.assertEqual(u'10000', localize(self.l)) |
| self.assertEqual(u'des. 31, 2009', localize(self.d)) |
| self.assertEqual(u'des. 31, 2009, 8:50 p.m.', localize(self.dt)) |
| self.assertEqual(u'66666.666', Template('{{ n }}').render(self.ctxt)) |
| self.assertEqual(u'99999.999', Template('{{ f }}').render(self.ctxt)) |
| self.assertEqual(u'des. 31, 2009', Template('{{ d }}').render(self.ctxt)) |
| self.assertEqual(u'des. 31, 2009, 8:50 p.m.', Template('{{ dt }}').render(self.ctxt)) |
| self.assertEqual(u'66666.67', Template('{{ n|floatformat:2 }}').render(self.ctxt)) |
| self.assertEqual(u'100000.0', Template('{{ f|floatformat }}').render(self.ctxt)) |
| self.assertEqual(u'10:15 a.m.', Template('{{ t|time:"TIME_FORMAT" }}').render(self.ctxt)) |
| self.assertEqual(u'12/31/2009', Template('{{ d|date:"SHORT_DATE_FORMAT" }}').render(self.ctxt)) |
| self.assertEqual(u'12/31/2009 8:50 p.m.', Template('{{ dt|date:"SHORT_DATETIME_FORMAT" }}').render(self.ctxt)) |
| |
| form = I18nForm({ |
| 'decimal_field': u'66666,666', |
| 'float_field': u'99999,999', |
| 'date_field': u'31/12/2009', |
| 'datetime_field': u'31/12/2009 20:50', |
| 'time_field': u'20:50', |
| 'integer_field': u'1.234', |
| }) |
| self.assertEqual(False, form.is_valid()) |
| self.assertEqual([u'Introdu\xefu un n\xfamero.'], form.errors['float_field']) |
| self.assertEqual([u'Introdu\xefu un n\xfamero.'], form.errors['decimal_field']) |
| self.assertEqual([u'Introdu\xefu una data v\xe0lida.'], form.errors['date_field']) |
| self.assertEqual([u'Introdu\xefu una data/hora v\xe0lides.'], form.errors['datetime_field']) |
| self.assertEqual([u'Introdu\xefu un n\xfamero sencer.'], form.errors['integer_field']) |
| |
| form2 = SelectDateForm({ |
| 'date_field_month': u'12', |
| 'date_field_day': u'31', |
| 'date_field_year': u'2009' |
| }) |
| self.assertEqual(True, form2.is_valid()) |
| self.assertEqual(datetime.date(2009, 12, 31), form2.cleaned_data['date_field']) |
| self.assertHTMLEqual( |
| u'<select name="mydate_month" id="id_mydate_month">\n<option value="1">gener</option>\n<option value="2">febrer</option>\n<option value="3">mar\xe7</option>\n<option value="4">abril</option>\n<option value="5">maig</option>\n<option value="6">juny</option>\n<option value="7">juliol</option>\n<option value="8">agost</option>\n<option value="9">setembre</option>\n<option value="10">octubre</option>\n<option value="11">novembre</option>\n<option value="12" selected="selected">desembre</option>\n</select>\n<select name="mydate_day" id="id_mydate_day">\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31" selected="selected">31</option>\n</select>\n<select name="mydate_year" id="id_mydate_year">\n<option value="2009" selected="selected">2009</option>\n<option value="2010">2010</option>\n<option value="2011">2011</option>\n<option value="2012">2012</option>\n<option value="2013">2013</option>\n<option value="2014">2014</option>\n<option value="2015">2015</option>\n<option value="2016">2016</option>\n<option value="2017">2017</option>\n<option value="2018">2018</option>\n</select>', |
| SelectDateWidget(years=range(2009, 2019)).render('mydate', datetime.date(2009, 12, 31)) |
| ) |
| |
| # We shouldn't change the behavior of the floatformat filter re: |
| # thousand separator and grouping when USE_L10N is False even |
| # if the USE_THOUSAND_SEPARATOR, NUMBER_GROUPING and |
| # THOUSAND_SEPARATOR settings are specified |
| with self.settings(USE_THOUSAND_SEPARATOR=True, |
| NUMBER_GROUPING=1, THOUSAND_SEPARATOR='!'): |
| self.assertEqual(u'66666.67', Template('{{ n|floatformat:2 }}').render(self.ctxt)) |
| self.assertEqual(u'100000.0', Template('{{ f|floatformat }}').render(self.ctxt)) |
| |
| def test_false_like_locale_formats(self): |
| """ |
| Ensure that the active locale's formats take precedence over the |
| default settings even if they would be interpreted as False in a |
| conditional test (e.g. 0 or empty string). |
| Refs #16938. |
| """ |
| from django.conf.locale.fr import formats as fr_formats |
| |
| # Back up original formats |
| backup_THOUSAND_SEPARATOR = fr_formats.THOUSAND_SEPARATOR |
| backup_FIRST_DAY_OF_WEEK = fr_formats.FIRST_DAY_OF_WEEK |
| |
| # Set formats that would get interpreted as False in a conditional test |
| fr_formats.THOUSAND_SEPARATOR = '' |
| fr_formats.FIRST_DAY_OF_WEEK = 0 |
| |
| with translation.override('fr'): |
| with self.settings(USE_L10N=True, USE_THOUSAND_SEPARATOR=True, |
| THOUSAND_SEPARATOR='!'): |
| self.assertEqual('', get_format('THOUSAND_SEPARATOR')) |
| # Even a second time (after the format has been cached)... |
| self.assertEqual('', get_format('THOUSAND_SEPARATOR')) |
| |
| with self.settings(USE_L10N=True, FIRST_DAY_OF_WEEK=1): |
| self.assertEqual(0, get_format('FIRST_DAY_OF_WEEK')) |
| # Even a second time (after the format has been cached)... |
| self.assertEqual(0, get_format('FIRST_DAY_OF_WEEK')) |
| |
| # Restore original formats |
| fr_formats.THOUSAND_SEPARATOR = backup_THOUSAND_SEPARATOR |
| fr_formats.FIRST_DAY_OF_WEEK = backup_FIRST_DAY_OF_WEEK |
| |
| def test_l10n_enabled(self): |
| settings.USE_L10N = True |
| # Catalan locale |
| with translation.override('ca', deactivate=True): |
| self.assertEqual('j \d\e F \d\e Y', get_format('DATE_FORMAT')) |
| self.assertEqual(1, get_format('FIRST_DAY_OF_WEEK')) |
| self.assertEqual(',', get_format('DECIMAL_SEPARATOR')) |
| self.assertEqual(u'10:15:48', time_format(self.t)) |
| self.assertEqual(u'31 de desembre de 2009', date_format(self.d)) |
| self.assertEqual(u'desembre del 2009', date_format(self.d, 'YEAR_MONTH_FORMAT')) |
| self.assertEqual(u'31/12/2009 20:50', date_format(self.dt, 'SHORT_DATETIME_FORMAT')) |
| self.assertEqual('No localizable', localize('No localizable')) |
| |
| settings.USE_THOUSAND_SEPARATOR = True |
| self.assertEqual(u'66.666,666', localize(self.n)) |
| self.assertEqual(u'99.999,999', localize(self.f)) |
| self.assertEqual(u'10.000', localize(self.l)) |
| self.assertEqual(u'True', localize(True)) |
| |
| settings.USE_THOUSAND_SEPARATOR = False |
| self.assertEqual(u'66666,666', localize(self.n)) |
| self.assertEqual(u'99999,999', localize(self.f)) |
| self.assertEqual(u'10000', localize(self.l)) |
| self.assertEqual(u'31 de desembre de 2009', localize(self.d)) |
| self.assertEqual(u'31 de desembre de 2009 a les 20:50', localize(self.dt)) |
| |
| settings.USE_THOUSAND_SEPARATOR = True |
| self.assertEqual(u'66.666,666', Template('{{ n }}').render(self.ctxt)) |
| self.assertEqual(u'99.999,999', Template('{{ f }}').render(self.ctxt)) |
| self.assertEqual(u'10.000', Template('{{ l }}').render(self.ctxt)) |
| |
| form3 = I18nForm({ |
| 'decimal_field': u'66.666,666', |
| 'float_field': u'99.999,999', |
| 'date_field': u'31/12/2009', |
| 'datetime_field': u'31/12/2009 20:50', |
| 'time_field': u'20:50', |
| 'integer_field': u'1.234', |
| }) |
| self.assertEqual(True, form3.is_valid()) |
| self.assertEqual(decimal.Decimal('66666.666'), form3.cleaned_data['decimal_field']) |
| self.assertEqual(99999.999, form3.cleaned_data['float_field']) |
| self.assertEqual(datetime.date(2009, 12, 31), form3.cleaned_data['date_field']) |
| self.assertEqual(datetime.datetime(2009, 12, 31, 20, 50), form3.cleaned_data['datetime_field']) |
| self.assertEqual(datetime.time(20, 50), form3.cleaned_data['time_field']) |
| self.assertEqual(1234, form3.cleaned_data['integer_field']) |
| |
| settings.USE_THOUSAND_SEPARATOR = False |
| self.assertEqual(u'66666,666', Template('{{ n }}').render(self.ctxt)) |
| self.assertEqual(u'99999,999', Template('{{ f }}').render(self.ctxt)) |
| self.assertEqual(u'31 de desembre de 2009', Template('{{ d }}').render(self.ctxt)) |
| self.assertEqual(u'31 de desembre de 2009 a les 20:50', Template('{{ dt }}').render(self.ctxt)) |
| self.assertEqual(u'66666,67', Template('{{ n|floatformat:2 }}').render(self.ctxt)) |
| self.assertEqual(u'100000,0', Template('{{ f|floatformat }}').render(self.ctxt)) |
| self.assertEqual(u'10:15:48', Template('{{ t|time:"TIME_FORMAT" }}').render(self.ctxt)) |
| self.assertEqual(u'31/12/2009', Template('{{ d|date:"SHORT_DATE_FORMAT" }}').render(self.ctxt)) |
| self.assertEqual(u'31/12/2009 20:50', Template('{{ dt|date:"SHORT_DATETIME_FORMAT" }}').render(self.ctxt)) |
| self.assertEqual(date_format(datetime.datetime.now(), "DATE_FORMAT"), Template('{% now "DATE_FORMAT" %}').render(self.ctxt)) |
| |
| form4 = I18nForm({ |
| 'decimal_field': u'66666,666', |
| 'float_field': u'99999,999', |
| 'date_field': u'31/12/2009', |
| 'datetime_field': u'31/12/2009 20:50', |
| 'time_field': u'20:50', |
| 'integer_field': u'1234', |
| }) |
| self.assertEqual(True, form4.is_valid()) |
| self.assertEqual(decimal.Decimal('66666.666'), form4.cleaned_data['decimal_field']) |
| self.assertEqual(99999.999, form4.cleaned_data['float_field']) |
| self.assertEqual(datetime.date(2009, 12, 31), form4.cleaned_data['date_field']) |
| self.assertEqual(datetime.datetime(2009, 12, 31, 20, 50), form4.cleaned_data['datetime_field']) |
| self.assertEqual(datetime.time(20, 50), form4.cleaned_data['time_field']) |
| self.assertEqual(1234, form4.cleaned_data['integer_field']) |
| |
| form5 = SelectDateForm({ |
| 'date_field_month': u'12', |
| 'date_field_day': u'31', |
| 'date_field_year': u'2009' |
| }) |
| self.assertEqual(True, form5.is_valid()) |
| self.assertEqual(datetime.date(2009, 12, 31), form5.cleaned_data['date_field']) |
| self.assertHTMLEqual( |
| u'<select name="mydate_day" id="id_mydate_day">\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31" selected="selected">31</option>\n</select>\n<select name="mydate_month" id="id_mydate_month">\n<option value="1">gener</option>\n<option value="2">febrer</option>\n<option value="3">mar\xe7</option>\n<option value="4">abril</option>\n<option value="5">maig</option>\n<option value="6">juny</option>\n<option value="7">juliol</option>\n<option value="8">agost</option>\n<option value="9">setembre</option>\n<option value="10">octubre</option>\n<option value="11">novembre</option>\n<option value="12" selected="selected">desembre</option>\n</select>\n<select name="mydate_year" id="id_mydate_year">\n<option value="2009" selected="selected">2009</option>\n<option value="2010">2010</option>\n<option value="2011">2011</option>\n<option value="2012">2012</option>\n<option value="2013">2013</option>\n<option value="2014">2014</option>\n<option value="2015">2015</option>\n<option value="2016">2016</option>\n<option value="2017">2017</option>\n<option value="2018">2018</option>\n</select>', |
| SelectDateWidget(years=range(2009, 2019)).render('mydate', datetime.date(2009, 12, 31)) |
| ) |
| |
| # Russian locale (with E as month) |
| with translation.override('ru', deactivate=True): |
| self.assertHTMLEqual( |
| u'<select name="mydate_day" id="id_mydate_day">\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31" selected="selected">31</option>\n</select>\n<select name="mydate_month" id="id_mydate_month">\n<option value="1">\u042f\u043d\u0432\u0430\u0440\u044c</option>\n<option value="2">\u0424\u0435\u0432\u0440\u0430\u043b\u044c</option>\n<option value="3">\u041c\u0430\u0440\u0442</option>\n<option value="4">\u0410\u043f\u0440\u0435\u043b\u044c</option>\n<option value="5">\u041c\u0430\u0439</option>\n<option value="6">\u0418\u044e\u043d\u044c</option>\n<option value="7">\u0418\u044e\u043b\u044c</option>\n<option value="8">\u0410\u0432\u0433\u0443\u0441\u0442</option>\n<option value="9">\u0421\u0435\u043d\u0442\u044f\u0431\u0440\u044c</option>\n<option value="10">\u041e\u043a\u0442\u044f\u0431\u0440\u044c</option>\n<option value="11">\u041d\u043e\u044f\u0431\u0440\u044c</option>\n<option value="12" selected="selected">\u0414\u0435\u043a\u0430\u0431\u0440\u044c</option>\n</select>\n<select name="mydate_year" id="id_mydate_year">\n<option value="2009" selected="selected">2009</option>\n<option value="2010">2010</option>\n<option value="2011">2011</option>\n<option value="2012">2012</option>\n<option value="2013">2013</option>\n<option value="2014">2014</option>\n<option value="2015">2015</option>\n<option value="2016">2016</option>\n<option value="2017">2017</option>\n<option value="2018">2018</option>\n</select>', |
| SelectDateWidget(years=range(2009, 2019)).render('mydate', datetime.date(2009, 12, 31)) |
| ) |
| |
| # English locale |
| with translation.override('en', deactivate=True): |
| self.assertEqual('N j, Y', get_format('DATE_FORMAT')) |
| self.assertEqual(0, get_format('FIRST_DAY_OF_WEEK')) |
| self.assertEqual('.', get_format('DECIMAL_SEPARATOR')) |
| self.assertEqual(u'Dec. 31, 2009', date_format(self.d)) |
| self.assertEqual(u'December 2009', date_format(self.d, 'YEAR_MONTH_FORMAT')) |
| self.assertEqual(u'12/31/2009 8:50 p.m.', date_format(self.dt, 'SHORT_DATETIME_FORMAT')) |
| self.assertEqual(u'No localizable', localize('No localizable')) |
| |
| settings.USE_THOUSAND_SEPARATOR = True |
| self.assertEqual(u'66,666.666', localize(self.n)) |
| self.assertEqual(u'99,999.999', localize(self.f)) |
| self.assertEqual(u'10,000', localize(self.l)) |
| |
| settings.USE_THOUSAND_SEPARATOR = False |
| self.assertEqual(u'66666.666', localize(self.n)) |
| self.assertEqual(u'99999.999', localize(self.f)) |
| self.assertEqual(u'10000', localize(self.l)) |
| self.assertEqual(u'Dec. 31, 2009', localize(self.d)) |
| self.assertEqual(u'Dec. 31, 2009, 8:50 p.m.', localize(self.dt)) |
| |
| settings.USE_THOUSAND_SEPARATOR = True |
| self.assertEqual(u'66,666.666', Template('{{ n }}').render(self.ctxt)) |
| self.assertEqual(u'99,999.999', Template('{{ f }}').render(self.ctxt)) |
| self.assertEqual(u'10,000', Template('{{ l }}').render(self.ctxt)) |
| |
| settings.USE_THOUSAND_SEPARATOR = False |
| self.assertEqual(u'66666.666', Template('{{ n }}').render(self.ctxt)) |
| self.assertEqual(u'99999.999', Template('{{ f }}').render(self.ctxt)) |
| self.assertEqual(u'Dec. 31, 2009', Template('{{ d }}').render(self.ctxt)) |
| self.assertEqual(u'Dec. 31, 2009, 8:50 p.m.', Template('{{ dt }}').render(self.ctxt)) |
| self.assertEqual(u'66666.67', Template('{{ n|floatformat:2 }}').render(self.ctxt)) |
| self.assertEqual(u'100000.0', Template('{{ f|floatformat }}').render(self.ctxt)) |
| self.assertEqual(u'12/31/2009', Template('{{ d|date:"SHORT_DATE_FORMAT" }}').render(self.ctxt)) |
| self.assertEqual(u'12/31/2009 8:50 p.m.', Template('{{ dt|date:"SHORT_DATETIME_FORMAT" }}').render(self.ctxt)) |
| |
| form5 = I18nForm({ |
| 'decimal_field': u'66666.666', |
| 'float_field': u'99999.999', |
| 'date_field': u'12/31/2009', |
| 'datetime_field': u'12/31/2009 20:50', |
| 'time_field': u'20:50', |
| 'integer_field': u'1234', |
| }) |
| self.assertEqual(True, form5.is_valid()) |
| self.assertEqual(decimal.Decimal('66666.666'), form5.cleaned_data['decimal_field']) |
| self.assertEqual(99999.999, form5.cleaned_data['float_field']) |
| self.assertEqual(datetime.date(2009, 12, 31), form5.cleaned_data['date_field']) |
| self.assertEqual(datetime.datetime(2009, 12, 31, 20, 50), form5.cleaned_data['datetime_field']) |
| self.assertEqual(datetime.time(20, 50), form5.cleaned_data['time_field']) |
| self.assertEqual(1234, form5.cleaned_data['integer_field']) |
| |
| form6 = SelectDateForm({ |
| 'date_field_month': u'12', |
| 'date_field_day': u'31', |
| 'date_field_year': u'2009' |
| }) |
| self.assertEqual(True, form6.is_valid()) |
| self.assertEqual(datetime.date(2009, 12, 31), form6.cleaned_data['date_field']) |
| self.assertHTMLEqual( |
| u'<select name="mydate_month" id="id_mydate_month">\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12" selected="selected">December</option>\n</select>\n<select name="mydate_day" id="id_mydate_day">\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31" selected="selected">31</option>\n</select>\n<select name="mydate_year" id="id_mydate_year">\n<option value="2009" selected="selected">2009</option>\n<option value="2010">2010</option>\n<option value="2011">2011</option>\n<option value="2012">2012</option>\n<option value="2013">2013</option>\n<option value="2014">2014</option>\n<option value="2015">2015</option>\n<option value="2016">2016</option>\n<option value="2017">2017</option>\n<option value="2018">2018</option>\n</select>', |
| SelectDateWidget(years=range(2009, 2019)).render('mydate', datetime.date(2009, 12, 31)) |
| ) |
| |
| def test_sub_locales(self): |
| """ |
| Check if sublocales fall back to the main locale |
| """ |
| with self.settings(USE_L10N=True, USE_THOUSAND_SEPARATOR=True): |
| with translation.override('de-at', deactivate=True): |
| self.assertEqual(u'66.666,666', Template('{{ n }}').render(self.ctxt)) |
| with translation.override('es-us', deactivate=True): |
| self.assertEqual(u'31 de diciembre de 2009', date_format(self.d)) |
| |
| def test_localized_input(self): |
| """ |
| Tests if form input is correctly localized |
| """ |
| settings.USE_L10N = True |
| with translation.override('de-at', deactivate=True): |
| form6 = CompanyForm({ |
| 'name': u'acme', |
| 'date_added': datetime.datetime(2009, 12, 31, 6, 0, 0), |
| 'cents_paid': decimal.Decimal('59.47'), |
| 'products_delivered': 12000, |
| }) |
| self.assertEqual(True, form6.is_valid()) |
| self.assertHTMLEqual( |
| form6.as_ul(), |
| u'<li><label for="id_name">Name:</label> <input id="id_name" type="text" name="name" value="acme" maxlength="50" /></li>\n<li><label for="id_date_added">Date added:</label> <input type="text" name="date_added" value="31.12.2009 06:00:00" id="id_date_added" /></li>\n<li><label for="id_cents_paid">Cents paid:</label> <input type="text" name="cents_paid" value="59,47" id="id_cents_paid" /></li>\n<li><label for="id_products_delivered">Products delivered:</label> <input type="text" name="products_delivered" value="12000" id="id_products_delivered" /></li>' |
| ) |
| self.assertEqual(localize_input(datetime.datetime(2009, 12, 31, 6, 0, 0)), '31.12.2009 06:00:00') |
| self.assertEqual(datetime.datetime(2009, 12, 31, 6, 0, 0), form6.cleaned_data['date_added']) |
| with self.settings(USE_THOUSAND_SEPARATOR=True): |
| # Checking for the localized "products_delivered" field |
| self.assertTrue(u'<input type="text" name="products_delivered" value="12.000" id="id_products_delivered" />' in form6.as_ul()) |
| |
| def test_iter_format_modules(self): |
| """ |
| Tests the iter_format_modules function. |
| """ |
| settings.USE_L10N = True |
| with translation.override('de-at', deactivate=True): |
| de_format_mod = import_module('django.conf.locale.de.formats') |
| self.assertEqual(list(iter_format_modules('de')), [de_format_mod]) |
| with self.settings(FORMAT_MODULE_PATH='regressiontests.i18n.other.locale'): |
| test_de_format_mod = import_module('regressiontests.i18n.other.locale.de.formats') |
| self.assertEqual(list(iter_format_modules('de')), [test_de_format_mod, de_format_mod]) |
| |
| def test_iter_format_modules_stability(self): |
| """ |
| Tests the iter_format_modules function always yields format modules in |
| a stable and correct order in presence of both base ll and ll_CC formats. |
| """ |
| settings.USE_L10N = True |
| en_format_mod = import_module('django.conf.locale.en.formats') |
| en_gb_format_mod = import_module('django.conf.locale.en_GB.formats') |
| self.assertEqual(list(iter_format_modules('en-gb')), [en_gb_format_mod, en_format_mod]) |
| |
| def test_get_format_modules_lang(self): |
| with self.settings(USE_L10N=True): |
| with translation.override('de', deactivate=True): |
| self.assertEqual('.', get_format('DECIMAL_SEPARATOR', lang='en')) |
| |
| def test_get_format_modules_stability(self): |
| with self.settings(USE_L10N=True, |
| FORMAT_MODULE_PATH='regressiontests.i18n.other.locale'): |
| with translation.override('de', deactivate=True): |
| old = "%r" % get_format_modules(reverse=True) |
| new = "%r" % get_format_modules(reverse=True) # second try |
| self.assertEqual(new, old, 'Value returned by get_formats_modules() must be preserved between calls.') |
| |
| def test_localize_templatetag_and_filter(self): |
| """ |
| Tests the {% localize %} templatetag |
| """ |
| context = Context({'value': 3.14 }) |
| template1 = Template("{% load l10n %}{% localize %}{{ value }}{% endlocalize %};{% localize on %}{{ value }}{% endlocalize %}") |
| template2 = Template("{% load l10n %}{{ value }};{% localize off %}{{ value }};{% endlocalize %}{{ value }}") |
| template3 = Template('{% load l10n %}{{ value }};{{ value|unlocalize }}') |
| template4 = Template('{% load l10n %}{{ value }};{{ value|localize }}') |
| output1 = '3,14;3,14' |
| output2 = '3,14;3.14;3,14' |
| output3 = '3,14;3.14' |
| output4 = '3.14;3,14' |
| with translation.override('de', deactivate=True): |
| with self.settings(USE_L10N=False): |
| self.assertEqual(template1.render(context), output1) |
| self.assertEqual(template4.render(context), output4) |
| with self.settings(USE_L10N=True): |
| self.assertEqual(template1.render(context), output1) |
| self.assertEqual(template2.render(context), output2) |
| self.assertEqual(template3.render(context), output3) |
| |
| class MiscTests(TestCase): |
| |
| def setUp(self): |
| self.rf = RequestFactory() |
| |
| def test_parse_spec_http_header(self): |
| """ |
| Testing HTTP header parsing. First, we test that we can parse the |
| values according to the spec (and that we extract all the pieces in |
| the right order). |
| """ |
| from django.utils.translation.trans_real import parse_accept_lang_header |
| p = parse_accept_lang_header |
| # Good headers. |
| self.assertEqual([('de', 1.0)], p('de')) |
| self.assertEqual([('en-AU', 1.0)], p('en-AU')) |
| self.assertEqual([('*', 1.0)], p('*;q=1.00')) |
| self.assertEqual([('en-AU', 0.123)], p('en-AU;q=0.123')) |
| self.assertEqual([('en-au', 0.5)], p('en-au;q=0.5')) |
| self.assertEqual([('en-au', 1.0)], p('en-au;q=1.0')) |
| self.assertEqual([('da', 1.0), ('en', 0.5), ('en-gb', 0.25)], p('da, en-gb;q=0.25, en;q=0.5')) |
| self.assertEqual([('en-au-xx', 1.0)], p('en-au-xx')) |
| self.assertEqual([('de', 1.0), ('en-au', 0.75), ('en-us', 0.5), ('en', 0.25), ('es', 0.125), ('fa', 0.125)], p('de,en-au;q=0.75,en-us;q=0.5,en;q=0.25,es;q=0.125,fa;q=0.125')) |
| self.assertEqual([('*', 1.0)], p('*')) |
| self.assertEqual([('de', 1.0)], p('de;q=0.')) |
| self.assertEqual([('en', 1.0), ('*', 0.5)], p('en; q=1.0, * ; q=0.5')) |
| self.assertEqual([], p('')) |
| |
| # Bad headers; should always return []. |
| self.assertEqual([], p('en-gb;q=1.0000')) |
| self.assertEqual([], p('en;q=0.1234')) |
| self.assertEqual([], p('en;q=.2')) |
| self.assertEqual([], p('abcdefghi-au')) |
| self.assertEqual([], p('**')) |
| self.assertEqual([], p('en,,gb')) |
| self.assertEqual([], p('en-au;q=0.1.0')) |
| self.assertEqual([], p('XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXZ,en')) |
| self.assertEqual([], p('da, en-gb;q=0.8, en;q=0.7,#')) |
| self.assertEqual([], p('de;q=2.0')) |
| self.assertEqual([], p('de;q=0.a')) |
| self.assertEqual([], p('')) |
| |
| def test_parse_literal_http_header(self): |
| """ |
| Now test that we parse a literal HTTP header correctly. |
| """ |
| g = get_language_from_request |
| r = self.rf.get('/') |
| r.COOKIES = {} |
| r.META = {'HTTP_ACCEPT_LANGUAGE': 'pt-br'} |
| self.assertEqual('pt-br', g(r)) |
| |
| r.META = {'HTTP_ACCEPT_LANGUAGE': 'pt'} |
| self.assertEqual('pt', g(r)) |
| |
| r.META = {'HTTP_ACCEPT_LANGUAGE': 'es,de'} |
| self.assertEqual('es', g(r)) |
| |
| r.META = {'HTTP_ACCEPT_LANGUAGE': 'es-ar,de'} |
| self.assertEqual('es-ar', g(r)) |
| |
| # This test assumes there won't be a Django translation to a US |
| # variation of the Spanish language, a safe assumption. When the |
| # user sets it as the preferred language, the main 'es' |
| # translation should be selected instead. |
| r.META = {'HTTP_ACCEPT_LANGUAGE': 'es-us'} |
| self.assertEqual(g(r), 'es') |
| |
| # This tests the following scenario: there isn't a main language (zh) |
| # translation of Django but there is a translation to variation (zh_CN) |
| # the user sets zh-cn as the preferred language, it should be selected |
| # by Django without falling back nor ignoring it. |
| r.META = {'HTTP_ACCEPT_LANGUAGE': 'zh-cn,de'} |
| self.assertEqual(g(r), 'zh-cn') |
| |
| def test_parse_language_cookie(self): |
| """ |
| Now test that we parse language preferences stored in a cookie correctly. |
| """ |
| g = get_language_from_request |
| r = self.rf.get('/') |
| r.COOKIES = {settings.LANGUAGE_COOKIE_NAME: 'pt-br'} |
| r.META = {} |
| self.assertEqual('pt-br', g(r)) |
| |
| r.COOKIES = {settings.LANGUAGE_COOKIE_NAME: 'pt'} |
| r.META = {} |
| self.assertEqual('pt', g(r)) |
| |
| r.COOKIES = {settings.LANGUAGE_COOKIE_NAME: 'es'} |
| r.META = {'HTTP_ACCEPT_LANGUAGE': 'de'} |
| self.assertEqual('es', g(r)) |
| |
| # This test assumes there won't be a Django translation to a US |
| # variation of the Spanish language, a safe assumption. When the |
| # user sets it as the preferred language, the main 'es' |
| # translation should be selected instead. |
| r.COOKIES = {settings.LANGUAGE_COOKIE_NAME: 'es-us'} |
| r.META = {} |
| self.assertEqual(g(r), 'es') |
| |
| # This tests the following scenario: there isn't a main language (zh) |
| # translation of Django but there is a translation to variation (zh_CN) |
| # the user sets zh-cn as the preferred language, it should be selected |
| # by Django without falling back nor ignoring it. |
| r.COOKIES = {settings.LANGUAGE_COOKIE_NAME: 'zh-cn'} |
| r.META = {'HTTP_ACCEPT_LANGUAGE': 'de'} |
| self.assertEqual(g(r), 'zh-cn') |
| |
| def test_get_language_from_path(self): |
| from django.utils.translation.trans_real import get_language_from_path as g |
| self.assertEqual(g('/pl/'), 'pl') |
| self.assertEqual(g('/pl'), 'pl') |
| self.assertEqual(g('/xyz/'), None) |
| |
| def test_get_language_from_path(self): |
| from django.utils.translation.trans_null import get_language_from_path as g |
| self.assertEqual(g('/pl/'), None) |
| self.assertEqual(g('/pl'), None) |
| self.assertEqual(g('/xyz/'), None) |
| |
| def test_percent_in_translatable_block(self): |
| extended_locale_paths = settings.LOCALE_PATHS + ( |
| os.path.join(here, 'other', 'locale'), |
| ) |
| with self.settings(LOCALE_PATHS=extended_locale_paths): |
| 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})), u'Das Ergebnis war 42%') |
| self.assertEqual(t_plur.render(Context({'percent': 42, 'num': 1})), u'42% stellt 1 Objekt dar') |
| self.assertEqual(t_plur.render(Context({'percent': 42, 'num': 4})), u'42% stellt 4 Objekte dar') |
| |
| |
| class ResolutionOrderI18NTests(TestCase): |
| |
| def setUp(self): |
| from django.utils.translation import trans_real |
| # Okay, this is brutal, but we have no other choice to fully reset |
| # the translation framework |
| trans_real._active = local() |
| trans_real._translations = {} |
| activate('de') |
| |
| def tearDown(self): |
| deactivate() |
| |
| def assertUgettext(self, msgid, msgstr): |
| result = ugettext(msgid) |
| self.assertTrue(msgstr in result, ("The string '%s' isn't in the " |
| "translation of '%s'; the actual result is '%s'." % (msgstr, msgid, result))) |
| |
| class AppResolutionOrderI18NTests(ResolutionOrderI18NTests): |
| |
| def setUp(self): |
| self.old_installed_apps = settings.INSTALLED_APPS |
| settings.INSTALLED_APPS = ['regressiontests.i18n.resolution'] + list(settings.INSTALLED_APPS) |
| super(AppResolutionOrderI18NTests, self).setUp() |
| |
| def tearDown(self): |
| settings.INSTALLED_APPS = self.old_installed_apps |
| super(AppResolutionOrderI18NTests, self).tearDown() |
| |
| def test_app_translation(self): |
| self.assertUgettext('Date/time', 'APP') |
| |
| class LocalePathsResolutionOrderI18NTests(ResolutionOrderI18NTests): |
| |
| def setUp(self): |
| self.old_locale_paths = settings.LOCALE_PATHS |
| settings.LOCALE_PATHS += (os.path.join(here, 'other', 'locale'),) |
| super(LocalePathsResolutionOrderI18NTests, self).setUp() |
| |
| def tearDown(self): |
| settings.LOCALE_PATHS = self.old_locale_paths |
| super(LocalePathsResolutionOrderI18NTests, self).tearDown() |
| |
| def test_locale_paths_translation(self): |
| self.assertUgettext('Time', 'LOCALE_PATHS') |
| |
| def test_locale_paths_override_app_translation(self): |
| extended_apps = list(settings.INSTALLED_APPS) + ['regressiontests.i18n.resolution'] |
| with self.settings(INSTALLED_APPS=extended_apps): |
| self.assertUgettext('Time', 'LOCALE_PATHS') |
| |
| def test_locale_paths_override_project_translation(self): |
| with self.settings(SETTINGS_MODULE='regressiontests'): |
| self.assertUgettext('Date/time', 'LOCALE_PATHS') |
| |
| class ProjectResolutionOrderI18NTests(ResolutionOrderI18NTests): |
| |
| def setUp(self): |
| self.old_settings_module = settings.SETTINGS_MODULE |
| settings.SETTINGS_MODULE = 'regressiontests' |
| super(ProjectResolutionOrderI18NTests, self).setUp() |
| |
| def tearDown(self): |
| settings.SETTINGS_MODULE = self.old_settings_module |
| super(ProjectResolutionOrderI18NTests, self).tearDown() |
| |
| def test_project_translation(self): |
| self.assertUgettext('Date/time', 'PROJECT') |
| |
| def test_project_override_app_translation(self): |
| extended_apps = list(settings.INSTALLED_APPS) + ['regressiontests.i18n.resolution'] |
| with self.settings(INSTALLED_APPS=extended_apps): |
| self.assertUgettext('Date/time', 'PROJECT') |
| |
| class DjangoFallbackResolutionOrderI18NTests(ResolutionOrderI18NTests): |
| |
| def test_django_fallback(self): |
| self.assertEqual(ugettext('Date/time'), 'Datum/Zeit') |
| |
| |
| class TestModels(TestCase): |
| def test_lazy(self): |
| tm = TestModel() |
| tm.save() |
| |
| def test_safestr(self): |
| c = Company(cents_paid=12, products_delivered=1) |
| c.name = SafeUnicode(u'Iñtërnâtiônàlizætiøn1') |
| c.save() |
| c.name = SafeString(u'Iñtërnâtiônàlizætiøn1'.encode('utf-8')) |
| c.save() |
| |
| |
| class TestLanguageInfo(TestCase): |
| def test_localized_language_info(self): |
| li = get_language_info('de') |
| self.assertEqual(li['code'], 'de') |
| self.assertEqual(li['name_local'], u'Deutsch') |
| self.assertEqual(li['name'], 'German') |
| self.assertEqual(li['bidi'], False) |
| |
| |
| class MultipleLocaleActivationTests(TestCase): |
| """ |
| Tests for template rendering behavior 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) |
| |
| 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): |
| with 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): |
| with 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): |
| with 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): |
| with 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): |
| with 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') |
