def test_unicode_subject(self):
        msg = Message(subject=make_lazy_string(lambda a: a, u"sübject"),
                      sender='[email protected]',
                      recipients=["[email protected]"])
        self.assertIn(b'=?utf-8?q?s=C3=BCbject?=', msg.as_bytes())

        msg = Message(subject=make_lazy_string(lambda a: a, u"[Foo Bar] Voici vos paramètres d'accès à"),
                      sender='[email protected]',
                      recipients=["[email protected]"])
        self.assertIn(b'=?utf-8?b?W0ZvbyBCYXJdIFZvaWNpIHZvcyBwYXJhbcOodHJlcyBkJ2FjY8OocyDDoA==?=', msg.as_bytes())

 def lazy_gettext(string, **variables):
     if is_lazy_string(string):
         return string
     translations = TrytonTranslations(module, 'nereid')
     return make_lazy_string(
         translations.lazy_ugettext, string, **variables
     )

def lazy_gettext(string, **variables):
    """ Similar to 'gettext' but the string returned is lazy which means
        it will be translated when it is used as an actual string."""
    try:
        from speaklater import make_lazy_string
        return make_lazy_string(gettext, string, **variables)
    except ImportError:
       return string % variables

def tw2_translation_string(sval):
    def lookup_provided_translator(_sval):
        mw = core.request_local().get('middleware')
        if not mw:
            return _sval
        return core.request_local()['middleware'].config.translator(_sval)

    return make_lazy_string(lambda: lookup_provided_translator(sval))

def lazy_pgettext(context, string, **variables):
    """Like :func:`pgettext` but the string returned is lazy which means
    it will be translated when it is used as an actual string.

    .. versionadded:: 0.7
    """
    from speaklater import make_lazy_string
    return make_lazy_string(pgettext, context, string, **variables)

def test_lazy_bundle():
    """Test lazy bundle."""
    bundle = LazyNpmBundle(
        make_lazy_string(lambda: 'test{0}.js'.format(1)),
        'test2.js'
    )

    expected = ['test1.js', 'test2.js']
    assert expected == bundle.contents

 def test_unicode_subject(self):
     try:
         from speaklater import make_lazy_string
     except ImportError:
         return
     msg = Message(subject=make_lazy_string(lambda a: a, u"sübject"),
                   sender='[email protected]',
                   recipients=["[email protected]"])
     self.assertIn('=?utf-8?q?s=C3=BCbject?=', msg.as_string())

 def dotslash(self, pth):
     """Mimic the unix './' behaviour."""
     if hasattr(self, "APP_DIR"):
         return self._get_app_dir(pth=pth)
     else:
         try:
             import speaklater
         except ImportError:
             raise RuntimeError("Configure django, or install speaklater.")
         else:
             return speaklater.make_lazy_string(self._get_app_dir, pth)

def tw2_translation_string(sval):
    def lookup_provided_translator(_sval):
        mw = core.request_local().get('middleware')
        if not mw:
            return _sval

        try:
            return core.request_local()['middleware'].config.translator(_sval)
        except TypeError as e:
            log.warn(traceback.format_exc())
            return _sval

    return make_lazy_string(lambda: lookup_provided_translator(sval))

 def dotslash(self, pth):
     if hasattr(self, "APP_DIR"):
         return os.path.join(self.APP_DIR, pth)
     else:
         try:
             import speaklater
         except ImportError:
             raise RuntimeError(
                 "configure django first, or install speaklater"
             )
         else:
             return speaklater.make_lazy_string(
                 self._get_app_dir, pth
             )

def lazy_gettext(string, **variables):
    """Like :func:`gettext` but the string returned is lazy which means
    it will be translated when it is used as an actual string.

    Example::

        hello = lazy_gettext(u'Hello World')

        @app.route('/')
        def index():
            return unicode(hello)
    """
    from speaklater import make_lazy_string
    return make_lazy_string(gettext, string, **variables)

    def test_jsonencoder(self):
        """Test JSON encoder."""
        from pybossa.extensions import JSONEncoder
        from speaklater import make_lazy_string
        encoder = JSONEncoder()
        sval = "Hello world"
        string = make_lazy_string(lambda: sval)

        encoder = JSONEncoder()

        data = encoder.encode(dict(foo=string))
        data = json.loads(data)
        err_msg = "The encoder should manage lazystrings"
        assert data.get('foo') == sval, err_msg

    def test_lazystring(self):
        # Skip this test if speaklater is not installed.
        try:
            from speaklater import make_lazy_string, _LazyString
        except ImportError:
            return

        # test_nospeaklater() overrides this import so we have to revert it
        # otherwise the test may fail because flask_json._LazyString
        # will be None
        flask_json._LazyString = _LazyString

        r = json_response(text=make_lazy_string(lambda: u'Привет'))
        assert_equals(r.status_code, 200)
        assert_equals(r.json['text'], u'Привет')

    def lazy_gettext(string):
        '''
        Like flask_babel's lazy_gettext, but doesn't interpolate strings. This
        is required for integration with flask_security, which does its
        own string interpolation but doesn't support i18n.

        For more information, see: https://github.com/GovLab/noi2/issues/41
        '''

        def gettext_no_interpolate(string):
            t = flask_babel.get_translations()
            if t is None:
                return string
            return t.ugettext(string)

        return make_lazy_string(gettext_no_interpolate, string)

def test_column_label_translation():
    app, db, admin = setup()

    Model1, _ = create_models(db)

    translated = Translator()
    label = make_lazy_string(translated, 'Column1')

    view = CustomModelView(Model1, db.session,
                           column_list=['test1', 'test3'],
                           column_labels=dict(test1=label),
                           column_filters=('test1',))

    translated.translate = True
    non_lazy_groups = view._get_filter_groups()
    json.dumps(non_lazy_groups)  # Filter dict is JSON serializable.
    ok_(translated('Column1') in non_lazy_groups)  # Label was translated.

def tw2_translation_string(sval):

    def lookup_provided_translator(_sval):
        mw = core.request_local().get('middleware')
        if not mw:
            return _sval

        try:
            translator = get_translator(mw.config.get_lang())
        except AttributeError:
            try:
                translator = mw.config.translator
            except AttributeError:
                return _sval

        return translator(_sval)

    return make_lazy_string(lambda: lookup_provided_translator(sval))

def test_column_label_translation():
    app, db, admin = setup()

    Model1, _ = create_models(db)

    translated = Translator()
    label = make_lazy_string(translated, 'Column1')

    view = CustomModelView(Model1, db.session,
                           column_list=['test1', 'test3'],
                           column_labels=dict(test1=label),
                           column_filters=('test1',))
    admin.add_view(view)

    translated.translate = True
    non_lazy_groups = view._get_filter_groups()
    json.dumps(non_lazy_groups)  # Filter dict is JSON serializable.
    ok_(translated('Column1') in non_lazy_groups)  # Label was translated.

    client = app.test_client()
    # Render index with active filter.
    rv = client.get('/admin/model1/?flt1_0=test')
    eq_(rv.status_code, 200)

 def ngettext(self, singular, plural, n):
     return make_lazy_string(_ngettext, singular, plural, n)

def lazy_gettext(*args, **kwargs):
    """Lazy gettext.

    https://github.com/mrjoes/flask-babelex/pull/8
    """
    return make_lazy_string(gettext, *args, **kwargs)

 def lazy_gettext(string, *args, **kwargs):
     if is_lazy_string(string):
         return string
     return make_lazy_string(lookup_func(), string, *args, **kwargs)