ui tests without base feature point working

1 files changed, 43 insertions, 169 deletions

diff --git a/archaeological_finds/tests.py b/archaeological_finds/tests.py
index 00e14307c..5d13bd2dd 100644
--- a/archaeological_finds/tests.py
+++ b/archaeological_finds/tests.py
@@ -2521,9 +2521,6 @@ class GeomaticTest(FindInit, TestCase):
         self.assertEqual(base_find.point_source, "P")
 
     def test_get_geo_items(self):
-        from archaeological_operations.models import Operation
-        from archaeological_context_records.models import ContextRecord
-        from archaeological_finds.models import BaseFind
         from ishtar_common.tests import GeomaticTest as BaseGeomaticTest
 
         #profile = models.get_current_profile()
@@ -2537,142 +2534,28 @@ class GeomaticTest(FindInit, TestCase):
         print(user.is_authenticated())'''
 
         geoms, pks = BaseGeomaticTest.setUpDefaultGeoItems(self.user)
-
+        dics = BaseGeomaticTest.geojson_geo_items(geoms, pks, test_get_geo_items=True)
         url_pts = reverse("api-get-geo-points")
         url_polys = reverse("api-get-geo-polygons")
 
-        cache_dics_t, cache_dics_f = {}, {}
-
-        def finds_first(x):
-            if x[:2] == "CR":
-                return 0
-            if x[:4] == "Find":
-                return -1
-            else:
-                return 1
-
-        labels = list(pks.keys())
-        labels.sort(key=finds_first)
-        for label in labels:
+        for label in dics.keys():
+            dic = dics[label]
+            get_pk = dic['get_pk']
             pk = pks[label]
-            if label[:4] == "Find":
-                dic_t = {
-                    "type": "Feature",
-                    "geometry": {
-                        "type": "MultiPolygon", "coordinates": geoms[2][0]
-                    },
-                    "properties": {"label": label},
-                }
-                dic_f = {
-                    "type": "Feature",
-                    "geometry": {
-                        "type": "Point", "coordinates": BaseGeomaticTest.pt_coords_from_label(label, geoms),
-                    },
-                    "properties": {"label": label},
-                }
-                cache_dics_t[label] = dic_t
-                cache_dics_f[label] = dic_f
-                res_t = BaseFind.objects.get(pk=pk).get_geo_items(get_polygons=True)
-                res_f = BaseFind.objects.get(pk=pk).get_geo_items(get_polygons=False)
-                get_pk = "?pk="
-
-            elif label[:2] == "CR":
-                cache_key = lambda x: "Find " + x + " from " + label
-                dic_t = {
-                    "type": "Feature",
-                    "geometry": {
-                        "type": "MultiPolygon", "coordinates": geoms[1][0]
-                    },
-                    "properties": {
-                        "label": label,
-                        "base-finds": {
-                            'type': 'FeatureCollection',
-                            'features': [
-                                cache_dics_t[cache_key("Polygon")],
-                                cache_dics_t[cache_key("Point")],
-                            ]
-                        }
-                    },
-                }
-                dic_f = {
-                    "type": "Feature",
-                    "geometry": {
-                        "type": "Point", "coordinates": BaseGeomaticTest.pt_coords_from_label(label, geoms),
-                    },
-                    "properties": {
-                        "label": label,
-                        "base-finds": {
-                            'type': 'FeatureCollection',
-                            'features': [
-                                cache_dics_f[cache_key("Polygon")],
-                                cache_dics_f[cache_key("Point")],
-                            ]
-                        }
-                    },
-                }
-                cache_dics_t[label] = dic_t
-                cache_dics_f[label] = dic_f
-                res_t = ContextRecord.objects.get(pk=pk).get_geo_items(get_polygons=True)
-                res_f = ContextRecord.objects.get(pk=pk).get_geo_items(get_polygons=False)
-                get_pk = "?context_record_pk="
-            else:
-                real_label = "OA3"
-                cache_key_prefix = "CR " + label + " "
-                if label == "Pt":
-                    real_label = "OA2"
-                dic_t = {
-                    "type": "Feature",
-                    "geometry": {
-                        "type": "MultiPolygon", "coordinates": geoms[0][0]
-                    },
-                    "properties": {
-                        "label": real_label,
-                        "context-records": {
-                            'type': 'FeatureCollection',
-                            'features': [
-                                cache_dics_t[cache_key_prefix + "Poly"],
-                                cache_dics_t[cache_key_prefix + "Pt"],
-                            ]
-                        }
-                    },
-                }
-                dic_f = {
-                    "type": "Feature",
-                    "geometry": {
-                        "type": "Point", "coordinates": BaseGeomaticTest.pt_coords_from_label(label, geoms),
-                    },
-                    "properties": {
-                        "label": real_label,
-                        "context-records": {
-                            'type': 'FeatureCollection',
-                            'features': [
-                                cache_dics_f[cache_key_prefix + "Poly"],
-                                cache_dics_f[cache_key_prefix + "Pt"],
-                            ]
-                        }
-                    },
-                }
-                res_t = Operation.objects.get(pk=pk).get_geo_items(get_polygons=True)
-                res_f = Operation.objects.get(pk=pk).get_geo_items(get_polygons=False)
-                get_pk = "?operation_pk="
-
-            self.assertEqual(res_t, dic_t)
-            print("url")
-            print(url_polys + get_pk + "0")
+
+            self.assertEqual(dic['res_polys'], dic['get_polys'])
             response = self.client.get(url_polys + get_pk + "0")
-            print('response')
-            print(response)
             self.assertEqual(response.status_code, 404)
             response = self.client.get(url_polys + get_pk + str(pk))
             self.assertEqual(response.status_code, 200)
-            self.assertEqual(dic_t, json.loads(response.content))
+            self.assertEqual(dic['get_polys'], json.loads(response.content))
 
-            self.assertEqual(dic_f, res_f)
+            self.assertEqual(dic['get_pts'], dic['res_pts'])
             response = self.client.get(url_pts + get_pk + "0")
             self.assertEqual(response.status_code, 404)
             response = self.client.get(url_pts + get_pk + str(pk))
             self.assertEqual(response.status_code, 200)
-            self.assertEqual(dic_f, json.loads(response.content))
+            self.assertEqual(dic['get_pts'], json.loads(response.content))
 
 
 
@@ -2976,56 +2859,47 @@ class TemplateTest(FindInit, TestCase):
 class SeleniumTestsBaseFinds(SeleniumTests):
     fixtures = FIND_FIXTURES
 
-    def _test_bf(self, i, dic_polygon, dic_point):
-        bf_label = self.selenium.find_element_by_xpath('//tbody/tr[' + str(i) + ']/td[2]').text
-        if bf_label[3:5] == "Pt":
-            dic_base = dic_point
+    def _test_bf(self, i, pks, geojsons):
+        bf_infos = self.selenium.find_element_by_xpath('//tbody/tr[' + str(i) + ']/td/a[@class="display_details"]')
+        self.scroll(bf_infos)
+        bf_infos.click()
+
+        bf_label = self.selenium.find_element_by_xpath('//small[@title="ID interne" or @title="Internal ID"]').text
+        bf_label = bf_label.split('-')
+        self.assertEqual(len(bf_label), 3)
+        bf_label = bf_label[2]
+        bf = models.BaseFind.objects.get(pk=pks[bf_label])
+        slug_pk = str(bf.SLUG) + "-" + str(bf.pk)
+        print('ACHTUNG: ', bf.most_precise_geo())
+        print(bf.multi_polygon.coords)
+        print(bf.multi_polygon_source)
+        print(bf.multi_polygon_source_item)
+        print(bf.point_2d.coords)
+        print(bf.point_source)
+        print(bf.point_source_item)
+
+        if False: #geojsons[bf_label]['precise']
+            bf_base = geojsons[bf_label]['get_pts']
         else:
-            dic_base = dic_polygon
-        bf = self.selenium.find_element_by_xpath('//tbody/tr[' + str(i) + ']/td/a[@class="display_details"]')
-        self.scroll(bf)
-        bf.click()
-
-        self.assertMap(dic_base)
+            bf_base = geojsons[bf_label]['get_polys']
+        self.assertMap(bf_base, slug_pk)
 
-        title = self.selenium.find_elements_by_xpath(
-            '//dl[@class="col-12"]/dt[text()="Display geo items" or text()="Afficher les éléments"]')
+        title = '//dl[@class="col-12"]/dt[text()="Display geo items" or text()="Afficher les éléments"]'
         dd = '//dl[@class="col-12"]/dd'
-        label = self.selenium.find_elements_by_xpath(dd + '/label[text()="Display associated features: "]')
-        disp = self.selenium.find_elements_by_xpath(dd + '/select[@name="display-geo-items"]')
-
-        self.assertLess(len(title), 1)
-        self.assertLess(len(label), 1)
-        self.assertLess(len(disp), 1)
+        disp = dd + '/input[@name="checkbox-geo-items"]'
+        get_poly = dd + '/select[@name="get-poly-geo-items"]'
+        self.assertNotInDOM(title)
+        self.assertNotInDOM(disp)
+        self.assertNotInDOM(get_poly)
 
     def test_geo_items(self):
-        self.selenium.implicitly_wait(5)
-        geo_elements, pks = self.setUpDefaultGeoItems()
-        poly_bf, centr_bf, pt_bf = geo_elements[2]
-
-        dic_polygon = {
-            'type': 'FeatureCollection',
-            'features': [
-                {'geometry':
-                     {'coordinates': poly_bf,
-                      'type': 'MultiPolygon'},
-                 'properties': {},
-                 'type': 'Feature'}
-            ]}
-        dic_point = {
-            'type': 'FeatureCollection',
-            'features': [
-                {'geometry':
-                     {'coordinates': pt_bf,
-                      'type': 'Point'},
-                 'properties': {},
-                 'type': 'Feature'}
-            ]}
+        pks, geojsons = self.pks_and_geojson()
         for i in range(1, 9):
+            self.WebDriverWait(self.selenium, 2).until(
+                lambda driver: driver.find_element_by_xpath(
+                    '//a[@class="nav-link dropdown-toggle"][@id="dropdown-menu-main"]'))
             dropdown = self.selenium.find_element_by_xpath('//a[@class="nav-link dropdown-toggle"][@id="dropdown-menu-main"]')
             self.scroll(dropdown)
             dropdown.click()
             self.selenium.find_element_by_xpath('//div[@class="dropdown-menu show"]/a[@href="/find_search/"]').click()
-            self._test_bf(i, dic_polygon, dic_point)
-
-        self.selenium.implicitly_wait(20)
+            self._test_bf(i, pks, geojsons)