Geo form - tests (refs #5386)

1 files changed, 480 insertions, 1 deletions

diff --git a/ishtar_common/tests.py b/ishtar_common/tests.py
index a7cc8361c..71bf38f28 100644
--- a/ishtar_common/tests.py
+++ b/ishtar_common/tests.py
@@ -39,7 +39,15 @@ from django.apps import apps
 from django.conf import settings
 from django.contrib.auth.models import User, Permission
 from django.contrib.contenttypes.models import ContentType
-from django.contrib.gis.geos import GEOSGeometry
+from django.contrib.gis.geos import (
+    GEOSGeometry, 
+    Point,
+    MultiPoint,
+    LineString,
+    MultiLineString,
+    Polygon,
+    MultiPolygon
+)
 from django.core.cache import cache
 from django.core.exceptions import ValidationError
 from django.core.files import File as DjangoFile
@@ -84,6 +92,7 @@ from ishtar_common.utils import (
     move_dict_data,
     rename_and_simplify_media_name,
     try_fix_file,
+    reverse_coordinates,
 )
 from ishtar_common.tasks import launch_export
 from ishtar_common import utils_secretary
@@ -2833,6 +2842,476 @@ class IshtarBasicTest(TestCase):
         self.assertEqual(town.cached_label, "Sin City - 99 (2050)")
 
 
+class GeoVectorTest(TestCase):
+    fixtures = FILE_FIXTURES
+
+    def setUp(self):
+        Operation = apps.get_model("archaeological_operations", "Operation")
+        self.username, self.password, self.user = create_superuser()
+        self.ct = ContentType.objects.get_for_model(models.GeoVectorData)
+        operation_type = models.OperationType.objects.get(txt_idx="arch_diagnostic")
+        dct = {
+            "year": 2010,
+            "operation_type_id": operation_type.pk,
+            "history_modifier": self.user,
+            "code_patriarche": 99999
+        }
+        self.operation = Operation.objects.create(**dct)
+
+        self.origin = models.GeoOriginType.objects.get(
+            txt_idx="georeferencement",
+        )
+        self.data_type = models.GeoDataType.objects.get(
+            txt_idx="operation-center",
+        )
+        self.provider = models.GeoProviderType.objects.get(
+            txt_idx="france-ign",
+        )
+        self.srs, _ = models.SpatialReferenceSystem.objects.get_or_create(
+            label="EPSG-27572",
+            txt_idx="epsg-27572",
+            srid=2154
+        )
+        self.app_source = "archaeological_operations"
+        self.model_source = "operation"
+        self.source_pk = self.operation.pk
+
+    def _test_get_create_geo(self, c, geom_type):
+        response = c.get(reverse(
+            "create-geo",
+            kwargs={
+                "app_source": self.app_source,
+                "model_source": self.model_source,
+                "source_pk": self.source_pk,
+                "geom_type": geom_type
+            }
+        ))
+        self.assertEqual(response.status_code, 200)
+        content = response.content.decode()
+        self.assertIn("id_name", content)
+        self.assertIn("id_origin", content)
+        self.assertIn("id_data_type", content)
+        self.assertIn("id_provider", content)
+        self.assertIn("id_comment", content)
+        return content
+
+    def _test_fields_geo_coordinates(self, edited_geo):
+        self.assertEqual(edited_geo.x, 1.3)
+        self.assertEqual(edited_geo.y, 3.4)
+        self.assertEqual(edited_geo.z, 4.4)
+        self.assertEqual(edited_geo.estimated_error_x, 0.1)
+        self.assertEqual(edited_geo.estimated_error_y, 0.1)
+        self.assertEqual(edited_geo.estimated_error_z, 0.1)
+        self.assertEqual(
+            edited_geo.spatial_reference_system,
+            self.srs
+        )
+
+    def _test_post_geo(self, c, geom_type, data, geo_vector=None):
+        if geo_vector:
+            response = c.post(reverse(
+                "edit-geo",
+                kwargs={
+                    "pk": geo_vector.pk,
+                }
+            ), data)
+        else:
+            response = c.post(reverse(
+                "create-geo",
+                kwargs={
+                    "app_source": self.app_source,
+                    "model_source": self.model_source,
+                    "source_pk": self.source_pk,
+                    "geom_type": geom_type
+                }
+            ), data)
+        edited_geo = models.GeoVectorData.objects.get(
+            name="Test Geo {}".format(geom_type)
+        )
+        self.assertRedirects(response, "/geo/edit/{}/".format(edited_geo.pk))
+        self.assertEqual(edited_geo.name, "Test Geo {}".format(geom_type))
+        self.assertEqual(edited_geo.origin, self.origin)
+        self.assertEqual(edited_geo.data_type, self.data_type)
+        self.assertEqual(edited_geo.provider, self.provider)
+        self.assertEqual(edited_geo.comment, "This is a comment")
+        self.assertEqual(edited_geo, self.operation.geodata.last())
+        return edited_geo
+
+    def _update_data_coordinates(self, data):
+        data.update({
+            "x": 1.3,
+            "y": 3.4,
+            "z": 4.4,
+            "estimated_error_x": 0.1,
+            "estimated_error_y": 0.1,
+            "estimated_error_z": 0.1,
+            "spatial_reference_system": self.srs.pk,
+        })
+        return data
+
+    def _init_default_data(self, geom_type):
+        data = {
+            f"related_items_{self.app_source}_{self.model_source}": self.operation.pk,
+            "name": "Test Geo {}".format(geom_type),
+            "origin": self.origin.pk,
+            "data_type": self.data_type.pk,
+            "provider": self.provider.pk,
+            "comment": "This is a comment",
+        }
+        return data
+
+    def test_create_geo_vector(self):
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        response = c.get(reverse(
+            "create-pre-geo",
+            kwargs={
+                "app_source": self.app_source,
+                "model_source": self.model_source,
+                "source_pk": self.source_pk,
+            }
+        ))
+        self.assertEqual(response.status_code, 200)
+        content = response.content.decode()
+        self.assertIn("coordinates", content)
+        self.assertIn("point_2d", content)
+        self.assertIn("point_3d", content)
+        self.assertIn("multi_points", content)
+        self.assertIn("multi_line", content)
+        self.assertIn("multi_polygon", content)
+
+    def test_create_geo_vector_coordinates(self):
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        geom_type = "coordinates"
+
+        content = self._test_get_create_geo(c, geom_type)
+        self.assertIn("id_x", content)
+        self.assertIn("id_y", content)
+        self.assertIn("id_z", content)
+        self.assertIn("id_estimated_error_x", content)
+        self.assertIn("id_estimated_error_y", content)
+        self.assertIn("id_estimated_error_z", content)
+        self.assertIn("id_spatial_reference_system", content)
+        self._test_post_create_pre_geo(c, geom_type)
+
+        data = self._init_default_data(geom_type)
+        data = self._update_data_coordinates(data)
+        edited_geo = self._test_post_geo(c, geom_type, data)
+        self._test_fields_geo_coordinates(edited_geo)
+
+    def test_create_geo_vector_point2d(self):
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        geom_type = "point_2d"
+        point_2d = Point(3.8, 3, srid=4326)
+
+        content = self._test_get_create_geo(c, geom_type)
+
+        self.assertIn("id_point_2d", content)
+        self._test_post_create_pre_geo(c, geom_type)
+        data = self._init_default_data(geom_type)
+        data.update({geom_type: reverse_coordinates(point_2d.ewkt)})
+        edited_geo = self._test_post_geo(c, geom_type, data)
+        self.assertEqual(edited_geo.point_2d.coords, point_2d.coords)
+        self.assertEqual(edited_geo.point_2d.srid, point_2d.srid)
+
+    def test_create_geo_vector_point3d(self):
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        geom_type = "point_3d"
+        point = Point(3.8, 3, 10, srid=4326)
+
+        content = self._test_get_create_geo(c, geom_type)
+        self.assertIn("id_point_3d", content)
+        self.assertIn("id_z", content)
+        self._test_post_create_pre_geo(c, geom_type)
+        data = self._init_default_data(geom_type)
+        data.update({
+            "point_3d": reverse_coordinates(point.ewkt),
+            "z": 10
+        })
+        edited_geo = self._test_post_geo(c, geom_type, data)
+        self.assertEqual(edited_geo.point_3d.coords, point.coords)
+        self.assertEqual(edited_geo.point_3d.srid, point.srid)
+        self.assertEqual(edited_geo.z, 10)
+
+    def test_create_geo_vector_multipoints(self):
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        geom_type = "multi_points"
+        points = MultiPoint(Point(3.8, 3), Point(7.8, 5), srid=4326)
+
+        content = self._test_get_create_geo(c, geom_type)
+
+        self.assertIn("id_multi_points", content)
+        self._test_post_create_pre_geo(c, geom_type)
+        data = self._init_default_data(geom_type)
+        data.update({geom_type: points.ewkt})
+        edited_geo = self._test_post_geo(c, geom_type, data)
+        self.assertEqual(
+            list(edited_geo.multi_points.coords), 
+            [tuple(reversed(t)) for t in points.coords]
+        )
+        self.assertEqual(edited_geo.multi_points.srid, 4326)
+
+    def test_create_geo_vector_multilines(self):
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        lines = MultiLineString(
+            LineString(Point(1, 1), Point(2, 2)),
+            LineString(Point(3, 3), Point(4, 4)),
+            srid=4326
+        )
+        geom_type = "multi_line"
+
+        content = self._test_get_create_geo(c, geom_type)
+
+        self.assertIn("id_multi_line", content)
+        self._test_post_create_pre_geo(c, geom_type)
+        data = self._init_default_data(geom_type)
+        data.update({geom_type: lines.ewkt})
+        edited_geo = self._test_post_geo(c, geom_type, data)
+        self.assertEqual(
+            list(edited_geo.multi_line.coords), 
+            [tuple(t[::-1] for t in tu) for tu in lines.coords]
+        )
+        self.assertEqual(edited_geo.multi_line.srid, 4326)
+
+    def test_create_geo_vector_multipolygon(self):
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        multi_polygon = MultiPolygon(
+            Polygon(((1, 1), (5, 1), (5, 5), (1, 1))),
+            Polygon(((2, 2), (2, 3), (3, 3), (2, 2))),
+            srid=4326
+        )
+        geom_type = "multi_polygon"
+
+        content = self._test_get_create_geo(c, geom_type)
+        self.assertIn("id_multi_polygon", content)
+        self._test_post_create_pre_geo(c, geom_type)
+        data = self._init_default_data(geom_type)
+        data.update({geom_type: multi_polygon.ewkt})
+        edited_geo = self._test_post_geo(c, geom_type, data)
+        self.assertEqual(
+            list(edited_geo.multi_polygon.coords),
+            [tuple(tuple(t[::-1] for t in tu) for tu in tup) for tup in multi_polygon.coords]
+        )
+        self.assertEqual(edited_geo.multi_polygon.srid, 4326)
+
+    def test_edit_geo_vector_coordinates(self):
+        c = Client()
+        c.login(username=self.username, password=self.password)
+
+        geom_type = "coordinates"
+        geo_vector = self._create_geo(geom_type)
+        geo_vector.x = 10.3
+        geo_vector.y = 32.4
+        geo_vector.z = 44.4
+        geo_vector.estimated_error_x = geo_vector.estimated_error_y = geo_vector.estimated_error_z = 2.43
+        geo_vector.spatial_reference_system = self.srs
+        geo_vector.save()
+
+        response = c.get(reverse("edit-geo", kwargs={"pk": geo_vector.pk}))
+        self.assertEqual(response.status_code, 200)
+        content = response.content.decode()
+        self._test_get_edit_geo(geo_vector, content)
+        self.assertIn(self.srs.label, content)
+        data = self._init_default_data(geom_type)
+        data = self._update_data_coordinates(data)
+        edited_geo = self._test_post_geo(c, geom_type, data, geo_vector)
+        self._test_fields_geo_coordinates(edited_geo)
+
+    def test_edit_geo_vector_point2d(self):
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        geom_type = "point_2d"
+        point_2d = Point(3.9, 3, srid=4326)
+        point_2d_for_edit = Point(6, 9.2, srid=4326)
+        geo_vector = self._create_geo(geom_type)
+        geo_vector.point_2d = point_2d
+        geo_vector.save()
+
+        response = c.get(reverse("edit-geo", kwargs={"pk": geo_vector.pk}))
+        self.assertEqual(response.status_code, 200)
+        content = response.content.decode()
+        self._test_get_edit_geo(geo_vector, content)
+        data = self._init_default_data(geom_type)
+        data.update({geom_type: point_2d_for_edit.ewkt})
+        edited_geo = self._test_post_geo(c, geom_type, data, geo_vector)
+        # Old version of django reverse coordinates
+        self.assertEqual(edited_geo.point_2d.coords, point_2d_for_edit.coords[::-1])
+        self.assertEqual(edited_geo.point_2d.srid, point_2d_for_edit.srid)
+
+    def test_edit_geo_vector_point3d(self):
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        geom_type = "point_3d"
+        point_3d = Point(3.9, 3, -40, srid=4326)
+        point_for_edit = Point(6, 9.2, 20, srid=4326)
+        geo_vector = self._create_geo(geom_type)
+        geo_vector.point_3d = point_3d
+        geo_vector.z = -40
+        geo_vector.save()
+
+        response = c.get(reverse("edit-geo", kwargs={"pk": geo_vector.pk}))
+        self.assertEqual(response.status_code, 200)
+        content = response.content.decode()
+        self._test_get_edit_geo(geo_vector, content)
+        data = self._init_default_data(geom_type)
+        data.update({"z": 20})
+        data.update({geom_type: reverse_coordinates(point_for_edit.ewkt)})
+        edited_geo = self._test_post_geo(c, geom_type, data, geo_vector)
+        # Old version of django reverse coordinates
+        self.assertEqual(edited_geo.point_3d.coords, point_for_edit.coords)
+        self.assertEqual(edited_geo.point_3d.srid, point_for_edit.srid)
+        self.assertEqual(edited_geo.z, 20)
+
+    def test_edit_geo_vector_multipoints(self):
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        geom_type = "multi_points"
+        points = MultiPoint(Point(34.9, 20.2), Point(64.2, 58.21), srid=4326)
+        points_edit = MultiPoint(Point(3.8, 3), Point(7.8, 5), srid=4326)
+        geo_vector = self._create_geo(geom_type)
+        geo_vector.multi_points = points
+        geo_vector.save()
+
+        response = c.get(reverse("edit-geo", kwargs={"pk": geo_vector.pk}))
+        self.assertEqual(response.status_code, 200)
+        content = response.content.decode()
+        self._test_get_edit_geo(geo_vector, content)
+        data = self._init_default_data(geom_type)
+        data.update({geom_type: points_edit.ewkt})
+        edited_geo = self._test_post_geo(c, geom_type, data, geo_vector)
+        # Old version of django reverse coordinates
+        self.assertEqual(
+            list(edited_geo.multi_points.coords), 
+            [tuple(reversed(t)) for t in points_edit.coords]
+        )
+        self.assertEqual(edited_geo.multi_points.srid, 4326)
+
+    def test_edit_geo_vector_multilines(self):
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        geom_type = "multi_line"
+        lines = MultiLineString(
+            LineString(Point(4, 5), Point(5, 10)),
+            LineString(Point(10, 49), Point(40, 1)),
+            srid=4326
+        )
+        lines_edit = MultiLineString(
+            LineString(Point(3, 2), Point(1, 2)),
+            LineString(Point(4, 5), Point(6, 7)),
+            srid=4326
+        )
+        geo_vector = self._create_geo(geom_type)
+        geo_vector.multi_line = lines
+        geo_vector.save()
+
+        response = c.get(reverse("edit-geo", kwargs={"pk": geo_vector.pk}))
+        self.assertEqual(response.status_code, 200)
+        content = response.content.decode()
+        self._test_get_edit_geo(geo_vector, content)
+        data = self._init_default_data(geom_type)
+        data.update({geom_type: lines_edit.ewkt})
+        edited_geo = self._test_post_geo(c, geom_type, data, geo_vector)
+        # Old version of django reverse coordinates
+        self.assertEqual(
+            list(edited_geo.multi_line.coords), 
+            [tuple(t[::-1] for t in tu) for tu in lines_edit.coords]
+        )
+        self.assertEqual(edited_geo.multi_line.srid, 4326)
+
+    def test_edit_geo_vector_multipolygon(self):
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        geom_type = "multi_polygon"
+        multi_polygon = MultiPolygon(
+            Polygon(((0, 0), (0, 1), (1, 1), (0, 0))),
+            Polygon(((1, 1), (1, 2), (2, 2), (1, 1))),
+            srid=4326
+        )
+        multi_polygon_edit = MultiPolygon(
+            Polygon(((1, 1), (5, 1), (5, 5), (1, 1))),
+            Polygon(((2, 2), (2, 3), (3, 3), (2, 2))),
+            srid=4326
+        )
+        geo_vector = self._create_geo(geom_type)
+        geo_vector.multi_polygon = multi_polygon
+        geo_vector.save()
+        
+        response = c.get(reverse("edit-geo", kwargs={"pk": geo_vector.pk}))
+        self.assertEqual(response.status_code, 200)
+        content = response.content.decode()
+        self._test_get_edit_geo(geo_vector, content)
+        data = self._init_default_data(geom_type)
+        data.update({geom_type: multi_polygon_edit.ewkt})
+        edited_geo = self._test_post_geo(c, geom_type, data, geo_vector)
+        # Old version of django reverse coordinates
+        self.assertEqual(
+            list(edited_geo.multi_polygon.coords),
+            [tuple(tuple(t[::-1] for t in tu) for tu in tup) for tup in multi_polygon_edit.coords]
+        )
+        self.assertEqual(edited_geo.multi_polygon.srid, 4326)
+
+    def _test_get_edit_geo(self, geo_vector, content):
+        geo_vector_dict = geo_vector.__dict__
+
+        self.assertIn(self.operation.name, content)
+        for field in geo_vector_dict:
+            val = geo_vector_dict[field]
+            if (
+                # Exclude fields not in form
+                # Must be careful if GeoVectorData models is modified
+                # and important boolean fields are added
+                val is not None and
+                type(val) is not bool and
+                field.startswith(("_", "id", "cached")) == False and
+                field.endswith("_id") == False
+            ):
+                self.assertIn(f"id_{field}", content)
+                if isinstance(val, GEOSGeometry):
+                    # TODO: need to know how osmwidget convert coordinates
+                    self.assertIn(str(val.srid), content)
+                else:
+                    self.assertIn(str(val), content)
+
+    def _create_geo(self, geom_type):
+        geo_vector = models.GeoVectorData.objects.create(
+            source_content_type_id=self.source_pk,
+            source_id=self.source_pk,
+            name=f"Before edition geo {geom_type}",
+            origin=self.origin,
+            data_type=self.data_type,
+            provider=self.provider,
+            comment="This is a comment not edited."
+        )
+        return geo_vector
+
+    def _test_post_create_pre_geo(self, c, geom_type):
+        data_pre_geo = {"geom_type": geom_type}
+        response = c.post(reverse(
+            "create-pre-geo",
+            kwargs={
+                "app_source": self.app_source,
+                "model_source": self.model_source,
+                "source_pk": self.source_pk,
+            }
+        ), data_pre_geo)
+
+        self.assertRedirects(
+            response,
+            "/geo/create/{}/{}/{}/{}/".format(
+                self.app_source,
+                self.model_source,
+                self.source_pk,
+                geom_type
+            )
+        )
+
+
 class NewItems(TestCase):
     fixtures = COMMON_FIXTURES