umap-project 2.6.2__py3-none-any.whl → 2.7.0__py3-none-any.whl

umap/tests/integration/test_owned_map.py

@@ -234,8 +234,8 @@ def test_can_delete_datalayer(live_server, map, login, datalayer):
     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(".panel.right").get_by_title("Delete layer").click()
+    page.get_by_role("button", name="OK").click()
     with page.expect_response(re.compile(r".*/datalayer/delete/.*")):
         page.get_by_role("button", name="Save").click()
     expect(markers).to_have_count(0)

umap/tests/integration/test_view_marker.py

@@ -106,3 +106,66 @@ def test_extended_properties_in_popup(live_server, map, page, bootstrap):
     expect(page.get_by_text("Alt: 241")).to_be_visible()
     expect(page.get_by_text("Zoom: 7")).to_be_visible()
     expect(page.get_by_text("Layer: test datalayer")).to_be_visible()
+
+
+def test_only_visible_markers_are_added_to_dom(live_server, map, page):
+    data = {
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "type": "Feature",
+                "properties": {
+                    "name": "marker 1",
+                    "description": "added to dom",
+                },
+                "geometry": {
+                    "type": "Point",
+                    "coordinates": [14.6, 48.5],
+                },
+            },
+            {
+                "type": "Feature",
+                "properties": {
+                    "name": "marker 2",
+                    "description": "not added to dom at load",
+                },
+                "geometry": {
+                    "type": "Point",
+                    "coordinates": [12.6, 44.5],
+                },
+            },
+        ],
+    }
+    DataLayerFactory(map=map, data=data)
+    map.settings["properties"]["showLabel"] = True
+    map.save()
+    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    markers = page.locator(".leaflet-marker-icon")
+    tooltips = page.locator(".leaflet-tooltip")
+    expect(markers).to_have_count(1)
+    expect(tooltips).to_have_count(1)
+
+    # Zoom in/out to show the other marker
+    page.get_by_label("Zoom out").click()
+    expect(markers).to_have_count(2)
+    expect(tooltips).to_have_count(2)
+    page.get_by_label("Zoom in").click()
+    expect(markers).to_have_count(1)
+    expect(tooltips).to_have_count(1)
+
+    # Drag map to show/hide the marker
+    map_el = page.locator("#map")
+    map_el.drag_to(
+        map_el,
+        source_position={"x": 100, "y": 600},
+        target_position={"x": 100, "y": 200},
+    )
+    expect(markers).to_have_count(2)
+    expect(tooltips).to_have_count(2)
+    map_el.drag_to(
+        map_el,
+        source_position={"x": 100, "y": 600},
+        target_position={"x": 100, "y": 200},
+    )
+    expect(markers).to_have_count(1)
+    expect(tooltips).to_have_count(1)

umap/tests/integration/test_view_polygon.py

@@ -1,4 +1,5 @@
 import re
+from copy import deepcopy
 
 import pytest
 from playwright.sync_api import expect
@@ -33,19 +34,9 @@ DATALAYER_DATA = {
 }
 
 
-@pytest.fixture
-def bootstrap(map, live_server):
-    map.settings["properties"]["zoom"] = 6
-    map.settings["geometry"] = {
-        "type": "Point",
-        "coordinates": [8.429, 53.239],
-    }
-    map.save()
+def test_should_open_popup_on_click(live_server, map, page):
     DataLayerFactory(map=map, data=DATALAYER_DATA)
-
-
-def test_should_open_popup_on_click(live_server, map, page, bootstrap):
-    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    page.goto(f"{live_server.url}{map.get_absolute_url()}#6/53.239/8.429")
     polygon = page.locator("path").first
     expect(polygon).to_have_attribute("fill-opacity", "0.3")
     polygon.click()
@@ -57,3 +48,12 @@ def test_should_open_popup_on_click(live_server, map, page, bootstrap):
     # Close popup
     page.locator("#map").click()
     expect(polygon).to_have_attribute("fill-opacity", "0.3")
+
+
+def test_should_not_react_to_click_if_interactive_false(live_server, map, page):
+    data = deepcopy(DATALAYER_DATA)
+    data["features"][0]["properties"]["_umap_options"] = {"interactive": False}
+    DataLayerFactory(map=map, data=data)
+    page.goto(f"{live_server.url}{map.get_absolute_url()}#6/53.239/8.429")
+    polygon = page.locator("path").first
+    expect(polygon).to_have_css("pointer-events", "none")

umap/tests/integration/test_websocket_sync.py

@@ -69,7 +69,7 @@ def test_websocket_connection_can_sync_markers(
 
     # Delete a marker from peer A and check it's been deleted on peer B
     a_first_marker.click(button="right")
-    peerA.get_by_role("link", name="Delete this feature").click()
+    peerA.get_by_role("button", name="Delete this feature").click()
     peerA.locator("dialog").get_by_role("button", name="OK").click()
     expect(a_marker_pane).to_have_count(1)
     expect(b_marker_pane).to_have_count(1)
@@ -153,7 +153,7 @@ def test_websocket_connection_can_sync_polygons(
 
     # Delete a polygon from peer A and check it's been deleted on peer B
     a_polygon.click(button="right")
-    peerA.get_by_role("link", name="Delete this feature").click()
+    peerA.get_by_role("button", name="Delete this feature").click()
     peerA.locator("dialog").get_by_role("button", name="OK").click()
     expect(a_polygons).to_have_count(0)
     expect(b_polygons).to_have_count(0)
@@ -268,7 +268,7 @@ def test_websocket_connection_can_sync_cloned_polygons(
 
     # Clone on peer B and save
     b_polygon.click(button="right")
-    peerB.get_by_role("link", name="Clone this feature").click()
+    peerB.get_by_role("button", name="Clone this feature").click()
 
     expect(peerB.locator("path")).to_have_count(2)
 
@@ -281,3 +281,65 @@ def test_websocket_connection_can_sync_cloned_polygons(
     peerB.get_by_role("button", name="Save").click()
 
     expect(peerB.locator("path")).to_have_count(2)
+
+
+@pytest.mark.xdist_group(name="websockets")
+def test_websocket_connection_can_sync_late_joining_peer(
+    new_page, live_server, websocket_server, tilelayer
+):
+    map = MapFactory(name="sync", edit_status=Map.ANONYMOUS)
+    map.settings["properties"]["syncEnabled"] = True
+    map.save()
+    DataLayerFactory(map=map, data={})
+
+    # Create first peer (A) and have it join immediately
+    peerA = new_page("Page A")
+    peerA.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+
+    # Add a marker from peer A
+    a_create_marker = peerA.get_by_title("Draw a marker")
+    expect(a_create_marker).to_be_visible()
+    a_create_marker.click()
+
+    a_map_el = peerA.locator("#map")
+    a_map_el.click(position={"x": 220, "y": 220})
+    peerA.locator("body").type("First marker")
+    peerA.locator("body").press("Escape")
+
+    # Add a polygon from peer A
+    create_polygon = peerA.locator(".leaflet-control-toolbar ").get_by_title(
+        "Draw a polygon"
+    )
+    create_polygon.click()
+
+    a_map_el.click(position={"x": 200, "y": 200})
+    a_map_el.click(position={"x": 100, "y": 200})
+    a_map_el.click(position={"x": 100, "y": 100})
+    a_map_el.click(position={"x": 200, "y": 100})
+    a_map_el.click(position={"x": 200, "y": 100})
+    peerA.keyboard.press("Escape")
+
+    # Now create peer B and have it join
+    peerB = new_page("Page B")
+    peerB.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+
+    # Check if peer B has received all the updates
+    b_marker_pane = peerB.locator(".leaflet-marker-pane > div")
+    b_polygons = peerB.locator(".leaflet-overlay-pane path[fill='DarkBlue']")
+
+    expect(b_marker_pane).to_have_count(1)
+    expect(b_polygons).to_have_count(1)
+
+    # Verify marker properties
+    peerB.locator(".leaflet-marker-icon").first.click()
+    peerB.get_by_role("link", name="Toggle edit mode (⇧+Click)").click()
+    expect(peerB.locator('input[name="name"]')).to_have_value("First marker")
+
+    # Verify polygon exists (we've already checked the count)
+    b_polygon = peerB.locator("path")
+    expect(b_polygon).to_be_visible()
+
+    # Optional: Verify polygon properties if you have any specific ones set
+
+    # Clean up: close edit mode
+    peerB.locator("body").press("Escape")

umap/tests/test_clean_tilelayer.py

@@ -0,0 +1,83 @@
+import pytest
+from django.core.management import call_command
+
+from umap.models import Map
+
+pytestmark = pytest.mark.django_db
+
+
+def test_can_delete_tilelayer_from_settings(map):
+    map.settings["properties"]["tilelayer"] = {
+        "name": "My TileLayer",
+        "maxZoom": 18,
+        "minZoom": 0,
+        "attribution": "My attribution",
+        "url_template": "http://{s}.foo.bar.baz/{z}/{x}/{y}.png",
+    }
+    map.save()
+    # Make sure its saved
+    map = Map.objects.get(pk=map.pk)
+    assert "tilelayer" in map.settings["properties"]
+    call_command(
+        "clean_tilelayer", "http://{s}.foo.bar.baz/{z}/{x}/{y}.png", "--no-input"
+    )
+    map = Map.objects.get(pk=map.pk)
+    assert "tilelayer" not in map.settings["properties"]
+
+
+def test_can_replace_tilelayer_url_in_map_settings(map):
+    map.settings["properties"]["tilelayer"] = {
+        "name": "My TileLayer",
+        "maxZoom": 18,
+        "minZoom": 0,
+        "attribution": "My attribution",
+        "url_template": "http://{s}.foo.bar.baz/{z}/{x}/{y}.png",
+    }
+    map.save()
+    new = "https://{s}.foo.bar.baz/{z}/{x}/{y}.png"
+    call_command(
+        "clean_tilelayer",
+        "http://{s}.foo.bar.baz/{z}/{x}/{y}.png",
+        new,
+        "--no-input",
+    )
+    map = Map.objects.get(pk=map.pk)
+    assert map.settings["properties"]["tilelayer"]["url_template"] == new
+
+
+def test_can_replace_tilelayer_by_name_in_map_settings(map, tilelayer):
+    map.settings["properties"]["tilelayer"] = {
+        "name": "My TileLayer",
+        "maxZoom": 18,
+        "minZoom": 0,
+        "attribution": "My attribution",
+        "url_template": "http://{s}.foo.bar.baz/{z}/{x}/{y}.png",
+    }
+    map.save()
+    call_command(
+        "clean_tilelayer",
+        "http://{s}.foo.bar.baz/{z}/{x}/{y}.png",
+        tilelayer.name,
+        "--no-input",
+    )
+    map = Map.objects.get(pk=map.pk)
+    assert map.settings["properties"]["tilelayer"] == tilelayer.json
+
+
+def test_can_replace_tilelayer_by_id_in_map_settings(map, tilelayer):
+    map.settings["properties"]["tilelayer"] = {
+        "name": "My TileLayer",
+        "maxZoom": 18,
+        "minZoom": 0,
+        "attribution": "My attribution",
+        "url_template": "http://{s}.foo.bar.baz/{z}/{x}/{y}.png",
+    }
+    map.save()
+    call_command(
+        "clean_tilelayer",
+        "http://{s}.foo.bar.baz/{z}/{x}/{y}.png",
+        tilelayer.pk,
+        "--no-input",
+    )
+    map = Map.objects.get(pk=map.pk)
+    assert map.settings["properties"]["tilelayer"] == tilelayer.json

umap/tests/test_datalayer.py

@@ -1,3 +1,4 @@
+import tempfile
 from pathlib import Path
 
 import pytest
@@ -269,3 +270,26 @@ def test_anonymous_can_edit_in_inherit_mode_and_map_in_public_mode(
     map.save()
     fake_request.user = AnonymousUser()
     assert datalayer.can_edit(fake_request)
+
+
+def test_should_remove_all_versions_on_delete(map, settings):
+    settings.UMAP_PURGATORY_ROOT = tempfile.mkdtemp()
+    datalayer = DataLayerFactory(uuid="0f1161c0-c07f-4ba4-86c5-8d8981d8a813", old_id=17)
+    root = Path(datalayer.storage_root())
+    before = len(datalayer.geojson.storage.listdir(root)[1])
+    other = "123456_1440918637.geojson"
+    files = [
+        f"{datalayer.pk}_1440924889.geojson",
+        f"{datalayer.pk}_1440923687.geojson",
+        f"{datalayer.pk}_1440918637.geojson",
+        f"{datalayer.old_id}_1440918537.geojson",
+        other,
+    ]
+    for path in files:
+        datalayer.geojson.storage.save(root / path, ContentFile("{}"))
+        datalayer.geojson.storage.save(root / f"{path}.gz", ContentFile("{}"))
+    assert len(datalayer.geojson.storage.listdir(root)[1]) == 10 + before
+    datalayer.delete()
+    found = datalayer.geojson.storage.listdir(root)[1]
+    assert found == [other, f"{other}.gz"]
+    assert len(list(Path(settings.UMAP_PURGATORY_ROOT).iterdir())) == 4 + before

umap/tests/test_map_views.py

@@ -368,6 +368,7 @@ def test_anonymous_create(cookieclient, post_data):
     assert (
         created_map.get_anonymous_edit_url() in j["permissions"]["anonymous_edit_url"]
     )
+    assert j["user"]["is_owner"] is True
     assert created_map.name == name
     key, value = created_map.signed_cookie_elements
     assert key in cookieclient.cookies
@@ -860,3 +861,22 @@ def test_ogp_links(client, map, datalayer):
     assert f'<meta property="og:title" content="{map.name}" />' in content
     assert f'<meta property="og:description" content="{map.description}" />' in content
     assert '<meta property="og:site_name" content="uMap" />' in content
+
+
+def test_non_public_map_should_have_noindex_meta(client, map, datalayer):
+    map.share_status = Map.OPEN
+    map.save()
+    response = client.get(map.get_absolute_url())
+    assert response.status_code == 200
+    assert (
+        '<meta name="robots" content="noindex,nofollow">' in response.content.decode()
+    )
+
+
+def test_demo_instance_should_have_noindex(client, map, datalayer, settings):
+    settings.UMAP_DEMO_SITE = True
+    response = client.get(map.get_absolute_url())
+    assert response.status_code == 200
+    assert (
+        '<meta name="robots" content="noindex,nofollow">' in response.content.decode()
+    )

umap/tests/test_purge_purgatory.py

@@ -0,0 +1,25 @@
+import os
+import tempfile
+from pathlib import Path
+
+from django.core.management import call_command
+
+
+def test_purge_purgatory(settings):
+    settings.UMAP_PURGATORY_ROOT = tempfile.mkdtemp()
+    root = Path(settings.UMAP_PURGATORY_ROOT)
+    old = root / "old.json"
+    old.write_text("{}")
+    stat = old.stat()
+    os.utime(old, times=(stat.st_mtime - 31 * 86400, stat.st_mtime - 31 * 86400))
+    recent = root / "recent.json"
+    recent.write_text("{}")
+    stat = recent.stat()
+    os.utime(recent, times=(stat.st_mtime - 8 * 86400, stat.st_mtime - 8 * 86400))
+    now = root / "now.json"
+    now.write_text("{}")
+    assert {f.name for f in root.iterdir()} == {"old.json", "recent.json", "now.json"}
+    call_command("purge_purgatory")
+    assert {f.name for f in root.iterdir()} == {"recent.json", "now.json"}
+    call_command("purge_purgatory", "--days=7")
+    assert {f.name for f in root.iterdir()} == {"now.json"}

umap/tests/test_websocket_server.py

@@ -0,0 +1,22 @@
+from umap.websocket_server import OperationMessage, PeerMessage, Request, ServerRequest
+
+
+def test_messages_are_parsed_correctly():
+    server = Request.model_validate(dict(kind="Server", action="list-peers")).root
+    assert type(server) is ServerRequest
+
+    operation = Request.model_validate(
+        dict(
+            kind="OperationMessage",
+            verb="upsert",
+            subject="map",
+            metadata={},
+            key="key",
+        )
+    ).root
+    assert type(operation) is OperationMessage
+
+    peer_message = Request.model_validate(
+        dict(kind="PeerMessage", sender="Alice", recipient="Bob", message={})
+    ).root
+    assert type(peer_message) is PeerMessage

umap/urls.py

@@ -115,11 +115,15 @@ i18n_urls += decorated_patterns(
         name="map_star",
     ),
     path("me", views.user_dashboard, name="user_dashboard"),
-    path("me/profile", views.user_profile, name="user_profile"),
     path("me/download", views.user_download, name="user_download"),
     path("me/teams", views.UserTeams.as_view(), name="user_teams"),
     path("team/create/", views.TeamNew.as_view(), name="team_new"),
 )
+
+if settings.UMAP_ALLOW_EDIT_PROFILE:
+    i18n_urls.append(
+        path("me/profile", login_required(views.user_profile), name="user_profile")
+    )
 i18n_urls += decorated_patterns(
     [login_required, team_members_only],
     path("team/<int:pk>/edit/", views.TeamUpdate.as_view(), name="team_update"),

umap/views.py

@@ -863,15 +863,17 @@ class MapCreate(FormLessEditMixin, PermissionsMixin, SessionMixin, CreateView):
             form.instance.owner = self.request.user
         self.object = form.save()
         permissions = self.get_permissions()
+        user_data = self.get_user_data()
         # User does not have the cookie yet.
         if not self.object.owner:
             anonymous_url = self.object.get_anonymous_edit_url()
             permissions["anonymous_edit_url"] = anonymous_url
+            user_data["is_owner"] = True
         response = simple_json_response(
             id=self.object.pk,
             url=self.object.get_absolute_url(),
             permissions=permissions,
-            user=self.get_user_data(),
+            user=user_data,
         )
         if not self.request.user.is_authenticated:
             key, value = self.object.signed_cookie_elements
@@ -908,7 +910,7 @@ def get_websocket_auth_token(request, map_id, map_inst):
     return simple_json_response(token=signed_token)
 
 
-class MapUpdate(FormLessEditMixin, PermissionsMixin, UpdateView):
+class MapUpdate(FormLessEditMixin, PermissionsMixin, SessionMixin, UpdateView):
     model = Map
     form_class = MapSettingsForm
     pk_url_kwarg = "map_id"
@@ -920,6 +922,7 @@ class MapUpdate(FormLessEditMixin, PermissionsMixin, UpdateView):
             id=self.object.pk,
             url=self.object.get_absolute_url(),
             permissions=self.get_permissions(),
+            user=self.get_user_data(),
         )
 
 
@@ -1359,7 +1362,7 @@ def logout(request):
 
 class LoginPopupEnd(TemplateView):
     """
-    End of a loggin process in popup.
+    End of a login process in popup.
     Basically close the popup.
     """