parler.tests.ModelAttributeTests.test_fallback_language_no_current() - Code Metrics - Inspection of "improve setup.py logic for sdist" - edoburu/django-parler - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a6fb63...42f11c )

by Diederik van der

created 2015-12-16 12:35 UTC

test_fallback_language_no_current() A

↳ Parent: parler.tests.ModelAttributeTests

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	1
dl	0
loc	12
rs	9.4286

from __future__ import unicode_literals
from django.utils import translation
from parler.models import TranslationDoesNotExist
from .utils import AppTestCase
from .testapp.models import SimpleModel, AnyLanguageModel, EmptyModel


class ModelAttributeTests(AppTestCase):
    """
    Test model construction
    """
    def test_untranslated_get(self):
        """
        Test the metaclass of the model.
        """
        try:
            value = SimpleModel().tr_title
        except Exception as e:
            self.assertIsInstance(e, TranslationDoesNotExist)
            self.assertIsInstance(e, AttributeError)
        else:
            self.fail("Expected exception from reading untranslated title, got {0}.".format(repr(value)))

        # Raising attribute error gives some additional benefits:
        self.assertEqual(getattr(SimpleModel(), 'tr_title', 'FOO'), 'FOO')
        self.assertFalse(hasattr(SimpleModel(), 'tr_title'))


    def test_default_language(self):
        """
        Test whether simple language assignments work.
        """
        with translation.override('ca-fr'):
            x = SimpleModel(id=99)   # uses get_language(), ID is to avoid reading cached items for 'en'
            self.assertEqual(x.get_current_language(), translation.get_language())
            self.assertEqual(translation.get_language(), 'ca-fr')

        x.shared = 'SHARED'
        x.tr_title = 'TRANS_CA'
        x.save()

        # Refetch
        with translation.override('en'):
            x = SimpleModel.objects.get(pk=x.pk)
            self.assertRaises(TranslationDoesNotExist, lambda: x.tr_title)

            # Switch context
            x.set_current_language('ca-fr')
            self.assertEqual(x.tr_title, 'TRANS_CA')


    def test_init_args(self):
        """
        Test whether passing translated attributes to __init__() works.
        """
        x = SimpleModel(tr_title='TRANS_TITLE')
        self.assertEqual(x.tr_title, "TRANS_TITLE")

        y = SimpleModel(tr_title='TRANS_TITLE', _current_language='nl')
        self.assertEqual(y.get_current_language(), 'nl')
        self.assertEqual(y.tr_title, "TRANS_TITLE")


    def test_create_args(self):
        y = SimpleModel.objects.language('nl').create(tr_title='TRANS_TITLE')
        self.assertEqual(y.get_current_language(), 'nl')
        self.assertEqual(y.tr_title, "TRANS_TITLE")


    def test_save_multiple(self):
        """
        Test the save_translations() function to store multiple languages.
        """
        x = SimpleModel()
        x.set_current_language('en')
        x.tr_title = "TITLE_EN"
        x.set_current_language('fr')
        x.tr_title = "TITLE_FR"
        x.set_current_language('es')
        x.tr_title = "TITLE_ES"
        x.set_current_language('nl')
        x.tr_title = "TITLE_NL"

        x.save()

        # Check if all translations are saved.
        self.assertEqual(sorted(x.translations.values_list('tr_title', flat=True)), ['TITLE_EN', 'TITLE_ES', 'TITLE_FR', 'TITLE_NL'])
        self.assertEqual(sorted(x.get_available_languages()), ['en', 'es', 'fr', 'nl'])
        self.assertTrue(x.has_translation('en'))
        self.assertTrue(x.has_translation('es'))
        self.assertFalse(x.has_translation('fi'))

        # Update 2 translations.
        # Only those should be updated in the database.
        x.set_current_language('es')
        x.tr_title = "TITLE_ES2"
        x.set_current_language('nl')
        x.tr_title = "TITLE_NL2"

        self.assertNumQueries(2, x.save_translations())

        # Any unmodified language is not saved.
        x.set_current_language('it', initialize=True)
        self.assertTrue(x.has_translation('it'))  # does return true for this object.
        self.assertNumQueries(0, x.save_translations())
        self.assertEqual(sorted(x.get_available_languages()), ['en', 'es', 'fr', 'nl'])


    def test_empty_model(self):
        """
        Test whether a translated model without any fields still works.
        """
        x = EmptyModel()
        x.set_current_language('en', initialize=True)
        x.set_current_language('fr', initialize=True)
        x.set_current_language('es')
        x.set_current_language('nl', initialize=True)
        x.save()

        self.assertEqual(sorted(x.get_available_languages()), ['en', 'fr', 'nl'])


    def test_create_translation(self):
        x = SimpleModel.objects.create()
        x.create_translation('en', tr_title='TITLE_EN')
        x.create_translation('fr', tr_title='TITLE_FR')

        self.assertEqual(sorted(x.get_available_languages()), ['en', 'fr'])


    def test_fallback_language(self):
        """
        Test whether the fallback language will be returned.
        """
        x = SimpleModel()
        x.set_current_language(self.conf_fallback)
        x.tr_title = "TITLE_FALLBACK"

        x.set_current_language(self.other_lang1)
        x.tr_title = 'TITLE_XX'
        x.save()

        with translation.override(self.other_lang2):
            x = SimpleModel.objects.get(pk=x.pk)
            self.assertEqual(x.tr_title, 'TITLE_FALLBACK')

    def test_fallback_variant(self):
        """Test de-us falls back to de"""
        x = SimpleModel()

        x.set_current_language('en')
        x.tr_title = "Hello"

        x.set_current_language('de')
        x.tr_title = "Hallo"
        x.save()

        with translation.override('de-ch'):
            x = SimpleModel.objects.get(pk=x.pk)
            self.assertEqual(x.tr_title, 'Hallo')

    def test_fallback_language_no_current(self):
        """
        Test whether the fallback language will be returned,
        even when the current language does not have a translation.
        """
        x = SimpleModel()
        x.set_current_language(self.conf_fallback)
        x.tr_title = "TITLE_FALLBACK"

        self.assertEqual(
            x.safe_translation_getter('tr_title', language_code=self.other_lang1),
            'TITLE_FALLBACK')

    def test_any_fallback_model(self):
        """
        Test whether a failure in the fallback language can return any saved language (if configured for it).
        """
        x = AnyLanguageModel()
        x.set_current_language(self.other_lang1)
        x.tr_title = "TITLE_XX"

        x.save()

        with translation.override(self.other_lang2):
            x = AnyLanguageModel.objects.get(pk=x.pk)
            self.assertRaises(TranslationDoesNotExist, lambda: x._get_translated_model(use_fallback=True))
            self.assertEqual(x.tr_title, 'TITLE_XX')  # Even though there is no current language, there is a value.

            self.assertNumQueries(0, lambda: x._get_any_translated_model())   # Can fetch from cache next time.
            self.assertEqual(x._get_any_translated_model().language_code, self.other_lang1)


    def test_any_fallback_function(self):
        x = SimpleModel()
        x.set_current_language(self.other_lang1)
        x.tr_title = "TITLE_XX"

        x.save()

        with translation.override(self.other_lang2):
            x = SimpleModel.objects.get(pk=x.pk)
            self.assertRaises(TranslationDoesNotExist, lambda: x._get_translated_model(use_fallback=True))
            self.assertIs(x.safe_translation_getter('tr_title', 'DEFAULT'), 'DEFAULT')  # No lanuage, gives default
            self.assertEqual(x.safe_translation_getter('tr_title', any_language=True), 'TITLE_XX')  # Even though there is no current language, there is a value.

            self.assertNumQueries(0, lambda: x._get_any_translated_model())   # Can fetch from cache next time.
            self.assertEqual(x._get_any_translated_model().language_code, self.other_lang1)

    def test_save_ignore_fallback_marker(self):
        """
        Test whether the ``save_translations()`` method skips fallback languages
        """
        x = SimpleModel()
        x.set_current_language(self.other_lang1)
        x.tr_title = "TITLE_XX"
        x.set_current_language(self.other_lang2)
        # try fetching, causing an fallback marker
        x.safe_translation_getter('tr_title', any_language=True)
        # Now save. This should not raise errors
        x.save()

    def test_model_with_zero_pk(self):
        """
        tests that the translated model is returned also when the pk is 0
        """
        x = SimpleModel()
        x.set_current_language(self.other_lang1)
        x.pk = 0
        x.tr_title = "EMPTY_PK"

        x.save()

        # now fetch it from db
        try:
            SimpleModel.objects.get(pk=x.pk)
        except TranslationDoesNotExist:
            self.fail("zero pk is not supported!")


1			from __future__ import unicode_literals
2			from django.utils import translation
3			from parler.models import TranslationDoesNotExist
4			from .utils import AppTestCase
5			from .testapp.models import SimpleModel, AnyLanguageModel, EmptyModel
6
7
8			class ModelAttributeTests(AppTestCase):
9			"""
10			Test model construction
11			"""
12			def test_untranslated_get(self):
13			"""
14			Test the metaclass of the model.
15			"""
16			try:
17			value = SimpleModel().tr_title
18			except Exception as e:
19			self.assertIsInstance(e, TranslationDoesNotExist)
20			self.assertIsInstance(e, AttributeError)
21			else:
22			self.fail("Expected exception from reading untranslated title, got {0}.".format(repr(value)))
23
24			# Raising attribute error gives some additional benefits:
25			self.assertEqual(getattr(SimpleModel(), 'tr_title', 'FOO'), 'FOO')
26			self.assertFalse(hasattr(SimpleModel(), 'tr_title'))
27
28
29			def test_default_language(self):
30			"""
31			Test whether simple language assignments work.
32			"""
33			with translation.override('ca-fr'):
34			x = SimpleModel(id=99) # uses get_language(), ID is to avoid reading cached items for 'en'
35			self.assertEqual(x.get_current_language(), translation.get_language())
36			self.assertEqual(translation.get_language(), 'ca-fr')
37
38			x.shared = 'SHARED'
39			x.tr_title = 'TRANS_CA'
40			x.save()
41
42			# Refetch
43			with translation.override('en'):
44			x = SimpleModel.objects.get(pk=x.pk)
45			self.assertRaises(TranslationDoesNotExist, lambda: x.tr_title)
46
47			# Switch context
48			x.set_current_language('ca-fr')
49			self.assertEqual(x.tr_title, 'TRANS_CA')
50
51
52			def test_init_args(self):
53			"""
54			Test whether passing translated attributes to __init__() works.
55			"""
56			x = SimpleModel(tr_title='TRANS_TITLE')
57			self.assertEqual(x.tr_title, "TRANS_TITLE")
58
59			y = SimpleModel(tr_title='TRANS_TITLE', _current_language='nl')
60			self.assertEqual(y.get_current_language(), 'nl')
61			self.assertEqual(y.tr_title, "TRANS_TITLE")
62
63
64			def test_create_args(self):
65			y = SimpleModel.objects.language('nl').create(tr_title='TRANS_TITLE')
66			self.assertEqual(y.get_current_language(), 'nl')
67			self.assertEqual(y.tr_title, "TRANS_TITLE")
68
69
70			def test_save_multiple(self):
71			"""
72			Test the save_translations() function to store multiple languages.
73			"""
74			x = SimpleModel()
75			x.set_current_language('en')
76			x.tr_title = "TITLE_EN"
77			x.set_current_language('fr')
78			x.tr_title = "TITLE_FR"
79			x.set_current_language('es')
80			x.tr_title = "TITLE_ES"
81			x.set_current_language('nl')
82			x.tr_title = "TITLE_NL"
83
84			x.save()
85
86			# Check if all translations are saved.
87			self.assertEqual(sorted(x.translations.values_list('tr_title', flat=True)), ['TITLE_EN', 'TITLE_ES', 'TITLE_FR', 'TITLE_NL'])
88			self.assertEqual(sorted(x.get_available_languages()), ['en', 'es', 'fr', 'nl'])
89			self.assertTrue(x.has_translation('en'))
90			self.assertTrue(x.has_translation('es'))
91			self.assertFalse(x.has_translation('fi'))
92
93			# Update 2 translations.
94			# Only those should be updated in the database.
95			x.set_current_language('es')
96			x.tr_title = "TITLE_ES2"
97			x.set_current_language('nl')
98			x.tr_title = "TITLE_NL2"
99
100			self.assertNumQueries(2, x.save_translations())
101
102			# Any unmodified language is not saved.
103			x.set_current_language('it', initialize=True)
104			self.assertTrue(x.has_translation('it')) # does return true for this object.
105			self.assertNumQueries(0, x.save_translations())
106			self.assertEqual(sorted(x.get_available_languages()), ['en', 'es', 'fr', 'nl'])
107
108
109			def test_empty_model(self):
110			"""
111			Test whether a translated model without any fields still works.
112			"""
113			x = EmptyModel()
114			x.set_current_language('en', initialize=True)
115			x.set_current_language('fr', initialize=True)
116			x.set_current_language('es')
117			x.set_current_language('nl', initialize=True)
118			x.save()
119
120			self.assertEqual(sorted(x.get_available_languages()), ['en', 'fr', 'nl'])
121
122
123			def test_create_translation(self):
124			x = SimpleModel.objects.create()
125			x.create_translation('en', tr_title='TITLE_EN')
126			x.create_translation('fr', tr_title='TITLE_FR')
127
128			self.assertEqual(sorted(x.get_available_languages()), ['en', 'fr'])
129
130
131			def test_fallback_language(self):
132			"""
133			Test whether the fallback language will be returned.
134			"""
135			x = SimpleModel()
136			x.set_current_language(self.conf_fallback)
137			x.tr_title = "TITLE_FALLBACK"
138
139			x.set_current_language(self.other_lang1)
140			x.tr_title = 'TITLE_XX'
141			x.save()
142
143			with translation.override(self.other_lang2):
144			x = SimpleModel.objects.get(pk=x.pk)
145			self.assertEqual(x.tr_title, 'TITLE_FALLBACK')
146
147			def test_fallback_variant(self):
148			"""Test de-us falls back to de"""
149			x = SimpleModel()
150
151			x.set_current_language('en')
152			x.tr_title = "Hello"
153
154			x.set_current_language('de')
155			x.tr_title = "Hallo"
156			x.save()
157
158			with translation.override('de-ch'):
159			x = SimpleModel.objects.get(pk=x.pk)
160			self.assertEqual(x.tr_title, 'Hallo')
161
162			def test_fallback_language_no_current(self):
163			"""
164			Test whether the fallback language will be returned,
165			even when the current language does not have a translation.
166			"""
167			x = SimpleModel()
168			x.set_current_language(self.conf_fallback)
169			x.tr_title = "TITLE_FALLBACK"
170
171			self.assertEqual(
172			x.safe_translation_getter('tr_title', language_code=self.other_lang1),
173			'TITLE_FALLBACK')
174
175			def test_any_fallback_model(self):
176			"""
177			Test whether a failure in the fallback language can return any saved language (if configured for it).
178			"""
179			x = AnyLanguageModel()
180			x.set_current_language(self.other_lang1)
181			x.tr_title = "TITLE_XX"
182
183			x.save()
184
185			with translation.override(self.other_lang2):
186			x = AnyLanguageModel.objects.get(pk=x.pk)
187			self.assertRaises(TranslationDoesNotExist, lambda: x._get_translated_model(use_fallback=True))
188			self.assertEqual(x.tr_title, 'TITLE_XX') # Even though there is no current language, there is a value.
189
190			self.assertNumQueries(0, lambda: x._get_any_translated_model()) # Can fetch from cache next time.
191			self.assertEqual(x._get_any_translated_model().language_code, self.other_lang1)
192
193
194			def test_any_fallback_function(self):
195			x = SimpleModel()
196			x.set_current_language(self.other_lang1)
197			x.tr_title = "TITLE_XX"
198
199			x.save()
200
201			with translation.override(self.other_lang2):
202			x = SimpleModel.objects.get(pk=x.pk)
203			self.assertRaises(TranslationDoesNotExist, lambda: x._get_translated_model(use_fallback=True))
204			self.assertIs(x.safe_translation_getter('tr_title', 'DEFAULT'), 'DEFAULT') # No lanuage, gives default
205			self.assertEqual(x.safe_translation_getter('tr_title', any_language=True), 'TITLE_XX') # Even though there is no current language, there is a value.
206
207			self.assertNumQueries(0, lambda: x._get_any_translated_model()) # Can fetch from cache next time.
208			self.assertEqual(x._get_any_translated_model().language_code, self.other_lang1)
209
210			def test_save_ignore_fallback_marker(self):
211			"""
212			Test whether the ``save_translations()`` method skips fallback languages
213			"""
214			x = SimpleModel()
215			x.set_current_language(self.other_lang1)
216			x.tr_title = "TITLE_XX"
217			x.set_current_language(self.other_lang2)
218			# try fetching, causing an fallback marker
219			x.safe_translation_getter('tr_title', any_language=True)
220			# Now save. This should not raise errors
221			x.save()
222
223			def test_model_with_zero_pk(self):
224			"""
225			tests that the translated model is returned also when the pk is 0
226			"""
227			x = SimpleModel()
228			x.set_current_language(self.other_lang1)
229			x.pk = 0
230			x.tr_title = "EMPTY_PK"
231
232			x.save()
233
234			# now fetch it from db
235			try:
236			SimpleModel.objects.get(pk=x.pk)
237			except TranslationDoesNotExist:
238			self.fail("zero pk is not supported!")
239

edoburu / django-parler

Push — master ( a6fb63...42f11c )

test_fallback_language_no_current() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like