def _pre_setup(self):
        # Add the models to the db.
        self._original_installed_apps = list(settings.INSTALLED_APPS)
        for app in self.apps:
            settings.INSTALLED_APPS.append(app)
        loading.cache.loaded = False
        call_command('syncdb', interactive=False, verbosity=0)
        call_command('update_badges', verbosity=0)
        badger.autodiscover()

        if get_url_prefix:
            # If we're in funfactoryland, make sure a locale prefix is 
            # set for urlresolvers
            locale = 'en-US'
            self.old_prefix = get_url_prefix()
            self.old_locale = get_language()
            rf = RequestFactory()
            set_url_prefix(Prefixer(rf.get('/%s/' % (locale,))))
            activate(locale)

        # Create a default user for tests
        self.user_1 = self._get_user(username="user_1",
                                     email="[email protected]",
                                     password="user_1_pass")

        # Call the original method that does the fixtures etc.
        super(test.TestCase, self)._pre_setup()

 def _switch_locale(self):
     if self.source_locale:
         lang = self.source_locale
     else:
         lang = self.addon.default_locale
     tower.activate(lang)
     return Locale(translation.to_locale(lang))

    def process_request(self, request):
        prefixer = Prefixer(request)
        set_url_prefixer(prefixer)
        full_path = prefixer.fix(prefixer.shortened_path)

        if "lang" in request.GET:
            # Blank out the locale so that we can set a new one. Remove lang
            # from the query params so we don't have an infinite loop.
            prefixer.locale = ""
            new_path = prefixer.fix(prefixer.shortened_path)
            query = dict((smart_str(k), v) for k, v in request.GET.iteritems() if k != "lang")
            return HttpResponseRedirect(urlparams(new_path, **query))

        if full_path != request.path:
            query_string = request.META.get("QUERY_STRING", "")
            full_path = urllib.quote(full_path.encode("utf-8"))

            if query_string:
                full_path = "%s?%s" % (full_path, query_string)

            response = HttpResponseRedirect(full_path)

            # Vary on Accept-Language if we changed the locale
            old_locale = prefixer.locale
            new_locale, _ = split_path(full_path)
            if old_locale != new_locale:
                response["Vary"] = "Accept-Language"

            return response

        request.path_info = "/" + prefixer.shortened_path
        request.LANGUAGE_CODE = prefixer.locale
        tower.activate(prefixer.locale)

    def process_request(self, request):
        # Find locale, app
        prefixer = urlresolvers.Prefixer(request)
        urlresolvers.set_url_prefix(prefixer)
        full_path = prefixer.fix(prefixer.shortened_path)

        if "lang" in request.GET:
            # Blank out the locale so that we can set a new one.  Remove lang
            # from query params so we don't have an infinite loop.
            prefixer.locale = ""
            new_path = prefixer.fix(prefixer.shortened_path)
            query = dict((smart_str(k), request.GET[k]) for k in request.GET)
            query.pop("lang")
            return HttpResponsePermanentRedirect(urlparams(new_path, **query))

        if full_path != request.path:
            query_string = request.META.get("QUERY_STRING", "")
            full_path = urllib.quote(full_path.encode("utf-8"))

            if query_string:
                full_path = "%s?%s" % (full_path, query_string)

            response = HttpResponsePermanentRedirect(full_path)

            # Vary on Accept-Language if we changed the locale.
            old_locale = prefixer.locale
            new_locale, _, _ = prefixer.split_path(full_path)
            if old_locale != new_locale:
                response["Vary"] = "Accept-Language"
            return response

        request.path_info = "/" + prefixer.shortened_path
        tower.activate(prefixer.locale)
        request.APP = amo.APPS.get(prefixer.app)
        request.LANG = prefixer.locale

    def process_request(self, request):
        a_l = get_accept_language(request)
        lang, ov_lang = a_l, ''
        stored_lang, stored_ov_lang = '', ''

        remembered = request.COOKIES.get('lang')
        if remembered:
            chunks = remembered.split(',')[:2]

            stored_lang = chunks[0]
            try:
                stored_ov_lang = chunks[1]
            except IndexError:
                pass

            if stored_lang.lower() in settings.LANGUAGE_URL_MAP:
                lang = stored_lang
            if stored_ov_lang.lower() in settings.LANGUAGE_URL_MAP:
                ov_lang = stored_ov_lang

        if 'lang' in request.REQUEST:
            # `get_language` uses request.GET['lang'] and does safety checks.
            ov_lang = a_l
            lang = Prefixer(request).get_language()
        elif a_l != ov_lang:
            # Change if Accept-Language differs from Overridden Language.
            lang = a_l
            ov_lang = ''

        # Update cookie if values have changed.
        if lang != stored_lang or ov_lang != stored_ov_lang:
            request.LANG_COOKIE = ','.join([lang, ov_lang])

        request.LANG = lang
        tower.activate(lang)

    def test_activation_locale_detect(self):
        p = self._profile()

        # Activate french and check if the locale was set correctly
        tower.activate('fr')
        u = RegisterProfile.objects.activate_profile(p.activation_key)
        eq_(u.get_profile().locale, 'fr')

    def process_request(self, request):
        prefixer = Prefixer(request)
        set_url_prefixer(prefixer)
        full_path = prefixer.fix(prefixer.shortened_path)

        if 'lang' in request.GET:
            # Blank out the locale so that we can set a new one. Remove lang
            # from the query params so we don't have an infinite loop.
            prefixer.locale = ''
            new_path = prefixer.fix(prefixer.shortened_path)
            query = dict((smart_str(k), v) for
                         k, v in request.GET.iteritems() if k != 'lang')
            return HttpResponsePermanentRedirect(urlparams(new_path, **query))

        if full_path != request.path:
            query_string = request.META.get('QUERY_STRING', '')
            full_path = urllib.quote(full_path.encode('utf-8'))

            if query_string:
                full_path = '%s?%s' % (full_path, query_string)

            response = HttpResponsePermanentRedirect(full_path)

            # Vary on Accept-Language if we changed the locale
            old_locale = prefixer.locale
            new_locale, _ = split_path(full_path)
            if old_locale != new_locale:
                response['Vary'] = 'Accept-Language'

            return response

        request.path_info = '/' + prefixer.shortened_path
        request.locale = prefixer.locale
        tower.activate(prefixer.locale)

def send_group_email(announcement_id):
    """Build and send the announcement emails to a group."""
    try:
        announcement = Announcement.objects.get(pk=announcement_id)
    except Announcement.DoesNotExist:
        return
    connection = get_connection(fail_silently=True)
    connection.open()
    group = announcement.group
    users = User.objects.filter(groups__in=[group])
    plain_content = bleach.clean(announcement.content_parsed,
                                 tags=[], strip=True).strip()
    email_kwargs = {'content': plain_content,
                    'domain': Site.objects.get_current().domain}
    template = 'announcements/email/announcement.ltxt'
    try:
        for u in users:
            # Localize email each time.
            activate(u.profile.locale or settings.LANGUAGE_CODE)
            subject = _('New announcement for {group}').format(
                group=group.name)
            message = loader.render_to_string(template, email_kwargs)
            m = EmailMessage(subject, message,
                             settings.NOTIFICATIONS_FROM_ADDRESS,
                             [u.email])
            connection.send_messages([m])
    finally:
        activate(settings.LANGUAGE_CODE)
        connection.close()

    def process_request(self, request):
        prefixer = urlresolvers.Prefixer(request)
        urlresolvers.set_url_prefix(prefixer)
        full_path = prefixer.fix(prefixer.shortened_path)

        if self._is_lang_change(request):
            # Blank out the locale so that we can set a new one. Remove lang
            # from the query params so we don't have an infinite loop.
            prefixer.locale = ''
            new_path = prefixer.fix(prefixer.shortened_path)
            query = dict((smart_str(k), request.GET[k]) for k in request.GET)
            query.pop('lang')
            return HttpResponsePermanentRedirect(urlparams(new_path, **query))

        if full_path != request.path:
            query_string = request.META.get('QUERY_STRING', '')
            full_path = urllib.quote(full_path.encode('utf-8'))

            if query_string:
                full_path = '?'.join(
                    [full_path, force_text(query_string, errors='ignore')])

            response = HttpResponsePermanentRedirect(full_path)

            # Vary on Accept-Language if we changed the locale
            old_locale = prefixer.locale
            new_locale, _ = urlresolvers.split_path(full_path)
            if old_locale != new_locale:
                response['Vary'] = 'Accept-Language'

            return response

        request.path_info = '/' + prefixer.shortened_path
        request.locale = prefixer.locale
        tower.activate(prefixer.locale)

 def test_unknown(self):
     """
     Test that when the current locale is not supported by Babel, it
     defaults to en-US.
     """
     activate('fy')
     eq_(Locale('en', 'US'), current_locale())

def ugettext_locale(message, locale):
    """Translate a message in a specific locale."""
    old_locale = get_language()
    tower.activate(locale)
    text = tower.ugettext(message)
    tower.activate(old_locale)

    return text

    def test_babel_number(self):
        number = 1000000
        activate('en-US')
        eq_(babel_number(number), u'1,000,000')

        activate('fr')
        # \xa0 is a non-breaking space
        eq_(babel_number(number), u'1\xa0000\xa0000')

 def test_no_activate(self, mock_activate):
     """If lang is Falsy, do not call activate."""
     activate('fr')
     eq_(get_language(), 'fr')
     with use_lang(None):
         eq_(get_language(), 'fr')
     eq_(get_language(), 'fr')
     ok_(not mock_activate.called)

def test_no_install_jinja_translations():
    """
    Setting `TOWER_INSTALL_JINJA_TRANSLATIONS` to False should skip setting
    the gettext and ngettext functions in the Jinja2 environment.
    """
    jingo.env.install_null_translations()
    tower.activate('xx')
    ok_(jingo.env.globals['gettext'] != _)

 def test_basic(self):
     """
     Test that translating a string works and doesn't change the current
     locale.
     """
     activate('fr')
     eq_(_locale('message', 'xxx'), 'translated')
     eq_(get_language(), 'fr')

    def test_babel_date(self):
        date = datetime(2011, 9, 23)
        activate('en-US')
        eq_(babel_date(date, 'short'), '9/23/11')
        eq_(babel_date(date, 'medium'), 'Sep 23, 2011')

        activate('fr')
        eq_(babel_date(date, 'short'), '23/09/11')
        eq_(babel_date(date, 'medium'), '23 sept. 2011')

 def _activate_lang(self):
     tower.activate(self.lang)
     lang = translation.get_language()
     if lang in charsets:
         self.encoding = charsets[lang]
     elif lang[:2] in charsets:
         self.encoding = charsets[lang[:2]]
     else:
         self.encoding = settings.DEFAULT_CHARSET

def use_lang(lang):
    """Temporarily use another language for translation."""
    if not lang:
        yield
    else:
        current_lang = get_language()
        activate(lang)
        yield
        activate(current_lang)

    def process_request(self, request):
        # Find locale, app
        prefixer = urlresolvers.Prefixer(request)
        urlresolvers.set_url_prefix(prefixer)
        full_path = prefixer.fix(prefixer.shortened_path)

        if 'lang' in request.GET:
            # Blank out the locale so that we can set a new one.  Remove lang
            # from query params so we don't have an infinite loop.
            prefixer.locale = ''
            new_path = prefixer.fix(prefixer.shortened_path)
            query = dict((smart_str(k), v) for k, v in request.GET.items()
                         if k not in ('lang', 'locale-only'))

            response = HttpResponsePermanentRedirect(
                    urlparams(new_path, **query))

            xenophobia = 0

            # User checked a box is the only reason this would happen.
            if 'locale-only' in request.GET:
                xenophobia = 1

            response.set_cookie('locale-only', xenophobia, expires=NEXT_YEAR)
            return response

        if full_path != request.path:
            query_string = request.META.get('QUERY_STRING', '')
            full_path = urllib.quote(full_path.encode('utf-8'))

            if query_string:
                full_path = "%s?%s" % (full_path, query_string)

            response = HttpResponsePermanentRedirect(full_path)

            # Vary on Accept-Language if we changed the locale.
            old_locale = prefixer.locale
            new_locale, _, _ = prefixer.split_path(full_path)
            if old_locale != new_locale:
                response['Vary'] = 'Accept-Language'
            return response

        request.path_info = '/' + prefixer.shortened_path
        tower.activate(prefixer.locale)
        request.APP = amo.APPS.get(prefixer.app)
        request.LANG = prefixer.locale

        if 'locale-only' in request.COOKIES:
            request.XENOPHOBIA = (request.COOKIES['locale-only'] == '1')
        else:
            try:
                conf = Config.objects.get(pk='xenophobia')
                request.XENOPHOBIA = conf.json.get(
                        translation.get_language(), False)
            except Config.DoesNotExist:
                request.XENOPHOBIA = False

 def activate_lang(self):
     """
     Activate the language for the user. If none is set will go to the site
     default which is en-US.
     """
     lang = self.lang if self.lang else settings.LANGUAGE_CODE
     old = translation.get_language()
     tower.activate(lang)
     yield
     tower.activate(old)