added test for LocalizedFileField and LocalizedFileFieldForm

tests/test_localized_file_field.py

@@ -0,0 +1,151 @@
+import os
+import shutil
+import tempfile as sys_tempfile
+import pickle
+
+from django import forms
+from django.test import TestCase, override_settings
+from django.core.files.base import File, ContentFile
+from django.core.files import temp as tempfile
+from localized_fields import LocalizedFileField, LocalizedValue
+from localized_fields.fields.localized_file_field import LocalizedFieldFile
+from localized_fields.forms import LocalizedFileFieldForm
+from localized_fields.localized_value import LocalizedFileValue
+from localized_fields.widgets import LocalizedFileWidget
+from .fake_model import get_fake_model
+
+
+MEDIA_ROOT = sys_tempfile.mkdtemp()
+
+
+@override_settings(MEDIA_ROOT=MEDIA_ROOT)
+class LocalizedFileFieldTestCase(TestCase):
+    """Tests the localized slug classes."""
+
+    @classmethod
+    def setUpClass(cls):
+        """Creates the test models in the database."""
+
+        super().setUpClass()
+
+        cls.FileFieldModel = get_fake_model(
+            'LocalizedFileFieldTestModel',
+            {
+                'file': LocalizedFileField(),
+            }
+        )
+        if not os.path.isdir(MEDIA_ROOT):
+            os.makedirs(MEDIA_ROOT)
+
+    @classmethod
+    def tearDownClass(cls):
+        super().tearDownClass()
+        shutil.rmtree(MEDIA_ROOT)
+
+    @classmethod
+    def test_assign(cls):
+        """Tests whether the :see:LocalizedFileValueDescriptor works properly"""
+
+        temp_file = tempfile.NamedTemporaryFile(dir=MEDIA_ROOT)
+        instance = cls.FileFieldModel()
+        instance.file = {'en': temp_file.name}
+        assert isinstance(instance.file.en, LocalizedFieldFile)
+        assert instance.file.en.name == temp_file.name
+
+        field_dump = pickle.dumps(instance.file)
+        instance = cls.FileFieldModel()
+        instance.file = pickle.loads(field_dump)
+        assert instance.file.en.field == instance._meta.get_field('file')
+        assert instance.file.en.instance == instance
+        assert isinstance(instance.file.en, LocalizedFieldFile)
+
+        instance = cls.FileFieldModel()
+        instance.file = {'en': ContentFile("test", "testfilename")}
+        assert isinstance(instance.file.en, LocalizedFieldFile)
+        assert instance.file.en.name == "testfilename"
+
+        another_instance = cls.FileFieldModel()
+        another_instance.file = {'ro': instance.file.en}
+        assert another_instance == another_instance.file.ro.instance
+        assert another_instance.file.ro.lang == 'ro'
+
+    @classmethod
+    def test_save_form_data(cls):
+        """Tests whether the :see:save_form_data function correctly set 
+        a valid value."""
+
+        instance = cls.FileFieldModel()
+        data = LocalizedFileValue({'en': False})
+        instance._meta.get_field('file').save_form_data(instance, data)
+        assert instance.file.en == ''
+
+    @classmethod
+    def test_pre_save(cls):
+        """Tests whether the :see:pre_save function works properly."""
+
+        instance = cls.FileFieldModel()
+        instance.file = {'en': ContentFile("test", "testfilename")}
+        instance._meta.get_field('file').pre_save(instance, False)
+        assert instance.file.en._committed == True
+
+    @classmethod
+    def test_file_methods(cls):
+        """Tests whether the :see:LocalizedFieldFile.delete method works
+        correctly."""
+
+        temp_file = File(tempfile.NamedTemporaryFile())
+        instance = cls.FileFieldModel()
+        # Calling delete on an unset FileField should not call the file deletion
+        # process, but fail silently
+        instance.file.en.delete()
+        instance.file.en.save('testfilename', temp_file)
+        assert instance.file.en.name == 'testfilename'
+        instance.file.en.delete()
+        assert instance.file.en.name is None
+
+    @classmethod
+    def test_generate_filename(cls):
+        """Tests whether the :see:LocalizedFieldFile.generate_filename method
+        works correctly."""
+
+        instance = cls.FileFieldModel()
+        field = instance._meta.get_field('file')
+        field.upload_to = '{lang}/'
+        filename = field.generate_filename(instance, 'test', 'en')
+        assert filename == 'en/test'
+        field.upload_to = lambda instance, filename, lang: \
+            '%s_%s' % (lang, filename)
+        filename = field.generate_filename(instance, 'test', 'en')
+        assert filename == 'en_test'
+
+    @staticmethod
+    def test_get_prep_value():
+        """Tests whether the :see:get_prep_value function returns correctly 
+        value."""
+
+        value = LocalizedValue({'en': None})
+        assert LocalizedFileField().get_prep_value(None) == 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 
+        a valid form."""
+
+        form_field = LocalizedFileField().formfield()
+        assert isinstance(form_field, LocalizedFileFieldForm)
+        assert isinstance(form_field, forms.FileField)
+        assert isinstance(form_field.widget, LocalizedFileWidget)
+
+    @staticmethod
+    def test_deconstruct():
+        """Tests whether the :see:LocalizedFileField
+        class's :see:deconstruct function works properly."""
+
+        name, path, args, kwargs = LocalizedFileField().deconstruct()
+        assert 'upload_to' in kwargs
+        assert 'storage' not in kwargs
+        name, path, \
+        args, kwargs = LocalizedFileField(storage='test').deconstruct()
+        assert 'storage' in kwargs

tests/test_localized_file_field_form.py

@@ -0,0 +1,41 @@
+from django.conf import settings
+from django.core.exceptions import ValidationError
+from django.forms.widgets import FILE_INPUT_CONTRADICTION
+from django.test import TestCase
+
+from localized_fields.forms import LocalizedFileFieldForm
+
+
+class LocalizedFileFieldFormTestCase(TestCase):
+    """Tests the workings of the :see:LocalizedFileFieldForm class."""
+
+    def test_clean(self):
+        """Tests whether the :see:clean function is working properly."""
+
+        formfield = LocalizedFileFieldForm(required=True)
+        with self.assertRaises(ValidationError):
+            formfield.clean([])
+        with self.assertRaises(ValidationError):
+            formfield.clean([], {'en': None})
+        with self.assertRaises(ValidationError):
+            formfield.clean("badvalue")
+        with self.assertRaises(ValidationError):
+            value = [FILE_INPUT_CONTRADICTION] * len(settings.LANGUAGES)
+            formfield.clean(value)
+
+        formfield = LocalizedFileFieldForm(required=False)
+        formfield.clean([''] * len(settings.LANGUAGES))
+        formfield.clean(['', ''], ['', ''])
+
+    def test_bound_data(self):
+        """Tests whether the :see:bound_data function is returns correctly 
+        value"""
+
+        formfield = LocalizedFileFieldForm()
+        assert formfield.bound_data([''], None) == ['']
+
+        initial = dict([(lang, '') for lang, _ in settings.LANGUAGES])
+        value = [None] * len(settings.LANGUAGES)
+        expected_value = [''] * len(settings.LANGUAGES)
+        assert formfield.bound_data(value, initial) == expected_value
+