umap-project 2.1.2__py3-none-any.whl → 2.1.3__py3-none-any.whl

umap/tests/integration/test_import.py

@@ -1,12 +1,16 @@
+import json
+import re
 from pathlib import Path
 
 import pytest
 from playwright.sync_api import expect
 
+from umap.models import DataLayer
+
 pytestmark = pytest.mark.django_db
 
 
-def test_umap_import_from_file(live_server, datalayer, page):
+def test_umap_import_from_file(live_server, tilelayer, page):
     page.goto(f"{live_server.url}/map/new/")
     button = page.get_by_title("Import data")
     expect(button).to_be_visible()
@@ -28,9 +32,40 @@ def test_umap_import_from_file(live_server, datalayer, page):
     # Close the import panel
     page.keyboard.press("Escape")
     assert not file_input.input_value()
+    expect(page.locator(".umap-main-edit-toolbox .map-name")).to_have_text(
+        "Carte sans nom"
+    )
+
+
+def test_umap_import_from_textarea(live_server, tilelayer, page, settings):
+    settings.UMAP_ALLOW_ANONYMOUS = True
+    page.goto(f"{live_server.url}/map/new/")
+    page.get_by_title("Import data").click()
+    textarea = page.locator(".umap-upload textarea")
+    path = Path(__file__).parent.parent / "fixtures/test_upload_data.umap"
+    textarea.fill(path.read_text())
+    page.locator('select[name="format"]').select_option("umap")
+    page.get_by_role("button", name="Import", exact=True).click()
+    layers = page.locator(".umap-browse-datalayers li")
+    expect(layers).to_have_count(2)
+    expect(page.locator(".umap-main-edit-toolbox .map-name")).to_have_text(
+        "Imported map"
+    )
+    page.get_by_role("button", name="See data layers").click()
+    expect(page.get_by_text("Tunnels")).to_be_visible()
+    expect(page.get_by_text("Cities")).to_be_visible()
+    expect(page.locator(".leaflet-control-minimap")).to_be_visible()
+    expect(
+        page.locator('img[src="https://tile.openstreetmap.fr/hot/6/32/21.png"]')
+    ).to_be_visible()
+    # Should not have imported umap_id, while in the file options
+    assert not page.evaluate("U.MAP.options.umap_id")
+    with page.expect_response(re.compile(r".*/datalayer/create/.*")):
+        page.get_by_role("button", name="Save").click()
+    assert page.evaluate("U.MAP.options.umap_id")
 
 
-def test_umap_import_geojson_from_textarea(live_server, datalayer, page):
+def test_import_geojson_from_textarea(tilelayer, live_server, page):
     page.goto(f"{live_server.url}/map/new/")
     layers = page.locator(".umap-browse-datalayers li")
     markers = page.locator(".leaflet-marker-icon")
@@ -52,3 +87,313 @@ def test_umap_import_geojson_from_textarea(live_server, datalayer, page):
     expect(layers).to_have_count(1)
     expect(markers).to_have_count(2)
     expect(paths).to_have_count(3)
+
+
+def test_import_kml_from_textarea(tilelayer, live_server, page):
+    page.goto(f"{live_server.url}/map/new/")
+    layers = page.locator(".umap-browse-datalayers li")
+    markers = page.locator(".leaflet-marker-icon")
+    paths = page.locator("path")
+    expect(markers).to_have_count(0)
+    expect(paths).to_have_count(0)
+    expect(layers).to_have_count(0)
+    button = page.get_by_title("Import data")
+    expect(button).to_be_visible()
+    button.click()
+    textarea = page.locator(".umap-upload textarea")
+    path = Path(__file__).parent.parent / "fixtures/test_upload_data.kml"
+    textarea.fill(path.read_text())
+    page.locator('select[name="format"]').select_option("kml")
+    button = page.get_by_role("button", name="Import", exact=True)
+    expect(button).to_be_visible()
+    button.click()
+    # A layer has been created
+    expect(layers).to_have_count(1)
+    expect(markers).to_have_count(1)
+    expect(paths).to_have_count(2)
+
+
+def test_import_gpx_from_textarea(tilelayer, live_server, page):
+    page.goto(f"{live_server.url}/map/new/")
+    layers = page.locator(".umap-browse-datalayers li")
+    markers = page.locator(".leaflet-marker-icon")
+    paths = page.locator("path")
+    expect(markers).to_have_count(0)
+    expect(paths).to_have_count(0)
+    expect(layers).to_have_count(0)
+    button = page.get_by_title("Import data")
+    expect(button).to_be_visible()
+    button.click()
+    textarea = page.locator(".umap-upload textarea")
+    path = Path(__file__).parent.parent / "fixtures/test_upload_data.gpx"
+    textarea.fill(path.read_text())
+    page.locator('select[name="format"]').select_option("gpx")
+    button = page.get_by_role("button", name="Import", exact=True)
+    expect(button).to_be_visible()
+    button.click()
+    # A layer has been created
+    expect(layers).to_have_count(1)
+    expect(markers).to_have_count(1)
+    expect(paths).to_have_count(1)
+
+
+def test_import_osm_from_textarea(tilelayer, live_server, page):
+    page.goto(f"{live_server.url}/map/new/")
+    layers = page.locator(".umap-browse-datalayers li")
+    markers = page.locator(".leaflet-marker-icon")
+    expect(markers).to_have_count(0)
+    expect(layers).to_have_count(0)
+    button = page.get_by_title("Import data")
+    expect(button).to_be_visible()
+    button.click()
+    textarea = page.locator(".umap-upload textarea")
+    path = Path(__file__).parent.parent / "fixtures/test_upload_data_osm.json"
+    textarea.fill(path.read_text())
+    page.locator('select[name="format"]').select_option("osm")
+    page.get_by_role("button", name="Import", exact=True).click()
+    # A layer has been created
+    expect(layers).to_have_count(1)
+    expect(markers).to_have_count(2)
+
+
+def test_import_csv_from_textarea(tilelayer, live_server, page):
+    page.goto(f"{live_server.url}/map/new/")
+    layers = page.locator(".umap-browse-datalayers li")
+    markers = page.locator(".leaflet-marker-icon")
+    expect(markers).to_have_count(0)
+    expect(layers).to_have_count(0)
+    button = page.get_by_title("Import data")
+    expect(button).to_be_visible()
+    button.click()
+    textarea = page.locator(".umap-upload textarea")
+    path = Path(__file__).parent.parent / "fixtures/test_upload_data.csv"
+    textarea.fill(path.read_text())
+    page.locator('select[name="format"]').select_option("csv")
+    page.get_by_role("button", name="Import", exact=True).click()
+    # A layer has been created
+    expect(layers).to_have_count(1)
+    expect(markers).to_have_count(2)
+
+
+def test_can_import_in_existing_datalayer(live_server, datalayer, page, openmap):
+    page.goto(f"{live_server.url}{openmap.get_absolute_url()}")
+    layers = page.locator(".umap-browse-datalayers li")
+    markers = page.locator(".leaflet-marker-icon")
+    expect(markers).to_have_count(1)
+    expect(layers).to_have_count(1)
+    page.get_by_role("button", name="Edit").click()
+    page.get_by_title("Import data").click()
+    textarea = page.locator(".umap-upload textarea")
+    path = Path(__file__).parent.parent / "fixtures/test_upload_data.csv"
+    textarea.fill(path.read_text())
+    page.locator('select[name="format"]').select_option("csv")
+    page.get_by_role("button", name="Import", exact=True).click()
+    # No layer has been created
+    expect(layers).to_have_count(1)
+    expect(markers).to_have_count(3)
+
+
+def test_can_replace_datalayer_data(live_server, datalayer, page, openmap):
+    page.goto(f"{live_server.url}{openmap.get_absolute_url()}")
+    layers = page.locator(".umap-browse-datalayers li")
+    markers = page.locator(".leaflet-marker-icon")
+    expect(markers).to_have_count(1)
+    expect(layers).to_have_count(1)
+    page.get_by_role("button", name="Edit").click()
+    page.get_by_title("Import data").click()
+    textarea = page.locator(".umap-upload textarea")
+    path = Path(__file__).parent.parent / "fixtures/test_upload_data.csv"
+    textarea.fill(path.read_text())
+    page.locator('select[name="format"]').select_option("csv")
+    page.get_by_label("Replace layer content").check()
+    page.get_by_role("button", name="Import", exact=True).click()
+    # No layer has been created
+    expect(layers).to_have_count(1)
+    expect(markers).to_have_count(2)
+
+
+def test_can_import_in_new_datalayer(live_server, datalayer, page, openmap):
+    page.goto(f"{live_server.url}{openmap.get_absolute_url()}")
+    layers = page.locator(".umap-browse-datalayers li")
+    markers = page.locator(".leaflet-marker-icon")
+    expect(markers).to_have_count(1)
+    expect(layers).to_have_count(1)
+    page.get_by_role("button", name="Edit").click()
+    page.get_by_title("Import data").click()
+    textarea = page.locator(".umap-upload textarea")
+    path = Path(__file__).parent.parent / "fixtures/test_upload_data.csv"
+    textarea.fill(path.read_text())
+    page.locator('select[name="format"]').select_option("csv")
+    page.get_by_label("Choose the layer to import").select_option(
+        label="Import in a new layer"
+    )
+    page.get_by_role("button", name="Import", exact=True).click()
+    # A new layer has been created
+    expect(layers).to_have_count(2)
+    expect(markers).to_have_count(3)
+
+
+def test_should_remove_dot_in_property_names(live_server, page, settings, tilelayer):
+    settings.UMAP_ALLOW_ANONYMOUS = True
+    data = {
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "geometry": {
+                    "type": "Point",
+                    "coordinates": [6.922931671142578, 47.481161607175736],
+                },
+                "type": "Feature",
+                "properties": {
+                    "color": "",
+                    "name": "Chez Rémy",
+                    "A . in the name": "",
+                },
+            },
+            {
+                "geometry": {
+                    "type": "LineString",
+                    "coordinates": [
+                        [2.4609375, 48.88639177703194],
+                        [2.48291015625, 48.76343113791796],
+                        [2.164306640625, 48.719961222646276],
+                    ],
+                },
+                "type": "Feature",
+                "properties": {"color": "", "name": "Périf", "with a dot.": ""},
+            },
+        ],
+    }
+    page.goto(f"{live_server.url}/map/new/")
+    page.get_by_title("Import data").click()
+    textarea = page.locator(".umap-upload textarea")
+    textarea.fill(json.dumps(data))
+    page.locator('select[name="format"]').select_option("geojson")
+    page.get_by_role("button", name="Import", exact=True).click()
+    with page.expect_response(re.compile(r".*/datalayer/create/.*")):
+        page.get_by_role("button", name="Save").click()
+    datalayer = DataLayer.objects.last()
+    saved_data = json.loads(Path(datalayer.geojson.path).read_text())
+    assert saved_data["features"][0]["properties"] == {
+        "color": "",
+        "name": "Chez Rémy",
+        "A _ in the name": "",
+    }
+    assert saved_data["features"][1]["properties"] == {
+        "color": "",
+        "name": "Périf",
+        "with a dot_": "",
+    }
+
+
+def test_import_geometry_collection(live_server, page, tilelayer):
+    data = {
+        "type": "GeometryCollection",
+        "geometries": [
+            {"type": "Point", "coordinates": [-80.6608, 35.0493]},
+            {
+                "type": "Polygon",
+                "coordinates": [
+                    [
+                        [-80.6645, 35.0449],
+                        [-80.6634, 35.0460],
+                        [-80.6625, 35.0455],
+                        [-80.6638, 35.0442],
+                        [-80.6645, 35.0449],
+                    ]
+                ],
+            },
+            {
+                "type": "LineString",
+                "coordinates": [
+                    [-80.66237, 35.05950],
+                    [-80.66269, 35.05926],
+                    [-80.66284, 35.05893],
+                    [-80.66308, 35.05833],
+                    [-80.66385, 35.04387],
+                    [-80.66303, 35.04371],
+                ],
+            },
+        ],
+    }
+    page.goto(f"{live_server.url}/map/new/")
+    layers = page.locator(".umap-browse-datalayers li")
+    markers = page.locator(".leaflet-marker-icon")
+    paths = page.locator("path")
+    expect(markers).to_have_count(0)
+    expect(paths).to_have_count(0)
+    expect(layers).to_have_count(0)
+    button = page.get_by_title("Import data")
+    expect(button).to_be_visible()
+    button.click()
+    textarea = page.locator(".umap-upload textarea")
+    textarea.fill(json.dumps(data))
+    page.locator('select[name="format"]').select_option("geojson")
+    page.get_by_role("button", name="Import", exact=True).click()
+    # A layer has been created
+    expect(layers).to_have_count(1)
+    expect(markers).to_have_count(1)
+    expect(paths).to_have_count(2)
+
+
+def test_import_multipolygon(live_server, page, tilelayer):
+    data = {
+        "type": "Feature",
+        "properties": {"name": "Some states"},
+        "geometry": {
+            "type": "MultiPolygon",
+            "coordinates": [
+                [
+                    [[-109, 36], [-109, 40], [-102, 37], [-109, 36]],
+                    [[-108, 39], [-107, 37], [-104, 37], [-108, 39]],
+                ],
+                [[[-119, 42], [-120, 39], [-114, 41], [-119, 42]]],
+            ],
+        },
+    }
+    page.goto(f"{live_server.url}/map/new/")
+    layers = page.locator(".umap-browse-datalayers li")
+    paths = page.locator("path")
+    expect(paths).to_have_count(0)
+    expect(layers).to_have_count(0)
+    button = page.get_by_title("Import data")
+    expect(button).to_be_visible()
+    button.click()
+    textarea = page.locator(".umap-upload textarea")
+    textarea.fill(json.dumps(data))
+    page.locator('select[name="format"]').select_option("geojson")
+    page.get_by_role("button", name="Import", exact=True).click()
+    # A layer has been created
+    expect(layers).to_have_count(1)
+    expect(paths).to_have_count(1)
+
+
+def test_import_multipolyline(live_server, page, tilelayer):
+    data = {
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "type": "Feature",
+                "properties": {},
+                "geometry": {
+                    "type": "MultiLineString",
+                    "coordinates": [[[-108, 46], [-113, 43]], [[-112, 45], [-115, 44]]],
+                },
+            }
+        ],
+    }
+    page.goto(f"{live_server.url}/map/new/")
+    layers = page.locator(".umap-browse-datalayers li")
+    paths = page.locator("path")
+    expect(paths).to_have_count(0)
+    expect(layers).to_have_count(0)
+    button = page.get_by_title("Import data")
+    expect(button).to_be_visible()
+    button.click()
+    textarea = page.locator(".umap-upload textarea")
+    textarea.fill(json.dumps(data))
+    page.locator('select[name="format"]').select_option("geojson")
+    page.get_by_role("button", name="Import", exact=True).click()
+    # A layer has been created
+    expect(layers).to_have_count(1)
+    expect(paths).to_have_count(1)

umap/tests/integration/test_map.py

@@ -1,12 +1,8 @@
-import json
 import re
-from pathlib import Path
 
 import pytest
 from playwright.sync_api import expect
 
-from umap.models import Map
-
 from ..base import DataLayerFactory
 
 pytestmark = pytest.mark.django_db
@@ -150,19 +146,28 @@ def test_default_view_latest_with_polygon(map, live_server, page):
     expect(layers).to_have_count(1)
 
 
+def test_default_view_locate(browser, live_server, map):
+    context = browser.new_context(
+        geolocation={"longitude": 8.52967, "latitude": 39.16267},
+        permissions=["geolocation"],
+    )
+    map.settings["properties"]["defaultView"] = "locate"
+    map.save()
+    page = context.new_page()
+    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    expect(page).to_have_url(re.compile(r".*#18/39\.16267/8\.52967"))
+
+
 def test_remote_layer_should_not_be_used_as_datalayer_for_created_features(
-    map, live_server, datalayer, page
+    openmap, live_server, datalayer, page
 ):
-    # Faster than doing a login
-    map.edit_status = Map.ANONYMOUS
-    map.save()
     datalayer.settings["remoteData"] = {
         "url": "https://overpass-api.de/api/interpreter?data=[out:xml];node[harbour=yes]({south},{west},{north},{east});out body;",
         "format": "osm",
         "from": "10",
     }
     datalayer.save()
-    page.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+    page.goto(f"{live_server.url}{openmap.get_absolute_url()}?edit")
     toggle = page.get_by_role("button", name="See data layers")
     expect(toggle).to_be_visible()
     toggle.click()
@@ -181,13 +186,10 @@ def test_remote_layer_should_not_be_used_as_datalayer_for_created_features(
     expect(layers).to_have_count(2)
 
 
-def test_can_hide_datalayer_from_caption(map, live_server, datalayer, page):
-    # Faster than doing a login
-    map.edit_status = Map.ANONYMOUS
-    map.save()
+def test_can_hide_datalayer_from_caption(openmap, live_server, datalayer, page):
     # Add another DataLayer
-    other = DataLayerFactory(map=map, name="Hidden", settings={"inCaption": False})
-    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    other = DataLayerFactory(map=openmap, name="Hidden", settings={"inCaption": False})
+    page.goto(f"{live_server.url}{openmap.get_absolute_url()}")
     toggle = page.get_by_text("About").first
     expect(toggle).to_be_visible()
     toggle.click()
@@ -199,28 +201,6 @@ def test_can_hide_datalayer_from_caption(map, live_server, datalayer, page):
     expect(hidden).to_be_hidden()
 
 
-def test_basic_choropleth_map(map, live_server, page):
-    path = Path(__file__).parent.parent / "fixtures/choropleth_region_chomage.geojson"
-    data = json.loads(path.read_text())
-    DataLayerFactory(data=data, map=map)
-    page.goto(f"{live_server.url}{map.get_absolute_url()}")
-    # Hauts-de-France
-    paths = page.locator("path[fill='#08519c']")
-    expect(paths).to_have_count(1)
-    # Occitanie
-    paths = page.locator("path[fill='#3182bd']")
-    expect(paths).to_have_count(1)
-    # Grand-Est, PACA
-    paths = page.locator("path[fill='#6baed6']")
-    expect(paths).to_have_count(2)
-    # Bourgogne-Franche-Comté, Centre-Val-de-Loire, IdF, Normandie, Corse, Nouvelle-Aquitaine
-    paths = page.locator("path[fill='#bdd7e7']")
-    expect(paths).to_have_count(6)
-    # Bretagne, Pays de la Loire, AURA
-    paths = page.locator("path[fill='#eff3ff']")
-    expect(paths).to_have_count(3)
-
-
 def test_minimap_on_load(map, live_server, datalayer, page):
     page.goto(f"{live_server.url}{map.get_absolute_url()}")
     expect(page.locator(".leaflet-control-minimap")).to_be_hidden()

umap/tests/integration/test_owned_map.py

@@ -231,3 +231,21 @@ def test_can_change_owner(map, live_server, login, user):
         save.click()
     modified = Map.objects.get(pk=map.pk)
     assert modified.owner == user
+
+
+def test_can_delete_datalayer(live_server, map, login, datalayer):
+    page = login(map.owner)
+    page.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+    layers = page.locator(".umap-browse-datalayers li")
+    markers = page.locator(".leaflet-marker-icon")
+    expect(layers).to_have_count(1)
+    expect(markers).to_have_count(1)
+    page.get_by_role("link", name="Manage layers").click()
+    page.once("dialog", lambda dialog: dialog.accept())
+    page.locator("#umap-ui-container").get_by_title("Delete layer").click()
+    with page.expect_response(re.compile(r".*/datalayer/delete/.*")):
+        page.get_by_role("button", name="Save").click()
+    expect(markers).to_have_count(0)
+    # FIXME does not work, resolve to 1 element, even if this command is empty:
+    # document.querySelectorAll(".umap-browse-datalayers li")
+    # expect(layers).to_have_count(0)

umap/tests/integration/test_picto.py

@@ -5,7 +5,7 @@ import pytest
 from django.core.files.base import ContentFile
 from playwright.sync_api import expect
 
-from umap.models import Map, Pictogram
+from umap.models import Pictogram
 
 from ..base import DataLayerFactory
 
@@ -37,12 +37,9 @@ def pictos():
     Pictogram(name="circle", pictogram=ContentFile(path.read_text(), path.name)).save()
 
 
-def test_can_change_picto_at_map_level(map, live_server, page, pictos):
-    # Faster than doing a login
-    map.edit_status = Map.ANONYMOUS
-    map.save()
-    DataLayerFactory(map=map, data=DATALAYER_DATA)
-    page.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+def test_can_change_picto_at_map_level(openmap, live_server, page, pictos):
+    DataLayerFactory(map=openmap, data=DATALAYER_DATA)
+    page.goto(f"{live_server.url}{openmap.get_absolute_url()}?edit")
     marker = page.locator(".umap-div-icon img")
     expect(marker).to_have_count(1)
     # Should have default img
@@ -71,13 +68,11 @@ def test_can_change_picto_at_map_level(map, live_server, page, pictos):
     expect(marker).to_have_attribute("src", "/static/umap/img/marker.svg")
 
 
-def test_can_change_picto_at_datalayer_level(map, live_server, page, pictos):
-    # Faster than doing a login
-    map.edit_status = Map.ANONYMOUS
-    map.settings["properties"]["iconUrl"] = "/uploads/pictogram/star.svg"
-    map.save()
-    DataLayerFactory(map=map, data=DATALAYER_DATA)
-    page.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+def test_can_change_picto_at_datalayer_level(openmap, live_server, page, pictos):
+    openmap.settings["properties"]["iconUrl"] = "/uploads/pictogram/star.svg"
+    openmap.save()
+    DataLayerFactory(map=openmap, data=DATALAYER_DATA)
+    page.goto(f"{live_server.url}{openmap.get_absolute_url()}?edit")
     marker = page.locator(".umap-div-icon img")
     expect(marker).to_have_count(1)
     # Should have default img
@@ -112,13 +107,11 @@ def test_can_change_picto_at_datalayer_level(map, live_server, page, pictos):
     expect(marker).to_have_attribute("src", "/uploads/pictogram/star.svg")
 
 
-def test_can_change_picto_at_marker_level(map, live_server, page, pictos):
-    # Faster than doing a login
-    map.edit_status = Map.ANONYMOUS
-    map.settings["properties"]["iconUrl"] = "/uploads/pictogram/star.svg"
-    map.save()
-    DataLayerFactory(map=map, data=DATALAYER_DATA)
-    page.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+def test_can_change_picto_at_marker_level(openmap, live_server, page, pictos):
+    openmap.settings["properties"]["iconUrl"] = "/uploads/pictogram/star.svg"
+    openmap.save()
+    DataLayerFactory(map=openmap, data=DATALAYER_DATA)
+    page.goto(f"{live_server.url}{openmap.get_absolute_url()}?edit")
     marker = page.locator(".umap-div-icon img")
     expect(marker).to_have_count(1)
     # Should have default img
@@ -152,12 +145,9 @@ def test_can_change_picto_at_marker_level(map, live_server, page, pictos):
     expect(marker).to_have_attribute("src", "/uploads/pictogram/star.svg")
 
 
-def test_can_use_remote_url_as_picto(map, live_server, page, pictos):
-    # Faster than doing a login
-    map.edit_status = Map.ANONYMOUS
-    map.save()
-    DataLayerFactory(map=map, data=DATALAYER_DATA)
-    page.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+def test_can_use_remote_url_as_picto(openmap, live_server, page, pictos):
+    DataLayerFactory(map=openmap, data=DATALAYER_DATA)
+    page.goto(f"{live_server.url}{openmap.get_absolute_url()}?edit")
     marker = page.locator(".umap-div-icon img")
     expect(marker).to_have_count(1)
     # Should have default img
@@ -195,12 +185,9 @@ def test_can_use_remote_url_as_picto(map, live_server, page, pictos):
     expect(symbols).to_have_count(1)
 
 
-def test_can_use_char_as_picto(map, live_server, page, pictos):
-    # Faster than doing a login
-    map.edit_status = Map.ANONYMOUS
-    map.save()
-    DataLayerFactory(map=map, data=DATALAYER_DATA)
-    page.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+def test_can_use_char_as_picto(openmap, live_server, page, pictos):
+    DataLayerFactory(map=openmap, data=DATALAYER_DATA)
+    page.goto(f"{live_server.url}{openmap.get_absolute_url()}?edit")
     marker = page.locator(".umap-div-icon span")
     # Should have default img, so not a span
     expect(marker).to_have_count(0)