← Back to branch summary

~ubuntu-branches/ubuntu/trusty/python-babel/trusty

« back to all changes in this revision

Viewing changes to tests/test_support.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2013-10-28 10:11:31 UTC
  • mfrom: (4.1.2 sid)
  • Revision ID: package-import@ubuntu.com-20131028101131-zwbmm8sc29iemmlr
Tags: 1.3-2ubuntu1
* Merge from Debian unstable.  Remaining changes:
  - debian/rules: Run the testsuite during builds.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_support.py
 
1
# -*- coding: utf-8 -*-
 
2
#
 
3
# Copyright (C) 2007-2011 Edgewall Software
 
4
# All rights reserved.
 
5
#
 
6
# This software is licensed as described in the file COPYING, which
 
7
# you should have received as part of this distribution. The terms
 
8
# are also available at http://babel.edgewall.org/wiki/License.
 
9
#
 
10
# This software consists of voluntary contributions made by many
 
11
# individuals. For the exact contribution history, see the revision
 
12
# history and logs, available at http://babel.edgewall.org/log/.
 
13
 
 
14
import inspect
 
15
import os
 
16
import shutil
 
17
import tempfile
 
18
import unittest
 
19
import pytest
 
20
from datetime import date, datetime, timedelta
 
21
 
 
22
from babel import support
 
23
from babel.messages import Catalog
 
24
from babel.messages.mofile import write_mo
 
25
from babel._compat import BytesIO
 
26
 
 
27
 
 
28
@pytest.mark.usefixtures("os_environ")
 
29
class TranslationsTestCase(unittest.TestCase):
 
30
 
 
31
    def setUp(self):
 
32
        # Use a locale which won't fail to run the tests
 
33
        os.environ['LANG'] = 'en_US.UTF-8'
 
34
        messages1 = [
 
35
            ('foo', {'string': 'Voh'}),
 
36
            ('foo', {'string': 'VohCTX', 'context': 'foo'}),
 
37
            (('foo1', 'foos1'), {'string': ('Voh1', 'Vohs1')}),
 
38
            (('foo1', 'foos1'), {'string': ('VohCTX1', 'VohsCTX1'), 'context': 'foo'}),
 
39
        ]
 
40
        messages2 = [
 
41
            ('foo', {'string': 'VohD'}),
 
42
            ('foo', {'string': 'VohCTXD', 'context': 'foo'}),
 
43
            (('foo1', 'foos1'), {'string': ('VohD1', 'VohsD1')}),
 
44
            (('foo1', 'foos1'), {'string': ('VohCTXD1', 'VohsCTXD1'), 'context': 'foo'}),
 
45
        ]
 
46
        catalog1 = Catalog(locale='en_GB', domain='messages')
 
47
        catalog2 = Catalog(locale='en_GB', domain='messages1')
 
48
        for ids, kwargs in messages1:
 
49
            catalog1.add(ids, **kwargs)
 
50
        for ids, kwargs in messages2:
 
51
            catalog2.add(ids, **kwargs)
 
52
        catalog1_fp = BytesIO()
 
53
        catalog2_fp = BytesIO()
 
54
        write_mo(catalog1_fp, catalog1)
 
55
        catalog1_fp.seek(0)
 
56
        write_mo(catalog2_fp, catalog2)
 
57
        catalog2_fp.seek(0)
 
58
        translations1 = support.Translations(catalog1_fp)
 
59
        translations2 = support.Translations(catalog2_fp, domain='messages1')
 
60
        self.translations = translations1.add(translations2, merge=False)
 
61
 
 
62
    def assertEqualTypeToo(self, expected, result):
 
63
        self.assertEqual(expected, result)
 
64
        assert type(expected) == type(result), "instance type's do not " + \
 
65
            "match: %r!=%r" % (type(expected), type(result))
 
66
 
 
67
    def test_pgettext(self):
 
68
        self.assertEqualTypeToo('Voh', self.translations.gettext('foo'))
 
69
        self.assertEqualTypeToo('VohCTX', self.translations.pgettext('foo',
 
70
                                                                     'foo'))
 
71
 
 
72
    def test_upgettext(self):
 
73
        self.assertEqualTypeToo(u'Voh', self.translations.ugettext('foo'))
 
74
        self.assertEqualTypeToo(u'VohCTX', self.translations.upgettext('foo',
 
75
                                                                       'foo'))
 
76
 
 
77
    def test_lpgettext(self):
 
78
        self.assertEqualTypeToo(b'Voh', self.translations.lgettext('foo'))
 
79
        self.assertEqualTypeToo(b'VohCTX', self.translations.lpgettext('foo',
 
80
                                                                       'foo'))
 
81
 
 
82
    def test_npgettext(self):
 
83
        self.assertEqualTypeToo('Voh1',
 
84
                                self.translations.ngettext('foo1', 'foos1', 1))
 
85
        self.assertEqualTypeToo('Vohs1',
 
86
                                self.translations.ngettext('foo1', 'foos1', 2))
 
87
        self.assertEqualTypeToo('VohCTX1',
 
88
                                self.translations.npgettext('foo', 'foo1',
 
89
                                                            'foos1', 1))
 
90
        self.assertEqualTypeToo('VohsCTX1',
 
91
                                self.translations.npgettext('foo', 'foo1',
 
92
                                                            'foos1', 2))
 
93
 
 
94
    def test_unpgettext(self):
 
95
        self.assertEqualTypeToo(u'Voh1',
 
96
                                self.translations.ungettext('foo1', 'foos1', 1))
 
97
        self.assertEqualTypeToo(u'Vohs1',
 
98
                                self.translations.ungettext('foo1', 'foos1', 2))
 
99
        self.assertEqualTypeToo(u'VohCTX1',
 
100
                                self.translations.unpgettext('foo', 'foo1',
 
101
                                                             'foos1', 1))
 
102
        self.assertEqualTypeToo(u'VohsCTX1',
 
103
                                self.translations.unpgettext('foo', 'foo1',
 
104
                                                             'foos1', 2))
 
105
 
 
106
    def test_lnpgettext(self):
 
107
        self.assertEqualTypeToo(b'Voh1',
 
108
                                self.translations.lngettext('foo1', 'foos1', 1))
 
109
        self.assertEqualTypeToo(b'Vohs1',
 
110
                                self.translations.lngettext('foo1', 'foos1', 2))
 
111
        self.assertEqualTypeToo(b'VohCTX1',
 
112
                                self.translations.lnpgettext('foo', 'foo1',
 
113
                                                             'foos1', 1))
 
114
        self.assertEqualTypeToo(b'VohsCTX1',
 
115
                                self.translations.lnpgettext('foo', 'foo1',
 
116
                                                             'foos1', 2))
 
117
 
 
118
    def test_dpgettext(self):
 
119
        self.assertEqualTypeToo(
 
120
            'VohD', self.translations.dgettext('messages1', 'foo'))
 
121
        self.assertEqualTypeToo(
 
122
            'VohCTXD', self.translations.dpgettext('messages1', 'foo', 'foo'))
 
123
 
 
124
    def test_dupgettext(self):
 
125
        self.assertEqualTypeToo(
 
126
            u'VohD', self.translations.dugettext('messages1', 'foo'))
 
127
        self.assertEqualTypeToo(
 
128
            u'VohCTXD', self.translations.dupgettext('messages1', 'foo', 'foo'))
 
129
 
 
130
    def test_ldpgettext(self):
 
131
        self.assertEqualTypeToo(
 
132
            b'VohD', self.translations.ldgettext('messages1', 'foo'))
 
133
        self.assertEqualTypeToo(
 
134
            b'VohCTXD', self.translations.ldpgettext('messages1', 'foo', 'foo'))
 
135
 
 
136
    def test_dnpgettext(self):
 
137
        self.assertEqualTypeToo(
 
138
            'VohD1', self.translations.dngettext('messages1', 'foo1', 'foos1', 1))
 
139
        self.assertEqualTypeToo(
 
140
            'VohsD1', self.translations.dngettext('messages1', 'foo1', 'foos1', 2))
 
141
        self.assertEqualTypeToo(
 
142
            'VohCTXD1', self.translations.dnpgettext('messages1', 'foo', 'foo1',
 
143
                                                     'foos1', 1))
 
144
        self.assertEqualTypeToo(
 
145
            'VohsCTXD1', self.translations.dnpgettext('messages1', 'foo', 'foo1',
 
146
                                                      'foos1', 2))
 
147
 
 
148
    def test_dunpgettext(self):
 
149
        self.assertEqualTypeToo(
 
150
            u'VohD1', self.translations.dungettext('messages1', 'foo1', 'foos1', 1))
 
151
        self.assertEqualTypeToo(
 
152
            u'VohsD1', self.translations.dungettext('messages1', 'foo1', 'foos1', 2))
 
153
        self.assertEqualTypeToo(
 
154
            u'VohCTXD1', self.translations.dunpgettext('messages1', 'foo', 'foo1',
 
155
                                                       'foos1', 1))
 
156
        self.assertEqualTypeToo(
 
157
            u'VohsCTXD1', self.translations.dunpgettext('messages1', 'foo', 'foo1',
 
158
                                                        'foos1', 2))
 
159
 
 
160
    def test_ldnpgettext(self):
 
161
        self.assertEqualTypeToo(
 
162
            b'VohD1', self.translations.ldngettext('messages1', 'foo1', 'foos1', 1))
 
163
        self.assertEqualTypeToo(
 
164
            b'VohsD1', self.translations.ldngettext('messages1', 'foo1', 'foos1', 2))
 
165
        self.assertEqualTypeToo(
 
166
            b'VohCTXD1', self.translations.ldnpgettext('messages1', 'foo', 'foo1',
 
167
                                                       'foos1', 1))
 
168
        self.assertEqualTypeToo(
 
169
            b'VohsCTXD1', self.translations.ldnpgettext('messages1', 'foo', 'foo1',
 
170
                                                        'foos1', 2))
 
171
 
 
172
    def test_load(self):
 
173
        tempdir = tempfile.mkdtemp()
 
174
        try:
 
175
            messages_dir = os.path.join(tempdir, 'fr', 'LC_MESSAGES')
 
176
            os.makedirs(messages_dir)
 
177
            catalog = Catalog(locale='fr', domain='messages')
 
178
            catalog.add('foo', 'bar')
 
179
            with open(os.path.join(messages_dir, 'messages.mo'), 'wb') as f:
 
180
                write_mo(f, catalog)
 
181
 
 
182
            translations = support.Translations.load(tempdir, locales=('fr',), domain='messages')
 
183
            self.assertEqual('bar', translations.gettext('foo'))
 
184
        finally:
 
185
            shutil.rmtree(tempdir)
 
186
 
 
187
 
 
188
class NullTranslationsTestCase(unittest.TestCase):
 
189
    def setUp(self):
 
190
        fp = BytesIO()
 
191
        write_mo(fp, Catalog(locale='de'))
 
192
        fp.seek(0)
 
193
        self.translations = support.Translations(fp=fp)
 
194
        self.null_translations = support.NullTranslations(fp=fp)
 
195
 
 
196
    def method_names(self):
 
197
        return [name for name in dir(self.translations) if 'gettext' in name]
 
198
 
 
199
    def test_same_methods(self):
 
200
        for name in self.method_names():
 
201
            if not hasattr(self.null_translations, name):
 
202
                self.fail('NullTranslations does not provide method %r' % name)
 
203
 
 
204
    def test_method_signature_compatibility(self):
 
205
        for name in self.method_names():
 
206
            translations_method = getattr(self.translations, name)
 
207
            null_method = getattr(self.null_translations, name)
 
208
            signature = inspect.getargspec
 
209
            self.assertEqual(signature(translations_method),
 
210
                             signature(null_method))
 
211
 
 
212
    def test_same_return_values(self):
 
213
        data = {
 
214
            'message': u'foo', 'domain': u'domain', 'context': 'tests',
 
215
            'singular': u'bar', 'plural': u'baz', 'num': 1,
 
216
            'msgid1': u'bar', 'msgid2': u'baz', 'n': 1,
 
217
        }
 
218
        for name in self.method_names():
 
219
            method = getattr(self.translations, name)
 
220
            null_method = getattr(self.null_translations, name)
 
221
            signature = inspect.getargspec(method)
 
222
            parameter_names = [name for name in signature[0] if name != 'self']
 
223
            values = [data[name] for name in parameter_names]
 
224
            self.assertEqual(method(*values), null_method(*values))
 
225
 
 
226
 
 
227
class LazyProxyTestCase(unittest.TestCase):
 
228
    def test_proxy_caches_result_of_function_call(self):
 
229
        self.counter = 0
 
230
        def add_one():
 
231
            self.counter += 1
 
232
            return self.counter
 
233
        proxy = support.LazyProxy(add_one)
 
234
        self.assertEqual(1, proxy.value)
 
235
        self.assertEqual(1, proxy.value)
 
236
 
 
237
    def test_can_disable_proxy_cache(self):
 
238
        self.counter = 0
 
239
        def add_one():
 
240
            self.counter += 1
 
241
            return self.counter
 
242
        proxy = support.LazyProxy(add_one, enable_cache=False)
 
243
        self.assertEqual(1, proxy.value)
 
244
        self.assertEqual(2, proxy.value)
 
245
 
 
246
 
 
247
def test_format_date():
 
248
    fmt = support.Format('en_US')
 
249
    assert fmt.date(date(2007, 4, 1)) == 'Apr 1, 2007'
 
250
 
 
251
 
 
252
def test_format_datetime():
 
253
    from pytz import timezone
 
254
    fmt = support.Format('en_US', tzinfo=timezone('US/Eastern'))
 
255
    when = datetime(2007, 4, 1, 15, 30)
 
256
    assert fmt.datetime(when) == 'Apr 1, 2007, 11:30:00 AM'
 
257
 
 
258
 
 
259
def test_format_time():
 
260
    from pytz import timezone
 
261
    fmt = support.Format('en_US', tzinfo=timezone('US/Eastern'))
 
262
    assert fmt.time(datetime(2007, 4, 1, 15, 30)) == '11:30:00 AM'
 
263
 
 
264
 
 
265
def test_format_timedelta():
 
266
    fmt = support.Format('en_US')
 
267
    assert fmt.timedelta(timedelta(weeks=11)) == '3 months'
 
268
 
 
269
 
 
270
def test_format_number():
 
271
    fmt = support.Format('en_US')
 
272
    assert fmt.number(1099) == '1,099'
 
273
 
 
274
 
 
275
def test_format_decimal():
 
276
    fmt = support.Format('en_US')
 
277
    assert fmt.decimal(1.2345) == '1.234'
 
278
 
 
279
 
 
280
def test_format_percent():
 
281
    fmt = support.Format('en_US')
 
282
    assert fmt.percent(0.34) == '34%'
 
283
 
 
284
 
 
285
def test_lazy_proxy():
 
286
    def greeting(name='world'):
 
287
        return u'Hello, %s!' % name
 
288
    lazy_greeting = support.LazyProxy(greeting, name='Joe')
 
289
    assert str(lazy_greeting) == u"Hello, Joe!"
 
290
    assert u'  ' + lazy_greeting == u'  Hello, Joe!'
 
291
    assert u'(%s)' % lazy_greeting == u'(Hello, Joe!)'
 
292
 
 
293
    greetings = [
 
294
        support.LazyProxy(greeting, 'world'),
 
295
        support.LazyProxy(greeting, 'Joe'),
 
296
        support.LazyProxy(greeting, 'universe'),
 
297
    ]
 
298
    greetings.sort()
 
299
    assert [str(g) for g in greetings] == [
 
300
        u"Hello, Joe!",
 
301
        u"Hello, universe!",
 
302
        u"Hello, world!",
 
303
    ]