def test_message_id_and_message_text(self):
message = gettextutils.Message('1')
self.assertEqual('1', message.msgid)
self.assertEqual('1', message)
message = gettextutils.Message('1', msgtext='A')
self.assertEqual('1', message.msgid)
self.assertEqual('A', message)
def test_translate_message_with_message_parameters(self, mock_translation):
message_with_params = 'A message with params: %s %s'
es_translation = 'A message with params in Spanish: %s %s'
message_param = 'A message param'
es_param_translation = 'A message param in Spanish'
another_message_param = 'Another message param'
another_es_param_translation = 'Another message param in Spanish'
translations = {message_with_params: es_translation,
message_param: es_param_translation,
another_message_param: another_es_param_translation}
translator = fakes.FakeTranslations.translator({'es': translations})
mock_translation.side_effect = translator
msg = gettextutils.Message(message_with_params)
param_1 = gettextutils.Message(message_param)
param_2 = gettextutils.Message(another_message_param)
msg = msg % (param_1, param_2)
default_translation = message_with_params % (message_param,
another_message_param)
expected_translation = es_translation % (es_param_translation,
another_es_param_translation)
self.assertEqual(expected_translation, msg.translate('es'))
self.assertEqual(default_translation, msg.translate('XX'))
def test_translate_message_with_object_param(self, mock_translation):
message_with_params = 'A message: %s'
es_translation = 'A message in Spanish: %s'
param = 'A Message param'
param_translation = 'A Message param in Spanish'
translations = {message_with_params: es_translation,
param: param_translation}
translator = fakes.FakeTranslations.translator({'es': translations})
mock_translation.side_effect = translator
msg = gettextutils.Message(message_with_params)
param_msg = gettextutils.Message(param)
# Here we are testing translation of a Message with another object
# that can be translated via its unicode() representation, this is
# very common for instance when modding an Exception with a Message
obj = SomeObject(param_msg)
msg = msg % obj
default_translation = message_with_params % param
expected_translation = es_translation % param_translation
self.assertEqual(expected_translation, msg.translate('es'))
self.assertEqual(default_translation, msg.translate('XX'))
def test_emit_translated_message_with_args(self, mock_translation):
log_message = 'A message to be logged %s'
log_message_translation = 'A message to be logged in Chinese %s'
log_arg = 'Arg to be logged'
log_arg_translation = 'An arg to be logged in Chinese'
translations = {log_message: log_message_translation,
log_arg: log_arg_translation}
translations_map = {'zh_CN': translations}
translator = fakes.FakeTranslations.translator(translations_map)
mock_translation.side_effect = translator
msg = gettextutils.Message(log_message)
arg = gettextutils.Message(log_arg)
self.logger.info(msg, arg)
self.assertIn(log_message_translation % log_arg_translation,
self.stream.getvalue())
def test_translate_message_non_default_locale(self,
mock_translation,
mock_getdefaultlocale):
message_with_params = 'A message with params: %(param)s'
es_translation = 'A message with params in Spanish: %(param)s'
zh_translation = 'A message with params in Chinese: %(param)s'
fr_translation = 'A message with params in French: %(param)s'
message_param = 'A Message param'
es_param_translation = 'A message param in Spanish'
zh_param_translation = 'A message param in Chinese'
fr_param_translation = 'A message param in French'
es_translations = {message_with_params: es_translation,
message_param: es_param_translation}
zh_translations = {message_with_params: zh_translation,
message_param: zh_param_translation}
fr_translations = {message_with_params: fr_translation,
message_param: fr_param_translation}
translator = fakes.FakeTranslations.translator({'es': es_translations,
'zh': zh_translations,
'fr': fr_translations})
mock_translation.side_effect = translator
mock_getdefaultlocale.return_value = ('es',)
msg = gettextutils.Message(message_with_params)
msg_param = gettextutils.Message(message_param)
msg = msg % {'param': msg_param}
es_translation = es_translation % {'param': es_param_translation}
zh_translation = zh_translation % {'param': zh_param_translation}
fr_translation = fr_translation % {'param': fr_param_translation}
# Because sys.getdefaultlocale() was Spanish,
# the default translation will be to Spanish
self.assertEqual(es_translation, msg)
self.assertEqual(es_translation, msg.translate())
self.assertEqual(es_translation, msg.translate('es'))
# Translation into other locales still works
self.assertEqual(zh_translation, msg.translate('zh'))
self.assertEqual(fr_translation, msg.translate('fr'))
def test_translate_message_with_named_parameters(self, mock_translation):
message_with_params = 'A message with params: %(param)s'
es_translation = 'A message with params in Spanish: %(param)s'
message_param = 'A Message param'
es_param_translation = 'A message param in Spanish'
translations = {message_with_params: es_translation,
message_param: es_param_translation}
translator = fakes.FakeTranslations.translator({'es': translations})
mock_translation.side_effect = translator
msg = gettextutils.Message(message_with_params)
msg_param = gettextutils.Message(message_param)
msg = msg % {'param': msg_param}
default_translation = message_with_params % {'param': message_param}
expected_translation = es_translation % {'param': es_param_translation}
self.assertEqual(expected_translation, msg.translate('es'))
self.assertEqual(default_translation, msg.translate('XX'))
def test_translate(self, mock_translation):
en_message = 'A message in the default locale'
es_translation = 'A message in Spanish'
message = gettextutils.Message(en_message)
es_translations = {en_message: es_translation}
translations_map = {'es': es_translations}
translator = fakes.FakeTranslations.translator(translations_map)
mock_translation.side_effect = translator
self.assertEqual(es_translation, message.translate('es'))
def test_emit_translated_message_with_named_args(self, mock_translation):
log_message = 'A message to be logged %(arg1)s $(arg2)s'
log_message_translation = 'Chinese msg to be logged %(arg1)s $(arg2)s'
log_arg_1 = 'Arg1 to be logged'
log_arg_1_translation = 'Arg1 to be logged in Chinese'
log_arg_2 = 'Arg2 to be logged'
log_arg_2_translation = 'Arg2 to be logged in Chinese'
translations = {log_message: log_message_translation,
log_arg_1: log_arg_1_translation,
log_arg_2: log_arg_2_translation}
translations_map = {'zh_CN': translations}
translator = fakes.FakeTranslations.translator(translations_map)
mock_translation.side_effect = translator
msg = gettextutils.Message(log_message)
arg_1 = gettextutils.Message(log_arg_1)
arg_2 = gettextutils.Message(log_arg_2)
self.logger.info(msg, {'arg1': arg_1, 'arg2': arg_2})
translation = log_message_translation % {'arg1': log_arg_1_translation,
'arg2': log_arg_2_translation}
self.assertIn(translation, self.stream.getvalue())
def test_translate(self, mock_translation):
en_message = 'A message in the default locale'
es_translation = 'A message in Spanish'
message = gettextutils.Message(en_message)
es_translations = {en_message: es_translation}
translations_map = {'es': es_translations}
translator = fakes.FakeTranslations.translator(translations_map)
mock_translation.side_effect = translator
# translate() works on msgs and on objects whose unicode reps are msgs
obj = SomeObject(message)
self.assertEqual(es_translation, gettextutils.translate(message, 'es'))
self.assertEqual(es_translation, gettextutils.translate(obj, 'es'))
def test_translate_message_from_unicoded_object(self, mock_translation):
en_message = 'A message in the default locale'
es_translation = 'A message in Spanish'
message = gettextutils.Message(en_message)
es_translations = {en_message: es_translation}
translations_map = {'es': es_translations}
translator = fakes.FakeTranslations.translator(translations_map)
mock_translation.side_effect = translator
# Here we are not testing the Message object directly but the result
# of unicoding() an object whose unicode representation is a Message
obj = SomeObject(message)
unicoded_obj = six.text_type(obj)
self.assertEqual(es_translation, unicoded_obj.translate('es'))
def test_translate_message_with_param(self, mock_translation):
message_with_params = 'A message: %s'
es_translation = 'A message in Spanish: %s'
param = 'A Message param'
translations = {message_with_params: es_translation}
translator = fakes.FakeTranslations.translator({'es': translations})
mock_translation.side_effect = translator
msg = gettextutils.Message(message_with_params)
msg = msg % param
default_translation = message_with_params % param
expected_translation = es_translation % param
self.assertEqual(expected_translation, msg.translate('es'))
self.assertEqual(default_translation, msg.translate('XX'))
def test_translate_multiple_languages(self, mock_translation):
en_message = 'A message in the default locale'
es_translation = 'A message in Spanish'
zh_translation = 'A message in Chinese'
message = gettextutils.Message(en_message)
es_translations = {en_message: es_translation}
zh_translations = {en_message: zh_translation}
translations_map = {'es': es_translations,
'zh': zh_translations}
translator = fakes.FakeTranslations.translator(translations_map)
mock_translation.side_effect = translator
self.assertEqual(es_translation, message.translate('es'))
self.assertEqual(zh_translation, message.translate('zh'))
self.assertEqual(en_message, message.translate(None))
self.assertEqual(en_message, message.translate('en'))
self.assertEqual(en_message, message.translate('XX'))
def test_create_message_non_english_default_locale(self,
mock_translation,
mock_getdefaultlocale):
msgid = 'A message in English'
es_translation = 'A message in Spanish'
es_translations = {msgid: es_translation}
translations_map = {'es': es_translations}
translator = fakes.FakeTranslations.translator(translations_map)
mock_translation.side_effect = translator
mock_getdefaultlocale.return_value = ('es',)
message = gettextutils.Message(msgid)
# The base representation of the message is in Spanish, as well as
# the default translation, since the default locale was Spanish.
self.assertEqual(es_translation, message)
self.assertEqual(es_translation, message.translate())
def test_translate_message_with_param_from_unicoded_obj(self,
mock_translation):
message_with_params = 'A message: %s'
es_translation = 'A message in Spanish: %s'
param = 'A Message param'
translations = {message_with_params: es_translation}
translator = fakes.FakeTranslations.translator({'es': translations})
mock_translation.side_effect = translator
msg = gettextutils.Message(message_with_params)
msg = msg % param
default_translation = message_with_params % param
expected_translation = es_translation % param
obj = SomeObject(msg)
unicoded_obj = six.text_type(obj)
self.assertEqual(expected_translation, unicoded_obj.translate('es'))
self.assertEqual(default_translation, unicoded_obj.translate('XX'))
def test_message_with_named_param(self):
message_with_params = 'A message with params: %(param)s'
msg = gettextutils.Message(message_with_params, domain='test_domain')
msg = msg % {'param': 'hello'}
ret = jsonutils.to_primitive(msg)
self.assertEqual(msg, ret)
# Copyright 2014 IBM Corp.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from essential.config import cfg
from essential import gettextutils
CONF = cfg.CONF
# Note that this is using the Message class directly instead of using
# gettextutils.enable_lazy() because this isolates the use of
# the Message class to this one instance instead of turning it on
# for all subsequent tests
opt = cfg.StrOpt('i18n',
default="i18n",
help=gettextutils.Message('helpful message'))
CONF.register_opt(opt, group='i18n')
def test_message_with_param(self):
message_with_params = 'A message with param: %s'
msg = gettextutils.Message(message_with_params, domain='test_domain')
msg = msg % 'test_domain'
ret = jsonutils.to_primitive(msg)
self.assertEqual(msg, ret)
def message(msg):
return gettextutils.Message(msg)
