Serialization: manage documenst (with filters) - refactoring

1 files changed, 206 insertions, 2 deletions

diff --git a/ishtar_common/tests.py b/ishtar_common/tests.py
index 5fbc8b875..96737c765 100644
--- a/ishtar_common/tests.py
+++ b/ishtar_common/tests.py
@@ -51,10 +51,12 @@ 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, serialization_info, \
+    SERIALIZATION_VERSION, \
     restore_serialized, conf_serialization, CONF_MODEL_LIST, \
     importer_serialization, IMPORT_MODEL_LIST, geo_serialization, \
-    GEO_MODEL_LIST, directory_serialization, DIRECTORY_MODEL_LIST
+    GEO_MODEL_LIST, directory_serialization, DIRECTORY_MODEL_LIST, \
+    document_serialization
+from ishtar_common.serializers_utils import serialization_info
 from ishtar_common.utils import post_save_geo, update_data, move_dict_data, \
     rename_and_simplify_media_name, try_fix_file
 
@@ -599,6 +601,19 @@ class CacheTest(TestCase):
 
 
 class GenericSerializationTest:
+    def create_document_default(self):
+        image_path = os.path.join(settings.ROOT_PATH, "..", "ishtar_common",
+                                  "tests", "test.png")
+        self.documents = []
+        for idx in range(12):
+            self.documents.append(models.Document.objects.create(
+                title="Test{}".format(idx),
+                associated_file=SimpleUploadedFile(
+                    'test.txt', b'no real content'),
+                image=SimpleUploadedFile(
+                    name='test.png', content=open(image_path, 'rb').read(),
+                    content_type='image/png')))
+
     def generic_serialization_test(self, serialize, no_test=False, kwargs=None):
         if not kwargs:
             kwargs = {}
@@ -748,6 +763,188 @@ class SerializationTest(GenericSerializationTest, TestCase):
         self.create_directory_default()
         self.generic_serialization_test(directory_serialization)
 
+    def create_document_default(self):
+        super(SerializationTest, self).create_document_default()
+        from archaeological_operations.models import Operation, \
+            ArchaeologicalSite, OperationType
+        from archaeological_context_records.models import ContextRecord
+        from archaeological_finds.models import Find, BaseFind
+        from archaeological_warehouse.models import Warehouse, Container, \
+            ContainerLocalisation, WarehouseDivision, WarehouseDivisionLink, \
+            WarehouseType, ContainerType
+
+        operation_type = OperationType.objects.all()[0]
+        dct = {'year': 2010, 'operation_type_id': operation_type.pk,
+               "code_patriarche": "66666"}
+        operation1 = Operation.objects.create(**dct)
+        operation1.documents.add(self.documents[0])
+        dct["code_patriarche"] = "66667"
+        operation2 = Operation.objects.create(**dct)
+        operation2.documents.add(self.documents[1])
+
+        site1 = ArchaeologicalSite.objects.create(reference="3333", name="test")
+        operation1.archaeological_sites.add(site1)
+        site1.documents.add(self.documents[2])
+        site2 = ArchaeologicalSite.objects.create(reference="444", name="test2")
+        operation2.archaeological_sites.add(site2)
+        site2.documents.add(self.documents[3])
+
+        dct = {'label': "Context record1", "operation": operation1}
+        cr1 = ContextRecord.objects.create(**dct)
+        cr1.documents.add(self.documents[4])
+        dct = {'label': "Context record2", "operation": operation2}
+        cr2 = ContextRecord.objects.create(**dct)
+        cr2.documents.add(self.documents[5])
+
+        dct = {'label': "Base find", "context_record": cr1}
+        base_find1 = BaseFind.objects.create(**dct)
+        dct = {'label': "Base find2", "context_record": cr2}
+        base_find2 = BaseFind.objects.create(**dct)
+
+        dct = {'label': "Find1"}
+        find1 = Find.objects.create(**dct)
+        find1.documents.add(self.documents[6])
+        find1.base_finds.add(base_find1)
+        dct = {'label': "Find2"}
+        find2 = Find.objects.create(**dct)
+        find2.documents.add(self.documents[7])
+        find2.base_finds.add(base_find2)
+
+        w1 = Warehouse.objects.create(
+            name="Test1",
+            external_id="test",
+            warehouse_type=WarehouseType.objects.all()[0],
+        )
+        w1.documents.add(self.documents[8])
+        w2 = Warehouse.objects.create(
+            name="Test2",
+            external_id="test2",
+            warehouse_type=WarehouseType.objects.all()[0],
+        )
+        w2.documents.add(self.documents[9])
+        self.warehouses = [w1, w2]
+        c1 = Container.objects.create(
+            location=w1,
+            responsible=w1,
+            container_type=ContainerType.objects.all()[0],
+            reference="Réf1",
+            index=1,
+            external_id="ref1-1"
+        )
+        c1.documents.add(self.documents[10])
+        c2 = Container.objects.create(
+            location=w2,
+            responsible=w2,
+            container_type=ContainerType.objects.all()[0],
+            reference="Réf2",
+            index=2,
+            external_id="ref2-2"
+        )
+        c2.documents.add(self.documents[11])
+        find1.container = c1
+        find1.container_ref = c1
+        find1.save()
+        find2.container = c2
+        find2.container_ref = c2
+        find2.save()
+        wd1 = WarehouseDivision.objects.create(
+            label="Étagère", txt_idx="etagere"
+        )
+        wd2 = WarehouseDivision.objects.create(
+            label="Allée", txt_idx="allee"
+        )
+        wl1 = WarehouseDivisionLink.objects.create(
+            warehouse=w1,
+            division=wd1
+        )
+        wl2 = WarehouseDivisionLink.objects.create(
+            warehouse=w2,
+            division=wd2
+        )
+        ContainerLocalisation.objects.create(
+            container=c1,
+            division=wl1,
+            reference="A1"
+        )
+        ContainerLocalisation.objects.create(
+            container=c2,
+            division=wl2,
+            reference="A2"
+        )
+
+    def test_base_document_serialization(self):
+        self.create_document_default()
+        self.generic_serialization_test(document_serialization)
+
+    def test_document_serialization(self):
+        self.create_document_default()
+        res = self.generic_serialization_test(
+            document_serialization)
+        docs = json.loads(
+            res[('documents', 'ishtar_common__Document')]
+        )
+        self.assertEqual(len(docs), 12)
+
+        from archaeological_operations.models import Operation, \
+            ArchaeologicalSite
+        result_queryset = Operation.objects.filter(
+            code_patriarche="66666")
+        res = self.generic_serialization_test(
+            document_serialization, no_test=True,
+            kwargs={"operation_queryset": result_queryset}
+        )
+        docs = json.loads(
+            res[('documents', 'ishtar_common__Document')]
+        )
+        self.assertEqual(len(docs), 6)
+
+        result_queryset = ArchaeologicalSite.objects.filter(
+            id=ArchaeologicalSite.objects.all()[0].id)
+        res = self.generic_serialization_test(
+            document_serialization, no_test=True,
+            kwargs={"site_queryset": result_queryset}
+        )
+        docs = json.loads(
+            res[('documents', 'ishtar_common__Document')]
+        )
+        self.assertEqual(len(docs), 6)
+
+        from archaeological_context_records.models import ContextRecord
+        result_queryset = ContextRecord.objects.filter(
+            id=ContextRecord.objects.all()[0].id)
+        res = self.generic_serialization_test(
+            document_serialization, no_test=True,
+            kwargs={"cr_queryset": result_queryset}
+        )
+        docs = json.loads(
+            res[('documents', 'ishtar_common__Document')]
+        )
+        self.assertEqual(len(docs), 6)
+
+        from archaeological_finds.models import Find
+        result_queryset = Find.objects.filter(
+            id=Find.objects.all()[0].id)
+        res = self.generic_serialization_test(
+            document_serialization, no_test=True,
+            kwargs={"find_queryset": result_queryset}
+        )
+        docs = json.loads(
+            res[('documents', 'ishtar_common__Document')]
+        )
+        self.assertEqual(len(docs), 6)
+
+        from archaeological_warehouse.models import Warehouse
+        result_queryset = Warehouse.objects.filter(
+            id=Warehouse.objects.all()[0].id)
+        res = self.generic_serialization_test(
+            document_serialization, no_test=True,
+            kwargs={"warehouse_queryset": result_queryset}
+        )
+        docs = json.loads(
+            res[('documents', 'ishtar_common__Document')]
+        )
+        self.assertEqual(len(docs), 6)
+
     def test_serialization_zip(self):
         zip_filename = type_serialization(archive=True)
         # only check the validity of the zip, the type content is tested above
@@ -845,6 +1042,13 @@ class SerializationTest(GenericSerializationTest, TestCase):
         self.generic_restore_test(zip_filename, current_number,
                                   DIRECTORY_MODEL_LIST)
 
+    def test_document_restore(self):
+        self.create_document_default()
+        current_number, zip_filename = self.generic_restore_test_genzip(
+            [models.Document], document_serialization)
+        self.generic_restore_test(zip_filename, current_number,
+                                  [models.Document])
+
 
 class AccessControlTest(TestCase):
     def test_administrator(self):