From 0f1d6636f6a78799b1834f3a0606cf5cdeac8e86 Mon Sep 17 00:00:00 2001 From: Alexandru Arnautu Date: Mon, 9 Mar 2020 12:21:40 +0200 Subject: [PATCH] Add tests for float field --- tests/test_float_field.py | 176 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 176 insertions(+) create mode 100644 tests/test_float_field.py diff --git a/tests/test_float_field.py b/tests/test_float_field.py new file mode 100644 index 0000000..60a620c --- /dev/null +++ b/tests/test_float_field.py @@ -0,0 +1,176 @@ +from django.test import TestCase +from django.db.utils import IntegrityError +from django.conf import settings +from django.db import connection +from django.utils import translation + +from localized_fields.fields import LocalizedFloatField + +from .fake_model import get_fake_model + + +class LocalizedFloatFieldTestCase(TestCase): + """Tests whether the :see:LocalizedFloatField + and :see:LocalizedFloatValue works properly.""" + + TestModel = None + + @classmethod + def setUpClass(cls): + super().setUpClass() + + cls.TestModel = get_fake_model({ + 'score': LocalizedFloatField() + }) + + def test_basic(self): + """Tests the basics of storing float values.""" + + obj = self.TestModel() + for index, (lang_code, _) in enumerate(settings.LANGUAGES): + obj.score.set(lang_code, index + 1.0) + obj.save() + + obj = self.TestModel.objects.all().first() + for index, (lang_code, _) in enumerate(settings.LANGUAGES): + assert obj.score.get(lang_code) == index + 1.0 + + def test_primary_language_required(self): + """Tests whether the primary language is required by + default and all other languages are optiona.""" + + # not filling in anything should raise IntegrityError, + # the primary language is required + with self.assertRaises(IntegrityError): + obj = self.TestModel() + obj.save() + + # when filling all other languages besides the primary language + # should still raise an error because the primary is always required + with self.assertRaises(IntegrityError): + obj = self.TestModel() + for lang_code, _ in settings.LANGUAGES: + if lang_code == settings.LANGUAGE_CODE: + continue + obj.score.set(lang_code, 23.0) + obj.save() + + def test_default_value_none(self): + """Tests whether the default value for optional languages + is NoneType.""" + + obj = self.TestModel() + obj.score.set(settings.LANGUAGE_CODE, 1234.0) + obj.save() + + for lang_code, _ in settings.LANGUAGES: + if lang_code == settings.LANGUAGE_CODE: + continue + + assert obj.score.get(lang_code) is None + + def test_translate(self): + """Tests whether casting the value to an float + results in the value being returned in the currently + active language as an float.""" + + obj = self.TestModel() + for index, (lang_code, _) in enumerate(settings.LANGUAGES): + obj.score.set(lang_code, index + 1.0) + obj.save() + + obj.refresh_from_db() + for index, (lang_code, _) in enumerate(settings.LANGUAGES): + with translation.override(lang_code): + assert float(obj.score) == index + 1.0 + assert obj.score.translate() == index + 1.0 + + def test_translate_primary_fallback(self): + """Tests whether casting the value to an float + results in the value begin returned in the active + language and falls back to the primary language + if there is no value in that language.""" + + obj = self.TestModel() + obj.score.set(settings.LANGUAGE_CODE, 25.0) + + secondary_language = settings.LANGUAGES[-1][0] + assert obj.score.get(secondary_language) is None + + with translation.override(secondary_language): + assert obj.score.translate() == 25.0 + assert float(obj.score) == 25.0 + + def test_get_default_value(self): + """Tests whether getting the value in a specific + language properly returns the specified default + in case it is not available.""" + + obj = self.TestModel() + obj.score.set(settings.LANGUAGE_CODE, 25.0) + + secondary_language = settings.LANGUAGES[-1][0] + assert obj.score.get(secondary_language) is None + assert obj.score.get(secondary_language, 1337.0) == 1337.0 + + def test_completely_optional(self): + """Tests whether having all languages optional + works properly.""" + + model = get_fake_model({ + 'score': LocalizedFloatField(null=True, required=[], blank=True) + }) + + obj = model() + obj.save() + + for lang_code, _ in settings.LANGUAGES: + assert getattr(obj.score, lang_code) is None + + def test_store_string(self): + """Tests whether the field properly raises + an error when trying to store a non-float.""" + + for lang_code, _ in settings.LANGUAGES: + obj = self.TestModel() + with self.assertRaises(IntegrityError): + obj.score.set(lang_code, 'haha') + obj.save() + + def test_none_if_illegal_value_stored(self): + """Tests whether None is returned for a language + if the value stored in the database is not an + float.""" + + obj = self.TestModel() + obj.score.set(settings.LANGUAGE_CODE, 25.0) + obj.save() + + with connection.cursor() as cursor: + table_name = self.TestModel._meta.db_table + cursor.execute("update %s set score = 'en=>haha'" % table_name) + + obj.refresh_from_db() + assert obj.score.get(settings.LANGUAGE_CODE) is None + + def test_default_value(self): + """Tests whether a default is properly set + when specified.""" + + model = get_fake_model({ + 'score': LocalizedFloatField(default={settings.LANGUAGE_CODE: 75.0}) + }) + + obj = model.objects.create() + assert obj.score.get(settings.LANGUAGE_CODE) == 75.0 + + obj = model() + for lang_code, _ in settings.LANGUAGES: + obj.score.set(lang_code, None) + obj.save() + + for lang_code, _ in settings.LANGUAGES: + if lang_code == settings.LANGUAGE_CODE: + assert obj.score.get(lang_code) == 75.0 + else: + assert obj.score.get(lang_code) is None