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

umap/tests/integration/test_import.py

@@ -1,16 +1,41 @@
+import json
+import platform
+import re
 from pathlib import Path
+from time import sleep
 
 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_layers_list_is_updated(live_server, tilelayer, page):
     page.goto(f"{live_server.url}/map/new/")
-    button = page.get_by_title("Import data")
-    expect(button).to_be_visible()
-    button.click()
+    modifier = "Cmd" if platform.system() == "Darwin" else "Ctrl"
+    page.get_by_role("link", name=f"Import data ({modifier}+I)").click()
+    # Should work
+    page.get_by_label("Choose the layer to import").select_option(
+        label="Import in a new layer"
+    )
+    page.get_by_role("link", name="Manage layers").click()
+    page.get_by_role("button", name="Add a layer").click()
+    page.locator('input[name="name"]').click()
+    page.locator('input[name="name"]').fill("foobar")
+    page.get_by_role("link", name=f"Import data ({modifier}+I)").click()
+    # Should still work
+    page.get_by_label("Choose the layer to import").select_option(
+        label="Import in a new layer"
+    )
+    # Now layer should be visible in the options
+    page.get_by_label("Choose the layer to import").select_option(label="foobar")
+
+
+def test_umap_import_from_file(live_server, tilelayer, page):
+    page.goto(f"{live_server.url}/map/new/")
+    page.get_by_title("Import data").click()
     file_input = page.locator("input[type='file']")
     with page.expect_file_chooser() as fc_info:
         file_input.click()
@@ -20,19 +45,55 @@ def test_umap_import_from_file(live_server, datalayer, page):
     button = page.get_by_role("button", name="Import", exact=True)
     expect(button).to_be_visible()
     button.click()
-    layers = page.locator(".umap-browse-datalayers li")
-    expect(layers).to_have_count(2)
-    nonloaded = page.locator(".umap-browse-datalayers li.off")
-    expect(nonloaded).to_have_count(1)
     assert file_input.input_value()
     # Close the import panel
     page.keyboard.press("Escape")
+    # Reopen
+    page.get_by_title("Import data").click()
+    sleep(1)  # Wait for CSS transition to happen
     assert not file_input.input_value()
+    expect(page.locator(".umap-main-edit-toolbox .map-name")).to_have_text(
+        "Carte sans nom"
+    )
+    page.get_by_title("See layers").click()
+    layers = page.locator(".umap-browser .datalayer")
+    expect(layers).to_have_count(2)
+    nonloaded = page.locator(".umap-browser .datalayer.off")
+    expect(nonloaded).to_have_count(1)
+
+
+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_role("button", name="See layers").click()
+    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-browser .datalayer")
+    expect(layers).to_have_count(2)
+    expect(page.locator(".umap-main-edit-toolbox .map-name")).to_have_text(
+        "Imported map"
+    )
+    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")
+    page.get_by_title("See layers").click()
+    layers = page.locator(".umap-browser .datalayer")
     markers = page.locator(".leaflet-marker-icon")
     paths = page.locator("path")
     expect(markers).to_have_count(0)
@@ -52,3 +113,339 @@ 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/")
+    page.get_by_title("See layers").click()
+    layers = page.locator(".umap-browser .datalayer")
+    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/")
+    page.get_by_title("See layers").click()
+    layers = page.locator(".umap-browser .datalayer")
+    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/")
+    page.get_by_title("See layers").click()
+    layers = page.locator(".umap-browser .datalayer")
+    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/")
+    page.get_by_title("See layers").click()
+    layers = page.locator(".umap-browser .datalayer")
+    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()}")
+    page.get_by_title("See layers").click()
+    layers = page.locator(".umap-browser .datalayer")
+    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()}")
+    page.get_by_title("See layers").click()
+    layers = page.locator(".umap-browser .datalayer")
+    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()}")
+    page.get_by_title("See layers").click()
+    layers = page.locator(".umap-browser .datalayer")
+    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/")
+    page.get_by_title("See layers").click()
+    layers = page.locator(".umap-browser .datalayer")
+    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/")
+    page.get_by_title("See layers").click()
+    layers = page.locator(".umap-browser .datalayer")
+    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/")
+    page.get_by_title("See layers").click()
+    layers = page.locator(".umap-browser .datalayer")
+    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_csv_without_valid_latlon_headers(tilelayer, live_server, page):
+    page.goto(f"{live_server.url}/map/new/")
+    page.get_by_title("See layers").click()
+    layers = page.locator(".umap-browser .datalayer")
+    markers = page.locator(".leaflet-marker-icon")
+    page.get_by_title("Import data").click()
+    textarea = page.locator(".umap-upload textarea")
+    textarea.fill("a,b,c\n12.23,48.34,mypoint\n12.23,48.34,mypoint2")
+    page.locator('select[name="format"]').select_option("csv")
+    page.get_by_role("button", name="Import", exact=True).click()
+    # FIXME do not create a layer
+    expect(layers).to_have_count(1)
+    expect(markers).to_have_count(0)
+    expect(page.locator(".umap-alert")).to_be_visible()

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
@@ -46,10 +42,10 @@ def test_default_view_without_datalayer_should_use_default_center(
 ):
     datalayer.settings["displayOnLoad"] = False
     datalayer.save()
-    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    page.goto(f"{live_server.url}{map.get_absolute_url()}?onLoadPanel=datalayers")
     # Hash is defined, so map is initialized
     expect(page).to_have_url(re.compile(r".*#7/48\..+/13\..+"))
-    layers = page.locator(".umap-browse-datalayers li")
+    layers = page.locator(".umap-browser .datalayer h5")
     expect(layers).to_have_count(1)
 
 
@@ -60,10 +56,10 @@ def test_default_view_latest_without_datalayer_should_use_default_center(
     datalayer.save()
     map.settings["properties"]["defaultView"] = "latest"
     map.save()
-    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    page.goto(f"{live_server.url}{map.get_absolute_url()}?onLoadPanel=datalayers")
     # Hash is defined, so map is initialized
     expect(page).to_have_url(re.compile(r".*#7/48\..+/13\..+"))
-    layers = page.locator(".umap-browse-datalayers li")
+    layers = page.locator(".umap-browser .datalayer h5")
     expect(layers).to_have_count(1)
 
 
@@ -74,21 +70,22 @@ def test_default_view_data_without_datalayer_should_use_default_center(
     datalayer.save()
     map.settings["properties"]["defaultView"] = "data"
     map.save()
-    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    page.goto(f"{live_server.url}{map.get_absolute_url()}?onLoadPanel=datalayers")
     # Hash is defined, so map is initialized
     expect(page).to_have_url(re.compile(r".*#7/48\..+/13\..+"))
-    layers = page.locator(".umap-browse-datalayers li")
+    layers = page.locator(".umap-browser .datalayer h5")
     expect(layers).to_have_count(1)
 
 
 def test_default_view_latest_with_marker(map, live_server, datalayer, page):
     map.settings["properties"]["defaultView"] = "latest"
     map.save()
-    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    page.goto(f"{live_server.url}{map.get_absolute_url()}?onLoadPanel=datalayers")
     # Hash is defined, so map is initialized
     expect(page).to_have_url(re.compile(r".*#7/48\..+/14\..+"))
-    layers = page.locator(".umap-browse-datalayers li")
+    layers = page.locator(".umap-browser .datalayer h5")
     expect(layers).to_have_count(1)
+    expect(page.locator(".leaflet-popup")).to_be_visible()
 
 
 def test_default_view_latest_with_line(map, live_server, page):
@@ -113,9 +110,9 @@ def test_default_view_latest_with_line(map, live_server, page):
     DataLayerFactory(map=map, data=data)
     map.settings["properties"]["defaultView"] = "latest"
     map.save()
-    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    page.goto(f"{live_server.url}{map.get_absolute_url()}?onLoadPanel=datalayers")
     expect(page).to_have_url(re.compile(r".*#8/48\..+/2\..+"))
-    layers = page.locator(".umap-browse-datalayers li")
+    layers = page.locator(".umap-browser .datalayer h5")
     expect(layers).to_have_count(1)
 
 
@@ -144,29 +141,38 @@ def test_default_view_latest_with_polygon(map, live_server, page):
     DataLayerFactory(map=map, data=data)
     map.settings["properties"]["defaultView"] = "latest"
     map.save()
-    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    page.goto(f"{live_server.url}{map.get_absolute_url()}?onLoadPanel=datalayers")
     expect(page).to_have_url(re.compile(r".*#8/48\..+/2\..+"))
-    layers = page.locator(".umap-browse-datalayers li")
+    layers = page.locator(".umap-browser .datalayer h5")
     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")
-    toggle = page.get_by_role("button", name="See data layers")
+    page.goto(f"{live_server.url}{openmap.get_absolute_url()}?edit")
+    toggle = page.get_by_role("button", name="See layers")
     expect(toggle).to_be_visible()
     toggle.click()
-    layers = page.locator(".umap-browse-datalayers li")
+    layers = page.locator(".umap-browser .datalayer h5")
     expect(layers).to_have_count(1)
     map_el = page.locator("#map")
     add_marker = page.get_by_title("Draw a marker")
@@ -174,53 +180,29 @@ def test_remote_layer_should_not_be_used_as_datalayer_for_created_features(
     marker = page.locator(".leaflet-marker-icon")
     expect(marker).to_have_count(0)
     add_marker.click()
-    map_el.click(position={"x": 100, "y": 100})
+    map_el.click(position={"x": 500, "y": 100})
     expect(marker).to_have_count(1)
     # A new datalayer has been created to host this created feature
     # given the remote one cannot accept new features
+    page.get_by_title("See layers").click()
     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()
     layers = page.locator(".umap-caption .datalayer-legend")
     expect(layers).to_have_count(1)
-    found = page.locator("#umap-ui-container").get_by_text(datalayer.name)
+    found = page.locator(".panel.left.on").get_by_text(datalayer.name)
     expect(found).to_be_visible()
-    hidden = page.locator("#umap-ui-container").get_by_text(other.name)
+    hidden = page.locator(".panel.left.on").get_by_text(other.name)
     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_map_list.py

@@ -0,0 +1,28 @@
+import pytest
+from playwright.sync_api import expect
+
+pytestmark = pytest.mark.django_db
+
+
+def test_should_not_render_any_control(live_server, tilelayer, page, map):
+    map.settings["properties"]["onLoadPanel"] = "databrowser"
+    map.settings["properties"]["miniMap"] = True
+    map.settings["properties"]["captionBar"] = True
+    map.save()
+    # Make sure those controls are visible in normal view
+    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    expect(page.locator(".leaflet-control-minimap")).to_be_visible()
+    expect(page.locator(".umap-browser")).to_be_visible()
+    expect(page.locator(".umap-caption-bar")).to_be_visible()
+    expect(page.locator(".leaflet-control-zoom")).to_be_visible()
+    expect(page.locator(".leaflet-control-attribution")).to_be_visible()
+
+    # Now load home page to have the list view
+    page.goto(live_server.url)
+    map_el = page.locator(".map_fragment")
+    expect(map_el).to_be_visible()
+    expect(map_el.locator(".leaflet-control-minimap")).to_be_hidden()
+    expect(map_el.locator(".umap-browser")).to_be_hidden()
+    expect(map_el.locator(".umap-caption-bar")).to_be_hidden()
+    expect(map_el.locator(".leaflet-control-zoom")).to_be_hidden()
+    expect(map_el.locator(".leaflet-control-attribution")).to_be_hidden()