Add LocalizedBooleanField (#93)

tests/test_boolean_field.py

@@ -0,0 +1,211 @@
+from django.conf import settings
+from django.db import connection
+from django.db.utils import IntegrityError
+from django.test import TestCase
+from django.utils import translation
+
+from localized_fields.fields import LocalizedBooleanField
+from localized_fields.value import LocalizedBooleanValue
+
+from .fake_model import get_fake_model
+
+
+class LocalizedBooleanFieldTestCase(TestCase):
+    """Tests whether the :see:LocalizedBooleanField and
+    :see:LocalizedIntegerValue works properly."""
+
+    TestModel = None
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+
+        cls.TestModel = get_fake_model({"translated": LocalizedBooleanField()})
+
+    def test_basic(self):
+        """Tests the basics of storing boolean values."""
+
+        obj = self.TestModel()
+        for lang_code, _ in settings.LANGUAGES:
+            obj.translated.set(lang_code, False)
+        obj.save()
+
+        obj = self.TestModel.objects.all().first()
+        for lang_code, _ in settings.LANGUAGES:
+            assert obj.translated.get(lang_code) is False
+
+    def test_primary_language_required(self):
+        """Tests whether the primary language is required by default and all
+        other languages are optional."""
+
+        # 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.translated.set(lang_code, True)
+            obj.save()
+
+    def test_default_value_none(self):
+        """Tests whether the default value for optional languages is
+        NoneType."""
+
+        obj = self.TestModel()
+        obj.translated.set(settings.LANGUAGE_CODE, True)
+        obj.save()
+
+        for lang_code, _ in settings.LANGUAGES:
+            if lang_code == settings.LANGUAGE_CODE:
+                continue
+
+            assert obj.translated.get(lang_code) is None
+
+    def test_translate(self):
+        """Tests whether casting the value to a boolean results in the value
+        being returned in the currently active language as a boolean."""
+
+        obj = self.TestModel()
+        for lang_code, _ in settings.LANGUAGES:
+            obj.translated.set(lang_code, True)
+        obj.save()
+
+        obj.refresh_from_db()
+        for lang_code, _ in settings.LANGUAGES:
+            with translation.override(lang_code):
+                assert bool(obj.translated) is True
+                assert obj.translated.translate() is True
+
+    def test_translate_primary_fallback(self):
+        """Tests whether casting the value to a boolean results in the value
+        being returned in the active language and falls back to the primary
+        language if there is no value in that language."""
+
+        obj = self.TestModel()
+        obj.translated.set(settings.LANGUAGE_CODE, True)
+
+        secondary_language = settings.LANGUAGES[-1][0]
+        assert obj.translated.get(secondary_language) is None
+
+        with translation.override(secondary_language):
+            assert obj.translated.translate() is True
+            assert bool(obj.translated) is True
+
+    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.translated.set(settings.LANGUAGE_CODE, True)
+
+        secondary_language = settings.LANGUAGES[-1][0]
+        assert obj.translated.get(secondary_language) is None
+        assert obj.translated.get(secondary_language, False) is False
+
+    def test_completely_optional(self):
+        """Tests whether having all languages optional works properly."""
+
+        model = get_fake_model(
+            {
+                "translated": LocalizedBooleanField(
+                    null=True, required=[], blank=True
+                )
+            }
+        )
+
+        obj = model()
+        obj.save()
+
+        for lang_code, _ in settings.LANGUAGES:
+            assert getattr(obj.translated, lang_code) is None
+
+    def test_store_string(self):
+        """Tests whether the field properly raises an error when trying to
+        store a non-boolean."""
+
+        for lang_code, _ in settings.LANGUAGES:
+            obj = self.TestModel()
+            with self.assertRaises(IntegrityError):
+                obj.translated.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 a boolean."""
+
+        obj = self.TestModel()
+        obj.translated.set(settings.LANGUAGE_CODE, False)
+        obj.save()
+
+        with connection.cursor() as cursor:
+            table_name = self.TestModel._meta.db_table
+            cursor.execute("update %s set translated = 'en=>haha'" % table_name)
+
+        with self.assertRaises(ValueError):
+            obj.refresh_from_db()
+
+    def test_default_value(self):
+        """Tests whether a default is properly set when specified."""
+
+        model = get_fake_model(
+            {
+                "translated": LocalizedBooleanField(
+                    default={settings.LANGUAGE_CODE: True}
+                )
+            }
+        )
+
+        obj = model.objects.create()
+        assert obj.translated.get(settings.LANGUAGE_CODE) is True
+
+        obj = model()
+        for lang_code, _ in settings.LANGUAGES:
+            obj.translated.set(lang_code, None)
+        obj.save()
+
+        for lang_code, _ in settings.LANGUAGES:
+            if lang_code == settings.LANGUAGE_CODE:
+                assert obj.translated.get(lang_code) is True
+            else:
+                assert obj.translated.get(lang_code) is None
+
+    def test_default_value_update(self):
+        """Tests whether a default is properly set when specified during
+        updates."""
+
+        model = get_fake_model(
+            {
+                "translated": LocalizedBooleanField(
+                    default={settings.LANGUAGE_CODE: True}, null=True
+                )
+            }
+        )
+
+        obj = model.objects.create(
+            translated=LocalizedBooleanValue({settings.LANGUAGE_CODE: False})
+        )
+        assert obj.translated.get(settings.LANGUAGE_CODE) is False
+
+        model.objects.update(
+            translated=LocalizedBooleanValue({settings.LANGUAGE_CODE: None})
+        )
+        obj.refresh_from_db()
+        assert obj.translated.get(settings.LANGUAGE_CODE) is True
+
+    def test_callable_default_value(self):
+        output = {"en": True}
+
+        def func():
+            return output
+
+        model = get_fake_model({"test": LocalizedBooleanField(default=func)})
+        obj = model.objects.create()
+
+        assert obj.test["en"] == output["en"]

tests/test_field.py

@@ -121,8 +121,8 @@ class LocalizedFieldTestCase(TestCase):
 
     @staticmethod
     def test_get_prep_value():
-        """"Tests whether the :see:get_prep_value function produces the
-        expected dictionary."""
+        """Tests whether the :see:get_prep_value function produces the expected
+        dictionary."""
 
         input_data = get_init_values()
         localized_value = LocalizedValue(input_data)