freeipa/tests/test_ipalib/test_text.py
John Dennis 689bea6575 text unit test should validate using installed mo file
We use custom gettext classes (e.g. GettextFactory &
NGettextFactory). We should exercise those classes with an installed
binary mo file to demonstrate we are actually returning the expected
translated strings for all strings defined as being translatable.

The test logic in install/po/test_i18n.py was recently enhanced to
make this type of testing easier and more complete.
tests/test_ipalib/test_text.py should import the new i18n test support
and run it.

Previously tests/test_ipalib/test_text.py made a feeble but incomplete
attempt to do the above but even that was often not run because the
test would skip because the necessary test files were not available
unless they had been manually created in the install/po subdir. It is
now possible to correct those deficiencies in the test.

This patch does the following:

* Moves the location of i18n test code and adjust references to it.
  install/po/test_i18n.py was moved to tests/i18n.py. This permits
  tests/test_ipalib/test_text.py to import the i18n test utilities
  in a clean fashion. The Makefile in install/po now calls this
  same file.

* Modfies test function in test_i18n.py to accept function pointers
  for retreiving a translation.

* Imports test_i18n.py from the install/po directory in the tree

* Creates a tmp directory for the test localedir

* Parses the current ipa.pot file in install/po and generates
  a test po and mo file with special unicode markers. It installs
  the test mo file in the tmp localedir. This is accomplished by
  calling create_po() from the test_i18n.py file.

* If any of the above does not work it raises nose.SkipTest with
  the reason, and skips the test.

* It sets up functions to get a translation and a plural translation
  via our text.GettextFactory class and text.NGettextFactory class
  respectively. This are the functions we use intenally to get
  translations. It set the localdir and lang which are used by those
  classes to match our test configuration. It then runs a validation
  test on every translation and it's plural found in the test.po file
  by calling po_file_iterate and passed it the function pointers to
  our internal routines.

* At the conclusion of the test it cleans up after itself.

Note: extraneous files are not created in the tree, only a tmp
directory is utilized.

Validating msgid's in C code was insufficient.

* Make the discovery of format conversions much more robust by authoring
  a new function parse_printf_fmt() that is able to discover each
  format conversion in a string and break it into it's individual
  subparts. One of those subparts is the argument selector index. In c
  code we need to know if the argumenet selector index is present to
  know if translator can reorder the substitution strings.

  This replaces the simplistic python_anonymous_substitutions_regexp
  which was insufficient to deal with other programming languages
  (e.g. c).

* Add get_prog_langs() function to return the set of programming
  languages a msgid appears in. This is necessar because the msdid
  validation is programming language specific.

https://fedorahosted.org/freeipa/ticket/2582
2012-04-10 18:11:48 -04:00

335 lines
11 KiB
Python

# Authors:
# Jason Gerard DeRose <jderose@redhat.com>
#
# Copyright (C) 2009 Red Hat
# see file 'COPYING' for use and warranty contextrmation
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
Test the `ipalib.text` module.
"""
import os
import shutil
import tempfile
import re
import nose
import locale
from tests.util import raises, assert_equal
from tests.i18n import create_po, po_file_iterate
from ipalib.request import context
from ipalib import request
from ipalib import text
from ipapython.ipautil import file_exists
singular = '%(count)d goose makes a %(dish)s'
plural = '%(count)d geese make a %(dish)s'
def test_create_translation():
f = text.create_translation
key = ('foo', None)
t = f(key)
assert context.__dict__[key] is t
class test_TestLang(object):
def setUp(self):
self.tmp_dir = None
self.saved_lang = None
self.lang = 'xh_ZA'
self.domain = 'ipa'
self.ipa_i18n_dir = os.path.join(os.path.dirname(__file__), '../../install/po')
self.pot_basename = '%s.pot' % self.domain
self.po_basename = '%s.po' % self.lang
self.mo_basename = '%s.mo' % self.domain
self.tmp_dir = tempfile.mkdtemp()
self.saved_lang = os.environ['LANG']
self.locale_dir = os.path.join(self.tmp_dir, 'test_locale')
self.msg_dir = os.path.join(self.locale_dir, self.lang, 'LC_MESSAGES')
if not os.path.exists(self.msg_dir):
os.makedirs(self.msg_dir)
self.pot_file = os.path.join(self.ipa_i18n_dir, self.pot_basename)
self.mo_file = os.path.join(self.msg_dir, self.mo_basename)
self.po_file = os.path.join(self.tmp_dir, self.po_basename)
result = create_po(self.pot_file, self.po_file, self.mo_file)
if result:
raise nose.SkipTest('Unable to create po file "%s" & mo file "%s" from pot file "%s"' %
(self.po_file, self.mo_file, self.pot_file))
if not file_exists(self.po_file):
raise nose.SkipTest('Test po file unavailable, run "make test" in install/po')
if not file_exists(self.mo_file):
raise nose.SkipTest('Test mo file unavailable, run "make test" in install/po')
self.po_file_iterate = po_file_iterate
def tearDown(self):
if self.saved_lang is not None:
os.environ['LANG'] = self.saved_lang
if self.tmp_dir is not None:
shutil.rmtree(self.tmp_dir)
def test_test_lang(self):
print "test_test_lang"
# The test installs the test message catalog under the xh_ZA
# (e.g. Zambia Xhosa) language by default. It would be nice to
# use a dummy language not associated with any real language,
# but the setlocale function demands the locale be a valid
# known locale, Zambia Xhosa is a reasonable choice :)
os.environ['LANG'] = self.lang
# Create a gettext translation object specifying our domain as
# 'ipa' and the locale_dir as 'test_locale' (i.e. where to
# look for the message catalog). Then use that translation
# object to obtain the translation functions.
def get_msgstr(msg):
gt = text.GettextFactory(localedir=self.locale_dir)(msg)
return unicode(gt)
def get_msgstr_plural(singular, plural, count):
ng = text.NGettextFactory(localedir=self.locale_dir)(singular, plural, count)
return ng(count)
result = self.po_file_iterate(self.po_file, get_msgstr, get_msgstr_plural)
assert result == 0
class test_LazyText(object):
klass = text.LazyText
def test_init(self):
inst = self.klass('foo', 'bar')
assert inst.domain == 'foo'
assert inst.localedir == 'bar'
assert inst.key == ('foo', 'bar')
class test_FixMe(object):
klass = text.FixMe
def test_init(self):
inst = self.klass('user.label')
assert inst.msg == 'user.label'
assert inst.domain is None
assert inst.localedir is None
def test_repr(self):
inst = self.klass('user.label')
assert repr(inst) == "FixMe('user.label')"
def test_unicode(self):
inst = self.klass('user.label')
assert unicode(inst) == u'<user.label>'
assert type(unicode(inst)) is unicode
class test_Gettext(object):
klass = text.Gettext
def test_init(self):
inst = self.klass('what up?', 'foo', 'bar')
assert inst.domain == 'foo'
assert inst.localedir == 'bar'
assert inst.msg is 'what up?'
assert inst.args == ('what up?', 'foo', 'bar')
def test_repr(self):
inst = self.klass('foo', 'bar', 'baz')
assert repr(inst) == "Gettext('foo', domain='bar', localedir='baz')"
def test_unicode(self):
inst = self.klass('what up?', 'foo', 'bar')
assert unicode(inst) == u'what up?'
def test_mod(self):
inst = self.klass('hello %(adj)s nurse', 'foo', 'bar')
assert inst % dict(adj='naughty', stuff='junk') == 'hello naughty nurse'
def test_eq(self):
inst1 = self.klass('what up?', 'foo', 'bar')
inst2 = self.klass('what up?', 'foo', 'bar')
inst3 = self.klass('Hello world', 'foo', 'bar')
inst4 = self.klass('what up?', 'foo', 'baz')
assert (inst1 == inst1) is True
assert (inst1 == inst2) is True
assert (inst1 == inst3) is False
assert (inst1 == inst4) is False
# Test with args flipped
assert (inst2 == inst1) is True
assert (inst3 == inst1) is False
assert (inst4 == inst1) is False
def test_ne(self):
inst1 = self.klass('what up?', 'foo', 'bar')
inst2 = self.klass('what up?', 'foo', 'bar')
inst3 = self.klass('Hello world', 'foo', 'bar')
inst4 = self.klass('what up?', 'foo', 'baz')
assert (inst1 != inst2) is False
assert (inst1 != inst2) is False
assert (inst1 != inst3) is True
assert (inst1 != inst4) is True
# Test with args flipped
assert (inst2 != inst1) is False
assert (inst3 != inst1) is True
assert (inst4 != inst1) is True
class test_NGettext(object):
klass = text.NGettext
def test_init(self):
inst = self.klass(singular, plural, 'foo', 'bar')
assert inst.singular is singular
assert inst.plural is plural
assert inst.domain == 'foo'
assert inst.localedir == 'bar'
assert inst.args == (singular, plural, 'foo', 'bar')
def test_repr(self):
inst = self.klass('sig', 'plu', 'foo', 'bar')
assert repr(inst) == \
"NGettext('sig', 'plu', domain='foo', localedir='bar')"
def test_call(self):
inst = self.klass(singular, plural, 'foo', 'bar')
assert inst(0) == plural
assert inst(1) == singular
assert inst(2) == plural
assert inst(3) == plural
def test_mod(self):
inst = self.klass(singular, plural, 'foo', 'bar')
assert inst % dict(count=0, dish='frown') == '0 geese make a frown'
assert inst % dict(count=1, dish='stew') == '1 goose makes a stew'
assert inst % dict(count=2, dish='pie') == '2 geese make a pie'
def test_eq(self):
inst1 = self.klass(singular, plural, 'foo', 'bar')
inst2 = self.klass(singular, plural, 'foo', 'bar')
inst3 = self.klass(singular, '%(count)d thingies', 'foo', 'bar')
inst4 = self.klass(singular, plural, 'foo', 'baz')
assert (inst1 == inst1) is True
assert (inst1 == inst2) is True
assert (inst1 == inst3) is False
assert (inst1 == inst4) is False
# Test with args flipped
assert (inst2 == inst1) is True
assert (inst3 == inst1) is False
assert (inst4 == inst1) is False
def test_ne(self):
inst1 = self.klass(singular, plural, 'foo', 'bar')
inst2 = self.klass(singular, plural, 'foo', 'bar')
inst3 = self.klass(singular, '%(count)d thingies', 'foo', 'bar')
inst4 = self.klass(singular, plural, 'foo', 'baz')
assert (inst1 != inst2) is False
assert (inst1 != inst2) is False
assert (inst1 != inst3) is True
assert (inst1 != inst4) is True
# Test with args flipped
assert (inst2 != inst1) is False
assert (inst3 != inst1) is True
assert (inst4 != inst1) is True
class test_GettextFactory(object):
klass = text.GettextFactory
def test_init(self):
# Test with defaults:
inst = self.klass()
assert inst.domain == 'ipa'
assert inst.localedir is None
# Test with overrides:
inst = self.klass('foo', 'bar')
assert inst.domain == 'foo'
assert inst.localedir == 'bar'
def test_repr(self):
# Test with defaults:
inst = self.klass()
assert repr(inst) == "GettextFactory(domain='ipa', localedir=None)"
# Test with overrides:
inst = self.klass('foo', 'bar')
assert repr(inst) == "GettextFactory(domain='foo', localedir='bar')"
def test_call(self):
inst = self.klass('foo', 'bar')
g = inst('what up?')
assert type(g) is text.Gettext
assert g.msg is 'what up?'
assert g.domain == 'foo'
assert g.localedir == 'bar'
class test_NGettextFactory(object):
klass = text.NGettextFactory
def test_init(self):
# Test with defaults:
inst = self.klass()
assert inst.domain == 'ipa'
assert inst.localedir is None
# Test with overrides:
inst = self.klass('foo', 'bar')
assert inst.domain == 'foo'
assert inst.localedir == 'bar'
def test_repr(self):
# Test with defaults:
inst = self.klass()
assert repr(inst) == "NGettextFactory(domain='ipa', localedir=None)"
# Test with overrides:
inst = self.klass('foo', 'bar')
assert repr(inst) == "NGettextFactory(domain='foo', localedir='bar')"
def test_call(self):
inst = self.klass('foo', 'bar')
ng = inst(singular, plural, 7)
assert type(ng) is text.NGettext
assert ng.singular is singular
assert ng.plural is plural
assert ng.domain == 'foo'
assert ng.localedir == 'bar'