umap-project 1.14.0a5__py3-none-any.whl → 2.0.0a0__py3-none-any.whl

umap/tests/integration/test_collaborative_editing.py

@@ -1,9 +1,14 @@
+import re
+from time import sleep
+
 from playwright.sync_api import expect
 
 from umap.models import DataLayer
 
 from ..base import DataLayerFactory, MapFactory
 
+DATALAYER_UPDATE = re.compile(r".*/datalayer/update/.*")
+
 
 def test_collaborative_editing_create_markers(context, live_server, tilelayer):
     # Let's create a new map with an empty datalayer
@@ -31,11 +36,17 @@ def test_collaborative_editing_create_markers(context, live_server, tilelayer):
     map_el_p1.click(position={"x": 200, "y": 200})
     expect(marker_pane_p1).to_have_count(1)
 
-    save_p1.click()
+    with page_one.expect_response(DATALAYER_UPDATE):
+        save_p1.click()
+        # Prefent two layers to be saved on the same second, as we compare them based
+        # on time in case of conflict. FIXME do not use time for comparison.
+        sleep(1)
     assert DataLayer.objects.get(pk=datalayer.pk).settings == {
         "browsable": True,
         "displayOnLoad": True,
         "name": "test datalayer",
+        "editMode": "advanced",
+        "inCaption": True,
     }
 
     # Now navigate to this map from another tab
@@ -60,7 +71,9 @@ def test_collaborative_editing_create_markers(context, live_server, tilelayer):
     map_el_p2.click(position={"x": 220, "y": 220})
     expect(marker_pane_p2).to_have_count(2)
 
-    save_p2.click()
+    with page_two.expect_response(DATALAYER_UPDATE):
+        save_p2.click()
+        sleep(1)
     # No change after the save
     expect(marker_pane_p2).to_have_count(2)
     assert DataLayer.objects.get(pk=datalayer.pk).settings == {
@@ -75,7 +88,8 @@ def test_collaborative_editing_create_markers(context, live_server, tilelayer):
     create_marker_p1.click()
     map_el_p1.click(position={"x": 150, "y": 150})
     expect(marker_pane_p1).to_have_count(2)
-    save_p1.click()
+    with page_one.expect_response(DATALAYER_UPDATE):
+        save_p1.click()
     # Should now get the other marker too
     expect(marker_pane_p1).to_have_count(3)
     assert DataLayer.objects.get(pk=datalayer.pk).settings == {
@@ -92,7 +106,9 @@ def test_collaborative_editing_create_markers(context, live_server, tilelayer):
     create_marker_p1.click()
     map_el_p1.click(position={"x": 180, "y": 150})
     expect(marker_pane_p1).to_have_count(4)
-    save_p1.click()
+    with page_one.expect_response(DATALAYER_UPDATE):
+        save_p1.click()
+        sleep(1)
     # Should now get the other marker too
     assert DataLayer.objects.get(pk=datalayer.pk).settings == {
         "browsable": True,
@@ -110,7 +126,9 @@ def test_collaborative_editing_create_markers(context, live_server, tilelayer):
     create_marker_p2.click()
     map_el_p2.click(position={"x": 250, "y": 150})
     expect(marker_pane_p2).to_have_count(3)
-    save_p2.click()
+    with page_two.expect_response(DATALAYER_UPDATE):
+        save_p2.click()
+        sleep(1)
     # Should now get the other markers too
     assert DataLayer.objects.get(pk=datalayer.pk).settings == {
         "browsable": True,

umap/tests/integration/test_dashboard.py

@@ -0,0 +1,17 @@
+import pytest
+from playwright.sync_api import expect
+
+from umap.models import Map
+
+pytestmark = pytest.mark.django_db
+
+
+def test_owner_can_delete_map_after_confirmation(map, live_server, login):
+    page = login(map.owner)
+    page.goto(f"{live_server.url}/en/me")
+    delete_button = page.get_by_title("Delete")
+    expect(delete_button).to_be_visible()
+    page.on("dialog", lambda dialog: dialog.accept())
+    with page.expect_navigation():
+        delete_button.click()
+    assert Map.objects.all().count() == 0

umap/tests/integration/test_edit_datalayer.py

@@ -9,9 +9,10 @@ def test_should_have_fieldset_for_layer_type_properties(page, live_server, tilel
     expect(button).to_be_visible()
     button.click()
 
-    edit = page.locator("#umap-ui-container").get_by_title("Edit", exact=True)
-    expect(edit).to_be_visible()
-    edit.click()
+    # Create a layer
+    page.get_by_title("Manage layers").click()
+    page.get_by_role("button", name="Add a layer").click()
+    page.locator("input[name=name]").fill("Layer 1")
 
     select = page.locator("#umap-ui-container .umap-field-type select")
     expect(select).to_be_visible()

umap/tests/integration/test_export_map.py

@@ -61,7 +61,7 @@ def test_umap_export(map, live_server, datalayer, page):
                 "attribution": "© OSM Contributors",
                 "maxZoom": 18,
                 "minZoom": 0,
-                "url_template": "https://{s}.tile.openstreetmap.fr/osmfr/{z}/{x}/{y}.png",
+                "url_template": "https://a.tile.openstreetmap.fr/osmfr/{z}/{x}/{y}.png",
             },
             "tilelayersControl": True,
             "zoom": 7,

umap/tests/integration/test_import.py

@@ -11,8 +11,9 @@ def test_umap_import_from_file(live_server, datalayer, page):
     button = page.get_by_title("Import data")
     expect(button).to_be_visible()
     button.click()
+    file_input = page.locator("input[type='file']")
     with page.expect_file_chooser() as fc_info:
-        page.locator("input[type='file']").click()
+        file_input.click()
     file_chooser = fc_info.value
     path = Path(__file__).parent.parent / "fixtures/display_on_load.umap"
     file_chooser.set_files(path)
@@ -20,9 +21,13 @@ def test_umap_import_from_file(live_server, datalayer, page):
     expect(button).to_be_visible()
     button.click()
     layers = page.locator(".umap-browse-datalayers li")
-    expect(layers).to_have_count(3)
+    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")
+    assert not file_input.input_value()
 
 
 def test_umap_import_geojson_from_textarea(live_server, datalayer, page):
@@ -32,7 +37,7 @@ def test_umap_import_geojson_from_textarea(live_server, datalayer, page):
     paths = page.locator("path")
     expect(markers).to_have_count(0)
     expect(paths).to_have_count(0)
-    expect(layers).to_have_count(1)
+    expect(layers).to_have_count(0)
     button = page.get_by_title("Import data")
     expect(button).to_be_visible()
     button.click()
@@ -43,7 +48,7 @@ def test_umap_import_geojson_from_textarea(live_server, datalayer, page):
     button = page.get_by_role("button", name="Import", exact=True)
     expect(button).to_be_visible()
     button.click()
-    # No layer has been created
+    # A layer has been created
     expect(layers).to_have_count(1)
     expect(markers).to_have_count(2)
     expect(paths).to_have_count(3)

umap/tests/integration/test_map.py

@@ -12,6 +12,47 @@ from ..base import DataLayerFactory
 pytestmark = pytest.mark.django_db
 
 
+def test_preconnect_for_tilelayer(map, page, live_server, tilelayer):
+    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    meta = page.locator('link[rel="preconnect"]')
+    expect(meta).to_have_count(1)
+    expect(meta).to_have_attribute("href", "//a.tile.openstreetmap.fr")
+    # Add custom tilelayer
+    map.settings["properties"]["tilelayer"] = {
+        "name": "OSM Piano FR",
+        "maxZoom": 20,
+        "minZoom": 0,
+        "attribution": "test",
+        "url_template": "https://a.piano.tiles.quaidorsay.fr/fr{r}/{z}/{x}/{y}.png",
+    }
+    map.save()
+    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    expect(meta).to_have_attribute("href", "//a.piano.tiles.quaidorsay.fr")
+    # Add custom tilelayer with variable in domain, should create a preconnect
+    map.settings["properties"]["tilelayer"] = {
+        "name": "OSM Piano FR",
+        "maxZoom": 20,
+        "minZoom": 0,
+        "attribution": "test",
+        "url_template": "https://{s}.piano.tiles.quaidorsay.fr/fr{r}/{z}/{x}/{y}.png",
+    }
+    map.save()
+    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    expect(meta).to_have_count(0)
+
+
+def test_default_view_without_datalayer_should_use_default_center(
+    map, live_server, datalayer, page
+):
+    datalayer.settings["displayOnLoad"] = False
+    datalayer.save()
+    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    # 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")
+    expect(layers).to_have_count(1)
+
+
 def test_default_view_latest_without_datalayer_should_use_default_center(
     map, live_server, datalayer, page
 ):
@@ -26,6 +67,20 @@ def test_default_view_latest_without_datalayer_should_use_default_center(
     expect(layers).to_have_count(1)
 
 
+def test_default_view_data_without_datalayer_should_use_default_center(
+    map, live_server, datalayer, page
+):
+    datalayer.settings["displayOnLoad"] = False
+    datalayer.save()
+    map.settings["properties"]["defaultView"] = "data"
+    map.save()
+    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    # 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")
+    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()
@@ -164,3 +219,12 @@ def test_basic_choropleth_map(map, live_server, page):
     # 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()
+    map.settings["properties"]["miniMap"] = True
+    map.save()
+    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    expect(page.locator(".leaflet-control-minimap")).to_be_visible()

umap/tests/integration/test_map_preview.py

@@ -0,0 +1,75 @@
+import json
+from urllib.parse import quote
+
+import pytest
+from playwright.sync_api import expect
+
+pytestmark = pytest.mark.django_db
+
+GEOJSON = {
+    "type": "FeatureCollection",
+    "features": [
+        {
+            "type": "Feature",
+            "properties": {
+                "name": "Niagara Falls",
+            },
+            "geometry": {
+                "type": "Point",
+                "coordinates": [-79.04, 43.08],
+            },
+        }
+    ],
+}
+CSV = "name,latitude,longitude\nNiagara Falls,43.08,-79.04"
+
+
+def test_map_preview(page, live_server, tilelayer):
+    page.goto(f"{live_server.url}/map/")
+    # Edit mode is not enabled
+    edit_button = page.get_by_role("button", name="Edit")
+    expect(edit_button).to_be_visible()
+
+
+def test_map_preview_can_load_remote_geojson(page, live_server, tilelayer):
+    def handle(route):
+        route.fulfill(json=GEOJSON)
+
+    # Intercept the route to the proxy
+    page.route("*/**/ajax-proxy/**", handle)
+
+    page.goto(f"{live_server.url}/map/?dataUrl=http://some.org/geo.json")
+    markers = page.locator(".leaflet-marker-icon")
+    expect(markers).to_have_count(1)
+
+
+def test_map_preview_can_load_remote_csv(page, live_server, tilelayer):
+    def handle(route):
+        csv = """name,latitude,longitude\nNiagara Falls,43.08,-79.04"""
+        route.fulfill(body=csv)
+
+    # Intercept the route to the proxy
+    page.route("*/**/ajax-proxy/**", handle)
+
+    page.goto(f"{live_server.url}/map/?dataUrl=http://some.org/geo.csv&dataFormat=csv")
+    markers = page.locator(".leaflet-marker-icon")
+    expect(markers).to_have_count(1)
+
+
+def test_map_preview_can_load_geojson_in_querystring(page, live_server, tilelayer):
+    page.goto(f"{live_server.url}/map/?data={quote(json.dumps(GEOJSON))}")
+    markers = page.locator(".leaflet-marker-icon")
+    expect(markers).to_have_count(1)
+
+
+def test_map_preview_can_load_csv_in_querystring(page, live_server, tilelayer):
+    page.goto(f"{live_server.url}/map/?data={quote(CSV)}&dataFormat=csv")
+    markers = page.locator(".leaflet-marker-icon")
+    expect(markers).to_have_count(1)
+
+
+def test_map_preview_can_change_styling_from_querystring(page, live_server, tilelayer):
+    page.goto(f"{live_server.url}/map/?data={quote(json.dumps(GEOJSON))}&color=DarkRed")
+    markers = page.locator(".leaflet-marker-icon .icon_container")
+    expect(markers).to_have_count(1)
+    expect(markers).to_have_css("background-color", "rgb(139, 0, 0)")

umap/tests/integration/test_owned_map.py

@@ -1,4 +1,4 @@
-from time import sleep
+import re
 
 import pytest
 from playwright.sync_api import expect
@@ -8,24 +8,6 @@ from umap.models import DataLayer, Map
 pytestmark = pytest.mark.django_db
 
 
-@pytest.fixture
-def login(context, settings, live_server):
-    def do_login(user):
-        # TODO use storage state to do login only once per session
-        # https://playwright.dev/python/docs/auth
-        settings.ENABLE_ACCOUNT_LOGIN = True
-        page = context.new_page()
-        page.goto(f"{live_server.url}/en/")
-        page.locator(".login").click()
-        page.get_by_placeholder("Username").fill(user.username)
-        page.get_by_placeholder("Password").fill("123123")
-        page.locator('#login_form input[type="submit"]').click()
-        sleep(1)  # Time for ajax login POST to proceed
-        return page
-
-    return do_login
-
-
 def test_map_update_with_owner(map, live_server, login):
     page = login(map.owner)
     page.goto(f"{live_server.url}{map.get_absolute_url()}")
@@ -183,18 +165,22 @@ def test_create(tilelayer, live_server, login, user):
     expect(marker).to_have_count(1)
     save = page.get_by_role("button", name="Save")
     expect(save).to_be_visible()
-    save.click()
-    sleep(1)  # Let save ajax go back
+    with page.expect_response(re.compile(r".*/datalayer/create/")):
+        save.click()
     expect(marker).to_have_count(1)
 
 
 def test_can_change_perms_after_create(tilelayer, live_server, login, user):
     page = login(user)
     page.goto(f"{live_server.url}/en/map/new")
+    # Create a layer
+    page.get_by_title("Manage layers").click()
+    page.get_by_role("button", name="Add a layer").click()
+    page.locator("input[name=name]").fill("Layer 1")
     save = page.get_by_role("button", name="Save")
     expect(save).to_be_visible()
-    save.click()
-    sleep(1)  # Let save ajax go back
+    with page.expect_response(re.compile(r".*/map/create/")):
+        save.click()
     edit_permissions = page.get_by_title("Update permissions and editors")
     expect(edit_permissions).to_be_visible()
     edit_permissions.click()
@@ -228,7 +214,7 @@ def test_can_change_owner(map, live_server, login, user):
     input.press("Tab")
     save = page.get_by_role("button", name="Save")
     expect(save).to_be_visible()
-    save.click()
-    sleep(1)  # Let save ajax go
+    with page.expect_response(re.compile(r".*/update/permissions/.*")):
+        save.click()
     modified = Map.objects.get(pk=map.pk)
     assert modified.owner == user

umap/tests/integration/test_picto.py

@@ -46,7 +46,7 @@ def test_can_change_picto_at_map_level(map, live_server, page, pictos):
     marker = page.locator(".umap-div-icon img")
     expect(marker).to_have_count(1)
     # Should have default img
-    expect(marker).to_have_attribute("src", "/static/umap/img/marker.png")
+    expect(marker).to_have_attribute("src", "/static/umap/img/marker.svg")
     edit_settings = page.get_by_title("Edit map properties")
     expect(edit_settings).to_be_visible()
     edit_settings.click()
@@ -66,7 +66,7 @@ def test_can_change_picto_at_map_level(map, live_server, page, pictos):
     symbols.click()
     expect(marker).to_have_attribute("src", "/uploads/pictogram/star.svg")
     undefine.click()
-    expect(marker).to_have_attribute("src", "/static/umap/img/marker.png")
+    expect(marker).to_have_attribute("src", "/static/umap/img/marker.svg")
 
 
 def test_can_change_picto_at_datalayer_level(map, live_server, page, pictos):
@@ -147,7 +147,7 @@ def test_can_use_remote_url_as_picto(map, live_server, page, pictos):
     marker = page.locator(".umap-div-icon img")
     expect(marker).to_have_count(1)
     # Should have default img
-    expect(marker).to_have_attribute("src", "/static/umap/img/marker.png")
+    expect(marker).to_have_attribute("src", "/static/umap/img/marker.svg")
     edit_settings = page.get_by_title("Edit map properties")
     expect(edit_settings).to_be_visible()
     edit_settings.click()

umap/tests/integration/test_querystring.py

@@ -0,0 +1,52 @@
+import re
+
+import pytest
+from playwright.sync_api import expect
+
+pytestmark = pytest.mark.django_db
+
+
+def test_scale_control(map, live_server, datalayer, page):
+    control = page.locator(".leaflet-control-scale")
+    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    expect(control).to_be_visible()
+    page.goto(f"{live_server.url}{map.get_absolute_url()}?scaleControl=false")
+    expect(control).to_be_hidden()
+
+
+def test_datalayers_control(map, live_server, datalayer, page):
+    control = page.locator(".umap-browse-toggle")
+    box = page.locator(".umap-browse-datalayers")
+    more = page.get_by_title("More controls")
+    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    expect(control).to_be_visible()
+    expect(box).to_be_hidden()
+    page.goto(f"{live_server.url}{map.get_absolute_url()}?datalayersControl=true")
+    expect(control).to_be_visible()
+    expect(box).to_be_hidden()
+    page.goto(f"{live_server.url}{map.get_absolute_url()}?datalayersControl=null")
+    expect(control).to_be_hidden()
+    expect(more).to_be_visible()
+    more.click()
+    expect(control).to_be_visible()
+    expect(box).to_be_hidden()
+    page.goto(f"{live_server.url}{map.get_absolute_url()}?datalayersControl=false")
+    expect(control).to_be_hidden()
+    expect(more).to_be_visible()
+    more.click()
+    expect(control).to_be_hidden()
+    expect(box).to_be_hidden()
+    page.goto(f"{live_server.url}{map.get_absolute_url()}?datalayersControl=expanded")
+    expect(control).to_be_hidden()
+    expect(box).to_be_visible()
+
+
+def test_can_deactivate_wheel_from_query_string(map, live_server, page):
+    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    expect(page).to_have_url(re.compile(r".*#7/.+"))
+    page.mouse.wheel(0, 1)
+    expect(page).to_have_url(re.compile(r".*#6/.+"))
+    page.goto(f"{live_server.url}{map.get_absolute_url()}?scrollWheelZoom=false")
+    expect(page).to_have_url(re.compile(r".*#7/.+"))
+    page.mouse.wheel(0, 1)
+    expect(page).to_have_url(re.compile(r".*#7/.+"))

umap/tests/integration/test_share.py

@@ -0,0 +1,22 @@
+import re
+
+import pytest
+from playwright.sync_api import expect
+
+pytestmark = pytest.mark.django_db
+
+
+def test_iframe_code(map, live_server, datalayer, page):
+    page.goto(f"{live_server.url}{map.get_absolute_url()}?share")
+    textarea = page.locator(".umap-share-iframe")
+    expect(textarea).to_be_visible()
+    expect(textarea).to_have_text(re.compile('src="'))
+    expect(textarea).to_have_text(re.compile('href="'))
+    # We should ave both, once for iframe link, once for full screen
+    expect(textarea).to_have_text(re.compile("scrollWheelZoom=true"))
+    expect(textarea).to_have_text(re.compile("scrollWheelZoom=false"))
+    expect(textarea).not_to_have_text(re.compile(f"datalayers={datalayer.pk}"))
+    # Open options
+    page.get_by_text("Embed and link options").click()
+    page.get_by_title("Keep current visible layers").click()
+    expect(textarea).to_have_text(re.compile(f"datalayers={datalayer.pk}"))