def test_translate(self):
SHARED_EN = 'shared'
TRANS_EN = 'English'
SHARED_JA = 'shared'
TRANS_JA = u'日本語'
en = Normal.objects.language('en').get(pk=1)
self.assertEqual(Normal._meta.translations_model.objects.count(), 1)
self.assertEqual(en.shared_field, SHARED_EN)
self.assertEqual(en.translated_field, TRANS_EN)
ja = en
ja.translate('ja')
ja.save()
self.assertEqual(Normal._meta.translations_model.objects.count(), 2)
self.assertEqual(ja.shared_field, SHARED_JA)
self.assertEqual(ja.translated_field, '')
ja.translated_field = TRANS_JA
ja.save()
self.assertEqual(Normal._meta.translations_model.objects.count(), 2)
self.assertEqual(ja.shared_field, SHARED_JA)
self.assertEqual(ja.translated_field, TRANS_JA)
with LanguageOverride('en'):
obj = self.reload(ja)
self.assertEqual(obj.shared_field, SHARED_EN)
self.assertEqual(obj.translated_field, TRANS_EN)
with LanguageOverride('ja'):
obj = self.reload(en)
self.assertEqual(obj.shared_field, SHARED_JA)
self.assertEqual(obj.translated_field, TRANS_JA)
def test_triple(self):
normal = Normal.objects.language('en').create(
shared_field='SHARED', translated_field='English')
other = Other.objects.create(normal=normal)
standard = Standard.objects.create(normal=normal,
normal_field='NORMAL FIELD')
obj = Normal.objects.language('en').get(standards__pk=standard.pk)
self.assertEqual(obj.pk, normal.pk)
obj = Normal.objects.language('en').get(others__pk=other.pk)
self.assertEqual(obj.pk, normal.pk)
# We created an english Normal object, so we want to make sure that we use 'en'
with LanguageOverride('en'):
obj = get_translation_aware_manager(Standard).get(
normal__others__pk=other.pk)
self.assertEqual(obj.pk, standard.pk)
# If we don't use language 'en', it should give DoesNotExist, when using the
# translation aware manager
with LanguageOverride('ja'):
manager = get_translation_aware_manager(Standard)
self.assertRaises(Standard.DoesNotExist,
manager.get,
normal__others__pk=other.pk)
# However, if we don't use the translation aware manager, we can query any
# the shared fields in any language, and it should return the object,
# even though there is no translated Normal objects
with LanguageOverride('ja'):
obj = Standard.objects.get(normal__others__pk=other.pk)
self.assertEqual(obj.pk, standard.pk)
def test_admin_dual(self):
SHARED = 'shared'
TRANS_EN = 'English'
TRANS_JA = u'日本語'
with self.login_user_context(username='******', password='******'):
url = reverse('admin:app_normal_add')
data_en = {
'shared_field': SHARED,
'translated_field': TRANS_EN,
'simplerel-TOTAL_FORMS': '0',
'simplerel-INITIAL_FORMS': '0',
'simplerel-MAX_NUM_FORMS': '0',
}
data_ja = {
'shared_field': SHARED,
'translated_field': TRANS_JA,
'simplerel-TOTAL_FORMS': '0',
'simplerel-INITIAL_FORMS': '0',
'simplerel-MAX_NUM_FORMS': '0',
}
with LanguageOverride('en'):
response = self.client.post(url, data_en)
self.assertEqual(response.status_code, 302)
self.assertEqual(Normal.objects.count(), 1)
with LanguageOverride('ja'):
response = self.client.post(url, data_ja)
self.assertEqual(response.status_code, 302)
self.assertEqual(Normal.objects.count(), 2)
en = Normal.objects.using_translations().get(language_code='en')
self.assertEqual(en.shared_field, SHARED)
self.assertEqual(en.translated_field, TRANS_EN)
ja = Normal.objects.using_translations().get(language_code='ja')
self.assertEqual(ja.shared_field, SHARED)
self.assertEqual(ja.translated_field, TRANS_JA)
def test_get_object(self):
# Check if it returns a model, if there is at least one translation
myadmin = self._get_admin(Normal)
rf = RequestFactory()
get_request = rf.get('/admin/app/normal/')
obj = Normal.objects.language("en").create(shared_field="shared", )
with LanguageOverride('en'):
self.assertEqual(
myadmin.get_object(get_request, obj.pk).pk, obj.pk)
self.assertEqual(
myadmin.get_object(get_request, obj.pk).shared_field,
obj.shared_field)
with LanguageOverride('ja'):
self.assertEqual(
myadmin.get_object(get_request, obj.pk).pk, obj.pk)
self.assertEqual(
myadmin.get_object(get_request, obj.pk).shared_field,
obj.shared_field)
# Check what happens if there is no translations at all
obj = Normal.objects.untranslated().create(shared_field="shared", )
self.assertEqual(myadmin.get_object(get_request, obj.pk).pk, obj.pk)
self.assertEqual(
myadmin.get_object(get_request, obj.pk).shared_field,
obj.shared_field)
def test_count(self):
with LanguageOverride('en'):
self.assertEqual(Normal.objects.count(), 1)
with LanguageOverride('ja'):
self.assertEqual(Normal.objects.count(), 1)
with LanguageOverride('invalid'):
self.assertEqual(Normal.objects.count(), 0)
self.assertEqual(Normal.objects.untranslated().count(), 1)
def test_create_instance_translated_nolang(self):
with LanguageOverride('en'):
obj = Normal(language_code='en', translated_field="English")
obj.save()
en = Normal.objects.language('en').get(pk=obj.pk)
self.assertEqual(en.translated_field, "English")
self.assertEqual(en.language_code, "en")
def test_filter_by_translated_field_requires_translation_aware_manager(
self):
en = Normal.objects.language('en').get(pk=1)
with LanguageOverride('en'):
self.assertRaises(WrongManager,
Standard.objects.filter,
normal__translated_field=en.translated_field)
def test_changelist(self):
url = reverse('admin:app_normal_changelist')
request = self.request_factory.get(url)
normaladmin = self._get_admin(Normal)
with LanguageOverride('en'):
queryset = normaladmin.queryset(request)
self.assertEqual(queryset.count(), 2)
def test_language(self):
with LanguageOverride('en'):
obj = Normal.objects.language('ja').get(pk=1)
self.assertEqual(obj.shared_field,
DOUBLE_NORMAL[1]['shared_field'])
self.assertEqual(obj.translated_field,
DOUBLE_NORMAL[1]['translated_field_ja'])
def test_admin_change_form_redirect_add_another(self):
lang = 'en'
with LanguageOverride('ja'):
with self.login_user_context(username='******', password='******'):
obj = Normal.objects.language(lang).create(
shared_field="shared",
translated_field='English',
)
url = '%s?language=%s' % (reverse('admin:app_normal_change',
args=(obj.pk, )), lang)
data = {
'translated_field': 'English NEW',
'shared_field': obj.shared_field,
'_addanother': '1',
'simplerel-TOTAL_FORMS': '0',
'simplerel-INITIAL_FORMS': '0',
'simplerel-MAX_NUM_FORMS': '0',
}
response = self.client.post(url, data)
self.assertEqual(response.status_code, 302, response.content)
expected_url = '%s?language=%s' % (
reverse('admin:app_normal_add'), lang)
self.assertTrue(response['Location'].endswith(expected_url))
obj = Normal.objects.language('en').get(pk=obj.pk)
self.assertEqual(obj.translated_field, "English NEW")
def test_shared_only(self):
with LanguageOverride('de'):
with self.assertNumQueries(2):
obj = Normal.objects.untranslated().get(pk=1)
self.assertEqual(obj.shared_field, 'Shared1')
self.assertRaises(Normal._meta.translations_model.DoesNotExist,
getattr, obj, 'translated_field')
def test_lazy_translation_getter(self):
translated_field_value = u"rød grød med fløde"
slovenian_string = u'pozdravčki čćžđš'
normal = Normal.objects.language("da").create(
shared_field="shared field",
translated_field=translated_field_value,
)
normal_si = Normal.objects.get(pk=normal.pk).translate('sl')
normal_si.translated_field = slovenian_string
normal_si.save()
Other.objects.create(normal=normal)
self.assertEqual(normal.lazy_translation_getter("translated_field"),
translated_field_value)
n2 = Normal.objects.get(pk=normal.pk)
self.assertEqual(n2.safe_translation_getter("translated_field"), None)
self.assertEqual(n2.lazy_translation_getter("translated_field"),
translated_field_value)
self.assertEqual(n2.safe_translation_getter("translated_field"),
translated_field_value)
with LanguageOverride('sl'):
n2 = Normal.objects.get(pk=normal.pk)
self.assertEqual(n2.safe_translation_getter("translated_field"),
None)
self.assertEqual(n2.lazy_translation_getter("translated_field"),
slovenian_string)
self.assertEqual(n2.safe_translation_getter("translated_field"),
slovenian_string)
def test_safe_translation_getter(self):
untranslated = Normal.objects.untranslated().get(pk=1)
with LanguageOverride('en'):
self.assertEqual(
untranslated.safe_translation_getter('translated_field', None),
None)
en = Normal.objects.untranslated().get(pk=1)
self.assertEqual(
untranslated.safe_translation_getter('translated_field',
"English"), "English")
with LanguageOverride('ja'):
self.assertEqual(
untranslated.safe_translation_getter('translated_field', None),
None)
self.assertEqual(
untranslated.safe_translation_getter('translated_field',
"Test"), "Test")
def test_single_instance_fallback(self):
# fetch an object in a language that does not exist
with LanguageOverride('de'):
with self.assertNumQueries(2):
obj = Normal.objects.untranslated().use_fallbacks(
'en', 'ja').get(pk=1)
self.assertEqual(obj.language_code, 'en')
self.assertEqual(obj.translated_field, 'English1')
def test_kwargs(self):
with LanguageOverride('en'):
kwargs = {'language_code': 'ja', 'pk': 1}
obj = Normal.objects.using_translations().get(**kwargs)
self.assertEqual(obj.shared_field,
DOUBLE_NORMAL[1]['shared_field'])
self.assertEqual(obj.translated_field,
DOUBLE_NORMAL[1]['translated_field_ja'])
def test_args(self):
with LanguageOverride('en'):
q = Q(language_code='ja', pk=1)
obj = Normal.objects.using_translations().get(q)
self.assertEqual(obj.shared_field,
DOUBLE_NORMAL[1]['shared_field'])
self.assertEqual(obj.translated_field,
DOUBLE_NORMAL[1]['translated_field_ja'])
def test_lookup_by_pk(self):
en = Normal.objects.language('en').get(pk=1)
by_pk = Standard.objects.get(normal__pk=en.pk)
with LanguageOverride('en'):
self.assertEqual(by_pk.normal.pk, en.pk)
self.assertEqual(by_pk.normal.shared_field, en.shared_field)
self.assertEqual(by_pk.normal.translated_field,
en.translated_field)
self.assertTrue(by_pk in en.standards.all())
def test_relation(self):
en = Normal.objects.language('en').get(pk=1)
ja = Normal.objects.language('ja').get(pk=1)
related = Standard.objects.get(pk=1)
with LanguageOverride('en'):
related = self.reload(related)
self.assertEqual(related.normal.pk, en.pk)
self.assertEqual(related.normal.shared_field, en.shared_field)
self.assertEqual(related.normal.translated_field,
en.translated_field)
self.assertTrue(related in en.standards.all())
with LanguageOverride('ja'):
related = self.reload(related)
self.assertEqual(related.normal.pk, ja.pk)
self.assertEqual(related.normal.shared_field, ja.shared_field)
self.assertEqual(related.normal.translated_field,
ja.translated_field)
self.assertTrue(related in ja.standards.all())
def test_correct_id_in_inline(self):
LANGUAGES = (
('en', u'English'),
('fr', u'Français'),
('da', u'Dansk'),
('ja', u'日本語'),
)
with SettingsOverride(LANGUAGES=LANGUAGES):
with LanguageOverride('en'):
normal = Normal.objects.language().create(
shared_field="whatever1",
translated_field="whatever in another language1")
normal2 = Normal.objects.language().create(
shared_field="whatever2",
translated_field="whatever in another language2")
normal3 = Normal.objects.language().create(
shared_field="whatever3",
translated_field="whatever in another language3")
simple1 = SimpleRelated.objects.language("en").create(
normal=normal3, translated_field="inline whatever translated")
simple1.translate("ja")
simple1.translated_field = "japanese stuff"
simple1.save()
simple1.translate("fr")
simple1.translated_field = "french stuff"
simple1.save()
simple1.translate("da")
simple1.translated_field = "danish stuff"
simple1.save()
with LanguageOverride('da'):
instance = SimpleRelated.objects.get(pk=simple1.pk)
class ExampleInlineForm(InlineModelForm):
class Meta:
model = SimpleRelated
form = ExampleInlineForm(instance=instance)
self.assertTrue(form.initial["id"] == instance.id)
def test_no_language_code_in_fields(self):
with LanguageOverride("en"):
form = NormalForm()
self.assertFalse(form.fields.has_key("language_code"))
form = NormalMediaForm()
self.assertFalse(form.fields.has_key("language_code"))
form = NormalFormExclude()
self.assertFalse(form.fields.has_key("language_code"))
def test_create_nolang(self):
with self.assertNumQueries(2):
with LanguageOverride('en'):
en = Normal.objects.create(
shared_field="shared",
translated_field='English',
)
self.assertEqual(en.shared_field, "shared")
self.assertEqual(en.translated_field, "English")
self.assertEqual(en.language_code, "en")
def test_form_wrong_field_in_class(self):
with LanguageOverride("en"):
with self.assertRaises(FieldError):
class WrongForm(TranslatableModelForm):
class Meta:
model = Normal
fields = ['a_field_that_doesnt_exist']
form = WrongForm()
def test_admin_change_form_title(self):
with LanguageOverride('en'):
with self.login_user_context(username='******', password='******'):
obj = Normal.objects.language('en').create(
shared_field="shared",
translated_field='English',
)
url = reverse('admin:app_normal_change', args=(obj.pk, ))
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertTrue('en' in response.content)
def test_all_translations(self):
# Create an unstranslated model and get the translations
myadmin = self._get_admin(Normal)
obj = Normal.objects.untranslated().create(shared_field="shared", )
self.assertEqual(myadmin.all_translations(obj), "")
# Create a english translated model and make sure the active language
# is highlighted in admin with <strong></strong>
obj = Normal.objects.language("en").create(shared_field="shared", )
with LanguageOverride('en'):
self.assertEqual(myadmin.all_translations(obj),
"<strong>en</strong>")
with LanguageOverride('ja'):
self.assertEqual(myadmin.all_translations(obj), "en")
# An unsaved object, shouldnt have any translations
obj = Normal()
self.assertEqual(myadmin.all_translations(obj), "")
def test_num_queries(self):
with LanguageOverride('en'):
en = Normal.objects.language('en').get(pk=1)
with self.assertNumQueries(1):
related = Standard.objects.select_related('normal').get(pk=1)
self.assertEqual(related.normal.pk, en.pk)
with self.assertNumQueries(0):
self.assertEqual(related.normal.shared_field, en.shared_field)
with self.assertNumQueries(1):
self.assertEqual(related.normal.translated_field,
en.translated_field)
def test_simple_iter(self):
with LanguageOverride('en'):
with self.assertNumQueries(1):
index = 0
for obj in Normal.objects.language():
index += 1
self.assertEqual(obj.shared_field,
DOUBLE_NORMAL[index]['shared_field'])
self.assertEqual(
obj.translated_field,
DOUBLE_NORMAL[index]['translated_field_en'])
with LanguageOverride('ja'):
with self.assertNumQueries(1):
index = 0
for obj in Normal.objects.language():
index += 1
self.assertEqual(obj.shared_field,
DOUBLE_NORMAL[index]['shared_field'])
self.assertEqual(
obj.translated_field,
DOUBLE_NORMAL[index]['translated_field_ja'])
def test_lookup_by_translated_field(self):
en = Normal.objects.language('en').get(pk=1)
translation_aware_manager = get_translation_aware_manager(Standard)
with LanguageOverride('en'):
by_translated_field = translation_aware_manager.get(
normal__translated_field=en.translated_field)
self.assertEqual(by_translated_field.normal.pk, en.pk)
self.assertEqual(by_translated_field.normal.shared_field,
en.shared_field)
self.assertEqual(by_translated_field.normal.translated_field,
en.translated_field)
self.assertTrue(by_translated_field in en.standards.all())
def test_update_view_get(self):
with LanguageOverride("en"):
response = self.client.get(reverse('update_normal', args=[self.object.id]))
self.assertTrue(response.status_code== 200)
response = self.client.get(reverse('update_normal_slug', kwargs={'slug': self.object.shared_field}))
self.assertTrue(response.status_code == 200)
response = self.client.get(reverse('update_normal', args=[self.object.id]) + "?%s=da" % TranslatableUpdateView.query_language_key)
self.assertTrue(response.status_code == 200)
response = self.client.get(reverse('update_normal', args=[self.object.id * 100]) + "?%s=da" % TranslatableUpdateView.query_language_key)
self.assertTrue(response.status_code == 404)
def test_create_fields_inline(self):
with LanguageOverride("en"):
# Fixtures (should eventually be shared with other tests)
translate_mixin = TranslatableModelAdminMixin()
formset = translatable_inlineformset_factory(
translate_mixin._language(self.request), Normal,
Related)( #self.request.POST,
instance=self.object)
self.assertTrue(formset.forms[0].fields.has_key("normal"))
self.assertTrue(formset.forms[0].fields.has_key("translated"))
self.assertTrue(
formset.forms[0].fields.has_key("translated_to_translated"))
self.assertFalse(formset.forms[0].fields.has_key("language_code"))
def test_normal_model_form_save(self):
with LanguageOverride('en'):
SHARED = 'Shared'
TRANSLATED = 'English'
data = {
'shared_field': SHARED,
'translated_field': TRANSLATED,
'language_code': 'en'
}
form = NormalForm(data)
# tested a non-translated ModelForm, and that takes 7 queries.
with self.assertNumQueries(2):
obj = form.save()
with self.assertNumQueries(0):
self.assertEqual(obj.shared_field, SHARED)
self.assertEqual(obj.translated_field, TRANSLATED)
self.assertNotEqual(obj.pk, None)
