get_geo_items for operations and tests

1 files changed, 238 insertions, 124 deletions

diff --git a/archaeological_finds/tests.py b/archaeological_finds/tests.py
index b04fa085a..ddb362fd4 100644
--- a/archaeological_finds/tests.py
+++ b/archaeological_finds/tests.py
@@ -2521,25 +2521,74 @@ class GeomaticTest(FindInit, TestCase):
         self.assertEqual(base_find.point_source, "P")
 
     def test_get_geo_items(self):
+        wgs84 = SpatialReferenceSystem.objects.get(srid=4326)
         profile = get_current_profile()
         profile.mapping = True
         profile.save()
-
-        find = self.finds[0]
-        base_find_pt = find.base_finds.all()[0]
-        srs, __ = SpatialReferenceSystem.objects.get_or_create(
-            txt_idx="wgs84",
-            defaults={"srid": 4326, "label": "WGS84", "auth_name": "EPSG"},
+        base_find = models.BaseFind.objects.all()[0]
+        context_record = ContextRecord.objects.get(pk=base_find.context_record.pk)
+        operation = self.create_operation()[0]
+        ope = self.create_operation()[1]
+        limit = (
+            "MULTIPOLYGON(((1 1,5 1,5 5,1 5,1 1),(2 2,2 3,3 3,3 2,2 2)),"
+            "((6 3,9 2,9 4,6 3)))"
         )
-
-        base_find_pt = models.BaseFind.objects.get(pk=base_find_pt.pk)
+        geom = GEOSGeometry("POINT({} {} {})".format(2, 43, 1), srid=4326)
+        geom_2d = GEOSGeometry("POINT({} {})".format(2, 43), srid=4326)
+        xy = 2, 43
+
+        def create_cr_with_bfs(operat, geom_cr, list_geom_bf, label_cr):
+            default = {
+                "label": label_cr,
+                "history_modifier": context_record.history_modifier,
+                "operation": operat,
+            }
+            cr = ContextRecord.objects.create(**default)
+            if geom_cr == "Point":
+                cr.point = geom
+                cr.multi_polygon = None
+                cr.multi_polygon_source = None
+                cr.multi_polygon_source_item = None
+                cr.x, cr.y = xy
+                cr.point_2d = geom_2d
+                cr.spatial_reference_system = wgs84
+            else:
+                cr.multi_polygon = "SRID=4326;" + limit
+                cr.multi_polygon_source = "P"
+                cr.multi_polygon_source_item = str(ContextRecord._meta.verbose_name)
+            cr.save()
+            cr = ContextRecord.objects.get(pk=cr.pk)
+
+            bfs = []
+            for i in range(len(list_geom_bf)):
+                default = {
+                    "label": "Find " + str(i + 1) + " from " + label_cr,
+                    "history_modifier": base_find.history_modifier,
+                    "context_record": cr,
+                }
+                bf = models.BaseFind.objects.create(**default)
+                if list_geom_bf[i] == "Point":
+                    bf.point = geom
+                    bf.multi_polygon = None
+                    bf.multi_polygon_source = None
+                    bf.multi_polygon_source_item = None
+                    bf.x, bf.y = xy
+                    bf.point_2d = geom_2d
+                    bf.spatial_reference_system = wgs84
+                else:
+                    bf.multi_polygon = "SRID=4326;" + limit
+                    bf.point_source = None
+                    bf.point_2d = None
+                    bf.point = None
+                bf.save()
+                bf = models.BaseFind.objects.get(pk=bf.pk)
+                bfs.append(bf)
+            return cr, bfs
 
         # with point
-        geom = GEOSGeometry("POINT({} {} {})".format(2, 43, 1), srid=4326)
-        base_find_pt.point = geom
-        base_find_pt.multi_polygon = None
-        base_find_pt.save()
-        base_find_pt = models.BaseFind.objects.get(pk=base_find_pt.pk)
+        cr_pt_pt, bfs = create_cr_with_bfs(operation, "Point", ["Point"], "CR Pt Pt")
+        base_find_pt = bfs[0]
+
         dic_pt_t = {
             "type": "Feature",
             "geometry": {"type": "MultiPolygon", "coordinates": []},
@@ -2554,30 +2603,27 @@ class GeomaticTest(FindInit, TestCase):
         # test API with point
         response = self.client.get(reverse("api-get-geo-point", kwargs={"pk": 0}))
         self.assertEqual(response.status_code, 404)
-        response = self.client.get(reverse("api-get-geo-point", kwargs={"pk": base_find_pt.pk}))
+        response = self.client.get(
+            reverse("api-get-geo-point", kwargs={"pk": base_find_pt.pk})
+        )
         self.assertEqual(response.status_code, 200)
         self.assertIn(json.dumps(dic_pt_f).encode("utf-8"), response.content)
 
         # test context record with point as base find
-        cr_pt_pt = ContextRecord.objects.get(pk=base_find_pt.context_record.pk)
-        pk = cr_pt_pt.pk
-        cr_pt_pt.point = geom
-        cr_pt_pt.multi_polygon = None
-        cr_pt_pt.multi_polygon_source = None
-        cr_pt_pt.multi_polygon_source_item = None
-        cr_pt_pt.save()
-        cr_pt_pt = ContextRecord.objects.get(pk=pk)
-
         dic_pt_f_copy = copy.deepcopy(dic_pt_f)
         dic_pt_pt_f = copy.deepcopy(dic_pt_f)
-        dic_pt_pt_f["properties"] = {"associated base finds": {"Find 1": dic_pt_f_copy}}
+        dic_pt_pt_f["properties"] = {
+            "associated base finds": {"Find 1 from CR Pt Pt": dic_pt_f_copy}
+        }
         self.assertEqual(dic_pt_pt_f, cr_pt_pt.get_geo_items(False))
 
         dic_pt_t_copy = copy.deepcopy(dic_pt_t)
         dic_pt_pt_t = {
             "type": "Feature",
             "geometry": {"type": "MultiPolygon", "coordinates": []},
-            "properties": {"associated base finds": {"Find 1": dic_pt_t_copy}},
+            "properties": {
+                "associated base finds": {"Find 1 from CR Pt Pt": dic_pt_t_copy}
+            },
         }
         self.assertEqual(dic_pt_pt_t, cr_pt_pt.get_geo_items(True))
 
@@ -2588,7 +2634,8 @@ class GeomaticTest(FindInit, TestCase):
         self.assertEqual(response.status_code, 404)
         response = self.client.get(
             reverse(
-                "api-get-geo-points-from-context", kwargs={"context_record_pk": cr_pt_pt.pk}
+                "api-get-geo-points-from-context",
+                kwargs={"context_record_pk": cr_pt_pt.pk},
             )
         )
         self.assertEqual(response.status_code, 200)
@@ -2602,17 +2649,18 @@ class GeomaticTest(FindInit, TestCase):
         self.assertEqual(response.status_code, 404)
         response = self.client.get(
             reverse(
-                "api-get-geo-polygons-from-context", kwargs={"context_record_pk": cr_pt_pt.pk}
+                "api-get-geo-polygons-from-context",
+                kwargs={"context_record_pk": cr_pt_pt.pk},
             )
         )
         self.assertEqual(response.status_code, 200)
         self.assertIn(json.dumps(dic_pt_pt_t).encode("utf-8"), response.content)
 
         # the context record is a multi-polygon
-        limit = (
-            "MULTIPOLYGON(((1 1,5 1,5 5,1 5,1 1),(2 2,2 3,3 3,3 2,2 2)),"
-            "((6 3,9 2,9 4,6 3)))"
+        cr_poly_pt, bfs = create_cr_with_bfs(
+            operation, "Polygon", ["Point"], "CR Poly Pt"
         )
+        base_find_pt = bfs[0]
         dic_poly_t = {
             "type": "Feature",
             "geometry": {
@@ -2627,16 +2675,10 @@ class GeomaticTest(FindInit, TestCase):
             },
         }
 
-        cr_poly_pt = ContextRecord.objects.get(pk=base_find_pt.context_record.pk)
-        pk = cr_poly_pt.pk
-        cr_poly_pt.multi_polygon = "SRID=4326;" + limit
-        cr_poly_pt.multi_polygon_source = "P"
-        cr_poly_pt.multi_polygon_source_item = str(ContextRecord._meta.verbose_name)
-        cr_poly_pt.save()
-        cr_poly_pt = ContextRecord.objects.get(pk=pk)
-
         dic_poly_pt_t = copy.deepcopy(dic_poly_t)
-        dic_poly_pt_t["properties"] = {"associated base finds": {"Find 1": dic_pt_t}}
+        dic_poly_pt_t["properties"] = {
+            "associated base finds": {"Find 1 from CR Poly Pt": dic_pt_t}
+        }
         self.assertEqual(dic_poly_pt_t, cr_poly_pt.get_geo_items(True))
 
         dic_poly_f = {
@@ -2646,7 +2688,7 @@ class GeomaticTest(FindInit, TestCase):
         dic_pt_f_copy = copy.deepcopy(dic_pt_f)
         dic_poly_pt_f = copy.deepcopy(dic_poly_f)
         dic_poly_pt_f["properties"] = {
-            "associated base finds": {"Find 1": dic_pt_f_copy}
+            "associated base finds": {"Find 1 from CR Poly Pt": dic_pt_f_copy}
         }
         self.assertEqual(dic_poly_pt_f, cr_poly_pt.get_geo_items(False))
 
@@ -2657,13 +2699,12 @@ class GeomaticTest(FindInit, TestCase):
         self.assertEqual(response.status_code, 404)
         response = self.client.get(
             reverse(
-                "api-get-geo-points-from-context", kwargs={"context_record_pk": cr_poly_pt.pk}
+                "api-get-geo-points-from-context",
+                kwargs={"context_record_pk": cr_poly_pt.pk},
             )
         )
         self.assertEqual(response.status_code, 200)
-        self.assertIn(
-            json.dumps(dic_poly_pt_f).encode("utf-8"), response.content
-        )
+        self.assertIn(json.dumps(dic_poly_pt_f).encode("utf-8"), response.content)
 
         response = self.client.get(
             reverse(
@@ -2673,25 +2714,18 @@ class GeomaticTest(FindInit, TestCase):
         self.assertEqual(response.status_code, 404)
         response = self.client.get(
             reverse(
-                "api-get-geo-polygons-from-context", kwargs={"context_record_pk": cr_poly_pt.pk}
+                "api-get-geo-polygons-from-context",
+                kwargs={"context_record_pk": cr_poly_pt.pk},
             )
         )
         self.assertEqual(response.status_code, 200)
         self.assertIn(json.dumps(dic_poly_pt_t).encode("utf-8"), response.content)
 
         # we add a base find which is a multi-polygon
-        default = {
-            "label": "Find 2",
-            "history_modifier": base_find_pt.history_modifier,
-            "context_record": base_find_pt.context_record,
-        }
-        base_find_poly = models.BaseFind.objects.create(**default)
-        base_find_poly.multi_polygon = "SRID=4326;" + limit
-        base_find_poly.point_source = None
-        base_find_poly.point_2d = None
-        base_find_poly.point = None
-        base_find_poly.save()
-        base_find_poly = models.BaseFind.objects.get(pk=base_find_poly.pk)
+        cr_poly_poly_and_pt, bfs = create_cr_with_bfs(
+            ope, "Polygon", ["Polygon", "Point"], "CR Poly Poly Pt"
+        )
+        base_find_poly, base_find_pt = bfs
 
         res_poly = base_find_poly.get_geo_items(get_polygons=True)
         self.assertEqual(dic_poly_t, res_poly)
@@ -2720,44 +2754,32 @@ class GeomaticTest(FindInit, TestCase):
 
         # context record is a polygon
         # (and one base find is a point and the other is a polygon)
-        self.assertEqual(base_find_pt.context_record.pk, base_find_poly.context_record.pk)
-        cr_poly_poly_and_pt = ContextRecord.objects.get(pk=base_find_pt.context_record.pk)
-        pk = cr_poly_poly_and_pt.pk
-        cr_poly_poly_and_pt.multi_polygon = "SRID=4326;" + limit
-        cr_poly_poly_and_pt.multi_polygon_source = "P"
-        cr_poly_poly_and_pt.multi_polygon_source_item = str(ContextRecord._meta.verbose_name)
-        cr_poly_poly_and_pt.save()
-        cr_poly_poly_and_pt = ContextRecord.objects.get(pk=pk)
-
+        self.assertEqual(
+            base_find_pt.context_record.pk, base_find_poly.context_record.pk
+        )
         dic_poly_t_copy = copy.deepcopy(dic_poly_t)
         dic_poly_poly_and_pt_t = copy.deepcopy(dic_poly_t)
         dic_poly_poly_and_pt_t["properties"] = {
             "associated base finds": {
-                "Find 1": dic_pt_t_copy,
-                "Find 2": dic_poly_t_copy,
+                "Find 1 from CR Poly Poly Pt": dic_poly_t_copy,
+                "Find 2 from CR Poly Poly Pt": dic_pt_t_copy,
             }
         }
-        dic_poly_poly_and_pt_t_2 = copy.deepcopy(dic_poly_poly_and_pt_t)
-        dic_poly_poly_and_pt_t_2['properties']['associated base finds'] = {
-            "Find 2": dic_poly_t_copy,
-            "Find 1": dic_pt_t_copy,
-        }
-        self.assertEqual(dic_poly_poly_and_pt_t, cr_poly_poly_and_pt.get_geo_items(True))
+        self.assertEqual(
+            dic_poly_poly_and_pt_t, cr_poly_poly_and_pt.get_geo_items(True)
+        )
 
         dic_poly_f_copy = copy.deepcopy(dic_poly_f)
         dic_poly_poly_and_pt_f = copy.deepcopy(dic_poly_f)
         dic_poly_poly_and_pt_f["properties"] = {
             "associated base finds": {
-                "Find 1": dic_pt_f_copy,
-                "Find 2": dic_poly_f_copy,
+                "Find 1 from CR Poly Poly Pt": dic_poly_f_copy,
+                "Find 2 from CR Poly Poly Pt": dic_pt_f_copy,
             }
         }
-        dic_poly_poly_and_pt_f_2 = copy.deepcopy(dic_poly_poly_and_pt_f)
-        dic_poly_poly_and_pt_f_2['properties']['associated base finds'] = {
-            "Find 2": dic_poly_f_copy,
-            "Find 1": dic_pt_f_copy,
-        }
-        self.assertEqual(dic_poly_poly_and_pt_f, cr_poly_poly_and_pt.get_geo_items(False))
+        self.assertEqual(
+            dic_poly_poly_and_pt_f, cr_poly_poly_and_pt.get_geo_items(False)
+        )
 
         # test of API for multipolygon context record with a multipolygon and a point as base find
         response = self.client.get(
@@ -2766,14 +2788,12 @@ class GeomaticTest(FindInit, TestCase):
         self.assertEqual(response.status_code, 404)
         response = self.client.get(
             reverse(
-                "api-get-geo-points-from-context", kwargs={"context_record_pk": cr_poly_poly_and_pt.pk}
+                "api-get-geo-points-from-context",
+                kwargs={"context_record_pk": cr_poly_poly_and_pt.pk},
             )
         )
         self.assertEqual(response.status_code, 200)
-        try:
-            self.assertIn(json.dumps(dic_poly_poly_and_pt_f).encode("utf-8"), response.content)
-        except:
-            self.assertIn(json.dumps(dic_poly_poly_and_pt_f_2).encode("utf-8"), response.content)
+        self.assertEqual(dic_poly_poly_and_pt_f, json.loads(response.content))
 
         response = self.client.get(
             reverse(
@@ -2783,51 +2803,35 @@ class GeomaticTest(FindInit, TestCase):
         self.assertEqual(response.status_code, 404)
         response = self.client.get(
             reverse(
-                "api-get-geo-polygons-from-context", kwargs={"context_record_pk": cr_poly_poly_and_pt.pk}
+                "api-get-geo-polygons-from-context",
+                kwargs={"context_record_pk": cr_poly_poly_and_pt.pk},
             )
         )
         self.assertEqual(response.status_code, 200)
-        try:
-            self.assertIn(json.dumps(dic_poly_poly_and_pt_t).encode("utf-8"), response.content)
-        except:
-            self.assertIn(json.dumps(dic_poly_poly_and_pt_t_2).encode("utf-8"), response.content)
+        self.assertEqual(dic_poly_poly_and_pt_t, json.loads(response.content))
 
         # context record is a point, base find 1 a point and base find 2 a polygon
-        cr_pt_poly_and_pt = ContextRecord.objects.get(pk=base_find_poly.context_record.pk)
-        pk = cr_pt_poly_and_pt.pk
-        cr_pt_poly_and_pt.point = geom
-        cr_pt_poly_and_pt.multi_polygon = None
-        cr_pt_poly_and_pt.multi_polygon_source = None
-        cr_pt_poly_and_pt.multi_polygon_source_item = None
-        cr_pt_poly_and_pt.save()
-        cr_pt_poly_and_pt = ContextRecord.objects.get(pk=pk)
+        cr_pt_poly_and_pt, bfs = create_cr_with_bfs(
+            ope, "Point", ["Polygon", "Point"], "CR Pt Poly Pt"
+        )
+        base_find_poly, base_find_pt = bfs
 
         dic_pt_poly_and_pt_t = copy.deepcopy(dic_pt_pt_t)
         dic_pt_poly_and_pt_t["properties"] = {
             "associated base finds": {
-                "Find 2": dic_poly_t_copy,
-                "Find 1": dic_pt_t_copy,
+                "Find 1 from CR Pt Poly Pt": dic_poly_t_copy,
+                "Find 2 from CR Pt Poly Pt": dic_pt_t_copy,
             }
         }
-        dic_pt_poly_and_pt_t_2 = copy.deepcopy(dic_pt_poly_and_pt_t)
-        dic_pt_poly_and_pt_t["properties"]["associated base finds"] = {
-            "Find 1": dic_pt_t_copy,
-            "Find 2": dic_poly_t_copy,
-        }
         self.assertEqual(dic_pt_poly_and_pt_t, cr_pt_poly_and_pt.get_geo_items(True))
 
         dic_pt_poly_and_pt_f = copy.deepcopy(dic_pt_pt_f)
         dic_pt_poly_and_pt_f["properties"] = {
             "associated base finds": {
-                "Find 1": dic_pt_f_copy,
-                "Find 2": dic_poly_f_copy,
+                "Find 1 from CR Pt Poly Pt": dic_poly_f_copy,
+                "Find 2 from CR Pt Poly Pt": dic_pt_f_copy,
             }
         }
-        dic_pt_poly_and_pt_f_2 = copy.deepcopy(dic_pt_poly_and_pt_f)
-        dic_pt_poly_and_pt_f["properties"]["associated base finds"] = {
-            "Find 2": dic_poly_f_copy,
-            "Find 1": dic_pt_f_copy,
-        }
         self.assertEqual(dic_pt_poly_and_pt_f, cr_pt_poly_and_pt.get_geo_items(False))
 
         # test of API for point context record with multipolygon as base find
@@ -2837,14 +2841,12 @@ class GeomaticTest(FindInit, TestCase):
         self.assertEqual(response.status_code, 404)
         response = self.client.get(
             reverse(
-                "api-get-geo-points-from-context", kwargs={"context_record_pk": cr_pt_poly_and_pt.pk}
+                "api-get-geo-points-from-context",
+                kwargs={"context_record_pk": cr_pt_poly_and_pt.pk},
             )
         )
         self.assertEqual(response.status_code, 200)
-        try:
-            self.assertIn(json.dumps(dic_pt_poly_and_pt_f).encode("utf-8"), response.content)
-        except:
-            self.assertIn(json.dumps(dic_pt_poly_and_pt_f_2).encode("utf-8"), response.content)
+        self.assertEqual(dic_pt_poly_and_pt_f, json.loads(response.content))
 
         response = self.client.get(
             reverse(
@@ -2854,14 +2856,126 @@ class GeomaticTest(FindInit, TestCase):
         self.assertEqual(response.status_code, 404)
         response = self.client.get(
             reverse(
-                "api-get-geo-polygons-from-context", kwargs={"context_record_pk": cr_pt_poly_and_pt.pk}
+                "api-get-geo-polygons-from-context",
+                kwargs={"context_record_pk": cr_pt_poly_and_pt.pk},
             )
         )
         self.assertEqual(response.status_code, 200)
-        try:
-            self.assertIn(json.dumps(dic_pt_poly_and_pt_t).encode("utf-8"), response.content)
-        except:
-            self.assertIn(json.dumps(dic_pt_poly_and_pt_t_2).encode("utf-8"), response.content)
+        self.assertEqual(dic_pt_poly_and_pt_t, json.loads(response.content))
+
+        # test of operation
+
+        dic_pt_pt_and_poly_pt_and_poly_f = copy.deepcopy(dic_pt_f)
+        dic_pt_pt_and_poly_pt_and_poly_f["properties"] = {
+            "associated context records": {
+                "CR Pt Poly Pt": dic_pt_poly_and_pt_f,
+                "CR Poly Poly Pt": dic_poly_poly_and_pt_f,
+            }
+        }
+        dic_pt_pt_and_poly_pt_and_poly_t = copy.deepcopy(dic_pt_t)
+        dic_pt_pt_and_poly_pt_and_poly_t["properties"] = {
+            "associated context records": {
+                "CR Pt Poly Pt": dic_pt_poly_and_pt_t,
+                "CR Poly Poly Pt": dic_poly_poly_and_pt_t,
+            }
+        }
+        dic_poly_pt_and_poly_pt_and_poly_f = copy.deepcopy(dic_poly_f)
+        dic_poly_pt_and_poly_pt_and_poly_f["properties"] = {
+            "associated context records": {
+                "CR Pt Poly Pt": dic_pt_poly_and_pt_f,
+                "CR Poly Poly Pt": dic_poly_poly_and_pt_f,
+            }
+        }
+        dic_poly_pt_and_poly_pt_and_poly_t = copy.deepcopy(dic_poly_t)
+        dic_poly_pt_and_poly_pt_and_poly_t["properties"] = {
+            "associated context records": {
+                "CR Pt Poly Pt": dic_pt_poly_and_pt_t,
+                "CR Poly Poly Pt": dic_poly_poly_and_pt_t,
+            }
+        }
+
+        ope_pt = Operation.objects.get(pk=ope.pk)
+        ope_pt.point = geom
+        ope_pt.multi_polygon = None
+        ope_pt.multi_polygon_source = None
+        ope_pt.multi_polygon_source_item = None
+        ope_pt.x, ope_pt.y = xy
+        ope_pt.point_2d = geom_2d
+        ope_pt.spatial_reference_system = wgs84
+        ope_pt.save()
+        ope_pt = Operation.objects.get(pk=ope_pt.pk)
+        self.assertEqual(dic_pt_pt_and_poly_pt_and_poly_f, ope_pt.get_geo_items(False))
+        self.assertEqual(dic_pt_pt_and_poly_pt_and_poly_t, ope_pt.get_geo_items(True))
+
+        response = self.client.get(
+            reverse("api-get-geo-polygons-from-operation", kwargs={"operation_pk": 0})
+        )
+        self.assertEqual(response.status_code, 404)
+        response = self.client.get(
+            reverse(
+                "api-get-geo-polygons-from-operation",
+                kwargs={"operation_pk": ope_pt.pk},
+            )
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(dic_pt_pt_and_poly_pt_and_poly_t, json.loads(response.content))
+
+        response = self.client.get(
+            reverse("api-get-geo-points-from-operation", kwargs={"operation_pk": 0})
+        )
+        self.assertEqual(response.status_code, 404)
+        response = self.client.get(
+            reverse(
+                "api-get-geo-points-from-operation", kwargs={"operation_pk": ope_pt.pk}
+            )
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(dic_pt_pt_and_poly_pt_and_poly_f, json.loads(response.content))
+
+        # ope is now a multipolygon
+        ope_poly = Operation.objects.get(pk=ope.pk)
+        ope_poly.multi_polygon = "SRID=4326;" + limit
+        ope_poly.point_source = None
+        ope_poly.point_2d = None
+        ope_poly.point = None
+        ope_poly.save()
+        ope_poly = Operation.objects.get(pk=ope_poly.pk)
+
+        self.assertEqual(
+            dic_poly_pt_and_poly_pt_and_poly_f, ope_poly.get_geo_items(False)
+        )
+        self.assertEqual(
+            dic_poly_pt_and_poly_pt_and_poly_t, ope_poly.get_geo_items(True)
+        )
+
+        response = self.client.get(
+            reverse("api-get-geo-polygons-from-operation", kwargs={"operation_pk": 0})
+        )
+        self.assertEqual(response.status_code, 404)
+        response = self.client.get(
+            reverse(
+                "api-get-geo-polygons-from-operation",
+                kwargs={"operation_pk": ope_pt.pk},
+            )
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(
+            dic_poly_pt_and_poly_pt_and_poly_t, json.loads(response.content)
+        )
+
+        response = self.client.get(
+            reverse("api-get-geo-points-from-operation", kwargs={"operation_pk": 0})
+        )
+        self.assertEqual(response.status_code, 404)
+        response = self.client.get(
+            reverse(
+                "api-get-geo-points-from-operation", kwargs={"operation_pk": ope_pt.pk}
+            )
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(
+            dic_poly_pt_and_poly_pt_and_poly_f, json.loads(response.content)
+        )