clean version of get_geo_items with ui integration and tests

5 files changed, 565 insertions, 492 deletions

diff --git a/archaeological_context_records/tests.py b/archaeological_context_records/tests.py
index c1117a68d..a089c1dc5 100644
--- a/archaeological_context_records/tests.py
+++ b/archaeological_context_records/tests.py
@@ -60,7 +60,8 @@ from ishtar_common.tests import (
     GenericSerializationTest,
     COMMON_FIXTURES,
     WAREHOUSE_FIXTURES,
-    SearchText, SeleniumTests,
+    SearchText,
+    SeleniumTests,
 )
 
 from archaeological_operations.models import Operation
@@ -952,8 +953,7 @@ class RecordRelationsTest(ContextRecordInit, TestCase):
         crs = self.context_records
 
         rel_type_1 = models.RelationType.objects.create(
-            symmetrical=False, txt_idx="rel_1",
-            logical_relation='included'
+            symmetrical=False, txt_idx="rel_1", logical_relation="included"
         )
         """
         6  7  8  9  10 = 11 = 12
@@ -971,31 +971,36 @@ class RecordRelationsTest(ContextRecordInit, TestCase):
            1       2
         """
         relations = (
-            (1, 3), (2, 3), (3, 4), (3, 5), (4, 6), (4, 7), (4, 8),
-            (5, 9), (5, 10)
+            (1, 3),
+            (2, 3),
+            (3, 4),
+            (3, 5),
+            (4, 6),
+            (4, 7),
+            (4, 8),
+            (5, 9),
+            (5, 10),
         )
         models.RecordRelations._no_post_treatments = True
         for child_idx, parent_idx in relations:
             models.RecordRelations.objects.create(
                 left_record=crs[child_idx - 1],
                 right_record=crs[parent_idx - 1],
-                relation_type=rel_type_1
+                relation_type=rel_type_1,
             )
         rel_type_2 = models.RelationType.objects.create(
-            symmetrical=True, txt_idx="rel_2",
-            logical_relation='equal'
-        )
-        equal_relations = (
-            (10, 11), (11, 12), (5, 13), (3, 14)
+            symmetrical=True, txt_idx="rel_2", logical_relation="equal"
         )
+        equal_relations = ((10, 11), (11, 12), (5, 13), (3, 14))
         for child_idx, parent_idx in equal_relations:
             models.RecordRelations.objects.create(
                 left_record=crs[child_idx - 1],
                 right_record=crs[parent_idx - 1],
-                relation_type=rel_type_2
+                relation_type=rel_type_2,
             )
         q = models.ContextRecordTree.objects.filter(
-            cr_parent_id=crs[2].pk, cr_id=crs[0].pk)
+            cr_parent_id=crs[2].pk, cr_id=crs[0].pk
+        )
         self.assertGreaterEqual(q.count(), 1)
 
         ## use tables
@@ -1052,58 +1057,60 @@ class RecordRelationsTest(ContextRecordInit, TestCase):
 
         # test remove a node
         nb = models.ContextRecordTree.objects.filter(
-            cr_parent=crs[6 - 1], cr=crs[3 - 1]).count()
+            cr_parent=crs[6 - 1], cr=crs[3 - 1]
+        ).count()
         self.assertEqual(nb, 1)
         models.RecordRelations.objects.filter(
-            left_record=crs[3 - 1],
-            right_record=crs[4 - 1]
+            left_record=crs[3 - 1], right_record=crs[4 - 1]
         ).delete()
         models.ContextRecordTree.update(crs[3 - 1].pk)
         models.ContextRecordTree.update(crs[4 - 1].pk)
         nb = models.ContextRecordTree.objects.filter(
-            cr_parent=crs[6 - 1], cr=crs[3 - 1]).count()
+            cr_parent=crs[6 - 1], cr=crs[3 - 1]
+        ).count()
         self.assertEqual(nb, 0)
 
         # test remove a node (update equal links)
         nb = models.ContextRecordTree.objects.filter(
-            cr_parent=crs[10 - 1], cr=crs[14 - 1]).count()
+            cr_parent=crs[10 - 1], cr=crs[14 - 1]
+        ).count()
         self.assertEqual(nb, 1)
         models.RecordRelations.objects.filter(
-            left_record=crs[3 - 1],
-            right_record=crs[5 - 1]
+            left_record=crs[3 - 1], right_record=crs[5 - 1]
         ).delete()
         models.ContextRecordTree.update(crs[3 - 1].pk)
         models.ContextRecordTree.update(crs[5 - 1].pk)
         nb = models.ContextRecordTree.objects.filter(
-            cr_parent=crs[10 - 1], cr=crs[14 - 1]).count()
+            cr_parent=crs[10 - 1], cr=crs[14 - 1]
+        ).count()
         self.assertEqual(nb, 0)
 
         # auto update
         models.RecordRelations._no_post_treatments = False
         models.RecordRelations.objects.create(
-            left_record=crs[3 - 1],
-            right_record=crs[4 - 1],
-            relation_type=rel_type_1
+            left_record=crs[3 - 1], right_record=crs[4 - 1], relation_type=rel_type_1
         )
         nb = models.ContextRecordTree.objects.filter(
-            cr_parent=crs[6 - 1], cr=crs[3 - 1]).count()
+            cr_parent=crs[6 - 1], cr=crs[3 - 1]
+        ).count()
         self.assertEqual(nb, 1)
         models.RecordRelations.objects.create(
-            left_record=crs[3 - 1],
-            right_record=crs[5 - 1],
-            relation_type=rel_type_1
+            left_record=crs[3 - 1], right_record=crs[5 - 1], relation_type=rel_type_1
         )
         nb = models.ContextRecordTree.objects.filter(
-            cr_parent=crs[10 - 1], cr=crs[14 - 1]).count()
+            cr_parent=crs[10 - 1], cr=crs[14 - 1]
+        ).count()
         self.assertEqual(nb, 1)
 
         # delete
         nb = models.ContextRecordTree.objects.filter(
-            cr_parent=crs[13 - 1], cr=crs[1 - 1]).count()
+            cr_parent=crs[13 - 1], cr=crs[1 - 1]
+        ).count()
         self.assertEqual(nb, 1)
         crs[3 - 1].delete()
         nb = models.ContextRecordTree.objects.filter(
-            cr_parent=crs[13 - 1], cr=crs[1 - 1]).count()
+            cr_parent=crs[13 - 1], cr=crs[1 - 1]
+        ).count()
         self.assertEqual(nb, 0)
 
         # delete on views
@@ -1114,7 +1121,8 @@ class RecordRelationsTest(ContextRecordInit, TestCase):
         models.ContextRecordTree.objects.filter(pk__isnull=False).delete()
         crs[4 - 1].delete()
         q = models.ContextRecordTree.objects.filter(
-            cr_parent_id=crs[1 - 1].pk, cr_id=crs[6 - 1].pk)
+            cr_parent_id=crs[1 - 1].pk, cr_id=crs[6 - 1].pk
+        )
         self.assertGreaterEqual(q.count(), 0)
 
     def _test_tree_(self, test_trees, context_record):
@@ -1122,12 +1130,15 @@ class RecordRelationsTest(ContextRecordInit, TestCase):
         for tree in test_trees:
             for tree_idx in range(len(tree) - 1):
                 q = models.ContextRecordTree.objects.filter(
-                    cr_parent=crs[tree[tree_idx] - 1], cr=crs[tree[tree_idx + 1] - 1])
+                    cr_parent=crs[tree[tree_idx] - 1], cr=crs[tree[tree_idx + 1] - 1]
+                )
                 self.assertEqual(
-                    q.count(), 1,
+                    q.count(),
+                    1,
                     msg="Tree relation ({}, {}) is missing for context "
-                        "record {}".format(tree[tree_idx + 1], tree[tree_idx],
-                                           context_record)
+                    "record {}".format(
+                        tree[tree_idx + 1], tree[tree_idx], context_record
+                    ),
                 )
 
     def _test_tree_generation(self, cr_idx, test_trees):
@@ -1365,61 +1376,79 @@ class GraphGenerationTest(ContextRecordInit, TestCase):
         self.assertNotIn('"CR 2D"', content)
 
 
-@tag('ui')
+@tag("ui")
 class SeleniumTestsContextRecords(SeleniumTests):
     fixtures = CONTEXT_RECORD_FIXTURES
 
     def _test_cr(self, i, pks, geojsons, method=None):
-        if method == 'from operation':
-            tbody = '.' + '/div' * 6 + '/table/tbody'
+        if method == "from operation":
+            tbody = "." + "/div" * 6 + "/table/tbody"
             title = self.selenium.find_element_by_xpath(
-                '//h3[contains(text(), "Unité d\'Enregistrement") or contains(text(), "Context record")]')
-            panel = title.find_element_by_xpath('./..')
-            details = panel.find_element_by_xpath(tbody + '/tr[' + str(i) + ']/td/a[@class="display_details"]')
+                '//h3[contains(text(), "Unité d\'Enregistrement") or contains(text(), "Context record")]'
+            )
+            panel = title.find_element_by_xpath("./..")
+            details = panel.find_element_by_xpath(
+                tbody + "/tr[" + str(i) + ']/td/a[@class="display_details"]'
+            )
             self.scroll(details)
-            label = panel.find_element_by_xpath(tbody + '/tr[' + str(i) + ']/td[2]').text
+            label = panel.find_element_by_xpath(
+                tbody + "/tr[" + str(i) + "]/td[2]"
+            ).text
             details.click()
         else:
-            tbody = './form' + '/div' * 7 + '/table/tbody'
+            tbody = "./form" + "/div" * 7 + "/table/tbody"
             title = '//h3[text()="Rechercher une unité d\'enregistrement" or text()="Context record search"]'
-            self.WebDriverWait(self.selenium, 2).until(lambda driver: driver.find_element_by_xpath(title))
+            self.WebDriverWait(self.selenium, self.waiting_time).until(
+                lambda driver: driver.find_element_by_xpath(title)
+            )
             title = self.selenium.find_element_by_xpath(title)
-            panel = title.find_element_by_xpath('./..')
-            details = panel.find_element_by_xpath(tbody + '/tr[' + str(i) + ']/td/a[@class="display_details"]')
+            panel = title.find_element_by_xpath("./..")
+            details = panel.find_element_by_xpath(
+                tbody + "/tr[" + str(i) + ']/td/a[@class="display_details"]'
+            )
             self.scroll(details)
             details.click()
-            label = self.selenium.find_element_by_xpath('//small[@title="ID interne" or @title="Internal ID"]').text
+            label = self.selenium.find_element_by_xpath(
+                '//small[@title="ID interne" or @title="Internal ID"]'
+            ).text
             label = label[1:]
         cr = models.ContextRecord.objects.get(pk=pks[label])
         slug_pk = str(cr.SLUG) + "-" + str(cr.pk)
 
-        if False:  # geojsons[label]['precise']
-            base = copy.deepcopy(geojsons[label]['get_pts'])
-        else:
-            base = copy.deepcopy(geojsons[label]['get_polys'])
+        base = copy.deepcopy(geojsons[label]["get_polys"])
 
         get_poly_id = "get-poly-for-" + slug_pk
         get_poly_label_id = "get-poly-label-for-" + slug_pk
         disp_bf_id = "disp-bf-for-" + slug_pk
 
-        cr_polys = geojsons[label]['get_polys']
-        bf_labels_polys = cr_polys['properties'].pop('base-finds')
-        bf_polys = {'type': 'FeatureCollection',
-                    'features': [geojsons[bf_label]['get_polys'] for bf_label in bf_labels_polys]
-                    }
+        cr_polys = geojsons[label]["get_polys"]
+        bf_labels_polys = cr_polys["properties"].pop("base-finds")
+        bf_polys = {
+            "type": "FeatureCollection",
+            "features": [
+                geojsons[bf_label]["get_polys"] for bf_label in bf_labels_polys
+            ],
+        }
 
-        cr_pts = geojsons[label]['get_pts']
-        bf_labels_pts = cr_pts['properties'].pop('base-finds')
-        bf_pts = {'type': 'FeatureCollection',
-                  'features': [geojsons[bf_label]['get_pts'] for bf_label in bf_labels_pts]
-                  }
+        cr_pts = geojsons[label]["get_pts"]
+        bf_labels_pts = cr_pts["properties"].pop("base-finds")
+        bf_pts = {
+            "type": "FeatureCollection",
+            "features": [geojsons[bf_label]["get_pts"] for bf_label in bf_labels_pts],
+        }
 
-        self.WebDriverWait(self.selenium, 2).until(
+        self.WebDriverWait(self.selenium, self.waiting_time).until(
             lambda driver: driver.find_element_by_xpath(
-                '//dl[@class="col-12"]/dt[text()="Display geo items" or text()="Afficher les éléments"]'))
+                '//dl[@class="col-12"]/dt[text()="Display geo items" or text()="Afficher les éléments"]'
+            )
+        )
         dd = '//dl[@class="col-12"]/dd'
-        self.selenium.find_element_by_xpath(dd + '/fieldset/label[@for="' + disp_bf_id + '"]')
-        disp_bf = self.selenium.find_element_by_xpath(dd + '/fieldset/input[@id="' + disp_bf_id + '"]')
+        self.selenium.find_element_by_xpath(
+            dd + '/fieldset/label[@for="' + disp_bf_id + '"]'
+        )
+        disp_bf = self.selenium.find_element_by_xpath(
+            dd + '/fieldset/input[@id="' + disp_bf_id + '"]'
+        )
         self.assertFalse(disp_bf.is_selected())
         select_get_poly = dd + '/select[@id="' + get_poly_id + '"]'
         get_poly_label = dd + '/label[@id="' + get_poly_label_id + '"]'
@@ -1430,35 +1459,37 @@ class SeleniumTestsContextRecords(SeleniumTests):
         # context record specific
 
         # click on "Base finds"
-        self.selenium.execute_script('return initialize_test_map(arguments[0])', slug_pk)
+        self.selenium.execute_script(
+            "return initialize_test_map(arguments[0])", slug_pk
+        )
         self.scroll(disp_bf)
         disp_bf.click()
         select_get_poly = dd + '/select[@id="' + get_poly_id + '"]'
         get_poly = self.selenium.find_element_by_xpath(select_get_poly)
         get_poly.click()
-        self.selenium.find_element_by_xpath(select_get_poly + '/option[@value="polygons"]').click()
+        self.selenium.find_element_by_xpath(
+            select_get_poly + '/option[@value="polygons"]'
+        ).click()
 
-        bf_geoms = [
-            bf_polys,
-            {'type': 'FeatureCollection', 'features': []}
-        ]
+        bf_geoms = [bf_polys, {"type": "FeatureCollection", "features": []}]
         self.assertTrue(disp_bf.is_selected())
         self.selenium.find_element_by_xpath(get_poly_label)
         self.assertMap(base, slug_pk, bf_geoms)
 
         get_poly = self.selenium.find_element_by_xpath(select_get_poly)
         get_poly.click()
-        self.selenium.find_element_by_xpath(select_get_poly + '/option[@value="points"]').click()
-        bf_geoms = [
-            bf_pts,
-            {'type': 'FeatureCollection', 'features': []}
-        ]
+        self.selenium.find_element_by_xpath(
+            select_get_poly + '/option[@value="points"]'
+        ).click()
+        bf_geoms = [bf_pts, {"type": "FeatureCollection", "features": []}]
         self.assertTrue(disp_bf.is_selected())
         self.selenium.find_element_by_xpath(get_poly_label)
         self.assertMap(base, slug_pk, bf_geoms)
 
         # Click on "None"
-        self.selenium.execute_script('return initialize_test_map(arguments[0])', slug_pk)
+        self.selenium.execute_script(
+            "return initialize_test_map(arguments[0])", slug_pk
+        )
         disp_bf.click()
         self.assertFalse(disp_bf.is_selected())
         self.assertNotInDOM(select_get_poly)
@@ -1469,31 +1500,44 @@ class SeleniumTestsContextRecords(SeleniumTests):
         pks, geojsons = self.pks_and_geojson()
         # from operation
         for i in range(1, 3):
-            self.WebDriverWait(self.selenium, 2).until(
+            self.WebDriverWait(self.selenium, self.waiting_time).until(
                 lambda driver: driver.find_element_by_xpath(
-                    '//a[@class="nav-link dropdown-toggle"][@id="dropdown-menu-main"]'))
+                    '//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"]')
+                '//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="/operation_search/"]').click()
-            details = self.selenium.find_element_by_xpath('//tbody/tr[' + str(i) + ']/td/a[@class="display_details"]')
+            self.selenium.find_element_by_xpath(
+                '//div[@class="dropdown-menu show"]/a[@href="/operation_search/"]'
+            ).click()
+            details = self.selenium.find_element_by_xpath(
+                "//tbody/tr[" + str(i) + ']/td/a[@class="display_details"]'
+            )
             self.scroll(details)
             details.click()
             self.selenium.find_element_by_xpath(
-                '//ul[@role="tablist"]/li/a[contains(text(), "Unités d\'Enregistrement") or contains(text(), "Context records")]').click()
+                '//ul[@role="tablist"]/li/a[contains(text(), "Unités d\'Enregistrement") or contains(text(), "Context records")]'
+            ).click()
             for j in range(1, 3):
                 self._test_cr(j, pks, copy.deepcopy(geojsons), method="from operation")
         # from search bar
         for i in range(1, 5):
-            self.WebDriverWait(self.selenium, 2).until(
+            self.WebDriverWait(self.selenium, self.waiting_time).until(
                 lambda driver: driver.find_element_by_xpath(
-                    '//a[@class="nav-link dropdown-toggle"][@id="dropdown-menu-main"]'))
+                    '//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"]')
+                '//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="/record_search/"]').click()
+            self.selenium.find_element_by_xpath(
+                '//div[@class="dropdown-menu show"]/a[@href="/record_search/"]'
+            ).click()
             self._test_cr(i, pks, copy.deepcopy(geojsons))
         # from bottom table, multiple displays
         for i in range(1, 4):
diff --git a/archaeological_finds/tests.py b/archaeological_finds/tests.py
index 4a1a005c6..17e327bd0 100644
--- a/archaeological_finds/tests.py
+++ b/archaeological_finds/tests.py
@@ -91,7 +91,8 @@ from ishtar_common.tests import (
     WAREHOUSE_FIXTURES,
     COMMON_FIXTURES,
     GenericSerializationTest,
-    SearchText, SeleniumTests,
+    SearchText,
+    SeleniumTests,
 )
 from archaeological_operations.tests import ImportTest, create_operation
 from archaeological_context_records.tests import ContextRecordInit
@@ -2506,15 +2507,10 @@ class GeomaticTest(FindInit, TestCase):
     def test_get_geo_items(self):
         from ishtar_common.tests import GeomaticTest as BaseGeomaticTest
 
-        #profile = models.get_current_profile()
+        # profile = models.get_current_profile()
         profile = get_current_profile()
         profile.mapping = True
         profile.save()
-        '''username, password, user = create_superuser()
-        client = Client()
-        client.login(username=username, password=password)
-        print("is_authenticated")
-        print(user.is_authenticated())'''
 
         geoms, pks = BaseGeomaticTest.setUpDefaultGeoItems(self.user)
         dics = BaseGeomaticTest.geojson_geo_items(geoms, pks, test_get_geo_items=True)
@@ -2523,22 +2519,22 @@ class GeomaticTest(FindInit, TestCase):
 
         for label in dics.keys():
             dic = dics[label]
-            get_pk = dic['get_pk']
+            get_pk = dic["get_pk"]
             pk = pks[label]
 
-            self.assertEqual(dic['res_polys'], dic['get_polys'])
+            self.assertEqual(dic["res_polys"], dic["get_polys"])
             response = self.client.get(url_polys + get_pk + "0")
             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['get_polys'], json.loads(response.content))
+            self.assertEqual(dic["get_polys"], json.loads(response.content))
 
-            self.assertEqual(dic['get_pts'], dic['res_pts'])
+            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['get_pts'], json.loads(response.content))
+            self.assertEqual(dic["get_pts"], json.loads(response.content))
 
 
 
@@ -2838,50 +2834,42 @@ class TemplateTest(FindInit, TestCase):
             if os.path.exists(tpl):
                 os.remove(tpl)
 
+
 @tag("ui")
 class SeleniumTestsBaseFinds(SeleniumTests):
     fixtures = FIND_FIXTURES
 
     def _test_bf(self, i, pks, geojsons, from_search=False):
-        title = self.selenium.find_element_by_xpath('//h3[contains(text(), "Mobilier") or contains(text(), "Find")]')
-        panel = title.find_element_by_xpath('./..')
+        title = self.selenium.find_element_by_xpath(
+            '//h3[contains(text(), "Mobilier") or contains(text(), "Find")]'
+        )
+        panel = title.find_element_by_xpath("./..")
         if from_search:
-            tbody = './form' + '/div' * 7 + '/table/tbody'
+            tbody = "./form" + "/div" * 7 + "/table/tbody"
         else:
-            tbody = '.' + '/div' * 6 + '/table/tbody'
-        details = panel.find_element_by_xpath(tbody + '/tr[' + str(i) + ']/td/a[@class="display_details"]')
+            tbody = "." + "/div" * 6 + "/table/tbody"
+        details = panel.find_element_by_xpath(
+            tbody + "/tr[" + str(i) + ']/td/a[@class="display_details"]'
+        )
         self.scroll(details)
         details.click()
         label = None
-        timeout = 20
         t = time()
-        while not label and time()-t < timeout:
-            for internalId in self.selenium.find_elements_by_xpath('//small[@title="ID interne" or @title="Internal ID"]'):
-                if 'Find' in internalId.text:
+        while not label and time() - t < self.waiting_time:
+            for internalId in self.selenium.find_elements_by_xpath(
+                '//small[@title="ID interne" or @title="Internal ID"]'
+            ):
+                if "Find" in internalId.text:
                     label = internalId.text
                     break
-        '''label = '//small[@title="ID interne" or @title="Internal ID"][contains(text(), "Find")]'
-        self.WebDriverWait(self.selenium, 2).until(
-            lambda driver: driver.find_element_by_xpath(label))
-        label = self.selenium.find_element_by_xpath(label).text'''
-        label = label.split('-')
+        label = label.split("-")
         self.assertEqual(len(label), 3)
         label = label[2]
 
         bf = models.BaseFind.objects.get(pk=pks[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[label]['get_pts']
-        else:
-            bf_base = geojsons[label]['get_polys']
+        slug_pk = bf.SLUG + "-" + str(bf.pk)
+
+        bf_base = geojsons[label]["get_polys"]
         self.assertMap(bf_base, slug_pk)
 
         title = '//dl[@class="col-12"]/dt[text()="Display geo items" or text()="Afficher les éléments"]'
@@ -2896,48 +2884,70 @@ class SeleniumTestsBaseFinds(SeleniumTests):
         pks, geojsons = self.pks_and_geojson()
         # from operation
         for i in range(1, 3):
-            self.WebDriverWait(self.selenium, 2).until(
+            self.WebDriverWait(self.selenium, self.waiting_time).until(
                 lambda driver: driver.find_element_by_xpath(
-                    '//a[@class="nav-link dropdown-toggle"][@id="dropdown-menu-main"]'))
+                    '//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"]')
+                '//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="/operation_search/"]').click()
-            details = self.selenium.find_element_by_xpath('//tbody/tr[' + str(i) + ']/td/a[@class="display_details"]')
+            self.selenium.find_element_by_xpath(
+                '//div[@class="dropdown-menu show"]/a[@href="/operation_search/"]'
+            ).click()
+            details = self.selenium.find_element_by_xpath(
+                "//tbody/tr[" + str(i) + ']/td/a[@class="display_details"]'
+            )
             self.scroll(details)
             details.click()
             self.selenium.find_element_by_xpath(
-                '//ul[@role="tablist"]/li/a[contains(text(), "Mobilier") or contains(text(), "Finds")]').click()
+                '//ul[@role="tablist"]/li/a[contains(text(), "Mobilier") or contains(text(), "Finds")]'
+            ).click()
             for j in range(1, 5):
                 self._test_bf(j, pks, copy.deepcopy(geojsons))
         # from context record
         for i in range(1, 5):
-            self.WebDriverWait(self.selenium, 2).until(
+            self.WebDriverWait(self.selenium, self.waiting_time).until(
                 lambda driver: driver.find_element_by_xpath(
-                    '//a[@class="nav-link dropdown-toggle"][@id="dropdown-menu-main"]'))
+                    '//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"]')
+                '//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="/record_search/"]').click()
-            details = self.selenium.find_element_by_xpath('//tbody/tr[' + str(i) + ']/td/a[@class="display_details"]')
+            self.selenium.find_element_by_xpath(
+                '//div[@class="dropdown-menu show"]/a[@href="/record_search/"]'
+            ).click()
+            details = self.selenium.find_element_by_xpath(
+                "//tbody/tr[" + str(i) + ']/td/a[@class="display_details"]'
+            )
             self.scroll(details)
             details.click()
             self.selenium.find_element_by_xpath(
-                '//ul[@role="tablist"]/li/a[contains(text(), "Mobilier") or contains(text(), "Finds")]').click()
+                '//ul[@role="tablist"]/li/a[contains(text(), "Mobilier") or contains(text(), "Finds")]'
+            ).click()
             for j in range(1, 3):
                 self._test_bf(j, pks, copy.deepcopy(geojsons))
         # from search
         for i in range(1, 9):
-            self.WebDriverWait(self.selenium, 2).until(
+            self.WebDriverWait(self.selenium, self.waiting_time).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"]')
+                    '//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.selenium.find_element_by_xpath(
+                '//div[@class="dropdown-menu show"]/a[@href="/find_search/"]'
+            ).click()
             self._test_bf(i, pks, copy.deepcopy(geojsons), from_search=True)
         # from bottom table
-        for i in range(1,8):
+        for i in range(1, 8):
             self._test_bf(i, pks, copy.deepcopy(geojsons), from_search=True)
diff --git a/archaeological_operations/tests.py b/archaeological_operations/tests.py
index 5927e769f..45cdc93dd 100644
--- a/archaeological_operations/tests.py
+++ b/archaeological_operations/tests.py
@@ -96,7 +96,8 @@ from ishtar_common.tests import (
     COMMON_FIXTURES,
     GenericSerializationTest,
     WAREHOUSE_FIXTURES,
-    SearchText, SeleniumTests,
+    SearchText,
+    SeleniumTests,
 )
 from ishtar_common.serializers import restore_serialized
 
@@ -195,8 +196,8 @@ class ImportTest(object):
         # target for this import
         target = (
             TargetKey.objects.filter(target__target="operation_type")
-                .order_by("-pk")
-                .all()[0]
+            .order_by("-pk")
+            .all()[0]
         )
         target.value = models.OperationType.objects.get(txt_idx="prog_excavation").pk
         target.is_set = True
@@ -301,7 +302,7 @@ class ImportTest(object):
         mcc = ImporterType.objects.get(name="MCC - UE")
         mcc_file = open(
             settings.ROOT_PATH + "../archaeological_context_records/tests/"
-                                 "MCC-context-records-example.csv",
+            "MCC-context-records-example.csv",
             "rb",
         )
         file_dict = {
@@ -1579,12 +1580,12 @@ class ParcelTest(ImportTest, TestCase):
                     self.assertTrue(
                         (values["section"], values["parcel_number"]) in result[year],
                         msg='Section - Parcel number: "%s - %s" is not '
-                            'in "%s"'
-                            % (
-                                values["section"],
-                                values["parcel_number"],
-                                str(result[year]),
-                            ),
+                        'in "%s"'
+                        % (
+                            values["section"],
+                            values["parcel_number"],
+                            str(result[year]),
+                        ),
                     )
                     parcels.pop(parcels.index(values))
                     result[year].pop(
@@ -1595,14 +1596,14 @@ class ParcelTest(ImportTest, TestCase):
                 parcels,
                 [],
                 msg='Parcel(s): "%s" haven\'t be '
-                    'recognized in "%s"' % (str(parcels), value),
+                'recognized in "%s"' % (str(parcels), value),
             )
             not_imported = [data for data in result.values() if data]
             self.assertEqual(
                 not_imported,
                 [],
                 msg='Parcel(s): "%s" haven\'t be '
-                    'recognized in "%s"' % (str(not_imported), value),
+                'recognized in "%s"' % (str(not_imported), value),
             )
 
 
@@ -1912,14 +1913,14 @@ class OperationTest(TestCase, OperationInitTest):
         operation.save()
         self.assertIsNotNone(operation.search_vector)
         for key in (
-                "old",
-                "dirty",
-                "daisy",
-                "'2010'",
-                "zardoz",
-                "huiaaa5",
-                "{}42huiaaa5".format(profile.operation_prefix.lower()),
-                "42huiaaa5",
+            "old",
+            "dirty",
+            "daisy",
+            "'2010'",
+            "zardoz",
+            "huiaaa5",
+            "{}42huiaaa5".format(profile.operation_prefix.lower()),
+            "42huiaaa5",
         ):
             self.assertIn(key, operation.search_vector)
 
@@ -2082,8 +2083,8 @@ class OperationTest(TestCase, OperationInitTest):
         f = BytesIO(response.content)
         filetype = (
             Popen("/usr/bin/file -b --mime -", shell=True, stdout=PIPE, stdin=PIPE)
-                .communicate(f.read(1024))[0]
-                .strip()
+            .communicate(f.read(1024))[0]
+            .strip()
         )
         self.assertTrue(filetype.startswith(b"application/pdf"))
 
@@ -2535,19 +2536,22 @@ class CustomFormTest(TestCase, OperationInitTest):
 
         response = c.get(
             reverse("get-operation"),
-            {"search_vector": "{}=endormie".format(slugify(cf1.label))})
+            {"search_vector": "{}=endormie".format(slugify(cf1.label))},
+        )
         result = json.loads(response.content.decode())
         self.assertEqual(result["recordsTotal"], 0)
 
         response = c.get(
             reverse("get-operation"),
-            {"search_vector": "{}=réveillée".format(slugify(cf1.label))})
+            {"search_vector": "{}=réveillée".format(slugify(cf1.label))},
+        )
         result = json.loads(response.content.decode())
         self.assertEqual(result["recordsTotal"], 1)
 
         response = c.get(
             reverse("get-operation"),
-            {"search_vector": "{}=oui".format(slugify(cf2.label))})
+            {"search_vector": "{}=oui".format(slugify(cf2.label))},
+        )
         result = json.loads(response.content.decode())
         self.assertEqual(result["recordsTotal"], 1)
 
@@ -4184,6 +4188,7 @@ class DocumentQATest(OperationInitTest, TestCase):
             models.Document.objects.get(pk=document_1.pk).source_type, source_type
         )
 
+
 @tag("ui")
 class SeleniumTestsOperations(SeleniumTests):
     fixtures = OPERATION_FIXTURES
@@ -4194,47 +4199,61 @@ class SeleniumTestsOperations(SeleniumTests):
         disp_cr_id = "disp-cr-for-" + slug_pk
         disp_bf_id = "disp-bf-for-" + slug_pk
 
-        ope_polys = geojsons[label]['get_polys']
-        cr_labels_polys = ope_polys['properties'].pop('context-records')
-        bf_labels_polys = ope_polys['properties'].pop('base-finds')
-        cr_polys = {'type': 'FeatureCollection', 'features': []}
+        ope_polys = geojsons[label]["get_polys"]
+        cr_labels_polys = ope_polys["properties"].pop("context-records")
+        bf_labels_polys = ope_polys["properties"].pop("base-finds")
+        cr_polys = {"type": "FeatureCollection", "features": []}
         for cr_label in cr_labels_polys:
-            geojsons[cr_label]['get_polys']['properties'] = None
-            cr_polys['features'].append(geojsons[cr_label]['get_polys'])
-        bf_polys = {'type': 'FeatureCollection',
-                    'features': [geojsons[bf_label]['get_polys'] for bf_label in bf_labels_polys]
-                    }
-
-        ope_pts = geojsons[label]['get_pts']
-        cr_labels_pts = ope_pts['properties'].pop('context-records')
-        cr_pts = {'type': 'FeatureCollection', 'features': []}
+            geojsons[cr_label]["get_polys"]["properties"] = None
+            cr_polys["features"].append(geojsons[cr_label]["get_polys"])
+        bf_polys = {
+            "type": "FeatureCollection",
+            "features": [
+                geojsons[bf_label]["get_polys"] for bf_label in bf_labels_polys
+            ],
+        }
+
+        ope_pts = geojsons[label]["get_pts"]
+        cr_labels_pts = ope_pts["properties"].pop("context-records")
+        cr_pts = {"type": "FeatureCollection", "features": []}
         for cr_label in cr_labels_pts:
-            geojsons[cr_label]['get_pts']['properties'] = None
-            cr_pts['features'].append(geojsons[cr_label]['get_pts'])
-        bf_labels_pts = ope_pts['properties'].pop('base-finds')
-        bf_pts = {'type': 'FeatureCollection',
-                    'features': [geojsons[bf_label]['get_pts'] for bf_label in bf_labels_pts]
-                    }
-
-        if False:  # geojsons[label]['precise']
-            ope_base = geojsons[label]['get_pts']
-        else:
-            ope_base = geojsons[label]['get_polys']
+            geojsons[cr_label]["get_pts"]["properties"] = None
+            cr_pts["features"].append(geojsons[cr_label]["get_pts"])
+        bf_labels_pts = ope_pts["properties"].pop("base-finds")
+        bf_pts = {
+            "type": "FeatureCollection",
+            "features": [geojsons[bf_label]["get_pts"] for bf_label in bf_labels_pts],
+        }
+
+        ope_base = geojsons[label]["get_polys"]
         title = self.selenium.find_element_by_xpath(
-            '//h3[text()="Rechercher une opération" or text()="Operation search"]')
-        panel = title.find_element_by_xpath('./..')
-        tbody = './form' + '/div'*7 + '/table/tbody'
-        details = panel.find_element_by_xpath(tbody + '/tr[' + str(i) + ']/td/a[@class="display_details"]')
+            '//h3[text()="Rechercher une opération" or text()="Operation search"]'
+        )
+        panel = title.find_element_by_xpath("./..")
+        tbody = "./form" + "/div" * 7 + "/table/tbody"
+        details = panel.find_element_by_xpath(
+            tbody + "/tr[" + str(i) + ']/td/a[@class="display_details"]'
+        )
         self.scroll(details)
         details.click()
-        self.WebDriverWait(self.selenium, 2).until(
+        self.WebDriverWait(self.selenium, self.waiting_time).until(
             lambda driver: driver.find_element_by_xpath(
-                '//dl[@class="col-12"]/dt[@id="display-geo-items-for-' + slug_pk + '"]'))
+                '//dl[@class="col-12"]/dt[@id="display-geo-items-for-' + slug_pk + '"]'
+            )
+        )
         dd = '//dl[@class="col-12"]/dd'
-        self.selenium.find_element_by_xpath(dd + '/fieldset/label[@for="' + disp_cr_id + '"]')
-        disp_cr = self.selenium.find_element_by_xpath(dd + '/fieldset/input[@id="' + disp_cr_id + '"]')
-        self.selenium.find_element_by_xpath(dd + '/fieldset/label[@for="' + disp_bf_id + '"]')
-        disp_bf = self.selenium.find_element_by_xpath(dd + '/fieldset/input[@id="' + disp_bf_id + '"]')
+        self.selenium.find_element_by_xpath(
+            dd + '/fieldset/label[@for="' + disp_cr_id + '"]'
+        )
+        disp_cr = self.selenium.find_element_by_xpath(
+            dd + '/fieldset/input[@id="' + disp_cr_id + '"]'
+        )
+        self.selenium.find_element_by_xpath(
+            dd + '/fieldset/label[@for="' + disp_bf_id + '"]'
+        )
+        disp_bf = self.selenium.find_element_by_xpath(
+            dd + '/fieldset/input[@id="' + disp_bf_id + '"]'
+        )
         self.assertFalse(disp_cr.is_selected())
         self.assertFalse(disp_bf.is_selected())
         select_get_poly = dd + '/select[@id="' + get_poly_id + '"]'
@@ -4244,14 +4263,11 @@ class SeleniumTestsOperations(SeleniumTests):
         self.assertMap(ope_base, slug_pk)
 
         # click on "Context records"
-        self.selenium.execute_script('initialize_test_map(arguments[0])', slug_pk)
+        self.selenium.execute_script("initialize_test_map(arguments[0])", slug_pk)
         self.scroll(disp_cr)
         disp_cr.click()
 
-        cr_geoms = [
-            {'type': 'FeatureCollection', 'features': []},
-            cr_polys
-        ]
+        cr_geoms = [{"type": "FeatureCollection", "features": []}, cr_polys]
         self.assertTrue(disp_cr.is_selected())
         self.assertFalse(disp_bf.is_selected())
         self.selenium.find_element_by_xpath(get_poly_label)
@@ -4259,18 +4275,17 @@ class SeleniumTestsOperations(SeleniumTests):
 
         get_poly = self.selenium.find_element_by_xpath(select_get_poly)
         get_poly.click()
-        self.selenium.find_element_by_xpath(select_get_poly + '/option[@value="points"]').click()
-        cr_geoms = [
-            {'type': 'FeatureCollection', 'features': []},
-            cr_pts
-        ]
+        self.selenium.find_element_by_xpath(
+            select_get_poly + '/option[@value="points"]'
+        ).click()
+        cr_geoms = [{"type": "FeatureCollection", "features": []}, cr_pts]
         self.assertTrue(disp_cr.is_selected())
         self.assertFalse(disp_bf.is_selected())
         self.selenium.find_element_by_xpath(get_poly_label)
         self.assertMap(ope_base, slug_pk, cr_geoms)
 
         # Click on everything
-        self.selenium.execute_script('initialize_test_map(arguments[0])', slug_pk)
+        self.selenium.execute_script("initialize_test_map(arguments[0])", slug_pk)
         disp_bf.click()
         every_geoms = [bf_pts, cr_pts]
         self.assertTrue(disp_cr.is_selected())
@@ -4278,9 +4293,11 @@ class SeleniumTestsOperations(SeleniumTests):
         self.selenium.find_element_by_xpath(get_poly_label)
         self.assertMap(ope_base, slug_pk, every_geoms)
 
-        self.selenium.execute_script('initialize_test_map(arguments[0])', slug_pk)
+        self.selenium.execute_script("initialize_test_map(arguments[0])", slug_pk)
         get_poly.click()
-        self.selenium.find_element_by_xpath(select_get_poly + '/option[@value="polygons"]').click()
+        self.selenium.find_element_by_xpath(
+            select_get_poly + '/option[@value="polygons"]'
+        ).click()
         every_geoms = [bf_polys, cr_polys]
         self.assertTrue(disp_cr.is_selected())
         self.assertTrue(disp_bf.is_selected())
@@ -4288,14 +4305,11 @@ class SeleniumTestsOperations(SeleniumTests):
         self.assertMap(ope_base, slug_pk, every_geoms)
 
         # click on "Base finds"
-        self.selenium.execute_script('initialize_test_map(arguments[0])', slug_pk)
+        self.selenium.execute_script("initialize_test_map(arguments[0])", slug_pk)
         self.scroll(disp_cr)
         disp_cr.click()
 
-        bf_geoms = [
-            bf_polys,
-            {'type': 'FeatureCollection', 'features': []}
-        ]
+        bf_geoms = [bf_polys, {"type": "FeatureCollection", "features": []}]
         self.assertFalse(disp_cr.is_selected())
         self.assertTrue(disp_bf.is_selected())
         self.selenium.find_element_by_xpath(get_poly_label)
@@ -4304,18 +4318,17 @@ class SeleniumTestsOperations(SeleniumTests):
         select_get_poly = dd + '/select[@id="' + get_poly_id + '"]'
         get_poly = self.selenium.find_element_by_xpath(select_get_poly)
         get_poly.click()
-        self.selenium.find_element_by_xpath(select_get_poly + '/option[@value="points"]').click()
-        bf_geoms = [
-            bf_pts,
-            {'type': 'FeatureCollection', 'features': []}
-        ]
+        self.selenium.find_element_by_xpath(
+            select_get_poly + '/option[@value="points"]'
+        ).click()
+        bf_geoms = [bf_pts, {"type": "FeatureCollection", "features": []}]
         self.assertFalse(disp_cr.is_selected())
         self.assertTrue(disp_bf.is_selected())
         self.selenium.find_element_by_xpath(get_poly_label)
         self.assertMap(ope_base, slug_pk, bf_geoms)
 
         # Click on "None"
-        self.selenium.execute_script('initialize_test_map(arguments[0])', slug_pk)
+        self.selenium.execute_script("initialize_test_map(arguments[0])", slug_pk)
         disp_bf.click()
         self.assertFalse(disp_cr.is_selected())
         self.assertFalse(disp_bf.is_selected())
@@ -4326,28 +4339,33 @@ class SeleniumTestsOperations(SeleniumTests):
     def test_geo_items(self):
         pks, geojsons = self.pks_and_geojson()
 
-        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.WebDriverWait(self.selenium, self.waiting_time).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"]'
+        )
         dropdown.click()
-        self.selenium.find_element_by_xpath('//div[@class="dropdown-menu show"]/a[@href="/operation_search/"]').click()
-        ope = models.Operation.objects.get(pk=pks['Poly'])
-        slug_pk_poly = str(ope.SLUG) + "-" + str(ope.pk)
-        self._test_operation(2, slug_pk_poly, copy.deepcopy(geojsons), 'Poly')
+        self.selenium.find_element_by_xpath(
+            '//div[@class="dropdown-menu show"]/a[@href="/operation_search/"]'
+        ).click()
+        ope = models.Operation.objects.get(pk=pks["Poly"])
+        slug_pk_poly = ope.SLUG + "-" + str(ope.pk)
+        self._test_operation(2, slug_pk_poly, copy.deepcopy(geojsons), "Poly")
 
         dropdown = self.selenium.find_element_by_xpath(
-            '//a[@class="nav-link dropdown-toggle"][@id="dropdown-menu-main"]')
+            '//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="/operation_search/"]').click()
-        ope = models.Operation.objects.get(pk=pks['Pt'])
-        print('\n')
-        print('OPERATION POINT')
-        print(ope)
-        print(ope.multi_polygon.coords)
-        print(ope.point_2d.coords)
-        slug_pk_pt = str(ope.SLUG) + "-" + str(ope.pk)
-        self._test_operation(1, slug_pk_pt, copy.deepcopy(geojsons), 'Pt')
+        self.selenium.find_element_by_xpath(
+            '//div[@class="dropdown-menu show"]/a[@href="/operation_search/"]'
+        ).click()
+        ope = models.Operation.objects.get(pk=pks["Pt"])
+        slug_pk_pt = ope.SLUG + "-" + str(ope.pk)
+        self._test_operation(1, slug_pk_pt, copy.deepcopy(geojsons), "Pt")
 
         # display both at the same time (1 is already displayed)
-        self._test_operation(2, slug_pk_poly, geojsons, 'Poly')
+        self._test_operation(2, slug_pk_poly, geojsons, "Poly")
diff --git a/ishtar_common/static/js/ishtar-map.js b/ishtar_common/static/js/ishtar-map.js
index aa7263f7f..4403c7b62 100644
--- a/ishtar_common/static/js/ishtar-map.js
+++ b/ishtar_common/static/js/ishtar-map.js
@@ -146,9 +146,9 @@ var TrackPositionControl = (function (Control) {
 
     if ( Control ) TrackPositionControl.__proto__ = Control;
     TrackPositionControl.prototype = Object.create( Control && Control.prototype );
-    TrackPositionControl.prototype.varructor = TrackPositionControl;
+    TrackPositionControl.prototype.constructor = TrackPositionControl;
 
-    TrackPositionControl.prototype.handvarrackPosition = function handvarrackPosition () {
+    TrackPositionControl.prototype.handleTrackPosition = function handleTrackPosition () {
         if (!geolocation[this.map_id]){
             set_geoloc_source(this.map_id);
         } else {
@@ -452,7 +452,7 @@ var open_map_window = function(map_id){
     };
 };
 
-var complete_list_label = "compvare list...";
+var complete_list_label = "complete list...";
 
 var _display_items = function(map_id, features, offset_x, offset_y){
     // console.log("display_items");
@@ -550,11 +550,12 @@ var vector_source = {};
 var vector_layer = {};
 var vector_features = {};
 
-// for test
-var geo_items_features = null;
-var current_test = false;
+/* for test */
+
+let geo_items_features = null;
+let current_test = false;
 var initialize_test_map = function (slug_pk) {
-    var id = "http-geo-items-ready-" + slug_pk;
+    const id = "http-geo-items-ready-" + slug_pk;
     geo_items_features = {};
     current_test = true;
     if ($("#"+id).length === 0) {
@@ -663,7 +664,7 @@ var display_lines_and_polys = function(map_id, lines_and_polys){
 
 var display_geo_items = function(map_id, base_url, slug, pk,
                               disp_cr, disp_bf, get_poly) {
-    var url = base_url;
+    let url = base_url;
     if (slug === "operation") {
         url += "?operation_pk=";
     }
@@ -677,9 +678,7 @@ var display_geo_items = function(map_id, base_url, slug, pk,
     httpRequest.onreadystatechange = function() {
         if (httpRequest.readyState === XMLHttpRequest.DONE) {
             if (httpRequest.status === 200) {
-                geo_items = to_geo_items(JSON.parse(httpRequest.responseText), slug, disp_cr, disp_bf)
-                console.log('geoitems')
-                console.log(geo_items)
+                const geo_items = to_geo_items(JSON.parse(httpRequest.responseText), slug, disp_cr, disp_bf)
                 if (current_test) {
                     geo_items_features[map_id] = [];
                 }
@@ -710,7 +709,7 @@ var to_geo_items = function (obj, slug, disp_cr, disp_bf) {
     if (slug === "operation") {
         const crs = obj['properties']['context-records'];
         for (const cr of crs['features']) {
-            if (disp_bf) {console.log(cr);
+            if (disp_bf) {
                 for (const bf of cr['properties']['base-finds']['features']) {
                     objects['base-finds']['features'].push(bf)
                 }
@@ -730,14 +729,14 @@ var to_geo_items = function (obj, slug, disp_cr, disp_bf) {
 }
 
 var display_associated_polys = function (map_id, polys, slug) {
-    _vector_features = geojson_format.readFeatures(polys);
-    _vector_source = new ol.source.Vector();
+    const _vector_features = geojson_format.readFeatures(polys);
+    const _vector_source = new ol.source.Vector();
     _vector_source.addFeatures(_vector_features);
-    style = get_associated_base_find_style;
+    let style = get_associated_base_find_style;
     if (slug === 'contextrecord') {
         style = get_associated_context_record_style;
     }
-    _vector_layer = new ol.layer.Vector({
+    const _vector_layer = new ol.layer.Vector({
         source: _vector_source,
         style: style
     });
@@ -771,20 +770,15 @@ var get_associated_context_record_style = function (feature) {
 };
 
 var display_associated_points = function (map_id, points, slug) {
-    console.log('geo items points')
-    console.log(points);
-    _point_features = geojson_format.readFeatures(points);
-    _cluster_source = new ol.source.Cluster({
+    const _point_features = geojson_format.readFeatures(points);
+    const _cluster_source = new ol.source.Cluster({
         distance: 40,
         source: new ol.source.Vector()
     });
     _cluster_source.getSource().addFeatures(_point_features);
     // TODO: create own style
-    style = cluster_get_style;
-    if (slug === 'contextrecord') {
-        style = style;
-    }
-    _cluster_layer = new ol.layer.Vector({
+    const style = cluster_get_style;
+    const _cluster_layer = new ol.layer.Vector({
         name: 'Cluster',
         source: _cluster_source,
         style: style
@@ -793,86 +787,16 @@ var display_associated_points = function (map_id, points, slug) {
     return _point_features;
 }
 
-// for test purpose
-// to insert in sheet_simple_map.html when working with maps
-// wait_for_map("map-{{window_id}}-{{geo_item.SLUG}}-{{geo_item.pk}}");
-var wait_for_map = function(map_id) {
-    map[map_id].on('rendercomplete', function(event) {
-        console.log("map fully loaded");
-    })
-    if (map_id in cluster_layer) {
-        console.log('cluster layer');
-        cluster_layer[map_id].on('change', function(event) {
-            if (cluster_layer.getState === "ready") {
-                console.log("cluster fully loaded");
-            }
-        })
-    }
-    if (map_id in vector_layer) {
-        console.log('vector layer');
-        vector_layer[map_id].on('change', function(event) {
-            if (vector_layer.getState === "ready") {
-                console.log("vector fully loaded");
-            }
-        })
-    }
-    if (map_id in cluster_source) {
-        console.log('cluster source');
-        cluster_source[map_id].on('change', function(event) {
-            if (cluster_source.getState === "ready") {
-                console.log("cluster source fully loaded");
-            }
-        })
-    }
-    if (map_id in vector_source) {
-        console.log('vector source');
-        vector_source[map_id].on('change', function(event) {
-            if (vector_source.getState === "ready") {
-                console.log("vector source fully loaded");
-            }
-        })
-    }
-}
-
-var get_map_by_id_test = function (id) {
-// problem here: async function because map and layers are not fully loaded directly
-    map[id].getLayers().getArray()[0].getSource().on(
-        'change', function (evt) {
-            console.log('change')
-            var source = evt.target;
-            if (source.getState() === "ready") {
-                console.log('ready');
-                console.log(map_layers[id][0].getSource().getKeys())
-            }
-        }
-    )
-    map[id].on(
-        'change', function (evt) {
-            console.log('change')
-            var map = evt.target;
-            if (map.getState() === "ready") {
-                console.log('ready');
-                console.log(map_layers[id][0].getSource().getKeys())
-            }
-        }
-    )
-    console.log("vector_features")
-    console.log(vector_features[id])
-    console.log("layers")
-    console.log(map_layers[id])
-    console.log("source")
-    console.log(map_layers[id][0].getSource())
-}
-
 var get_features_by_id = function (id) {
+    let base_features = null
     if (vector_features[id] == null) {
-        var base_features = geojson_format.writeFeaturesObject(point_features[id], {decimals: 5});
+        base_features = geojson_format.writeFeaturesObject(point_features[id], {decimals: 5});
     } else {
-        var base_features = geojson_format.writeFeaturesObject(vector_features[id], {decimals: 5});
+        base_features = geojson_format.writeFeaturesObject(vector_features[id], {decimals: 5});
     }
-    var geo_items_feats = [];
+    const geo_items_feats = [];
     if (geo_items_features && id in geo_items_features) {
-        for (var features of geo_items_features[id]) {
+        for (const features of geo_items_features[id]) {
             geo_items_feats.push(geojson_format.writeFeaturesObject(features, {decimals: 5}));
         }
     }
@@ -880,5 +804,14 @@ var get_features_by_id = function (id) {
 }
 
 var base_features_type = function (id) {
-    return "vector " + typeof vector_features[id] + ", cluster " + typeof point_features[id] ;
+    if (vector_features[id] == null) {
+        if (point_features[id] == null) {
+            return 'both null';
+        }
+        else { return 'Point'; }
+    }
+    if (point_features[id] == null) {
+        return 'MultiPolygon';
+    }
+    else { return 'Point and MultiPolygon' }
 }
diff --git a/ishtar_common/tests.py b/ishtar_common/tests.py
index 1c757dd2a..2077a3781 100644
--- a/ishtar_common/tests.py
+++ b/ishtar_common/tests.py
@@ -84,6 +84,9 @@ from ishtar_common.utils import (
 from ishtar_common.tasks import launch_export
 from ishtar_common import utils_secretary
 
+from django.contrib.staticfiles.testing import StaticLiveServerTestCase
+from selenium.webdriver.firefox.webdriver import WebDriver
+
 
 COMMON_FIXTURES = [
     settings.ROOT_PATH + "../fixtures/initial_data-auth-fr.json",
@@ -797,7 +800,7 @@ class SerializationTest(GenericSerializationTest, TestCase):
             AlterationCauseType,
             TreatmentEmergencyType,
             CommunicabilityType,
-            FunctionalArea
+            FunctionalArea,
         )
         from archaeological_operations.models import CulturalAttributionType
 
@@ -2735,18 +2738,24 @@ class GeomaticTest(TestCase):
         from ishtar_common.models_common import SpatialReferenceSystem
 
         wgs84 = SpatialReferenceSystem.objects.get(srid=4326)
-        poly_ope = ("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)))")
+        poly_ope = (
+            "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)))"
+        )
         point_ope = GEOSGeometry("POINT({} {} {})".format(3.8, 3, 1), srid=4326)
         point_2d_ope = GEOSGeometry("POINT({} {})".format(3.8, 3), srid=4326)
         xy_ope = 3.8, 3
-        poly_cr = ("MULTIPOLYGON(((2 1,5 1,5 5,1 5,2 1),(2 2,2 3,3 3,3 2,2 2)),"
-                   "((6 3,9 2,9 4,6 3)))")
+        poly_cr = (
+            "MULTIPOLYGON(((2 1,5 1,5 5,1 5,2 1),(2 2,2 3,3 3,3 2,2 2)),"
+            "((6 3,9 2,9 4,6 3)))"
+        )
         point_cr = GEOSGeometry("POINT({} {} {})".format(3.9, 3, 1), srid=4326)
         point_2d_cr = GEOSGeometry("POINT({} {})".format(3.9, 3), srid=4326)
         xy_cr = 3.9, 3
-        poly_bf = ("MULTIPOLYGON(((2 1,4 1,4 4,1 4,2 1),(2 2,2 3,3 3,3 2,2 2)),"
-                   "((6 3,9 2,9 4,6 3)))")
+        poly_bf = (
+            "MULTIPOLYGON(((2 1,4 1,4 4,1 4,2 1),(2 2,2 3,3 3,3 2,2 2)),"
+            "((6 3,9 2,9 4,6 3)))"
+        )
         point_bf = GEOSGeometry("POINT({} {} {})".format(3.9, 2.9, 1), srid=4326)
         point_2d_bf = GEOSGeometry("POINT({} {})".format(3.9, 2.9), srid=4326)
         xy_bf = 3.9, 2.9
@@ -2808,7 +2817,7 @@ class GeomaticTest(TestCase):
             bf.save()
             bf = BaseFind.objects.get(pk=bf.pk)
             bfs.append(bf)
-            pks[default['label']] = bf.pk
+            pks[default["label"]] = bf.pk
 
             find = Find.objects.create()
             find.base_finds.add(bf)
@@ -2821,30 +2830,61 @@ class GeomaticTest(TestCase):
 
         ope1 = create_operation(user)
         ope2 = create_operation(user)
-        pks = {'Pt': ope1.pk, 'Poly': ope2.pk}
+        pks = {"Pt": ope1.pk, "Poly": ope2.pk}
 
-        pks.update(GeomaticTest.create_cr_with_bfs(ope1, "Point", "Point", ["Polygon", "Point"], "CR Pt Pt"))
-        pks.update(GeomaticTest.create_cr_with_bfs(ope1, "Point", "Polygon", ["Polygon", "Point"], "CR Pt Poly"))
-        pks.update(GeomaticTest.create_cr_with_bfs(ope2, "Polygon", "Point", ["Polygon", "Point"], "CR Poly Pt"))
-        pks.update(GeomaticTest.create_cr_with_bfs(ope2, "Polygon", "Polygon", ["Polygon", "Point"], "CR Poly Poly"))
+        pks.update(
+            GeomaticTest.create_cr_with_bfs(
+                ope1, "Point", "Point", ["Polygon", "Point"], "CR Pt Pt"
+            )
+        )
+        pks.update(
+            GeomaticTest.create_cr_with_bfs(
+                ope1, "Point", "Polygon", ["Polygon", "Point"], "CR Pt Poly"
+            )
+        )
+        pks.update(
+            GeomaticTest.create_cr_with_bfs(
+                ope2, "Polygon", "Point", ["Polygon", "Point"], "CR Poly Pt"
+            )
+        )
+        pks.update(
+            GeomaticTest.create_cr_with_bfs(
+                ope2, "Polygon", "Polygon", ["Polygon", "Point"], "CR Poly Poly"
+            )
+        )
 
         geom_ope = [
-            [[[[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]]]],
+            [
+                [
+                    [[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]]],
+            ],
             [3.86111, 3.02778],
-            [3.8, 3]
+            [3.8, 3],
         ]
         geom_cr = [
-            [[[[2, 1], [5, 1], [5, 5], [1, 5], [2, 1]], [[2, 2], [2, 3], [3, 3], [3, 2], [2, 2]]],
-             [[[6, 3], [9, 2], [9, 4], [6, 3]]]],
+            [
+                [
+                    [[2, 1], [5, 1], [5, 5], [1, 5], [2, 1]],
+                    [[2, 2], [2, 3], [3, 3], [3, 2], [2, 2]],
+                ],
+                [[[6, 3], [9, 2], [9, 4], [6, 3]]],
+            ],
             [4.17708, 3.11458],
-            [3.9, 3]
+            [3.9, 3],
         ]
         geom_bf = [
-            [[[[2, 1], [4, 1], [4, 4], [1, 4], [2, 1]], [[2, 2], [2, 3], [3, 3], [3, 2], [2, 2]]],
-             [[[6, 3], [9, 2], [9, 4], [6, 3]]]],
+            [
+                [
+                    [[2, 1], [4, 1], [4, 4], [1, 4], [2, 1]],
+                    [[2, 2], [2, 3], [3, 3], [3, 2], [2, 2]],
+                ],
+                [[[6, 3], [9, 2], [9, 4], [6, 3]]],
+            ],
             [4.42105, 2.73684],
-            [3.9, 2.9]
+            [3.9, 2.9],
         ]
         return [geom_ope, geom_cr, geom_bf], pks
 
@@ -2883,38 +2923,63 @@ class GeomaticTest(TestCase):
     def test_setUpDefaultGeoItems(self):
         from django.contrib.gis.geos import GEOSGeometry
         from archaeological_operations.models import Operation
+
         username, password, user = create_superuser()
         base_geoms, pks = self.setUpDefaultGeoItems(user)
         geoms = []
         for geom in base_geoms:
-            poly = GEOSGeometry(json.dumps({'type': 'MultiPolygon', 'coordinates': geom[0]}))
-            centr = GEOSGeometry(json.dumps({'type': 'Point', 'coordinates': geom[1]}))
-            pt = GEOSGeometry(json.dumps({'type': 'Point', 'coordinates': geom[2]}))
+            poly = GEOSGeometry(
+                json.dumps({"type": "MultiPolygon", "coordinates": geom[0]})
+            )
+            centr = GEOSGeometry(json.dumps({"type": "Point", "coordinates": geom[1]}))
+            pt = GEOSGeometry(json.dumps({"type": "Point", "coordinates": geom[2]}))
             geoms.append([poly, centr, pt])
-        ope_pt = Operation.objects.get(pk=pks['Pt'])
+        ope_pt = Operation.objects.get(pk=pks["Pt"])
         self.assertPt(ope_pt, geoms[0])
-        ope_poly = Operation.objects.get(pk=pks['Poly'])
-        print(ope_poly)
-        print(ope_poly.point_2d)
+        ope_poly = Operation.objects.get(pk=pks["Poly"])
         self.assertPoly(ope_poly, geoms[0])
 
-        cr_poly_poly = ope_poly.context_record.get(pk=pks['CR Poly Poly'])
+        cr_poly_poly = ope_poly.context_record.get(pk=pks["CR Poly Poly"])
         self.assertPoly(cr_poly_poly, geoms[1])
-        cr_poly_pt = ope_poly.context_record.get(pk=pks['CR Poly Pt'])
+        cr_poly_pt = ope_poly.context_record.get(pk=pks["CR Poly Pt"])
         self.assertPt(cr_poly_pt, geoms[1])
-        cr_pt_poly = ope_pt.context_record.get(pk=pks['CR Pt Poly'])
+        cr_pt_poly = ope_pt.context_record.get(pk=pks["CR Pt Poly"])
         self.assertPoly(cr_pt_poly, geoms[1], geoms[0][2])
-        cr_pt_pt = ope_pt.context_record.get(pk=pks['CR Pt Pt'])
+        cr_pt_pt = ope_pt.context_record.get(pk=pks["CR Pt Pt"])
         self.assertPt(cr_pt_pt, geoms[1])
 
-        self.assertPt(cr_pt_pt.base_finds.get(pk=pks['Find Point from CR Pt Pt']), geoms[2])
-        self.assertPoly(cr_pt_pt.base_finds.get(pk=pks['Find Polygon from CR Pt Pt']), geoms[2], geoms[1][2])
-        self.assertPt(cr_poly_pt.base_finds.get(pk=pks['Find Point from CR Poly Pt']), geoms[2])
-        self.assertPoly(cr_poly_pt.base_finds.get(pk=pks['Find Polygon from CR Poly Pt']), geoms[2], geoms[1][2])
-        self.assertPt(cr_pt_poly.base_finds.get(pk=pks['Find Point from CR Pt Poly']), geoms[2])
-        self.assertPoly(cr_pt_poly.base_finds.get(pk=pks['Find Polygon from CR Pt Poly']), geoms[2], geoms[0][2])
-        self.assertPt(cr_poly_poly.base_finds.get(pk=pks['Find Point from CR Poly Poly']), geoms[2])
-        self.assertPoly(cr_poly_poly.base_finds.get(pk=pks['Find Polygon from CR Poly Poly']), geoms[2])
+        self.assertPt(
+            cr_pt_pt.base_finds.get(pk=pks["Find Point from CR Pt Pt"]), geoms[2]
+        )
+        self.assertPoly(
+            cr_pt_pt.base_finds.get(pk=pks["Find Polygon from CR Pt Pt"]),
+            geoms[2],
+            geoms[1][2],
+        )
+        self.assertPt(
+            cr_poly_pt.base_finds.get(pk=pks["Find Point from CR Poly Pt"]), geoms[2]
+        )
+        self.assertPoly(
+            cr_poly_pt.base_finds.get(pk=pks["Find Polygon from CR Poly Pt"]),
+            geoms[2],
+            geoms[1][2],
+        )
+        self.assertPt(
+            cr_pt_poly.base_finds.get(pk=pks["Find Point from CR Pt Poly"]), geoms[2]
+        )
+        self.assertPoly(
+            cr_pt_poly.base_finds.get(pk=pks["Find Polygon from CR Pt Poly"]),
+            geoms[2],
+            geoms[0][2],
+        )
+        self.assertPt(
+            cr_poly_poly.base_finds.get(pk=pks["Find Point from CR Poly Poly"]),
+            geoms[2],
+        )
+        self.assertPoly(
+            cr_poly_poly.base_finds.get(pk=pks["Find Polygon from CR Poly Poly"]),
+            geoms[2],
+        )
 
     @staticmethod
     def geojson_geo_items(geoms, pks, test_get_geo_items=False):
@@ -2942,15 +3007,14 @@ class GeomaticTest(TestCase):
             if label[:4] == "Find":
                 dic_t = {
                     "type": "Feature",
-                    "geometry": {
-                        "type": "MultiPolygon", "coordinates": geoms[2][0]
-                    },
+                    "geometry": {"type": "MultiPolygon", "coordinates": geoms[2][0]},
                     "properties": {"label": label},
                 }
                 dic_f = {
                     "type": "Feature",
                     "geometry": {
-                        "type": "Point", "coordinates": pt_coords,
+                        "type": "Point",
+                        "coordinates": pt_coords,
                     },
                     "properties": {"label": label},
                 }
@@ -2958,7 +3022,9 @@ class GeomaticTest(TestCase):
                 cache_dics_f[label] = dic_f
                 if test_get_geo_items:
                     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)
+                    res_f = BaseFind.objects.get(pk=pk).get_geo_items(
+                        get_polygons=False
+                    )
                     get_pk = "?pk="
                 else:
                     get_polys = dic_t
@@ -2968,47 +3034,56 @@ class GeomaticTest(TestCase):
                 cache_key = lambda x: "Find " + x + " from " + label
                 dic_t = {
                     "type": "Feature",
-                    "geometry": {
-                        "type": "MultiPolygon", "coordinates": geoms[1][0]
-                    },
+                    "geometry": {"type": "MultiPolygon", "coordinates": geoms[1][0]},
                     "properties": {
                         "label": label,
                         "base-finds": {
-                            'type': 'FeatureCollection',
-                            'features': [
+                            "type": "FeatureCollection",
+                            "features": [
                                 cache_dics_t[cache_key("Polygon")],
                                 cache_dics_t[cache_key("Point")],
-                            ]
-                        }
+                            ],
+                        },
                     },
                 }
                 dic_f = {
                     "type": "Feature",
                     "geometry": {
-                        "type": "Point", "coordinates": pt_coords,
+                        "type": "Point",
+                        "coordinates": pt_coords,
                     },
                     "properties": {
                         "label": label,
                         "base-finds": {
-                            'type': 'FeatureCollection',
-                            'features': [
+                            "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
                 if test_get_geo_items:
-                    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)
+                    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:
                     get_polys = copy.deepcopy(dic_t)
-                    get_polys['properties']['base-finds'] = [cache_key("Polygon"), cache_key("Point")]
+                    get_polys["properties"]["base-finds"] = [
+                        cache_key("Polygon"),
+                        cache_key("Point"),
+                    ]
                     get_pts = copy.deepcopy(dic_f)
-                    get_pts['properties']['base-finds'] = [cache_key("Polygon"), cache_key("Point")]
+                    get_pts["properties"]["base-finds"] = [
+                        cache_key("Polygon"),
+                        cache_key("Point"),
+                    ]
             else:
                 real_label = "OA3"
                 cache_key_prefix = "CR " + label + " "
@@ -3016,78 +3091,86 @@ class GeomaticTest(TestCase):
                     real_label = "OA2"
                 dic_t = {
                     "type": "Feature",
-                    "geometry": {
-                        "type": "MultiPolygon", "coordinates": geoms[0][0]
-                    },
+                    "geometry": {"type": "MultiPolygon", "coordinates": geoms[0][0]},
                     "properties": {
                         "label": real_label,
                         "context-records": {
-                            'type': 'FeatureCollection',
-                            'features': [
+                            "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": pt_coords,
+                        "type": "Point",
+                        "coordinates": pt_coords,
                     },
                     "properties": {
                         "label": real_label,
                         "context-records": {
-                            'type': 'FeatureCollection',
-                            'features': [
+                            "type": "FeatureCollection",
+                            "features": [
                                 cache_dics_f[cache_key_prefix + "Poly"],
                                 cache_dics_f[cache_key_prefix + "Pt"],
-                            ]
-                        }
+                            ],
+                        },
                     },
                 }
                 if test_get_geo_items:
-                    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)
+                    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="
                 else:
                     get_polys = copy.deepcopy(dic_t)
                     bf_labels = []
-                    for cr in dic_t['properties']['context-records']['features']:
-                        for bf in cr['properties']['base-finds']['features']:
-                            bf_labels.append(bf['properties']['label'])
-                    get_polys['properties'] = {
-                        'context-records': [
+                    for cr in dic_t["properties"]["context-records"]["features"]:
+                        for bf in cr["properties"]["base-finds"]["features"]:
+                            bf_labels.append(bf["properties"]["label"])
+                    get_polys["properties"] = {
+                        "context-records": [
                             cache_key_prefix + "Poly",
-                            cache_key_prefix + "Pt"
+                            cache_key_prefix + "Pt",
                         ],
-                        'base-finds': bf_labels
+                        "base-finds": bf_labels,
                     }
                     get_pts = copy.deepcopy(dic_f)
                     bf_labels = []
-                    for cr in dic_f['properties']['context-records']['features']:
-                        for bf in cr['properties']['base-finds']['features']:
-                            bf_labels.append(bf['properties']['label'])
-                    get_pts['properties'] = {
-                        'context-records': [
+                    for cr in dic_f["properties"]["context-records"]["features"]:
+                        for bf in cr["properties"]["base-finds"]["features"]:
+                            bf_labels.append(bf["properties"]["label"])
+                    get_pts["properties"] = {
+                        "context-records": [
                             cache_key_prefix + "Poly",
-                            cache_key_prefix + "Pt"
+                            cache_key_prefix + "Pt",
                         ],
-                        'base-finds': bf_labels
+                        "base-finds": bf_labels,
                     }
 
             if test_get_geo_items:
-                res[label] = {'get_polys': dic_t,
-                              'get_pts': dic_f,
-                              'res_polys': res_t,
-                              'res_pts': res_f,
-                              'get_pk': get_pk}
+                res[label] = {
+                    "get_polys": dic_t,
+                    "get_pts": dic_f,
+                    "res_polys": res_t,
+                    "res_pts": res_f,
+                    "get_pk": get_pk,
+                }
             else:
-                res[label] = {'get_polys': get_polys,
-                              'get_pts': get_pts,
-                              'precise': precise}
+                res[label] = {
+                    "get_polys": get_polys,
+                    "get_pts": get_pts,
+                    "precise": precise,
+                }
         return res
 
+
 class NewItems(TestCase):
     fixtures = COMMON_FIXTURES
 
@@ -3492,8 +3575,6 @@ class TemplateGenerationTest(TestCase):
                 for key in expected_keys:
                     self.assertIn(key, filtr)
 
-from django.contrib.staticfiles.testing import StaticLiveServerTestCase
-from selenium.webdriver.firefox.webdriver import WebDriver
 
 @tag("ui")
 class SeleniumTests(StaticLiveServerTestCase):
@@ -3504,8 +3585,9 @@ class SeleniumTests(StaticLiveServerTestCase):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
+        cls.waiting_time = 20
         cls.selenium = WebDriver()
-        cls.selenium.implicitly_wait(20)
+        cls.selenium.implicitly_wait(cls.waiting_time)
 
     @classmethod
     def tearDownClass(cls):
@@ -3524,14 +3606,17 @@ class SeleniumTests(StaticLiveServerTestCase):
 
         # login
         self.username, self.password, self.user = create_superuser()
-        self.selenium.get('%s%s' % (self.live_server_url, '/accounts/login/'))
-        self.WebDriverWait(self.selenium, 2).until(
-            lambda driver: driver.find_element_by_name("username"))
+        self.selenium.get("%s%s" % (self.live_server_url, "/accounts/login/"))
+        self.WebDriverWait(self.selenium, self.waiting_time).until(
+            lambda driver: driver.find_element_by_name("username")
+        )
         username_input = self.selenium.find_element_by_name("username")
         username_input.send_keys(self.username)
         password_input = self.selenium.find_element_by_name("password")
         password_input.send_keys(self.password)
-        self.selenium.find_element_by_xpath('//button[@type="submit"][@class="btn btn-primary"]').click()
+        self.selenium.find_element_by_xpath(
+            '//button[@type="submit"][@class="btn btn-primary"]'
+        ).click()
 
     def setUpDefaultGeoItems(self):
         return GeomaticTest.setUpDefaultGeoItems(self.user)
@@ -3546,67 +3631,50 @@ class SeleniumTests(StaticLiveServerTestCase):
             "var viewPortHeight = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);"
             + "var elementTop = arguments[0].getBoundingClientRect().top;"
             + "window.scrollBy(0, elementTop-(viewPortHeight/2));",
-            element)
-
-    '''
-    arguments: 
-        i is the number of the row (starting at 1)
-        target and source are a tuple of french/english slugs corresponding respectively to the slug of the item of 
-        which we want some details and the slug of the item from which we launched the search
-    '''
-    def click_on_details(self, i, target, source=None):
-        table = '//table[contains(@id, ' + target[0] + ') or contains(@id, ' + target[1] + ')]'
-        if source:
-            table += '[contains(@id, ' + source[0] + ') or contains(@id, ' + source[1] + ')]'
-        details = table + '/tbody/' + '/tr[' + str(i) + ']/td/a[@class="display_details"]'
-        details = self.selenium.find_element_by_xpath(details)
-        self.scroll(details)
-        details.click()
+            element,
+        )
 
     def assertNotInDOM(self, xpath):
-        self.selenium.implicitly_wait(3)
+        self.selenium.implicitly_wait(self.waiting_time / 5)
         try:
-            self.WebDriverWait(self.selenium, 2).until(
+            self.WebDriverWait(self.selenium, self.waiting_time / 5).until(
                 self.EC.visibility_of_element_located((self.By.XPATH, xpath))
             )
             found = True
         except:
             found = False
-        self.selenium.implicitly_wait(20)
+        self.selenium.implicitly_wait(self.waiting_time)
         self.assertFalse(found)
 
     def assertMap(self, dic_base, slug_pk, features_collecs=None):
-        dic_base = {'type': 'FeatureCollection', 'features': [dic_base]}
+        dic_base = {"type": "FeatureCollection", "features": [dic_base]}
         mapid = None
-        timeout = 20
         t = time()
-        while not mapid and time()-t < timeout:
+        while not mapid and time() - t < self.waiting_time:
             mapdivs = self.selenium.find_elements_by_class_name("window-map")
             for mapdiv in mapdivs:
                 if slug_pk in mapdiv.get_attribute("id"):
                     mapid = mapdiv.get_attribute("id")
                     break
-        id = int(re.search(r'\d+$', mapid).group())
+        id = int(re.search(r"\d+$", mapid).group())
         # TODO: use the map and not the map_features in the js function
         if features_collecs:
-            self.WebDriverWait(self.selenium, 2).until(
-                self.EC.visibility_of_element_located((self.By.ID, "http-geo-items-ready-"+slug_pk))
+            self.WebDriverWait(self.selenium, self.waiting_time).until(
+                self.EC.visibility_of_element_located(
+                    (self.By.ID, "http-geo-items-ready-" + slug_pk)
+                )
             )
-        print('id : ', id)
-        print('mapid : ', mapid)
-        print('slug_pk : ', slug_pk)
-        print(self.selenium.execute_script('return base_features_type(arguments[0])', mapid))
-        base_features, geo_items_feats = self.selenium.execute_script('return get_features_by_id(arguments[0])', mapid)
-        base_features['features'][0]['properties'].pop('name')
-        dic_base['features'][0]['properties'] = {'id': id}
-        print('feat : ', base_features)
-        print('dic : ', dic_base)
+        base_features, geo_items_feats = self.selenium.execute_script(
+            "return get_features_by_id(arguments[0])", mapid
+        )
+        base_features["features"][0]["properties"].pop("name")
+        base_features_type = self.selenium.execute_script(
+            "return base_features_type(arguments[0])", mapid
+        )
+        dic_base["features"][0]["properties"] = {"id": id}
+        self.assertEqual(
+            base_features_type, dic_base["features"][0]["geometry"]["type"]
+        )
         self.assertEqual(base_features, dic_base)
         if features_collecs:
-            print('feat : ', geo_items_feats)
-            print('dic : ', features_collecs)
-            try:
-                self.assertEqual(geo_items_feats, features_collecs)
-            except:
-                self.selenium.implicitly_wait(10000)
-                self.selenium.find_element_by_xpath('doesnet')
+            self.assertEqual(geo_items_feats, features_collecs)