Serialization: manage medias, manage model order (serialization and restore), serialize conf

1 files changed, 64 insertions, 8 deletions

diff --git a/ishtar_common/tests.py b/ishtar_common/tests.py
index 7e1948bf0..0e3832e24 100644
--- a/ishtar_common/tests.py
+++ b/ishtar_common/tests.py
@@ -37,6 +37,7 @@ from django.contrib.contenttypes.models import ContentType
 from django.core.cache import cache
 from django.core.exceptions import ValidationError
 from django.core.files import File as DjangoFile
+from django.core.files.uploadedfile import SimpleUploadedFile
 from django.core.management import call_command
 from django.core.urlresolvers import reverse
 from django.db.models.fields import BooleanField
@@ -50,8 +51,8 @@ from ishtar_common import models
 from ishtar_common import views
 from ishtar_common.apps import admin_site
 from ishtar_common.serializers import type_serialization, \
-    SERIALIZATION_VERSION, get_model_from_filename, serialization_info, \
-    restore_serialized
+    SERIALIZATION_VERSION, serialization_info, \
+    restore_serialized, conf_serialization, CONF_MODEL_LIST
 from ishtar_common.utils import post_save_geo, update_data, move_dict_data, \
     rename_and_simplify_media_name, try_fix_file
 
@@ -598,22 +599,58 @@ class CacheTest(TestCase):
 class SerializationTest(TestCase):
     fixtures = COMMON_FIXTURES + WAREHOUSE_FIXTURES
 
-    def test_type_serialization(self):
-        json_result = type_serialization()
-        for k in json_result.keys():
+    def generic_serialization_test(self, serialize):
+        json_result = serialize()
+        for key in json_result.keys():
+            __, k = key
             module_name, model_name = k.split("__")
             module = importlib.import_module(module_name + ".models")
             model = getattr(module, model_name)
             current_count = model.objects.count()
-            serialization_count = len(json.loads(json_result[k]))
+            serialization_count = len(json.loads(json_result[key]))
             # has to be at least equal (can be superior for model with
-            # recursivity)
+            # recursion)
             self.assertTrue(
                 serialization_count >= current_count,
                 msg="Serialization for model {}.{} failed. {} serialized {} "
                     "expected".format(module.__name__, model_name,
                                       serialization_count, current_count))
 
+    def test_type_serialization(self):
+        self.generic_serialization_test(type_serialization)
+
+    def create_default_conf(self):
+        values = {}
+        models.get_current_profile()  # create a default profile
+        models.GlobalVar.objects.create(slug="test")
+        cform = models.CustomForm.objects.create(
+            name="Test", form='ishtar_common.forms.TestForm')
+        models.ExcludedField.objects.create(custom_form=cform,
+                                            field="ExcludedField")
+        CT = ContentType.objects.get_for_model(models.OrganizationType)
+        models.JsonDataSection.objects.create(
+            content_type=CT,
+            name="Test",
+        )
+        JF = models.JsonDataField.objects.create(
+            name="Test", content_type=CT, key="test"
+        )
+        models.CustomFormJsonField.objects.create(
+            custom_form=cform, json_field=JF, label="test"
+        )
+        mod = models.ImporterModel.objects.get(
+            klass="ishtar_common.models.Organization"
+        )
+        values["document_template"] = models.DocumentTemplate.objects.create(
+            name="Test", slug="test", associated_model=mod,
+            template=SimpleUploadedFile('test.txt', b'no real content')
+        )
+        return values
+
+    def test_conf_serialization(self):
+        self.create_default_conf()
+        self.generic_serialization_test(conf_serialization)
+
     def test_serialization_zip(self):
         zip_filename = type_serialization(archive=True)
         # only check the validity of the zip, the type content is tested above
@@ -633,7 +670,6 @@ class SerializationTest(TestCase):
                     info = serialization_info()
                     info["serialize-version"] = "-42"
                     json_file.write(json.dumps(info, indent=2))
-
                 zip_file.write(filename, arcname=base_filename)
         with self.assertRaises(ValueError):
             restore_serialized(zip_filename)
@@ -677,6 +713,26 @@ class SerializationTest(TestCase):
         self.assertTrue(OperationRT.objects.filter(
             inverse_relation__isnull=False).count())
 
+    def test_conf_restore(self):
+        values = self.create_default_conf()
+        current_number = {}
+        for model in CONF_MODEL_LIST:
+            current_number[model.__name__] = model.objects.count()
+        zip_filename = conf_serialization(archive=True)
+        os.remove(values["document_template"].template.path)
+
+        restore_serialized(zip_filename, delete_existing=True)
+        for model in CONF_MODEL_LIST:
+            previous_nb = current_number[model.__name__]
+            current_nb = model.objects.count()
+            self.assertEqual(
+                previous_nb, current_nb,
+                msg="Restore for model {} failed. Initial: {}, restored: "
+                    "{}.".format(model.__name__, previous_nb, current_nb))
+        self.assertTrue(
+            os.path.isfile(values["document_template"].template.path)
+        )
+
 
 class AccessControlTest(TestCase):
     def test_administrator(self):