ui tests without base feature point working

6 files changed, 451 insertions, 441 deletions

diff --git a/archaeological_context_records/tests.py b/archaeological_context_records/tests.py
index daa38c26b..769d6a2b2 100644
--- a/archaeological_context_records/tests.py
+++ b/archaeological_context_records/tests.py
@@ -16,7 +16,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 # See the file COPYING for details.
-
+import copy
 import csv
 import json
 from io import StringIO
@@ -1369,102 +1369,88 @@ class GraphGenerationTest(ContextRecordInit, TestCase):
 class SeleniumTestsContextRecords(SeleniumTests):
     fixtures = CONTEXT_RECORD_FIXTURES
 
-    def _test_cr(self, i, dic_polygon, dic_point, geom_bf):
-        cr_label = self.selenium.find_element_by_xpath('//tbody/tr[' + str(i) + ']/td[2]').text
-        if cr_label[3:5] == "Pt":
-            dic_base = dic_point
+    def _test_cr(self, i, pks, geojsons):
+        infos = self.selenium.find_element_by_xpath('//tbody/tr[' + str(i) + ']/td/a[@class="display_details"]')
+        self.scroll(infos)
+        infos.click()
+
+        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:
-            dic_base = dic_polygon
-        cr = self.selenium.find_element_by_xpath('//tbody/tr[' + str(i) + ']/td/a[@class="display_details"]')
-        self.scroll(cr)
-        cr.click()
+            base = copy.deepcopy(geojsons[label]['get_polys'])
+        self.assertMap(base, slug_pk)
+
+        get_poly_id = "get-poly-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_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(
             lambda driver: driver.find_element_by_xpath(
                 '//dl[@class="col-12"]/dt[text()="Display geo items" or text()="Afficher les éléments"]'))
-        self.selenium.find_element_by_xpath(
-            '//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 + '/label[text()="Display associated features: "]')
-        select = dd + '/select[@name="display-geo-items"]'
-        disp = self.selenium.find_element_by_xpath(select)
-        self.assertEqual(disp.get_attribute("value"), "")
-        self.assertMap(dic_base)
+        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 + '"]'
+        self.assertNotInDOM(select_get_poly)
+        self.assertMap(base, slug_pk)
 
         # context record specific
 
         # click on "Base finds"
-        self.selenium.execute_script('return initialize_test_map()')
-        self.scroll(disp)
-        disp.click()
-        self.selenium.find_element_by_xpath(select + '/option[@value="basefinds"]').click()
-        cr_geoms = [
-            {'type': 'FeatureCollection',
-             'features': [
-                 {'geometry':
-                      {'coordinates': geom_bf[0],
-                       'type': 'MultiPolygon'},
-                  'properties': {'label': 'Find 1 from ' + cr_label},
-                  'type': 'Feature'},
-                 {'geometry': {'coordinates': geom_bf[0],
-                               'type': 'MultiPolygon'},
-                  'properties': {'label': 'Find 2 from ' + cr_label},
-                  'type': 'Feature'}]
-             }
+        self.selenium.execute_script('return initialize_test_map(arguments[0])', slug_pk)
+        self.scroll(disp_bf)
+        disp_bf.click()
+
+        bf_geoms = [
+            bf_polys,
+            {'type': 'FeatureCollection', 'features': []}
         ]
-        self.assertMap(dic_base, cr_geoms)
+        self.assertTrue(disp_bf.is_selected())
+        self.assertMap(base, slug_pk, bf_geoms)
 
-        select_get_poly = dd + '/select[@name="get-polygons"]'
+        select_get_poly = dd + '/select[@id="' + get_poly_id + '"]'
         get_poly = self.selenium.find_element_by_xpath(select_get_poly)
-        self.selenium.execute_script('return initialize_test_map()')
         get_poly.click()
         self.selenium.find_element_by_xpath(select_get_poly + '/option[@value="points"]').click()
-        cr_geoms = [
-            {'type': 'FeatureCollection',
-             'features': [
-                 {'geometry':
-                      {'coordinates': geom_bf[1],
-                       'type': 'Point'},
-                  'properties': {'label': 'Find 1 from ' + cr_label},
-                  'type': 'Feature'},
-                 {'geometry': {'coordinates': geom_bf[2],
-                               'type': 'Point'},
-                  'properties': {'label': 'Find 2 from ' + cr_label},
-                  'type': 'Feature'}]
-             }
+        bf_geoms = [
+            bf_pts,
+            {'type': 'FeatureCollection', 'features': []}
         ]
-        self.assertMap(dic_base, cr_geoms)
+        self.assertTrue(disp_bf.is_selected())
+        self.assertMap(base, slug_pk, bf_geoms)
 
         # Click on "None"
-        self.selenium.execute_script('return initialize_test_map()')
-        disp.click()
-        self.selenium.find_element_by_xpath(select + '/option[@value=""]').click()
-        self.assertMap(dic_base)
+        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)
+        self.assertMap(base, slug_pk)
 
     def test_geo_items(self):
-        geo_elements, ope_pks = self.setUpDefaultGeoItems()
-        poly_cr, centr_cr, pt_cr = geo_elements[1]
-
-        dic_polygon = {
-            'type': 'FeatureCollection',
-            'features': [
-                {'geometry':
-                    {'coordinates': poly_cr,
-                     'type': 'MultiPolygon'},
-                    'properties': {},
-                    'type': 'Feature'}
-            ]}
-        dic_point = {
-            'type': 'FeatureCollection',
-            'features': [
-                {'geometry':
-                     {'coordinates': pt_cr,
-                    'type': 'Point'},
-                 'properties': {},
-                 'type': 'Feature'}
-            ]}
+        pks, geojsons = self.pks_and_geojson()
         for i in range(1, 5):
-            dropdown = self.selenium.find_element_by_xpath('//a[@class="nav-link dropdown-toggle"][@id="dropdown-menu-main"]')
+            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="/record_search/"]').click()
-            self._test_cr(i, dic_polygon, dic_point, geo_elements[2])
\ No newline at end of file
+            self._test_cr(i, pks, geojsons)
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)
diff --git a/archaeological_operations/tests.py b/archaeological_operations/tests.py
index 90d74ae7d..a4b73453e 100644
--- a/archaeological_operations/tests.py
+++ b/archaeological_operations/tests.py
@@ -19,7 +19,6 @@
 
 import json
 import datetime
-import re
 from subprocess import Popen, PIPE
 from io import StringIO, BytesIO
 import tempfile
@@ -4244,185 +4243,149 @@ class DocumentQATest(OperationInitTest, TestCase):
 class SeleniumTestsOperations(SeleniumTests):
     fixtures = OPERATION_FIXTURES
 
-    def _test_operation(self, i, dic_base, geom_cr, geom_bf):
+    def _test_operation(self, i, slug_pk, geojsons, label):
+        get_poly_id = "get-poly-for-" + slug_pk
+        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': []}
+        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': []}
+        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']
+
         self.selenium.find_element_by_xpath('//tbody/tr[' + str(i) + ']/td/a[@class="display_details"]').click()
         self.WebDriverWait(self.selenium, 2).until(
             lambda driver: driver.find_element_by_xpath(
                 '//dl[@class="col-12"]/dt[text()="Display geo items" or text()="Afficher les éléments"]'))
-        self.selenium.find_element_by_xpath(
-            '//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 + '/label[text()="Display associated features: "]')
-        select = dd + '/select[@name="display-geo-items"]'
-        disp = self.selenium.find_element_by_xpath(select)
-        self.assertEqual(disp.get_attribute("value"), "")
-        self.assertMap(dic_base)
-
-        # operation specific
-        poly_cr, centr_cr, pt_cr = geom_cr
-        poly_bf, centr_bf, pt_bf = geom_bf
+        self.selenium.find_element_by_xpath(dd + '/fieldset/label[text()="Display context records"]')
+        disp_cr = self.selenium.find_element_by_xpath(dd + '/fieldset/input[@id="' + disp_cr_id + '"]')
+        self.selenium.find_element_by_xpath(dd + '/fieldset/label[text()="Display context records"]')
+        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 + '"]'
+        self.assertNotInDOM(select_get_poly)
+        self.assertMap(ope_base, slug_pk)
 
         # click on "Context records"
-        self.selenium.execute_script('return initialize_test_map()')
-        self.scroll(disp)
-        disp.click()
-        self.selenium.find_element_by_xpath(select + '/option[@value="contextrecords"]').click()
+        self.selenium.execute_script('return initialize_test_map(arguments[0])', slug_pk)
+        self.scroll(disp_cr)
+        disp_cr.click()
 
         cr_geoms = [
-            {'type': 'FeatureCollection',
-             'features': [
-                 {'geometry':
-                     {'coordinates': poly_cr,
-                         'type': 'MultiPolygon'},
-                     'properties': None,
-                     'type': 'Feature'},
-                 {'geometry':
-                      {'coordinates': poly_cr, 'type': 'MultiPolygon'},
-                  'properties': None, 'type': 'Feature'}]}
+            {'type': 'FeatureCollection', 'features': []},
+            cr_polys
         ]
-        self.assertMap(dic_base, cr_geoms)
+        self.assertTrue(disp_cr.is_selected())
+        self.assertFalse(disp_bf.is_selected())
+        self.assertMap(ope_base, slug_pk, cr_geoms)
 
-        select_get_poly = dd + '/select[@name="get-polygons"]'
         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': [
-                 {'geometry':
-                      {'coordinates': centr_cr, 'type': 'Point'},
-                  'properties': None,
-                  'type': 'Feature'},
-                 {'geometry':
-                      {'coordinates': pt_cr, 'type': 'Point'},
-                  'properties': None, 'type': 'Feature'}]}
+            {'type': 'FeatureCollection', 'features': []},
+            cr_pts
         ]
-        self.assertMap(dic_base, cr_geoms)
-
-        # Click on "Everything"
-        disp.click()
-        self.selenium.find_element_by_xpath(select + '/option[@value="basefinds"]').click()
-        self.selenium.execute_script('return initialize_test_map()')
+        self.assertTrue(disp_cr.is_selected())
+        self.assertFalse(disp_bf.is_selected())
+        self.assertMap(ope_base, slug_pk, cr_geoms)
+
+        # Click on everything
+        self.selenium.execute_script('return initialize_test_map(arguments[0])', slug_pk)
+        disp_bf.click()
+        every_geoms = [bf_pts, cr_pts]
+        self.assertTrue(disp_cr.is_selected())
+        self.assertTrue(disp_bf.is_selected())
+        self.assertMap(ope_base, slug_pk, every_geoms)
+
+        self.selenium.execute_script('return initialize_test_map(arguments[0])', slug_pk)
         get_poly.click()
         self.selenium.find_element_by_xpath(select_get_poly + '/option[@value="polygons"]').click()
-        every_geoms = [
-            {'type': 'FeatureCollection',
-             'features': [{
-                 'geometry': {
-                     'coordinates': poly_bf,
-                     'type': 'MultiPolygon'},
-                 'properties': {'label': 'Find 1 from CR Poly Poly Pt'},
-                 'type': 'Feature'},
-                 {'geometry': {
-                     'coordinates': poly_bf,
-                     'type': 'MultiPolygon'},
-                     'properties': {'label': 'Find 2 from CR Poly Poly Pt'},
-                     'type': 'Feature'}
-             ]},
-            {'type': 'FeatureCollection',
-             'features': [
-                 {'geometry': {
-                     'coordinates': poly_bf,
-                     'type': 'MultiPolygon'},
-                     'properties': {'label': 'Find 1 from CR Pt Poly Pt'}, 'type': 'Feature'},
-                 {'geometry': {
-                     'coordinates': poly_bf, 'type': 'MultiPolygon'},
-                     'properties': {'label': 'Find 2 from CR Pt Poly Pt'},
-                     'type': 'Feature'}
-             ]},
-            {'type': 'FeatureCollection',
-             'features': [
-                 {'geometry': {
-                     'coordinates': poly_cr,
-                     'type': 'MultiPolygon'},
-                     'properties': None,
-                     'type': 'Feature'},
-                 {'geometry': {
-                     'coordinates': poly_cr,
-                     'type': 'MultiPolygon'},
-                     'properties': None,
-                     'type': 'Feature'}
-             ]}]
-        self.assertMap(dic_base, every_geoms)
-
-        self.selenium.execute_script('return initialize_test_map()')
+        every_geoms = [bf_polys, cr_polys]
+        self.assertTrue(disp_cr.is_selected())
+        self.assertTrue(disp_bf.is_selected())
+        self.assertMap(ope_base, slug_pk, every_geoms)
+
+        # click on "Base finds"
+        self.selenium.execute_script('return initialize_test_map(arguments[0])', slug_pk)
+        self.scroll(disp_cr)
+        disp_cr.click()
+
+        bf_geoms = [
+            bf_polys,
+            {'type': 'FeatureCollection', 'features': []}
+        ]
+        self.assertFalse(disp_cr.is_selected())
+        self.assertTrue(disp_bf.is_selected())
+        self.assertMap(ope_base, slug_pk, bf_geoms)
+
+        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()
-        every_geoms = [
-            {'type': 'FeatureCollection',
-             'features': [{
-                 'geometry': {
-                     'coordinates': centr_bf,
-                     'type': 'Point'},
-                 'properties': {'label': 'Find 1 from CR Poly Poly Pt'},
-                 'type': 'Feature'},
-                 {'geometry': {
-                     'coordinates': pt_bf,
-                     'type': 'Point'},
-                     'properties': {'label': 'Find 2 from CR Poly Poly Pt'},
-                     'type': 'Feature'}
-             ]},
-            {'type': 'FeatureCollection',
-             'features': [
-                 {'geometry': {
-                     'coordinates': centr_bf,
-                     'type': 'Point'},
-                     'properties': {'label': 'Find 1 from CR Pt Poly Pt'}, 'type': 'Feature'},
-                 {'geometry': {
-                     'coordinates': pt_bf, 'type': 'Point'},
-                     'properties': {'label': 'Find 2 from CR Pt Poly Pt'},
-                     'type': 'Feature'}
-             ]},
-            {'type': 'FeatureCollection',
-             'features': [
-                 {'geometry': {
-                     'coordinates': centr_cr,
-                     'type': 'Point'},
-                     'properties': None,
-                     'type': 'Feature'},
-                 {'geometry': {
-                     'coordinates': pt_cr,
-                     'type': 'Point'},
-                     'properties': None,
-                     'type': 'Feature'}
-             ]}]
-        self.assertMap(dic_base, every_geoms)
+        bf_geoms = [
+            bf_pts,
+            {'type': 'FeatureCollection', 'features': []}
+        ]
+        self.assertFalse(disp_cr.is_selected())
+        self.assertTrue(disp_bf.is_selected())
+        self.assertMap(ope_base, slug_pk, bf_geoms)
 
         # Click on "None"
-        self.selenium.execute_script('return initialize_test_map()')
-        disp.click()
-        self.selenium.find_element_by_xpath(select + '/option[@value=""]').click()
-        self.assertMap(dic_base)
+        self.selenium.execute_script('return initialize_test_map(arguments[0])', slug_pk)
+        disp_bf.click()
+        self.assertFalse(disp_cr.is_selected())
+        self.assertFalse(disp_bf.is_selected())
+        self.assertNotInDOM(select_get_poly)
+        self.assertMap(ope_base, slug_pk)
 
     def test_geo_items(self):
-        geo_elements, ope_pks = self.setUpDefaultGeoItems()
-        poly_ope, centr_ope, pt_ope = geo_elements[0]
-
-        dic_poly = {
-            'type': 'FeatureCollection',
-            'features': [
-                {'geometry':
-                     {'coordinates': poly_ope,
-                      'type': 'MultiPolygon'},
-                 'properties': {},
-                 'type': 'Feature'}
-            ]}
-        dic_pt = {
-            'type': 'FeatureCollection',
-            'features': [
-                {'geometry':
-                     {'coordinates': pt_ope,
-                      'type': 'MultiPolygon'},
-                 'properties': {},
-                 'type': 'Feature'}
-            ]}
-
-        self.selenium.find_element_by_xpath('//a[@class="nav-link dropdown-toggle"][@id="dropdown-menu-main"]').click()
-        self.selenium.find_element_by_xpath('//div[@class="dropdown-menu show"]/a[@href="/operation_search/"]').click()
-        self._test_operation(1, dic_poly, geo_elements[1], geo_elements[2]) # polygon based operation
+        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"]')
+        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, geojsons, 'Poly')
+
+        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="/operation_search/"]').click()
-        self._test_operation(2, dic_pt, geo_elements[1], geo_elements[2]) # point based operation
+        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, geojsons, 'Pt')
 
diff --git a/ishtar_common/static/js/ishtar-map.js b/ishtar_common/static/js/ishtar-map.js
index 00aadfd9b..ab8096b06 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.constructor = TrackPositionControl;
+    TrackPositionControl.prototype.varructor = TrackPositionControl;
 
-    TrackPositionControl.prototype.handleTrackPosition = function handleTrackPosition () {
+    TrackPositionControl.prototype.handvarrackPosition = function handvarrackPosition () {
         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 = "complete list...";
+var complete_list_label = "compvare list...";
 
 var _display_items = function(map_id, features, offset_x, offset_y){
     // console.log("display_items");
@@ -553,13 +553,14 @@ var vector_features = {};
 // for test
 var geo_items_features = null;
 var current_test = false;
-var initialize_test_map = function () {
+var initialize_test_map = function (slug_pk) {
+    var id = "http-geo-items-ready-" + slug_pk;
     geo_items_features = {};
     current_test = true;
-    if ($("#http-geo-items-ready").length === 0) {
-        $("#display-geo-items").after('<div id="http-geo-items-ready">Ready!</div>');
+    if ($("#"+id).length === 0) {
+        $("#display-geo-items").after('<div id="'+id+'">Ready!</div>');
     }
-    $("#http-geo-items-ready").hide();
+    $("#"+id).hide();
 }
 
 var initialize_base_map = function(map_id, layers){
@@ -614,17 +615,12 @@ var display_map = function(map_id, points, lines_and_polys, layers){
         link_template[map_id] = lines_and_polys['link_template'];
     }
     if (map[map_id]){
-
         redraw_map(map_id, layers);
     } else {
         initialize_base_map(map_id, layers);
     }
-    //console.log('map init')
-    //console.log(map[map_id]);
     display_points(map_id, points);
     display_lines_and_polys(map_id, lines_and_polys);
-    //console.log('map after points');
-    //console.log(map[map_id]);
 
     init_popup(map_id);
 
@@ -637,8 +633,6 @@ var display_map = function(map_id, points, lines_and_polys, layers){
 };
 
 var display_points = function(map_id, points){
-    //console.log('points');
-    //console.log(points);
     if (!points) return;
     point_features[map_id] = geojson_format.readFeatures(points);
     enable_clustering(map_id);
@@ -701,7 +695,7 @@ var display_geo_items = function(map_id, base_url, slug, pk,
                 if (current_test) {
                     geo_items_features[map_id].push(bfs)
                     geo_items_features[map_id].push(crs)
-                    $("#http-geo-items-ready").show();
+                    $("#http-geo-items-ready-"+slug+"-"+pk).show();
                 }
             } else { return; }
         }
@@ -872,19 +866,19 @@ var get_map_by_id_test = function (id) {
 
 var get_features_by_id = function (id) {
     if (vector_features[id] == null) {
-        var base_features = geojson_format.writeFeaturesObject(point_features[id], {decimals: 3});
+        var base_features = geojson_format.writeFeaturesObject(point_features[id], {decimals: 5});
     } else {
-        var base_features = geojson_format.writeFeaturesObject(vector_features[id], {decimals: 3});
+        var base_features = geojson_format.writeFeaturesObject(vector_features[id], {decimals: 5});
     }
     var geo_items_feats = [];
     if (geo_items_features && id in geo_items_features) {
         for (var features of geo_items_features[id]) {
-            geo_items_feats.push(geojson_format.writeFeaturesObject(features, {decimals: 3}));
+            geo_items_feats.push(geojson_format.writeFeaturesObject(features, {decimals: 5}));
         }
     }
     return [base_features, geo_items_feats];
 }
 
-var print = function (id) {
+var base_features_type = function (id) {
     return "vector " + typeof vector_features[id] + ", cluster " + typeof point_features[id] ;
-}
\ No newline at end of file
+}
diff --git a/ishtar_common/templates/ishtar/blocks/sheet_geo_items.html b/ishtar_common/templates/ishtar/blocks/sheet_geo_items.html
index 93b9a5b35..33b3dc5ed 100644
--- a/ishtar_common/templates/ishtar/blocks/sheet_geo_items.html
+++ b/ishtar_common/templates/ishtar/blocks/sheet_geo_items.html
@@ -1,20 +1,20 @@
 {% load i18n window_field %}{% if PROFILE.mapping %}
 {% if geo_item.point_2d or geo_item.multi_polygon %}
 <dl class="col-12">
-    <dt>{% trans "Display geo items" %}</dt>
+    <dt id="display-geo-items">{% trans "Display geo items" %}</dt>
     <dd>
         <fieldset>
             {% if geo_item.SLUG == "operation" %}
-            <input type="checkbox" id="disp-cr-for-{{geo_item.SLUG}}-{{geo_item.pk}}">
+            <input type="checkbox" id="disp-cr-for-{{geo_item.SLUG}}-{{geo_item.pk}}" class='checkbox-geo-items'>
             <label for="disp-cr-for-{{geo_item.SLUG}}-{{geo_item.pk}}">{% trans "Display context records" %}</label>
             {% endif %}
-            <input type="checkbox" id="disp-bf-for-{{geo_item.SLUG}}-{{geo_item.pk}}">
+            <input type="checkbox" id="disp-bf-for-{{geo_item.SLUG}}-{{geo_item.pk}}" class='checkbox-geo-items'>
             <label for="disp-bf-for-{{geo_item.SLUG}}-{{geo_item.pk}}">{% trans "Display base finds" %}</label>
         </fieldset>
     </dd>
     <dd>
         <label for="get-poly-for-{{geo_item.SLUG}}-{{geo_item.pk}}" id="get-poly-label-for-{{geo_item.SLUG}}-{{geo_item.pk}}">{% trans "Geometry: " %}</label>
-        <select id="get-poly-for-{{geo_item.SLUG}}-{{geo_item.pk}}">
+        <select id="get-poly-for-{{geo_item.SLUG}}-{{geo_item.pk}}" class='get-poly-geo-items'>
             <option value="polygons" selected="selected">{% trans "Display polygons" %}</option>
             <option value="points">{% trans "Display points" %}</option>
         </select>
diff --git a/ishtar_common/tests.py b/ishtar_common/tests.py
index a3a2e4b5b..71242db6b 100644
--- a/ishtar_common/tests.py
+++ b/ishtar_common/tests.py
@@ -16,9 +16,8 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 # See the file COPYING for details.
-import re
-
 from bs4 import BeautifulSoup as Soup
+import re
 import csv
 import datetime
 import importlib
@@ -2862,23 +2861,23 @@ class GeomaticTest(TestCase):
     @staticmethod
     def pt_coords_from_label(label, geoms):
         if label[:2] == "Pt":
-            return geoms[0][2]
+            return geoms[0][2], True
         if label[:4] == "Poly":
-            return geoms[0][1]
+            return geoms[0][1], False
         if label[:2] == "CR":
             if label[-2:] == "Pt":
-                return geoms[1][2]
+                return geoms[1][2], True
             if label[3:5] == "Pt":
-                return geoms[0][2]
-            return geoms[1][1]
+                return geoms[0][2], True
+            return geoms[1][1], False
         if label[5:10] == "Point":
-            return geoms[2][2]
+            return geoms[2][2], True
         # label has shape Find Polygon from CR xxx xxx
         if label[-2:] == "Pt":
-            return geoms[1][2]
+            return geoms[1][2], True
         if label[21:23] == "Pt":
-            return geoms[0][2]
-        return geoms[2][1]
+            return geoms[0][2], True
+        return geoms[2][1], False
 
     def assertPt(self, item, geom):
         self.assertEqual(item.multi_polygon.coords, geom[0].coords)
@@ -2927,6 +2926,177 @@ class GeomaticTest(TestCase):
         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):
+        from archaeological_operations.models import Operation
+        from archaeological_context_records.models import ContextRecord
+        from archaeological_finds.models import BaseFind
+        import copy
+
+        cache_dics_t, cache_dics_f = {}, {}
+        res = {}
+
+        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:
+            pk = pks[label]
+            pt_coords, precise = GeomaticTest.pt_coords_from_label(label, geoms)
+            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": pt_coords,
+                    },
+                    "properties": {"label": label},
+                }
+                cache_dics_t[label] = dic_t
+                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)
+                    get_pk = "?pk="
+                else:
+                    get_polys = dic_t
+                    get_pts = dic_f
+
+            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": pt_coords,
+                    },
+                    "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
+                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)
+                    get_pk = "?context_record_pk="
+                else:
+                    get_polys = copy.deepcopy(dic_t)
+                    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")]
+            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": pt_coords,
+                    },
+                    "properties": {
+                        "label": real_label,
+                        "context-records": {
+                            '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)
+                    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': [
+                            cache_key_prefix + "Poly",
+                            cache_key_prefix + "Pt"
+                        ],
+                        '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': [
+                            cache_key_prefix + "Poly",
+                            cache_key_prefix + "Pt"
+                        ],
+                        '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}
+            else:
+                res[label] = {'get_polys': get_polys,
+                              'get_pts': get_pts,
+                              'precise': precise}
+        return res
 
 class NewItems(TestCase):
     fixtures = COMMON_FIXTURES
@@ -3446,6 +3616,11 @@ class SeleniumTests(StaticLiveServerTestCase):
     def setUpDefaultGeoItems(self):
         return GeomaticTest.setUpDefaultGeoItems(self.user)
 
+    def pks_and_geojson(self):
+        geoms, pks = self.setUpDefaultGeoItems()
+        geojsons = GeomaticTest.geojson_geo_items(geoms, pks)
+        return pks, geojsons
+
     def scroll(self, element):
         self.selenium.execute_script(
             "var viewPortHeight = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);"
@@ -3453,20 +3628,38 @@ class SeleniumTests(StaticLiveServerTestCase):
             + "window.scrollBy(0, elementTop-(viewPortHeight/2));",
             element)
 
-    def assertMap(self, dic_base, features_collecs=None):
-        mapdiv = self.selenium.find_element_by_id("window-map")
-        mapid = mapdiv.get_attribute("id")
+    def assertNotInDOM(self, xpath):
+        self.selenium.implicitly_wait(5)
+        try:
+            self.WebDriverWait(self.selenium, 2).until(
+                self.EC.visibility_of_element_located((self.By.XPATH, xpath))
+            )
+            found = True
+        except:
+            found = False
+        self.selenium.implicitly_wait(20)
+        self.assertFalse(found)
+
+    def assertMap(self, dic_base, slug_pk, features_collecs=None):
+        dic_base = {'type': 'FeatureCollection', 'features': [dic_base]}
+        mapdivs = self.selenium.find_elements_by_class_name("window-map")
+        mapid = None
+        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())
         # 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"))
+                self.EC.visibility_of_element_located((self.By.ID, "http-geo-items-ready-"+slug_pk))
             )
         print(id)
-        print(self.selenium.execute_script('return print(arguments[0])', mapid))
+        print('mapid : ', mapid)
+        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
+        dic_base['features'][0]['properties'] = {'id': id}
         print('feat : ', base_features)
         print('dic : ', dic_base)
         self.assertEqual(base_features, dic_base)