From f5c6c574ada26ec0b2766f5ca20bb2b5b7393ec5 Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Mon, 19 Apr 2010 07:34:46 +0000 Subject: Dip a toe in the i18n waters. --- repoze/bfg/tests/test_configuration.py | 17 ++++ repoze/bfg/tests/test_i18n.py | 175 +++++++++++++++++++++++++++++++++ 2 files changed, 192 insertions(+) create mode 100644 repoze/bfg/tests/test_i18n.py (limited to 'repoze/bfg/tests') diff --git a/repoze/bfg/tests/test_configuration.py b/repoze/bfg/tests/test_configuration.py index 99d564b91..b4f7600f5 100644 --- a/repoze/bfg/tests/test_configuration.py +++ b/repoze/bfg/tests/test_configuration.py @@ -265,6 +265,15 @@ class ConfiguratorTests(unittest.TestCase): self.assertEqual(reg.getUtility(IRendererFactory, 'yeah'), renderer) + def test_setup_registry_translator_factory(self): + from repoze.bfg.registry import Registry + from repoze.bfg.interfaces import ITranslatorFactory + factory = object() + reg = Registry() + config = self._makeOne(reg) + config.setup_registry(translator_factory=factory) + self.assertEqual(reg.getUtility(ITranslatorFactory), factory) + def test_add_settings_settings_already_registered(self): from repoze.bfg.registry import Registry from repoze.bfg.interfaces import ISettings @@ -1727,6 +1736,14 @@ class ConfiguratorTests(unittest.TestCase): request = self._makeRequest(config) self.assertEqual(wrapped(None, request).__class__, StaticURLParser) + def test_set_translator_factory(self): + from repoze.bfg.interfaces import ITranslatorFactory + def factory(): pass + config = self._makeOne() + config.set_translator_factory(factory) + self.assertEqual(config.registry.getUtility(ITranslatorFactory), + factory) + def test_set_notfound_view(self): from zope.interface import implementedBy from repoze.bfg.interfaces import IRequest diff --git a/repoze/bfg/tests/test_i18n.py b/repoze/bfg/tests/test_i18n.py new file mode 100644 index 000000000..603f26a55 --- /dev/null +++ b/repoze/bfg/tests/test_i18n.py @@ -0,0 +1,175 @@ +import unittest + +class Test_get_translator(unittest.TestCase): + def _callFUT(self, request): + from repoze.bfg.i18n import get_translator + return get_translator(request) + + def test_no_ITranslatorFactory(self): + request = DummyRequest() + request.registry = DummyRegistry() + translator = self._callFUT(request) + self.assertEqual(translator, None) + + def test_no_registry_on_request(self): + request = DummyRequest() + translator = self._callFUT(request) + self.assertEqual(translator, None) + + def test_with_ITranslatorFactory_from_registry(self): + request = DummyRequest() + tfactory = DummyTranslatorFactory() + request.registry = DummyRegistry(tfactory) + translator = self._callFUT(request) + self.assertEqual(translator.request, request) + + def test_with_ITranslatorFactory_from_request_cache(self): + request = DummyRequest() + request.registry = DummyRegistry() + request._bfg_translator = 'abc' + translator = self._callFUT(request) + self.assertEqual(translator, 'abc') + + def test_with_ITranslatorFactory_from_request_neg_cache(self): + request = DummyRequest() + request.registry = DummyRegistry() + request._bfg_translator = False + translator = self._callFUT(request) + self.assertEqual(translator, None) + +class TestInterpolationOnlyTranslator(unittest.TestCase): + def _makeOne(self, request): + from repoze.bfg.i18n import InterpolationOnlyTranslator + return InterpolationOnlyTranslator(request) + + def test_it(self): + message = DummyMessage('text %(a)s', mapping={'a':'1'}) + translator = self._makeOne(None) + result = translator(message) + self.assertEqual(result, u'text 1') + +class TestTranslationString(unittest.TestCase): + def _getTargetClass(self): + from repoze.bfg.i18n import TranslationString + return TranslationString + + def _makeOne(self, text, **kw): + return self._getTargetClass()(text, **kw) + + def test_ctor_defaults(self): + ts = self._makeOne('text') + self.assertEqual(ts, u'text') + self.assertEqual(ts.msgid, u'text') + self.assertEqual(ts.domain, None) + self.assertEqual(ts.mapping, {}) + + def test_ctor_nondefaults(self): + ts = self._makeOne( + 'text', msgid='msgid', domain='domain', mapping='mapping') + self.assertEqual(ts, u'text') + self.assertEqual(ts.msgid, 'msgid') + self.assertEqual(ts.domain, 'domain') + self.assertEqual(ts.mapping, 'mapping') + + def test___reduce__(self): + klass = self._getTargetClass() + ts = self._makeOne('text') + result = ts.__reduce__() + self.assertEqual(result, (klass, (u'text', u'text', None, {}))) + + def test___getstate__(self): + ts = self._makeOne( + 'text', msgid='msgid', domain='domain', mapping='mapping') + result = ts.__getstate__() + self.assertEqual(result, (u'text', 'msgid', 'domain', 'mapping')) + +class Test_chameleon_translate(unittest.TestCase): + def setUp(self): + request = DummyRequest() + from repoze.bfg.configuration import Configurator + self.config = Configurator() + self.config.begin(request=request) + self.request = request + + def tearDown(self): + self.config.end() + + def _callFUT(self, text, **kw): + from repoze.bfg.i18n import chameleon_translate + return chameleon_translate(text, **kw) + + def test_text_None(self): + result = self._callFUT(None) + self.assertEqual(result, None) + + def test_no_current_request(self): + self.config.manager.pop() + result = self._callFUT('text') + self.assertEqual(result, 'text') + + def test_with_current_request_no_translator(self): + result = self._callFUT('text') + self.assertEqual(result, 'text') + self.assertEqual(self.request.chameleon_target_language, None) + + def test_with_current_request_and_translator(self): + from repoze.bfg.interfaces import ITranslatorFactory + translator = DummyTranslator() + factory = DummyTranslatorFactory(translator) + self.config.registry.registerUtility(factory, ITranslatorFactory) + result = self._callFUT('text') + self.assertEqual(result, 'text') + self.assertEqual(self.request.chameleon_target_language, None) + self.assertEqual(result.msgid, 'text') + self.assertEqual(result.domain, None) + self.assertEqual(result.mapping, {}) + + def test_with_allargs(self): + from repoze.bfg.interfaces import ITranslatorFactory + translator = DummyTranslator() + factory = DummyTranslatorFactory(translator) + self.config.registry.registerUtility(factory, ITranslatorFactory) + result = self._callFUT('text', domain='domain', mapping={'a':'1'}, + context=None, target_language='lang', + default='default') + self.assertEqual(self.request.chameleon_target_language, 'lang') + self.assertEqual(result, 'default') + self.assertEqual(result.msgid, 'text') + self.assertEqual(result.domain, 'domain') + self.assertEqual(result.mapping, {'a':'1'}) + +class DummyMessage(unicode): + def __new__(cls, text, msgid=None, domain=None, mapping=None): + self = unicode.__new__(cls, text) + if msgid is None: + msgid = unicode(text) + self.msgid = msgid + self.domain = domain + self.mapping = mapping or {} + return self + +class DummyRequest(object): + pass + +class DummyRegistry(object): + def __init__(self, tfactory=None): + self.tfactory = tfactory + + def queryUtility(self, iface): + return self.tfactory + +class DummyTranslator(object): + def __call__(self, message): + return message + +class DummyTranslatorFactory(object): + def __init__(self, translator=None): + self.translator = translator + + def __call__(self, request): + self.request = request + if self.translator is None: + return self + return self.translator + + -- cgit v1.2.3