Merge pull request #29 from MELScience/required

Improved functionality of required parameter

tests/test_field.py

@@ -9,11 +9,31 @@ from localized_fields.forms import LocalizedFieldForm
 from localized_fields.value import LocalizedValue
 
 from .data import get_init_values
+from .fake_model import get_fake_model
 
 
 class LocalizedFieldTestCase(TestCase):
     """Tests the :see:LocalizedField class."""
 
+    @staticmethod
+    def test_init():
+        """Tests whether the :see:__init__ function
+        correctly handles parameters"""
+
+        field = LocalizedField(blank=True)
+        assert field.required == []
+
+        field = LocalizedField(blank=False)
+        assert field.required == [settings.LANGUAGE_CODE]
+
+        field = LocalizedField(required=True)
+        assert field.required == [lang_code for lang_code, _ in
+                                  settings.LANGUAGES]
+
+        field = LocalizedField(required=False)
+        assert field.required == []
+
+
     @staticmethod
     def test_from_db_value():
         """Tests whether the :see:from_db_value function
@@ -156,3 +176,90 @@ class LocalizedFieldTestCase(TestCase):
             LocalizedField().formfield(),
             LocalizedFieldForm
         )
+
+        # case optional filling
+        field = LocalizedField(blank=True, required=[])
+        assert not field.formfield().required
+        for field in field.formfield().fields:
+            assert not field.required
+
+        # case required for any language
+        field = LocalizedField(blank=False, required=[])
+        assert field.formfield().required
+        for field in field.formfield().fields:
+            assert not field.required
+
+        # case required for specific languages
+        required_langs = ['ro', 'nl']
+        field = LocalizedField(blank=False, required=required_langs)
+        assert field.formfield().required
+        for field in field.formfield().fields:
+            if field.label in required_langs:
+                assert field.required
+            else:
+                assert not field.required
+
+        # case required for all languages
+        field = LocalizedField(blank=False, required=True)
+        assert field.formfield().required
+        for field in field.formfield().fields:
+            assert field.required
+
+    def test_required_all(self):
+        """Tests whether passing required=True properly validates
+        that all languages are filled in."""
+
+        model = get_fake_model(dict(
+            title=LocalizedField(required=True)
+        ))
+
+        with self.assertRaises(IntegrityError):
+            model.objects.create(title=dict(ro='romanian', nl='dutch'))
+
+        with self.assertRaises(IntegrityError):
+            model.objects.create(title=dict(nl='dutch'))
+
+        with self.assertRaises(IntegrityError):
+            model.objects.create(title=dict(random='random'))
+
+        with self.assertRaises(IntegrityError):
+            model.objects.create(title=dict())
+
+        with self.assertRaises(IntegrityError):
+            model.objects.create(title=None)
+
+        with self.assertRaises(IntegrityError):
+            model.objects.create(title='')
+
+        with self.assertRaises(IntegrityError):
+            model.objects.create(title='         ')
+
+    def test_required_some(self):
+        """Tests whether passing an array to required,
+        properly validates whether the specified languages
+        are marked as required."""
+
+        model = get_fake_model(dict(
+            title=LocalizedField(required=['nl', 'ro'])
+        ))
+
+        with self.assertRaises(IntegrityError):
+            model.objects.create(title=dict(ro='romanian', nl='dutch'))
+
+        with self.assertRaises(IntegrityError):
+            model.objects.create(title=dict(nl='dutch'))
+
+        with self.assertRaises(IntegrityError):
+            model.objects.create(title=dict(random='random'))
+
+        with self.assertRaises(IntegrityError):
+            model.objects.create(title=dict())
+
+        with self.assertRaises(IntegrityError):
+            model.objects.create(title=None)
+
+        with self.assertRaises(IntegrityError):
+            model.objects.create(title='')
+
+        with self.assertRaises(IntegrityError):
+            model.objects.create(title='         ')

tests/test_file_field.py

@@ -72,7 +72,7 @@ class LocalizedFileFieldTestCase(TestCase):
 
     @classmethod
     def test_save_form_data(cls):
-        """Tests whether the :see:save_form_data function correctly set 
+        """Tests whether the :see:save_form_data function correctly set
         a valid value."""
 
         instance = cls.FileFieldModel()
@@ -87,7 +87,7 @@ class LocalizedFileFieldTestCase(TestCase):
         instance = cls.FileFieldModel()
         instance.file = {'en': ContentFile("test", "testfilename")}
         instance._meta.get_field('file').pre_save(instance, False)
-        assert instance.file.en._committed == True
+        assert instance.file.en._committed is True
 
     @classmethod
     def test_file_methods(cls):
@@ -135,17 +135,17 @@ class LocalizedFileFieldTestCase(TestCase):
 
     @staticmethod
     def test_get_prep_value():
-        """Tests whether the :see:get_prep_value function returns correctly 
+        """Tests whether the :see:get_prep_value function returns correctly
         value."""
 
         value = LocalizedValue({'en': None})
-        assert LocalizedFileField().get_prep_value(None) == None
+        assert LocalizedFileField().get_prep_value(None) is None
         assert isinstance(LocalizedFileField().get_prep_value(value), dict)
         assert LocalizedFileField().get_prep_value(value)['en'] == ''
 
     @staticmethod
     def test_formfield():
-        """Tests whether the :see:formfield function correctly returns 
+        """Tests whether the :see:formfield function correctly returns
         a valid form."""
 
         form_field = LocalizedFileField().formfield()
@@ -161,6 +161,5 @@ class LocalizedFileFieldTestCase(TestCase):
         name, path, args, kwargs = LocalizedFileField().deconstruct()
         assert 'upload_to' in kwargs
         assert 'storage' not in kwargs
-        name, path, \
-        args, kwargs = LocalizedFileField(storage='test').deconstruct()
+        name, path, args, kwargs = LocalizedFileField(storage='test').deconstruct()
         assert 'storage' in kwargs

tests/test_file_field_form.py

@@ -28,7 +28,7 @@ class LocalizedFileFieldFormTestCase(TestCase):
         formfield.clean(['', ''], ['', ''])
 
     def test_bound_data(self):
-        """Tests whether the :see:bound_data function is returns correctly 
+        """Tests whether the :see:bound_data function is returns correctly
         value"""
 
         formfield = LocalizedFileFieldForm()
@@ -38,4 +38,3 @@ class LocalizedFileFieldFormTestCase(TestCase):
         value = [None] * len(settings.LANGUAGES)
         expected_value = [''] * len(settings.LANGUAGES)
         assert formfield.bound_data(value, initial) == expected_value
-

tests/test_form.py

@@ -11,8 +11,8 @@ class LocalizedFieldFormTestCase(TestCase):
     def test_init():
         """Tests whether the constructor correctly
         creates a field for every language."""
-
-        form = LocalizedFieldForm()
+        # case required for specific language
+        form = LocalizedFieldForm(required=[settings.LANGUAGE_CODE])
 
         for (lang_code, _), field in zip(settings.LANGUAGES, form.fields):
             assert field.label == lang_code
@@ -22,6 +22,25 @@ class LocalizedFieldFormTestCase(TestCase):
             else:
                 assert not field.required
 
+        # case required for all languages
+        form = LocalizedFieldForm(required=True)
+        assert form.required
+        for field in form.fields:
+            assert field.required
+
+        # case optional filling
+        form = LocalizedFieldForm(required=False)
+        assert not form.required
+        for field in form.fields:
+            assert not field.required
+
+        # case required for any language
+        form = LocalizedFieldForm(required=[])
+        assert form.required
+        for field in form.fields:
+            assert not field.required
+
+
     @staticmethod
     def test_compress():
         """Tests whether the :see:compress function

tests/test_slug_fields.py

@@ -124,7 +124,7 @@ class LocalizedSlugFieldTestCase(TestCase):
         def generate_slug(instance):
             return instance.title
 
-        model = get_fake_model({
+        get_fake_model({
             'title': LocalizedField(),
             'slug': LocalizedUniqueSlugField(populate_from=generate_slug)
         })
@@ -138,7 +138,6 @@ class LocalizedSlugFieldTestCase(TestCase):
         for lang_code, lang_name in settings.LANGUAGES:
             assert obj.slug.get(lang_code) == 'title-%s' % lang_name.lower()
 
-
     @staticmethod
     def test_populate_multiple_from_fields():
         """Tests whether populating the slug from multiple

tests/test_value.py

@@ -149,8 +149,6 @@ class LocalizedValueTestCase(TestCase):
         __str__'s fallback functionality properly respects
         the LOCALIZED_FIELDS_FALLBACKS setting."""
 
-        test_value = 'myvalue'
-
         settings.LOCALIZED_FIELDS_FALLBACKS = {
             'nl': ['ro']
         }