umap-project 2.8.1__py3-none-any.whl → 2.9.0__py3-none-any.whl

umap/tests/integration/test_websocket_sync.py

@@ -1,6 +1,8 @@
 import re
 
 import pytest
+import redis
+from django.conf import settings
 from playwright.sync_api import expect
 
 from umap.models import DataLayer, Map
@@ -9,11 +11,21 @@ from ..base import DataLayerFactory, MapFactory
 
 DATALAYER_UPDATE = re.compile(r".*/datalayer/update/.*")
 
+pytestmark = pytest.mark.django_db
+
+
+def setup_function():
+    # Sync client to prevent headache with pytest / pytest-asyncio and async
+    client = redis.from_url(settings.REDIS_URL)
+    # Make sure there are no dead peers in the Redis hash, otherwise asking for
+    # operations from another peer may never be answered
+    # FIXME this should not happen in an ideal world
+    assert client.connection_pool.connection_kwargs["db"] == 15
+    client.flushdb()
+
 
 @pytest.mark.xdist_group(name="websockets")
-def test_websocket_connection_can_sync_markers(
-    new_page, live_server, websocket_server, tilelayer
-):
+def test_websocket_connection_can_sync_markers(new_page, asgi_live_server, tilelayer):
     map = MapFactory(name="sync", edit_status=Map.ANONYMOUS)
     map.settings["properties"]["syncEnabled"] = True
     map.save()
@@ -21,9 +33,9 @@ def test_websocket_connection_can_sync_markers(
 
     # Create two tabs
     peerA = new_page("Page A")
-    peerA.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+    peerA.goto(f"{asgi_live_server.url}{map.get_absolute_url()}?edit")
     peerB = new_page("Page B")
-    peerB.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+    peerB.goto(f"{asgi_live_server.url}{map.get_absolute_url()}?edit")
 
     a_marker_pane = peerA.locator(".leaflet-marker-pane > div")
     b_marker_pane = peerB.locator(".leaflet-marker-pane > div")
@@ -44,9 +56,10 @@ def test_websocket_connection_can_sync_markers(
     expect(peerB.get_by_role("button", name="Cancel edits")).to_be_hidden()
     peerA.locator("body").type("Synced name")
     peerA.locator("body").press("Escape")
+    peerA.wait_for_timeout(300)
 
     peerB.locator(".leaflet-marker-icon").first.click()
-    peerB.get_by_role("link", name="Toggle edit mode (⇧+Click)").click()
+    peerB.get_by_role("button", name="Toggle edit mode (⇧+Click)").click()
     expect(peerB.locator('input[name="name"]')).to_have_value("Synced name")
 
     a_first_marker = peerA.locator("div:nth-child(4) > div:nth-child(2)").first
@@ -79,9 +92,7 @@ def test_websocket_connection_can_sync_markers(
 
 
 @pytest.mark.xdist_group(name="websockets")
-def test_websocket_connection_can_sync_polygons(
-    context, live_server, websocket_server, tilelayer
-):
+def test_websocket_connection_can_sync_polygons(context, asgi_live_server, tilelayer):
     map = MapFactory(name="sync", edit_status=Map.ANONYMOUS)
     map.settings["properties"]["syncEnabled"] = True
     map.save()
@@ -89,16 +100,14 @@ def test_websocket_connection_can_sync_polygons(
 
     # Create two tabs
     peerA = context.new_page()
-    peerA.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+    peerA.goto(f"{asgi_live_server.url}{map.get_absolute_url()}?edit")
     peerB = context.new_page()
-    peerB.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+    peerB.goto(f"{asgi_live_server.url}{map.get_absolute_url()}?edit")
 
     b_map_el = peerB.locator("#map")
 
     # Click on the Draw a polygon button on a new map.
-    create_line = peerA.locator(".leaflet-control-toolbar ").get_by_title(
-        "Draw a polygon"
-    )
+    create_line = peerA.locator(".umap-edit-bar ").get_by_title("Draw a polygon")
     create_line.click()
 
     a_polygons = peerA.locator(".leaflet-overlay-pane path[fill='DarkBlue']")
@@ -113,11 +122,11 @@ def test_websocket_connection_can_sync_polygons(
     map.click(position={"x": 100, "y": 100})
     map.click(position={"x": 100, "y": 100})
 
-    # It is created on peerA, but not yet synced
+    # It is created on peerA, and should be on peerB
     expect(a_polygons).to_have_count(1)
-    expect(b_polygons).to_have_count(0)
+    expect(b_polygons).to_have_count(1)
 
-    # Escaping the edition syncs
+    # Escaping the edition should not duplicate
     peerA.keyboard.press("Escape")
     expect(a_polygons).to_have_count(1)
     expect(b_polygons).to_have_count(1)
@@ -130,7 +139,7 @@ def test_websocket_connection_can_sync_polygons(
     assert b_polygon_bbox_t1 == a_polygon_bbox_t1
 
     b_polygon.click()
-    peerB.get_by_role("link", name="Toggle edit mode (⇧+Click)").click()
+    peerB.get_by_role("button", name="Toggle edit mode (⇧+Click)").click()
 
     edited_vertex = peerB.locator("div:nth-child(6)").first
     edited_vertex.drag_to(b_map_el, target_position={"x": 233, "y": 126})
@@ -144,7 +153,7 @@ def test_websocket_connection_can_sync_polygons(
 
     # Move the polygon on peer B and check it moved also on peer A
     b_polygon.click()
-    peerB.get_by_role("link", name="Toggle edit mode (⇧+Click)").click()
+    peerB.get_by_role("button", name="Toggle edit mode (⇧+Click)").click()
 
     b_polygon.drag_to(b_map_el, target_position={"x": 400, "y": 400})
     peerB.keyboard.press("Escape")
@@ -164,7 +173,7 @@ def test_websocket_connection_can_sync_polygons(
 
 @pytest.mark.xdist_group(name="websockets")
 def test_websocket_connection_can_sync_map_properties(
-    new_page, live_server, websocket_server, tilelayer
+    new_page, asgi_live_server, tilelayer
 ):
     map = MapFactory(name="sync", edit_status=Map.ANONYMOUS)
     map.settings["properties"]["syncEnabled"] = True
@@ -173,30 +182,32 @@ def test_websocket_connection_can_sync_map_properties(
 
     # Create two tabs
     peerA = new_page()
-    peerA.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+    peerA.goto(f"{asgi_live_server.url}{map.get_absolute_url()}?edit")
     peerB = new_page()
-    peerB.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+    peerB.goto(f"{asgi_live_server.url}{map.get_absolute_url()}?edit")
 
     # Name change is synced
-    peerA.get_by_role("link", name="Edit map name and caption").click()
+    peerA.get_by_role("button", name="Edit map name and caption").click()
     peerA.locator('input[name="name"]').click()
     peerA.locator('input[name="name"]').fill("it syncs!")
 
     expect(peerB.locator(".map-name").last).to_have_text("it syncs!")
 
     # Zoom control is synced
-    peerB.get_by_role("link", name="Map advanced properties").click()
+    peerB.get_by_role("button", name="Map advanced properties").click()
     peerB.locator("summary").filter(has_text="User interface options").click()
-    peerB.locator("div").filter(
-        has_text=re.compile(r"^Display the zoom control")
-    ).locator("label").nth(2).click()
+    switch = peerB.locator("div.formbox").filter(
+        has_text=re.compile("Display the zoom control")
+    )
+    expect(switch).to_be_visible()
+    switch.get_by_text("Never").click()
 
     expect(peerA.locator(".leaflet-control-zoom")).to_be_hidden()
 
 
 @pytest.mark.xdist_group(name="websockets")
 def test_websocket_connection_can_sync_datalayer_properties(
-    new_page, live_server, websocket_server, tilelayer
+    new_page, asgi_live_server, tilelayer
 ):
     map = MapFactory(name="sync", edit_status=Map.ANONYMOUS)
     map.settings["properties"]["syncEnabled"] = True
@@ -205,19 +216,19 @@ def test_websocket_connection_can_sync_datalayer_properties(
 
     # Create two tabs
     peerA = new_page()
-    peerA.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+    peerA.goto(f"{asgi_live_server.url}{map.get_absolute_url()}?edit")
     peerB = new_page()
-    peerB.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+    peerB.goto(f"{asgi_live_server.url}{map.get_absolute_url()}?edit")
 
     # Layer addition, name and type are synced
-    peerA.get_by_role("link", name="Manage layers").click()
+    peerA.get_by_role("button", name="Manage layers").click()
     peerA.get_by_role("button", name="Add a layer").click()
     peerA.locator('input[name="name"]').click()
     peerA.locator('input[name="name"]').fill("synced layer!")
     peerA.get_by_role("combobox").select_option("Choropleth")
     peerA.locator("body").press("Escape")
 
-    peerB.get_by_role("link", name="Manage layers").click()
+    peerB.get_by_role("button", name="Manage layers").click()
     peerB.locator(".panel.right").get_by_role("button", name="Edit").first.click()
     expect(peerB.locator('input[name="name"]')).to_have_value("synced layer!")
     expect(peerB.get_by_role("combobox")).to_have_value("Choropleth")
@@ -225,7 +236,7 @@ def test_websocket_connection_can_sync_datalayer_properties(
 
 @pytest.mark.xdist_group(name="websockets")
 def test_websocket_connection_can_sync_cloned_polygons(
-    context, live_server, websocket_server, tilelayer
+    context, asgi_live_server, tilelayer
 ):
     map = MapFactory(name="sync", edit_status=Map.ANONYMOUS)
     map.settings["properties"]["syncEnabled"] = True
@@ -234,16 +245,14 @@ def test_websocket_connection_can_sync_cloned_polygons(
 
     # Create two tabs
     peerA = context.new_page()
-    peerA.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+    peerA.goto(f"{asgi_live_server.url}{map.get_absolute_url()}?edit")
     peerB = context.new_page()
-    peerB.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+    peerB.goto(f"{asgi_live_server.url}{map.get_absolute_url()}?edit")
 
     b_map_el = peerB.locator("#map")
 
     # Click on the Draw a polygon button on a new map.
-    create_line = peerA.locator(".leaflet-control-toolbar ").get_by_title(
-        "Draw a polygon"
-    )
+    create_line = peerA.locator(".umap-edit-bar ").get_by_title("Draw a polygon")
     create_line.click()
 
     a_polygons = peerA.locator(".leaflet-overlay-pane path[fill='DarkBlue']")
@@ -278,7 +287,7 @@ def test_websocket_connection_can_sync_cloned_polygons(
     peerB.locator("path").nth(1).drag_to(b_map_el, target_position={"x": 400, "y": 400})
     peerB.locator("path").nth(1).click()
     peerB.locator("summary").filter(has_text="Shape properties").click()
-    peerB.locator(".header > a:nth-child(2)").first.click()
+    peerB.locator(".umap-field-color button.define").first.click()
     peerB.get_by_title("Orchid", exact=True).first.click()
     peerB.locator("#map").press("Escape")
     peerB.get_by_role("button", name="Save").click()
@@ -288,7 +297,7 @@ def test_websocket_connection_can_sync_cloned_polygons(
 
 @pytest.mark.xdist_group(name="websockets")
 def test_websocket_connection_can_sync_late_joining_peer(
-    new_page, live_server, websocket_server, tilelayer
+    new_page, asgi_live_server, tilelayer
 ):
     map = MapFactory(name="sync", edit_status=Map.ANONYMOUS)
     map.settings["properties"]["syncEnabled"] = True
@@ -297,7 +306,7 @@ def test_websocket_connection_can_sync_late_joining_peer(
 
     # 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")
+    peerA.goto(f"{asgi_live_server.url}{map.get_absolute_url()}?edit")
 
     # Add a marker from peer A
     a_create_marker = peerA.get_by_title("Draw a marker")
@@ -308,11 +317,10 @@ def test_websocket_connection_can_sync_late_joining_peer(
     a_map_el.click(position={"x": 220, "y": 220})
     peerA.locator("body").type("First marker")
     peerA.locator("body").press("Escape")
+    peerA.wait_for_timeout(300)
 
     # Add a polygon from peer A
-    create_polygon = peerA.locator(".leaflet-control-toolbar ").get_by_title(
-        "Draw a polygon"
-    )
+    create_polygon = peerA.locator(".umap-edit-bar ").get_by_title("Draw a polygon")
     create_polygon.click()
 
     a_map_el.click(position={"x": 200, "y": 200})
@@ -324,7 +332,7 @@ def test_websocket_connection_can_sync_late_joining_peer(
 
     # Now create peer B and have it join
     peerB = new_page("Page B")
-    peerB.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+    peerB.goto(f"{asgi_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")
@@ -335,7 +343,7 @@ def test_websocket_connection_can_sync_late_joining_peer(
 
     # Verify marker properties
     peerB.locator(".leaflet-marker-icon").first.click()
-    peerB.get_by_role("link", name="Toggle edit mode (⇧+Click)").click()
+    peerB.get_by_role("button", 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)
@@ -349,7 +357,7 @@ def test_websocket_connection_can_sync_late_joining_peer(
 
 
 @pytest.mark.xdist_group(name="websockets")
-def test_should_sync_datalayers(new_page, live_server, websocket_server, tilelayer):
+def test_should_sync_datalayers(new_page, asgi_live_server, tilelayer):
     map = MapFactory(name="sync", edit_status=Map.ANONYMOUS)
     map.settings["properties"]["syncEnabled"] = True
     map.save()
@@ -358,12 +366,12 @@ def test_should_sync_datalayers(new_page, live_server, websocket_server, tilelay
 
     # Create two tabs
     peerA = new_page("Page A")
-    peerA.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+    peerA.goto(f"{asgi_live_server.url}{map.get_absolute_url()}?edit")
     peerB = new_page("Page B")
-    peerB.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+    peerB.goto(f"{asgi_live_server.url}{map.get_absolute_url()}?edit")
 
     # Create a new layer from peerA
-    peerA.get_by_role("link", name="Manage layers").click()
+    peerA.get_by_role("button", name="Manage layers").click()
     peerA.get_by_role("button", name="Add a layer").click()
 
     # Check layer has been sync to peerB
@@ -371,7 +379,7 @@ def test_should_sync_datalayers(new_page, live_server, websocket_server, tilelay
     expect(peerB.get_by_text("Layer 1")).to_be_visible()
 
     # Draw a marker in layer 1 from peerA
-    peerA.get_by_role("link", name="Draw a marker (Ctrl+M)").click()
+    peerA.get_by_role("button", name="Draw a marker (Ctrl+M)").click()
     peerA.locator("#map").click()
 
     # Check marker is visible from peerB
@@ -384,20 +392,22 @@ def test_should_sync_datalayers(new_page, live_server, websocket_server, tilelay
     assert DataLayer.objects.count() == 1
 
     # Create another layer from peerA and draw a marker on it (without saving to server)
-    peerA.get_by_role("link", name="Manage layers").click()
+    peerA.get_by_role("button", name="Manage layers").click()
     peerA.get_by_role("button", name="Add a layer").click()
-    peerA.get_by_role("link", name="Draw a marker (Ctrl+M)").click()
+    peerA.get_by_role("button", name="Draw a marker (Ctrl+M)").click()
     peerA.locator("#map").click()
 
     # Make sure this new marker is in Layer 2 for peerB
-    expect(peerB.get_by_text("Layer 2")).to_be_visible()
+    # Show features for this layer in the brower.
+    peerB.get_by_role("heading", name="Layer 2").locator(".datalayer-name").click()
+    expect(peerB.locator("li").filter(has_text="Layer 2")).to_be_visible()
     peerB.locator(".panel.left").get_by_role("button", name="Show/hide layer").nth(
         1
     ).click()
     expect(peerB.locator(".leaflet-marker-icon")).to_be_visible()
 
     # Now draw a marker from peerB
-    peerB.get_by_role("link", name="Draw a marker (Ctrl+M)").click()
+    peerB.get_by_role("button", name="Draw a marker (Ctrl+M)").click()
     peerB.locator("#map").click()
     peerB.locator('input[name="name"]').fill("marker from peerB")
 
@@ -413,26 +423,93 @@ def test_should_sync_datalayers(new_page, live_server, websocket_server, tilelay
         1
     ).click()
 
-    # Now peerA saves the layer 2 to the server
-    with peerA.expect_response(re.compile(".*/datalayer/update/.*")):
-        peerA.get_by_role("button", name="Save").click()
+    # Peer A should not be in dirty state
+    expect(peerA.locator("body")).not_to_have_class(re.compile(".*umap-is-dirty.*"))
+
+    # Peer A should only have two markers
+    expect(peerA.locator(".leaflet-marker-icon")).to_have_count(2)
 
     assert DataLayer.objects.count() == 2
 
 
 @pytest.mark.xdist_group(name="websockets")
-def test_create_and_sync_map(
-    new_page, live_server, websocket_server, tilelayer, login, user
-):
+def test_should_sync_datalayers_delete(new_page, asgi_live_server, tilelayer):
+    map = MapFactory(name="sync", edit_status=Map.ANONYMOUS)
+    map.settings["properties"]["syncEnabled"] = True
+    map.save()
+    data1 = {
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "type": "Feature",
+                "properties": {
+                    "name": "Point 1",
+                },
+                "geometry": {"type": "Point", "coordinates": [0.065918, 48.385442]},
+            },
+        ],
+        "_umap_options": {
+            "name": "datalayer 1",
+        },
+    }
+    data2 = {
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "type": "Feature",
+                "properties": {
+                    "name": "Point 2",
+                },
+                "geometry": {"type": "Point", "coordinates": [3.55957, 49.767074]},
+            },
+        ],
+        "_umap_options": {
+            "name": "datalayer 2",
+        },
+    }
+    DataLayerFactory(map=map, data=data1)
+    DataLayerFactory(map=map, data=data2)
+
+    # Create two tabs
+    peerA = new_page("Page A")
+    peerA.goto(f"{asgi_live_server.url}{map.get_absolute_url()}?edit")
+    peerB = new_page("Page B")
+    peerB.goto(f"{asgi_live_server.url}{map.get_absolute_url()}?edit")
+
+    peerA.get_by_role("button", name="Open browser").click()
+    expect(peerA.get_by_text("datalayer 1")).to_be_visible()
+    expect(peerA.get_by_text("datalayer 2")).to_be_visible()
+    peerB.get_by_role("button", name="Open browser").click()
+    expect(peerB.get_by_text("datalayer 1")).to_be_visible()
+    expect(peerB.get_by_text("datalayer 2")).to_be_visible()
+
+    # Delete "datalayer 2" in peerA
+    peerA.locator(".datalayer").get_by_role("button", name="Delete layer").first.click()
+    peerA.get_by_role("button", name="OK").click()
+    expect(peerA.get_by_text("datalayer 2")).to_be_hidden()
+    expect(peerB.get_by_text("datalayer 2")).to_be_hidden()
+
+    # Save delete to the server
+    with peerA.expect_response(re.compile(".*/datalayer/delete/.*")):
+        peerA.get_by_role("button", name="Save").click()
+    expect(peerA.get_by_text("datalayer 2")).to_be_hidden()
+    expect(peerB.get_by_text("datalayer 2")).to_be_hidden()
+
+
+@pytest.mark.xdist_group(name="websockets")
+def test_create_and_sync_map(new_page, asgi_live_server, tilelayer, login, user):
     # Create a syncable map with peerA
     peerA = login(user, prefix="Page A")
-    peerA.goto(f"{live_server.url}/en/map/new/")
+    peerA.goto(f"{asgi_live_server.url}/en/map/new/")
+    peerA.get_by_role("button", name="Map advanced properties").click()
+    expect(peerA.get_by_text("Real-time collaboration", exact=True)).to_be_hidden()
     with peerA.expect_response(re.compile("./map/create/.*")):
         peerA.get_by_role("button", name="Save Draft").click()
-    peerA.get_by_role("link", name="Map advanced properties").click()
+    peerA.get_by_role("button", name="Map advanced properties").click()
+    expect(peerA.get_by_text("Real-time collaboration", exact=True)).to_be_visible()
     peerA.get_by_text("Real-time collaboration", exact=True).click()
     peerA.get_by_text("Enable real-time").click()
-    peerA.get_by_role("link", name="Update permissions and editors").click()
+    peerA.get_by_role("button", name="Update permissions and editors").click()
     peerA.locator('select[name="share_status"]').select_option(str(Map.PUBLIC))
     with peerA.expect_response(re.compile("./update/settings/.*")):
         peerA.get_by_role("button", name="Save").click()
@@ -458,6 +535,11 @@ def test_create_and_sync_map(
     expect(markersA).to_have_count(1)
     expect(markersB).to_have_count(1)
 
+    # Make sure only one layer has been created on peer B
+    peerB.get_by_role("button", name="Open browser").click()
+    expect(peerB.locator("h5").get_by_text("Layer 1")).to_be_visible()
+    peerB.get_by_role("button", name="Close").click()
+
     # Save and quit edit mode again
     with peerA.expect_response(re.compile("./datalayer/create/.*")):
         peerA.get_by_role("button", name="Save").click()
@@ -484,3 +566,96 @@ def test_create_and_sync_map(
     peerA.get_by_role("button", name="Edit").click()
     expect(markersA).to_have_count(2)
     expect(markersB).to_have_count(2)
+
+
+@pytest.mark.xdist_group(name="websockets")
+def test_saved_datalayer_are_not_duplicated(new_page, asgi_live_server, tilelayer):
+    map = MapFactory(name="sync", edit_status=Map.ANONYMOUS)
+    map.settings["properties"]["syncEnabled"] = True
+    map.save()
+
+    # Create one tab
+    peerA = new_page("Page A")
+    peerA.goto(f"{asgi_live_server.url}{map.get_absolute_url()}?edit")
+    # Create a new datalayer
+    peerA.get_by_title("Manage layers").click()
+    peerA.get_by_title("Add a layer").click()
+    peerA.locator("#map").click(position={"x": 220, "y": 220})
+    # Save layer to the server, so now the datalayer exist on the server AND
+    # is still in the live operations of peer A
+    with peerA.expect_response(re.compile(".*/datalayer/create/.*")):
+        peerA.get_by_role("button", name="Save").click()
+
+    # Now load the map from another tab
+    peerB = new_page("Page B")
+    peerB.goto(peerA.url)
+    peerB.get_by_role("button", name="Open browser").click()
+    expect(peerB.get_by_text("Layer 1")).to_be_visible()
+    peerB.get_by_role("button", name="Edit").click()
+    peerA.wait_for_timeout(300)  # Let the synchro roll on.
+    expect(peerB.get_by_text("Layer 1")).to_be_visible()
+
+
+@pytest.mark.xdist_group(name="websockets")
+def test_should_sync_saved_status(new_page, asgi_live_server, tilelayer):
+    map = MapFactory(name="sync", edit_status=Map.ANONYMOUS)
+    map.settings["properties"]["syncEnabled"] = True
+    map.save()
+
+    # Create two tabs
+    peerA = new_page("Page A")
+    peerA.goto(f"{asgi_live_server.url}{map.get_absolute_url()}?edit")
+    peerB = new_page("Page B")
+    peerB.goto(f"{asgi_live_server.url}{map.get_absolute_url()}?edit")
+
+    # Create a new marker from peerA
+    peerA.get_by_title("Draw a marker").click()
+    peerA.locator("#map").click(position={"x": 220, "y": 220})
+
+    # Peer A should be in dirty state
+    expect(peerA.locator("body")).to_have_class(re.compile(".*umap-is-dirty.*"))
+
+    # Peer B should not be in dirty state
+    expect(peerB.locator("body")).not_to_have_class(re.compile(".*umap-is-dirty.*"))
+
+    # Create a new marker from peerB
+    peerB.get_by_title("Draw a marker").click()
+    peerB.locator("#map").click(position={"x": 200, "y": 250})
+
+    # Peer B should be in dirty state
+    expect(peerB.locator("body")).to_have_class(re.compile(".*umap-is-dirty.*"))
+
+    # Peer A should still be in dirty state
+    expect(peerA.locator("body")).to_have_class(re.compile(".*umap-is-dirty.*"))
+
+    # Save layer to the server from peerA
+    with peerA.expect_response(re.compile(".*/datalayer/create/.*")):
+        peerA.get_by_role("button", name="Save").click()
+
+    # Peer B should not be in dirty state
+    expect(peerB.locator("body")).not_to_have_class(re.compile(".*umap-is-dirty.*"))
+
+    # Peer A should not be in dirty state
+    expect(peerA.locator("body")).not_to_have_class(re.compile(".*umap-is-dirty.*"))
+
+
+@pytest.mark.xdist_group(name="websockets")
+def test_should_sync_line_on_escape(new_page, asgi_live_server, tilelayer):
+    map = MapFactory(name="sync", edit_status=Map.ANONYMOUS)
+    map.settings["properties"]["syncEnabled"] = True
+    map.save()
+
+    # Create two tabs
+    peerA = new_page("Page A")
+    peerA.goto(f"{asgi_live_server.url}{map.get_absolute_url()}?edit")
+    peerB = new_page("Page B")
+    peerB.goto(f"{asgi_live_server.url}{map.get_absolute_url()}?edit")
+
+    # Create a new marker from peerA
+    peerA.get_by_title("Draw a polyline").click()
+    peerA.locator("#map").click(position={"x": 220, "y": 220})
+    peerA.locator("#map").click(position={"x": 200, "y": 200})
+    peerA.locator("body").press("Escape")
+
+    expect(peerA.locator("path")).to_have_count(1)
+    expect(peerB.locator("path")).to_have_count(1)

umap/tests/settings.py

@@ -29,3 +29,5 @@ PASSWORD_HASHERS = [
 WEBSOCKET_ENABLED = True
 WEBSOCKET_BACK_PORT = "8010"
 WEBSOCKET_FRONT_URI = "ws://localhost:8010"
+
+REDIS_URL = "redis://localhost:6379/15"

umap/tests/test_datalayer.py

@@ -1,4 +1,3 @@
-import tempfile
 from pathlib import Path
 
 import pytest
@@ -290,5 +289,5 @@ def test_should_remove_all_versions_on_delete(map, settings):
         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"]
+    found = set(datalayer.geojson.storage.listdir(root)[1])
+    assert found == {other, f"{other}.gz"}

umap/tests/test_datalayer_views.py

@@ -1,6 +1,8 @@
 import json
 from copy import deepcopy
+from datetime import datetime, timedelta
 from pathlib import Path
+from unittest import mock
 from uuid import uuid4
 
 import pytest
@@ -156,11 +158,14 @@ def test_should_not_be_possible_to_update_with_wrong_map_id_in_url(
 
 
 def test_delete(client, datalayer, map):
+    assert map.datalayers.count() == 1
     url = reverse("datalayer_delete", args=(map.pk, datalayer.pk))
     client.login(username=map.owner.username, password="123123")
     response = client.post(url, {}, follow=True)
     assert response.status_code == 200
-    assert not DataLayer.objects.filter(pk=datalayer.pk).count()
+    assert DataLayer.objects.filter(pk=datalayer.pk).count()
+    assert map.datalayers.count() == 0
+    assert DataLayer.objects.get(pk=datalayer.pk).share_status == DataLayer.DELETED
     # Check that map has not been impacted
     assert Map.objects.filter(pk=map.pk).exists()
     # Test response is a json
@@ -621,3 +626,17 @@ def test_optimistic_merge_conflicting_change_raises(
     modified_datalayer = DataLayer.objects.get(pk=datalayer.pk)
     merged_features = json.load(modified_datalayer.geojson)["features"]
     assert merged_features == client1_data["features"]
+
+
+def test_saving_datalayer_should_change_map_last_modified(
+    client, datalayer, map, post_data
+):
+    with mock.patch("django.utils.timezone.now") as mocked:
+        mocked.return_value = datetime.utcnow() - timedelta(days=8)
+        map.save()  # Change last_modified to past
+    old_modified_at = map.modified_at.date()
+    url = reverse("datalayer_update", args=(map.pk, datalayer.pk))
+    client.login(username=map.owner.username, password="123123")
+    response = client.post(url, post_data, follow=True)
+    assert response.status_code == 200
+    assert Map.objects.get(pk=map.pk).modified_at.date() != old_modified_at

umap/tests/test_empty_trash.py

@@ -4,15 +4,17 @@ from unittest import mock
 import pytest
 from django.core.management import call_command
 
-from umap.models import Map
+from umap.models import DataLayer, Map
 
-from .base import MapFactory
+from .base import DataLayerFactory, MapFactory
 
 pytestmark = pytest.mark.django_db
 
 
 def test_empty_trash(user):
     recent = MapFactory(owner=user)
+    recent_layer = DataLayerFactory(map=recent)
+    deleted_layer = DataLayerFactory(map=recent)
     recent_deleted = MapFactory(owner=user)
     recent_deleted.move_to_trash()
     recent_deleted.save()
@@ -20,15 +22,20 @@ def test_empty_trash(user):
         mocked.return_value = datetime.utcnow() - timedelta(days=8)
         old_deleted = MapFactory(owner=user)
         old_deleted.move_to_trash()
-        old_deleted.save()
+        deleted_layer.move_to_trash()
         old = MapFactory(owner=user)
     assert Map.objects.count() == 4
+    assert DataLayer.objects.count() == 2
     call_command("empty_trash", "--days=7", "--dry-run")
     assert Map.objects.count() == 4
+    assert DataLayer.objects.count() == 2
     call_command("empty_trash", "--days=9")
     assert Map.objects.count() == 4
+    assert DataLayer.objects.count() == 2
     call_command("empty_trash", "--days=7")
     assert not Map.objects.filter(pk=old_deleted.pk)
     assert Map.objects.filter(pk=old.pk)
     assert Map.objects.filter(pk=recent.pk)
     assert Map.objects.filter(pk=recent_deleted.pk)
+    assert not DataLayer.objects.filter(pk=deleted_layer.pk)
+    assert DataLayer.objects.filter(pk=recent_layer.pk)