def test_exact_match_gets_priority(self, accept_header, expected):
# Release 'es-419, es, es-es'
DarkLangConfig(released_languages=('es-419, es, es-es'),
changed_by=self.user,
enabled=True).save()
self.assertAcceptEquals(
expected, self.process_middleware_request(accept=accept_header))
def test_disabled(self):
DarkLangConfig(enabled=False, changed_by=self.user).save()
self.assertAcceptEquals(
'notrel;q=0.3, rel;q=1.0, unrel;q=0.5',
self.process_middleware_request(accept='notrel;q=0.3, rel;q=1.0, unrel;q=0.5')
)
# With DarkLang disabled the clear should not change the session language
self._set_client_session_language('rel')
self._post_clear_preview_lang()
self.client.get('/home')
self.assert_session_lang_equals(
'rel',
self.client.session
)
# Test that setting the preview language with DarkLang disabled does nothing
self._set_client_session_language('unrel')
self._post_set_preview_lang('rel')
self.client.get('/home')
self.assert_session_lang_equals(
'unrel',
self.client.session
)
def test_partial_match_es419(self, accept_header, expected):
# Release es-419
DarkLangConfig(released_languages=('es-419, en'),
changed_by=self.user,
enabled=True).save()
self.assertAcceptEquals(
expected, self.process_middleware_request(accept=accept_header))
def test_partial_match_esar_es(self):
# If I release 'es', 'es-AR' should get 'es', not English
DarkLangConfig(released_languages=('es, en'),
changed_by=self.user,
enabled=True).save()
self.assertAcceptEquals(
'es;q=1.0',
self.process_middleware_request(accept='es-AR;q=1.0, pt;q=0.5'))
def test_accept_chinese_language_codes(self):
DarkLangConfig(released_languages=('zh-cn, zh-hk, zh-tw'),
changed_by=self.user,
enabled=True).save()
self.assertAcceptEquals(
'zh-cn;q=1.0, zh-tw;q=0.5, zh-hk;q=0.3',
self.process_middleware_request(
accept='zh-Hans;q=1.0, zh-Hant-TW;q=0.5, zh-HK;q=0.3'))
def release_languages(self, languages):
"""
Release a set of languages using the dark lang interface.
languages is a list of comma-separated lang codes, eg, 'ar, es-419'
"""
user = User()
user.save()
DarkLangConfig(released_languages=languages,
changed_by=user,
enabled=True).save()
def setUp(self):
super(DarkLangMiddlewareTests, self).setUp()
self.user = UserFactory.build(username='******', email='*****@*****.**', password='******')
self.user.save()
self.client = Client()
self.client.login(username=self.user.username, password='******')
DarkLangConfig(
released_languages='rel',
changed_by=self.user,
enabled=True
).save()
def test_context(self, mock_enterprise_customer_for_request):
self.request.site = SiteFactory.create()
UserPreferenceFactory(user=self.user, key='pref-lang', value='lt-lt')
DarkLangConfig(released_languages='en',
changed_by=self.user,
enabled=True,
beta_languages='lt-lt',
enable_beta_languages=True).save()
mock_enterprise_customer_for_request.return_value = {}
with override_settings(LANGUAGES=[EN, LT_LT], LANGUAGE_CODE='en'):
context = account_settings_context(self.request)
user_accounts_api_url = reverse(
"accounts_api", kwargs={'username': self.user.username})
self.assertEqual(context['user_accounts_api_url'],
user_accounts_api_url)
user_preferences_api_url = reverse(
'preferences_api', kwargs={'username': self.user.username})
self.assertEqual(context['user_preferences_api_url'],
user_preferences_api_url)
for attribute in self.FIELDS:
self.assertIn(attribute, context['fields'])
self.assertEqual(
context['user_accounts_api_url'],
reverse("accounts_api",
kwargs={'username': self.user.username}))
self.assertEqual(
context['user_preferences_api_url'],
reverse('preferences_api',
kwargs={'username': self.user.username}))
self.assertEqual(context['duplicate_provider'], 'facebook')
self.assertEqual(context['auth']['providers'][0]['name'],
'Facebook')
self.assertEqual(context['auth']['providers'][1]['name'], 'Google')
self.assertEqual(context['sync_learner_profile_data'], False)
self.assertEqual(context['edx_support_url'],
settings.SUPPORT_SITE_LINK)
self.assertEqual(context['enterprise_name'], None)
self.assertEqual(context['enterprise_readonly_account_fields'], {
'fields':
list(get_enterprise_readonly_account_fields(self.user))
})
expected_beta_language = {
'code': 'lt-lt',
'name': settings.LANGUAGE_DICT.get('lt-lt')
}
self.assertEqual(context['beta_language'], expected_beta_language)
def test_released_languages(self, default_lang, languages,
dark_lang_released, expected_languages):
"""
Tests for the released languages.
"""
with override_settings(LANGUAGES=languages,
LANGUAGE_CODE=default_lang):
user = User()
user.save()
DarkLangConfig(released_languages=', '.join(dark_lang_released),
changed_by=user,
enabled=True).save()
released_languages = language_api.released_languages()
self.assertEqual(released_languages, expected_languages)
def test_partial_match_es_la(self, latin_america_code):
# We need to figure out the best way to implement this. There are a ton of LA country
# codes that ought to fall back to 'es-419' rather than 'es-es'.
# http://unstats.un.org/unsd/methods/m49/m49regin.htm#americas
# If I release 'es, es-419'
# Latin American codes should get es-419
DarkLangConfig(released_languages=('es, es-419'),
changed_by=self.user,
enabled=True).save()
self.assertAcceptEquals(
'es-419;q=1.0',
self.process_middleware_request(
accept='{};q=1.0, pt;q=0.5'.format(latin_america_code)))
def test_accept_mixed_case(self):
self.assertAcceptEquals(
'rel;q=1.0, rel;q=0.5',
self.process_middleware_request(accept='rel-TER;q=1.0, REL;q=0.5'))
DarkLangConfig(released_languages='REL-TER',
changed_by=self.user,
enabled=True).save()
# Since we have only released "rel-ter", the requested code "rel" will
# fuzzy match to "rel-ter", in addition to "rel-ter" exact matching "rel-ter"
self.assertAcceptEquals(
'rel-ter;q=1.0, rel-ter;q=0.5',
self.process_middleware_request(accept='rel-ter;q=1.0, rel;q=0.5'))
def setUp(self):
"""
Set up the environment for the test case and ensures correct DarkLang configurations.
"""
super(DefaultLocaleMiddlewareTest, self).setUp()
self.middleware = DefaultLocaleMiddleware()
self.request_factory = RequestFactory()
self.user = UserFactory()
DarkLangConfig(
released_languages='en,ar,eo',
changed_by=self.user,
enabled=True
).save()
def test_beta_languages(self):
"""
Tests for the beta languages.
"""
with override_settings(LANGUAGES=[EN, ES_419, LT_LT],
LANGUAGE_CODE='en'):
user = User()
user.save()
DarkLangConfig(released_languages='es-419',
changed_by=user,
enabled=True,
beta_languages='lt-lt',
enable_beta_languages=True).save()
released_languages = language_api.released_languages()
expected_languages = [EN, ES_419, LT_LT]
self.assertEqual(released_languages, expected_languages)
def test_accept_multiple_released_langs(self):
DarkLangConfig(released_languages=('rel, unrel'),
changed_by=self.user,
enabled=True).save()
self.assertAcceptEquals(
'rel;q=1.0, unrel;q=0.5',
self.process_middleware_request(accept='rel;q=1.0, unrel;q=0.5'))
self.assertAcceptEquals(
'rel;q=1.0, unrel;q=0.5',
self.process_middleware_request(
accept='rel;q=1.0, notrel;q=0.3, unrel;q=0.5'))
self.assertAcceptEquals(
'rel;q=1.0, unrel;q=0.5',
self.process_middleware_request(
accept='notrel;q=0.3, rel;q=1.0, unrel;q=0.5'))
def test_i18n(self):
"""
Test that a block's rendered content respects the Accept-Language header and returns translated content.
"""
block_id = library_api.create_library_block(self.library.key,
"problem",
"i18n_problem").usage_key
new_olx = """
<problem display_name="New Multi Choice Question" max_attempts="5">
<multiplechoiceresponse>
<p>This is a normal capa problem. It has "maximum attempts" set to **5**.</p>
<label>Blockstore is designed to store.</label>
<choicegroup type="MultipleChoice">
<choice correct="false">XBlock metadata only</choice>
<choice correct="true">XBlock data/metadata and associated static asset files</choice>
<choice correct="false">Static asset files for XBlocks and courseware</choice>
<choice correct="false">XModule metadata only</choice>
</choicegroup>
</multiplechoiceresponse>
</problem>
""".strip()
library_api.set_library_block_olx(block_id, new_olx)
library_api.publish_changes(self.library.key)
# Enable the dummy language in darklang
DarkLangConfig(released_languages='eo',
changed_by=self.student_a,
enabled=True).save()
client = APIClient()
# View the problem without specifying a language
default_public_view = client.get(
URL_BLOCK_RENDER_VIEW.format(block_key=block_id,
view_name='public_view'))
assert 'Submit' in default_public_view.data['content']
assert 'Süßmït' not in default_public_view.data['content']
# View the problem and request the dummy language
dummy_public_view = client.get(URL_BLOCK_RENDER_VIEW.format(
block_key=block_id, view_name='public_view'),
HTTP_ACCEPT_LANGUAGE='eo')
assert 'Süßmït' in dummy_public_view.data['content']
assert 'Submit' not in dummy_public_view.data['content']
def test_include_language_selector(self, theme, language, include_language_selector):
self._set_feature_flag(True)
DarkLangConfig(released_languages='en,eo,es-419,fr', enabled=True, changed_by=User().save()).save()
with with_comprehensive_theme_context(theme):
params = {
key: val for key, val in [
('language', language), ('include-language-selector', include_language_selector)
] if val
}
resp = self._get_footer(accepts="text/html", params=params)
self.assertEqual(resp.status_code, 200)
if include_language_selector:
selected_language = language if language else 'en'
self._verify_language_selector(resp.content, selected_language)
else:
self.assertNotIn('footer-language-selector', resp.content)
def test_course_expiration_banner_with_unicode(self,
mock_strftime_localized,
mock_get_date_string):
"""
Ensure that switching to other languages that have unicode in their
date representations will not cause the course home page to 404.
"""
fake_unicode_start_time = u"üñîçø∂é_ßtå®t_tîµé"
mock_strftime_localized.return_value = fake_unicode_start_time
date_string = u'<span class="localized-datetime" data-format="shortDate" \
data-datetime="{formatted_date}" data-language="{language}">{formatted_date_localized}</span>'
mock_get_date_string.return_value = date_string
config = CourseDurationLimitConfig(course=CourseOverview.get_from_id(
self.course.id),
enabled=True,
enabled_as_of=datetime(2018,
1,
1,
tzinfo=UTC))
config.save()
url = course_home_url(self.course)
user = self.create_user_for_course(self.course,
CourseUserType.UNENROLLED)
CourseEnrollment.enroll(user, self.course.id)
language = 'eo'
DarkLangConfig(released_languages=language,
changed_by=user,
enabled=True).save()
response = self.client.get(url, HTTP_ACCEPT_LANGUAGE=language)
self.assertEqual(response.status_code, 200)
self.assertEqual(response['Content-Language'], language)
# Check that if the string is incorrectly not marked as unicode we still get the error
with mock.patch(
"openedx.features.course_duration_limits.access.get_date_string",
return_value=date_string.encode('utf-8')):
response = self.client.get(url, HTTP_ACCEPT_LANGUAGE=language)
self.assertEqual(response.status_code, 500)
def test_closest_released_language(self, released_languages, course_language, expected_language):
DarkLangConfig(released_languages=released_languages, enabled=True, changed_by=self.user).save()
course_overview = CourseOverviewFactory.create(language=course_language)
self.assertEqual(course_overview.closest_released_language, expected_language)