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

umap/tests/integration/test_choropleth.py

@@ -0,0 +1,89 @@
+import json
+from pathlib import Path
+
+import pytest
+from playwright.sync_api import expect
+
+from ..base import DataLayerFactory
+
+pytestmark = pytest.mark.django_db
+
+
+def test_basic_choropleth_map_with_default_color(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
+    expect(page.locator("path[fill='#08519c']")).to_have_count(1)
+    # Occitanie
+    expect(page.locator("path[fill='#3182bd']")).to_have_count(1)
+    # Grand-Est, PACA
+    expect(page.locator("path[fill='#6baed6']")).to_have_count(2)
+    # Bourgogne-Franche-Comté, Centre-Val-de-Loire, IdF, Normandie, Corse, Nouvelle-Aquitaine
+    expect(page.locator("path[fill='#bdd7e7']")).to_have_count(6)
+    # Bretagne, Pays de la Loire, AURA
+    expect(page.locator("path[fill='#eff3ff']")).to_have_count(3)
+
+
+def test_basic_choropleth_map_with_custom_brewer(openmap, live_server, page):
+    path = Path(__file__).parent.parent / "fixtures/choropleth_region_chomage.geojson"
+    data = json.loads(path.read_text())
+
+    # Change brewer at load
+    data["_umap_options"]["choropleth"]["brewer"] = "Reds"
+    DataLayerFactory(data=data, map=openmap)
+
+    page.goto(f"{live_server.url}{openmap.get_absolute_url()}")
+    # Hauts-de-France
+    expect(page.locator("path[fill='#a50f15']")).to_have_count(1)
+    # Occitanie
+    expect(page.locator("path[fill='#de2d26']")).to_have_count(1)
+    # Grand-Est, PACA
+    expect(page.locator("path[fill='#fb6a4a']")).to_have_count(2)
+    # Bourgogne-Franche-Comté, Centre-Val-de-Loire, IdF, Normandie, Corse, Nouvelle-Aquitaine
+    expect(page.locator("path[fill='#fcae91']")).to_have_count(6)
+    # Bretagne, Pays de la Loire, AURA
+    expect(page.locator("path[fill='#fee5d9']")).to_have_count(3)
+
+    # Now change brewer from UI
+    page.get_by_role("button", name="Edit").click()
+    page.get_by_role("link", name="Manage layers").click()
+    page.locator(".panel").get_by_title("Edit", exact=True).click()
+    page.get_by_role("heading", name="Choropleth: settings").click()
+    page.locator('select[name="brewer"]').select_option("Greens")
+
+    # Hauts-de-France
+    expect(page.locator("path[fill='#006d2c']")).to_have_count(1)
+    # Occitanie
+    expect(page.locator("path[fill='#31a354']")).to_have_count(1)
+    # Grand-Est, PACA
+    expect(page.locator("path[fill='#74c476']")).to_have_count(2)
+    # Bourgogne-Franche-Comté, Centre-Val-de-Loire, IdF, Normandie, Corse, Nouvelle-Aquitaine
+    expect(page.locator("path[fill='#bae4b3']")).to_have_count(6)
+    # Bretagne, Pays de la Loire, AURA
+    expect(page.locator("path[fill='#edf8e9']")).to_have_count(3)
+
+
+def test_basic_choropleth_map_with_custom_classes(openmap, live_server, page):
+    path = Path(__file__).parent.parent / "fixtures/choropleth_region_chomage.geojson"
+    data = json.loads(path.read_text())
+
+    # Change brewer at load
+    data["_umap_options"]["choropleth"]["classes"] = 6
+    DataLayerFactory(data=data, map=openmap)
+
+    page.goto(f"{live_server.url}{openmap.get_absolute_url()}")
+
+    # Hauts-de-France
+    expect(page.locator("path[fill='#08519c']")).to_have_count(1)
+    # Occitanie
+    expect(page.locator("path[fill='#3182bd']")).to_have_count(1)
+    # PACA
+    expect(page.locator("path[fill='#6baed6']")).to_have_count(1)
+    # Grand-Est
+    expect(page.locator("path[fill='#9ecae1']")).to_have_count(1)
+    # Bourgogne-Franche-Comté, Centre-Val-de-Loire, IdF, Normandie, Corse, Nouvelle-Aquitaine
+    expect(page.locator("path[fill='#c6dbef']")).to_have_count(6)
+    # Bretagne, Pays de la Loire, AURA
+    expect(page.locator("path[fill='#eff3ff']")).to_have_count(3)

umap/tests/integration/test_collaborative_editing.py

@@ -1,9 +1,11 @@
+import json
 import re
+from pathlib import Path
 from time import sleep
 
 from playwright.sync_api import expect
 
-from umap.models import DataLayer
+from umap.models import DataLayer, Map
 
 from ..base import DataLayerFactory, MapFactory
 
@@ -265,3 +267,30 @@ def test_same_second_edit_doesnt_conflict(context, live_server, tilelayer):
         "id": str(datalayer.pk),
         "permissions": {"edit_status": 1},
     }
+
+
+def test_should_display_alert_on_conflict(context, live_server, datalayer, openmap):
+    # Open the map on two pages.
+    page_one = context.new_page()
+    page_one.goto(f"{live_server.url}{openmap.get_absolute_url()}?edit")
+    page_two = context.new_page()
+    page_two.goto(f"{live_server.url}{openmap.get_absolute_url()}?edit")
+
+    page_one.locator(".leaflet-marker-icon").click(modifiers=["Shift"])
+    page_one.locator('input[name="name"]').fill("new name")
+    with page_one.expect_response(re.compile(r".*/datalayer/update/.*")):
+        page_one.get_by_role("button", name="Save").click()
+
+    page_two.locator(".leaflet-marker-icon").click(modifiers=["Shift"])
+    page_two.locator('input[name="name"]').fill("custom name")
+    with page_two.expect_response(re.compile(r".*/datalayer/update/.*")):
+        page_two.get_by_role("button", name="Save").click()
+    saved = DataLayer.objects.last()
+    data = json.loads(Path(saved.geojson.path).read_text())
+    assert data["features"][0]["properties"]["name"] == "new name"
+    expect(page_two.get_by_text("Woops! Someone else seems to")).to_be_visible()
+    with page_two.expect_response(re.compile(r".*/datalayer/update/.*")):
+        page_two.get_by_role("button", name="Save anyway").click()
+    saved = DataLayer.objects.last()
+    data = json.loads(Path(saved.geojson.path).read_text())
+    assert data["features"][0]["properties"]["name"] == "custom name"

umap/tests/integration/test_dashboard.py

@@ -36,3 +36,13 @@ def test_dashboard_map_preview(map, live_server, datalayer, login):
     expect(dialog).to_be_visible()
     # Let's check we have a marker on it, so we can guess the map loaded correctly
     expect(dialog.locator(".leaflet-marker-icon")).to_be_visible()
+
+
+def test_no_delete_button_for_editors(map, live_server, datalayer, login, user):
+    map.name = "Map I cannot delete"
+    map.editors.add(user)
+    map.save()
+    page = login(user)
+    page.goto(f"{live_server.url}/en/me")
+    expect(page.get_by_text("Map I cannot delete")).to_be_visible()
+    expect(page.get_by_title("Delete")).to_be_hidden()

umap/tests/integration/test_datalayer.py

@@ -0,0 +1,132 @@
+import json
+
+import pytest
+from django.core.files.base import ContentFile
+from playwright.sync_api import expect
+
+from ..base import DataLayerFactory
+
+pytestmark = pytest.mark.django_db
+
+
+def set_options(datalayer, **options):
+    # For now we need to change both the DB and the FS…
+    datalayer.settings.update(options)
+    data = json.load(datalayer.geojson.file)
+    data["_umap_options"].update(**options)
+    datalayer.geojson = ContentFile(json.dumps(data), "foo.json")
+    datalayer.save()
+
+
+def test_honour_displayOnLoad_false(map, live_server, datalayer, page):
+    set_options(datalayer, displayOnLoad=False)
+    page.goto(f"{live_server.url}{map.get_absolute_url()}?onLoadPanel=datalayers")
+    expect(page.locator(".leaflet-marker-icon")).to_be_hidden()
+    layers = page.locator(".umap-browser .datalayer")
+    markers = page.locator(".leaflet-marker-icon")
+    layers_off = page.locator(".umap-browser .datalayer.off")
+    expect(layers).to_have_count(1)
+    expect(layers_off).to_have_count(1)
+    page.get_by_role("button", name="See layers").click()
+    page.get_by_label("Zoom in").click()
+    expect(markers).to_be_hidden()
+    page.get_by_title("Show/hide layer").click()
+    expect(layers_off).to_have_count(0)
+    expect(markers).to_be_visible()
+
+
+def test_should_honour_fromZoom(live_server, map, datalayer, page):
+    set_options(datalayer, displayOnLoad=True, fromZoom=6)
+    page.goto(f"{live_server.url}{map.get_absolute_url()}#5/48.55/14.68")
+    markers = page.locator(".leaflet-marker-icon")
+    expect(markers).to_be_hidden()
+    page.goto(f"{live_server.url}{map.get_absolute_url()}#6/48.55/14.68")
+    markers = page.locator(".leaflet-marker-icon")
+    expect(markers).to_be_visible()
+    page.get_by_label("Zoom out").click()
+    expect(markers).to_be_hidden()
+    page.get_by_label("Zoom in").click()
+    expect(markers).to_be_visible()
+    page.get_by_label("Zoom in").click()
+    expect(markers).to_be_visible()
+
+
+def test_should_honour_toZoom(live_server, map, datalayer, page):
+    set_options(datalayer, displayOnLoad=True, toZoom=6)
+    page.goto(f"{live_server.url}{map.get_absolute_url()}#7/48.55/14.68")
+    markers = page.locator(".leaflet-marker-icon")
+    expect(markers).to_be_hidden()
+    page.goto(f"{live_server.url}{map.get_absolute_url()}#6/48.55/14.68")
+    markers = page.locator(".leaflet-marker-icon")
+    expect(markers).to_be_visible()
+    page.get_by_label("Zoom out").click()
+    expect(markers).to_be_visible()
+    page.get_by_label("Zoom in").click()
+    expect(markers).to_be_visible()
+    page.get_by_label("Zoom in").click()
+    # FIXME does not work (but works when using PWDEBUG=1), not sure why
+    # may be a race condition related to css transition
+    # expect(markers).to_be_hidden()
+
+
+def test_should_honour_color_variable(live_server, map, page):
+    data = {
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "type": "Feature",
+                "properties": {"mycolor": "aliceblue", "name": "Point 4"},
+                "geometry": {"type": "Point", "coordinates": [0.856934, 45.290347]},
+            },
+            {
+                "type": "Feature",
+                "properties": {"name": "a polygon", "mycolor": "tomato"},
+                "geometry": {
+                    "type": "Polygon",
+                    "coordinates": [
+                        [
+                            [2.12, 49.57],
+                            [1.08, 49.02],
+                            [2.51, 47.55],
+                            [3.19, 48.77],
+                            [2.12, 49.57],
+                        ]
+                    ],
+                },
+            },
+        ],
+        "_umap_options": {
+            "name": "Calque 2",
+            "color": "{mycolor}",
+            "fillColor": "{mycolor}",
+        },
+    }
+    DataLayerFactory(map=map, data=data)
+    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    expect(page.locator(".leaflet-overlay-pane path[fill='tomato']"))
+    markers = page.locator(".leaflet-marker-icon .icon_container")
+    expect(markers).to_have_css("background-color", "rgb(240, 248, 255)")
+
+
+def test_datalayers_in_query_string(live_server, datalayer, map, page):
+    map.settings["properties"]["onLoadPanel"] = "datalayers"
+    map.save()
+    with_old_id = DataLayerFactory(old_id=134, map=map, name="with old id")
+    set_options(with_old_id, name="with old id")
+    visible = page.locator(".umap-browser .datalayer:not(.off) .datalayer-name")
+    hidden = page.locator(".umap-browser .datalayer.off .datalayer-name")
+    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    expect(visible).to_have_count(2)
+    expect(hidden).to_have_count(0)
+    page.goto(f"{live_server.url}{map.get_absolute_url()}?datalayers={datalayer.pk}")
+    expect(visible).to_have_count(1)
+    expect(visible).to_have_text(datalayer.name)
+    expect(hidden).to_have_count(1)
+    expect(hidden).to_have_text(with_old_id.name)
+    page.goto(
+        f"{live_server.url}{map.get_absolute_url()}?datalayers={with_old_id.old_id}"
+    )
+    expect(visible).to_have_count(1)
+    expect(visible).to_have_text(with_old_id.name)
+    expect(hidden).to_have_count(1)
+    expect(hidden).to_have_text(datalayer.name)

umap/tests/integration/test_draw_polygon.py

@@ -0,0 +1,363 @@
+import json
+import re
+from pathlib import Path
+
+import pytest
+from playwright.sync_api import expect
+
+from umap.models import DataLayer
+
+pytestmark = pytest.mark.django_db
+
+
+def save_and_get_json(page):
+    with page.expect_response(re.compile(r".*/datalayer/create/.*")):
+        page.get_by_role("button", name="Save").click()
+    datalayer = DataLayer.objects.last()
+    return json.loads(Path(datalayer.geojson.path).read_text())
+
+
+def test_draw_polygon(page, live_server, tilelayer):
+    page.goto(f"{live_server.url}/en/map/new/")
+
+    # Click on the Draw a polygon button on a new map.
+    create_line = page.locator(".leaflet-control-toolbar ").get_by_title(
+        "Draw a polygon"
+    )
+    create_line.click()
+
+    # Check no polygon is present by default.
+    # We target with the color, because there is also the drawing line guide (dash-array)
+    # around
+    lines = page.locator(".leaflet-overlay-pane path[stroke='DarkBlue']")
+    guide = page.locator(".leaflet-overlay-pane > svg > g > path")
+    expect(lines).to_have_count(0)
+    expect(guide).to_have_count(0)
+
+    # Click on the map, it will create a polygon.
+    map = page.locator("#map")
+    map.click(position={"x": 200, "y": 200})
+    expect(lines).to_have_count(1)
+    expect(guide).to_have_count(1)
+    map.click(position={"x": 100, "y": 200})
+    expect(lines).to_have_count(1)
+    expect(guide).to_have_count(2)
+    map.click(position={"x": 100, "y": 100})
+    expect(lines).to_have_count(1)
+    expect(guide).to_have_count(2)
+    # Click again to finish
+    map.click(position={"x": 100, "y": 100})
+    expect(lines).to_have_count(1)
+    expect(guide).to_have_count(0)
+
+
+def test_clicking_esc_should_finish_polygon(page, live_server, tilelayer):
+    page.goto(f"{live_server.url}/en/map/new/")
+
+    # Click on the Draw a polygon button on a new map.
+    create_line = page.locator(".leaflet-control-toolbar ").get_by_title(
+        "Draw a polygon"
+    )
+    create_line.click()
+
+    # Check no polygon is present by default.
+    # We target with the color, because there is also the drawing line guide (dash-array)
+    # around
+    lines = page.locator(".leaflet-overlay-pane path[stroke='DarkBlue']")
+    guide = page.locator(".leaflet-overlay-pane > svg > g > path")
+    expect(lines).to_have_count(0)
+    expect(guide).to_have_count(0)
+
+    # Click on the map, it will create a polygon.
+    map = page.locator("#map")
+    map.click(position={"x": 200, "y": 200})
+    expect(lines).to_have_count(1)
+    expect(guide).to_have_count(1)
+    map.click(position={"x": 100, "y": 200})
+    expect(lines).to_have_count(1)
+    expect(guide).to_have_count(2)
+    map.click(position={"x": 100, "y": 100})
+    expect(lines).to_have_count(1)
+    expect(guide).to_have_count(2)
+    # Click ESC to finish
+    page.keyboard.press("Escape")
+    expect(lines).to_have_count(1)
+    expect(guide).to_have_count(0)
+
+
+def test_clicking_esc_should_delete_polygon_if_empty(page, live_server, tilelayer):
+    page.goto(f"{live_server.url}/en/map/new/")
+
+    # Click on the Draw a polygon button on a new map.
+    create_line = page.locator(".leaflet-control-toolbar ").get_by_title(
+        "Draw a polygon"
+    )
+    create_line.click()
+
+    # Check no polygon is present by default.
+    # We target with the color, because there is also the drawing line guide (dash-array)
+    # around
+    lines = page.locator(".leaflet-overlay-pane path[stroke='DarkBlue']")
+    guide = page.locator(".leaflet-overlay-pane > svg > g > path")
+    expect(lines).to_have_count(0)
+    expect(guide).to_have_count(0)
+
+    # Click ESC to finish, no polygon should have been created
+    page.keyboard.press("Escape")
+    expect(lines).to_have_count(0)
+    expect(guide).to_have_count(0)
+
+
+def test_clicking_esc_should_delete_polygon_if_invalid(page, live_server, tilelayer):
+    page.goto(f"{live_server.url}/en/map/new/")
+
+    # Click on the Draw a polygon button on a new map.
+    create_line = page.locator(".leaflet-control-toolbar ").get_by_title(
+        "Draw a polygon"
+    )
+    create_line.click()
+
+    # Check no polygon is present by default.
+    # We target with the color, because there is also the drawing line guide (dash-array)
+    # around
+    lines = page.locator(".leaflet-overlay-pane path[stroke='DarkBlue']")
+    guide = page.locator(".leaflet-overlay-pane > svg > g > path")
+    expect(lines).to_have_count(0)
+    expect(guide).to_have_count(0)
+
+    # Click on the map twice, it will start a polygon.
+    map = page.locator("#map")
+    map.click(position={"x": 200, "y": 200})
+    expect(lines).to_have_count(1)
+    expect(guide).to_have_count(1)
+    map.click(position={"x": 100, "y": 200})
+    expect(lines).to_have_count(1)
+    expect(guide).to_have_count(2)
+    # Click ESC to finish, the polygon is invalid, it should not be persisted
+    page.keyboard.press("Escape")
+    expect(lines).to_have_count(0)
+    expect(guide).to_have_count(0)
+
+
+def test_can_draw_multi(live_server, page, tilelayer):
+    page.goto(f"{live_server.url}/en/map/new/")
+    polygons = page.locator(".leaflet-overlay-pane path")
+    expect(polygons).to_have_count(0)
+    multi_button = page.get_by_title("Add a polygon to the current multi")
+    expect(multi_button).to_be_hidden()
+    page.get_by_title("Draw a polygon").click()
+    map = page.locator("#map")
+    map.click(position={"x": 150, "y": 100})
+    map.click(position={"x": 150, "y": 150})
+    map.click(position={"x": 100, "y": 150})
+    map.click(position={"x": 100, "y": 100})
+    # Click again to finish
+    map.click(position={"x": 100, "y": 100})
+    expect(multi_button).to_be_visible()
+    expect(polygons).to_have_count(1)
+    multi_button.click()
+    map.click(position={"x": 250, "y": 200})
+    map.click(position={"x": 250, "y": 250})
+    map.click(position={"x": 200, "y": 250})
+    map.click(position={"x": 200, "y": 200})
+    # Click again to finish
+    map.click(position={"x": 200, "y": 200})
+    expect(polygons).to_have_count(1)
+    page.keyboard.press("Escape")
+    expect(multi_button).to_be_hidden()
+    polygons.first.click(button="right", position={"x": 10, "y": 10})
+    expect(page.get_by_role("link", name="Transform to lines")).to_be_hidden()
+    expect(page.get_by_role("link", name="Remove shape from the multi")).to_be_visible()
+
+
+def test_can_draw_hole(page, live_server, tilelayer):
+    page.goto(f"{live_server.url}/en/map/new/")
+
+    page.get_by_title("Draw a polygon").click()
+
+    polygons = page.locator(".leaflet-overlay-pane path")
+    vertices = page.locator(".leaflet-vertex-icon")
+
+    # Click on the map, it will create a polygon.
+    map = page.locator("#map")
+    map.click(position={"x": 200, "y": 100})
+    map.click(position={"x": 200, "y": 200})
+    map.click(position={"x": 100, "y": 200})
+    map.click(position={"x": 100, "y": 100})
+    # Click again to finish
+    map.click(position={"x": 100, "y": 100})
+    expect(polygons).to_have_count(1)
+    expect(vertices).to_have_count(4)
+
+    # First vertex of the hole will be created here
+    map.click(position={"x": 180, "y": 120})
+    page.get_by_role("link", name="Start a hole here").click()
+    map.click(position={"x": 180, "y": 180})
+    map.click(position={"x": 120, "y": 180})
+    map.click(position={"x": 120, "y": 120})
+    # Click again to finish
+    map.click(position={"x": 120, "y": 120})
+    expect(polygons).to_have_count(1)
+    expect(vertices).to_have_count(8)
+    # Click on the polygon but not in the hole
+    polygons.first.click(button="right", position={"x": 10, "y": 10})
+    expect(page.get_by_role("link", name="Transform to lines")).to_be_hidden()
+
+
+def test_can_transfer_shape_from_simple_polygon(live_server, page, tilelayer):
+    page.goto(f"{live_server.url}/en/map/new/")
+    polygons = page.locator(".leaflet-overlay-pane path")
+    expect(polygons).to_have_count(0)
+    page.get_by_title("Draw a polygon").click()
+    map = page.locator("#map")
+
+    # Draw a first polygon
+    map.click(position={"x": 150, "y": 100})
+    map.click(position={"x": 150, "y": 150})
+    map.click(position={"x": 100, "y": 150})
+    map.click(position={"x": 100, "y": 100})
+    # Click again to finish
+    map.click(position={"x": 100, "y": 100})
+    expect(polygons).to_have_count(1)
+
+    # Draw another polygon
+    page.get_by_title("Draw a polygon").click()
+    map.click(position={"x": 250, "y": 200})
+    map.click(position={"x": 250, "y": 250})
+    map.click(position={"x": 200, "y": 250})
+    map.click(position={"x": 200, "y": 200})
+    # Click again to finish
+    map.click(position={"x": 200, "y": 200})
+    expect(polygons).to_have_count(2)
+
+    # Now that polygon 2 is selected, right click on first one
+    # and transfer shape
+    polygons.first.click(position={"x": 20, "y": 20}, button="right")
+    page.get_by_role("link", name="Transfer shape to edited feature").click()
+    expect(polygons).to_have_count(1)
+
+
+def test_can_extract_shape(live_server, page, tilelayer):
+    page.goto(f"{live_server.url}/en/map/new/")
+    polygons = page.locator(".leaflet-overlay-pane path")
+    expect(polygons).to_have_count(0)
+    page.get_by_title("Draw a polygon").click()
+    map = page.locator("#map")
+    map.click(position={"x": 150, "y": 100})
+    map.click(position={"x": 150, "y": 150})
+    map.click(position={"x": 100, "y": 150})
+    map.click(position={"x": 100, "y": 100})
+    # Click again to finish
+    map.click(position={"x": 100, "y": 100})
+    expect(polygons).to_have_count(1)
+    extract_button = page.get_by_role("link", name="Extract shape to separate feature")
+    expect(extract_button).to_be_hidden()
+    page.get_by_title("Add a polygon to the current multi").click()
+    map.click(position={"x": 250, "y": 200})
+    map.click(position={"x": 250, "y": 250})
+    map.click(position={"x": 200, "y": 250})
+    map.click(position={"x": 200, "y": 200})
+    # Click again to finish
+    map.click(position={"x": 200, "y": 200})
+    expect(polygons).to_have_count(1)
+    polygons.first.click(position={"x": 20, "y": 20}, button="right")
+    extract_button.click()
+    expect(polygons).to_have_count(2)
+
+
+def test_cannot_transfer_shape_to_line(live_server, page, tilelayer):
+    page.goto(f"{live_server.url}/en/map/new/")
+    polygons = page.locator(".leaflet-overlay-pane path")
+    expect(polygons).to_have_count(0)
+    page.get_by_title("Draw a polygon").click()
+    map = page.locator("#map")
+    map.click(position={"x": 150, "y": 100})
+    map.click(position={"x": 150, "y": 150})
+    map.click(position={"x": 100, "y": 150})
+    map.click(position={"x": 100, "y": 100})
+    # Click again to finish
+    map.click(position={"x": 100, "y": 100})
+    expect(polygons).to_have_count(1)
+    extract_button = page.get_by_role("link", name="Extract shape to separate feature")
+    polygons.first.click(position={"x": 20, "y": 20}, button="right")
+    expect(extract_button).to_be_hidden()
+    page.get_by_title("Draw a polyline").click()
+    map.click(position={"x": 200, "y": 250})
+    map.click(position={"x": 200, "y": 200})
+    # Click again to finish
+    map.click(position={"x": 200, "y": 200})
+    expect(polygons).to_have_count(2)
+    polygons.first.click(position={"x": 20, "y": 20}, button="right")
+    expect(extract_button).to_be_hidden()
+
+
+def test_cannot_transfer_shape_to_marker(live_server, page, tilelayer):
+    page.goto(f"{live_server.url}/en/map/new/")
+    polygons = page.locator(".leaflet-overlay-pane path")
+    expect(polygons).to_have_count(0)
+    page.get_by_title("Draw a polygon").click()
+    map = page.locator("#map")
+    map.click(position={"x": 150, "y": 100})
+    map.click(position={"x": 150, "y": 150})
+    map.click(position={"x": 100, "y": 150})
+    map.click(position={"x": 100, "y": 100})
+    # Click again to finish
+    map.click(position={"x": 100, "y": 100})
+    expect(polygons).to_have_count(1)
+    extract_button = page.get_by_role("link", name="Extract shape to separate feature")
+    polygons.first.click(position={"x": 20, "y": 20}, button="right")
+    expect(extract_button).to_be_hidden()
+    page.get_by_title("Draw a marker").click()
+    map.click(position={"x": 250, "y": 200})
+    expect(polygons).to_have_count(1)
+    polygons.first.click(position={"x": 20, "y": 20}, button="right")
+    expect(extract_button).to_be_hidden()
+
+
+def test_can_clone_polygon(live_server, page, tilelayer, settings):
+    settings.UMAP_ALLOW_ANONYMOUS = True
+    page.goto(f"{live_server.url}/en/map/new/")
+    polygons = page.locator(".leaflet-overlay-pane path")
+    expect(polygons).to_have_count(0)
+    page.get_by_title("Draw a polygon").click()
+    map = page.locator("#map")
+    map.click(position={"x": 200, "y": 100})
+    map.click(position={"x": 200, "y": 200})
+    map.click(position={"x": 100, "y": 200})
+    map.click(position={"x": 100, "y": 100})
+    # Click again to finish
+    map.click(position={"x": 100, "y": 100})
+    expect(polygons).to_have_count(1)
+    polygons.first.click(button="right")
+    page.get_by_role("link", name="Clone this feature").click()
+    expect(polygons).to_have_count(2)
+    data = save_and_get_json(page)
+    assert len(data["features"]) == 2
+    assert data["features"][0]["geometry"]["type"] == "Polygon"
+    assert data["features"][0]["geometry"] == data["features"][1]["geometry"]
+
+
+def test_can_transform_polygon_to_line(live_server, page, tilelayer, settings):
+    settings.UMAP_ALLOW_ANONYMOUS = True
+    page.goto(f"{live_server.url}/en/map/new/")
+    paths = page.locator(".leaflet-overlay-pane path")
+    polygons = page.locator(".leaflet-overlay-pane path[fill='DarkBlue']")
+    expect(polygons).to_have_count(0)
+    page.get_by_title("Draw a polygon").click()
+    map = page.locator("#map")
+    map.click(position={"x": 200, "y": 100})
+    map.click(position={"x": 200, "y": 200})
+    map.click(position={"x": 100, "y": 200})
+    map.click(position={"x": 100, "y": 100})
+    # Click again to finish
+    map.click(position={"x": 100, "y": 100})
+    expect(polygons).to_have_count(1)
+    expect(paths).to_have_count(1)
+    polygons.first.click(button="right")
+    page.get_by_role("link", name="Transform to lines").click()
+    # No more polygons (will fill), but one path, it must be a line
+    expect(polygons).to_have_count(0)
+    expect(paths).to_have_count(1)
+    data = save_and_get_json(page)
+    assert len(data["features"]) == 1
+    assert data["features"][0]["geometry"]["type"] == "LineString"