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)