umap-project 2.5.1__py3-none-any.whl → 2.6.0__py3-none-any.whl

umap/tests/integration/test_draw_polyline.py

@@ -1,22 +1,11 @@
-import json
-import re
-from pathlib import Path
-
 import pytest
 from playwright.sync_api import expect
 
-from umap.models import DataLayer
+from .helpers import save_and_get_json
 
 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_polyline(page, live_server, tilelayer):
     page.goto(f"{live_server.url}/en/map/new/")
 
@@ -187,7 +176,7 @@ def test_can_transfer_shape_from_simple_polyline(live_server, page, tilelayer):
     map.click(position={"x": 100, "y": 200})
     expect(lines).to_have_count(1)
 
-    # Draw another polygon
+    # Draw another line
     page.get_by_title("Draw a polyline").click()
     map.click(position={"x": 250, "y": 250})
     map.click(position={"x": 200, "y": 250})
@@ -196,7 +185,7 @@ def test_can_transfer_shape_from_simple_polyline(live_server, page, tilelayer):
     map.click(position={"x": 200, "y": 200})
     expect(lines).to_have_count(2)
 
-    # Now that polygon 2 is selected, right click on first one
+    # Now that line 2 is selected, right click on first one
     # and transfer shape
     lines.first.click(position={"x": 10, "y": 1}, button="right")
     page.get_by_role("link", name="Transfer shape to edited feature").click()
@@ -235,18 +224,19 @@ def test_can_transfer_shape_from_multi(live_server, page, tilelayer, settings):
     map.click(position={"x": 300, "y": 300})
     expect(lines).to_have_count(2)
 
-    # Now that polygon 2 is selected, right click on first one
+    # Now that line 2 is selected, right click on first one
     # and transfer shape
     lines.first.click(position={"x": 10, "y": 1}, button="right")
     page.get_by_role("link", name="Transfer shape to edited feature").click()
     expect(lines).to_have_count(2)
     data = save_and_get_json(page)
-    # FIXME this should be a LineString, not MultiLineString
     assert data["features"][0]["geometry"] == {
         "coordinates": [
-            [[-6.569824, 52.49616], [-7.668457, 52.49616], [-7.668457, 53.159947]]
+            [-6.569824, 52.49616],
+            [-7.668457, 52.49616],
+            [-7.668457, 53.159947],
         ],
-        "type": "MultiLineString",
+        "type": "LineString",
     }
     assert data["features"][1]["geometry"] == {
         "coordinates": [

umap/tests/integration/test_edit_datalayer.py

@@ -107,14 +107,14 @@ def test_can_change_icon_class(live_server, openmap, page):
     page.locator(".panel.right").get_by_title("Edit", exact=True).click()
     page.get_by_text("Shape properties").click()
     page.locator(".umap-field-iconClass a.define").click()
-    page.get_by_text("Circle").click()
+    page.get_by_text("Circle", exact=True).click()
     expect(page.locator(".umap-circle-icon")).to_be_visible()
     expect(page.locator(".umap-div-icon")).to_be_hidden()
 
 
 def test_can_change_name(live_server, openmap, page, datalayer):
     page.goto(
-        f"{live_server.url}{openmap.get_absolute_url()}?edit&datalayersControl=expanded"
+        f"{live_server.url}{openmap.get_absolute_url()}?edit&onLoadPanel=databrowser"
     )
     page.get_by_role("link", name="Manage layers").click()
     page.locator(".panel.right").get_by_title("Edit", exact=True).click()
@@ -133,7 +133,7 @@ def test_can_change_name(live_server, openmap, page, datalayer):
 
 def test_can_create_new_datalayer(live_server, openmap, page, datalayer):
     page.goto(
-        f"{live_server.url}{openmap.get_absolute_url()}?edit&datalayersControl=expanded"
+        f"{live_server.url}{openmap.get_absolute_url()}?edit&onLoadPanel=databrowser"
     )
     page.get_by_role("link", name="Manage layers").click()
     page.get_by_role("button", name="Add a layer").click()

umap/tests/integration/test_import.py

@@ -9,6 +9,8 @@ from playwright.sync_api import expect
 
 from umap.models import DataLayer
 
+from .helpers import save_and_get_json
+
 pytestmark = pytest.mark.django_db
 
 
@@ -142,7 +144,8 @@ def test_import_kml_from_textarea(tilelayer, live_server, page):
     expect(paths).to_have_count(2)
 
 
-def test_import_gpx_from_textarea(tilelayer, live_server, page):
+def test_import_gpx_from_textarea(tilelayer, live_server, page, settings):
+    settings.UMAP_ALLOW_ANONYMOUS = True
     page.goto(f"{live_server.url}/map/new/")
     page.get_by_title("Open browser").click()
     layers = page.locator(".umap-browser .datalayer")
@@ -163,6 +166,42 @@ def test_import_gpx_from_textarea(tilelayer, live_server, page):
     expect(layers).to_have_count(1)
     expect(markers).to_have_count(1)
     expect(paths).to_have_count(1)
+    data = save_and_get_json(page)
+    assert data["features"][0]["geometry"] == {
+        "coordinates": [
+            [
+                -121.7295456,
+                45.4431641,
+            ],
+            [
+                -121.72908,
+                45.4428615,
+            ],
+            [
+                -121.7279085,
+                45.4425697,
+            ],
+        ],
+        "type": "LineString",
+    }
+    assert data["features"][0]["properties"] == {
+        "description": "Simple description",
+        "desc": "Simple description",
+        "name": "Simple path",
+    }
+    assert data["features"][1]["geometry"] == {
+        "coordinates": [
+            -121.72904,
+            45.44283,
+            1374,
+        ],
+        "type": "Point",
+    }
+    assert data["features"][1]["properties"] == {
+        "description": "Simple description",
+        "desc": "Simple description",
+        "name": "Simple Point",
+    }
 
 
 def test_import_osm_from_textarea(tilelayer, live_server, page):
@@ -476,7 +515,7 @@ def test_create_remote_data(page, live_server, tilelayer):
     page.route("*/**/ajax-proxy/**", handle)
     page.goto(f"{live_server.url}/map/new/")
     expect(page.locator(".leaflet-marker-icon")).to_be_hidden()
-    page.get_by_role("link", name="Import data (Ctrl+I)").click()
+    page.get_by_role("link", name="Import data").click()
     page.get_by_placeholder("Provide an URL here").click()
     page.get_by_placeholder("Provide an URL here").fill("https://remote.org/data.json")
     page.locator("[name=format]").select_option("geojson")
@@ -513,7 +552,7 @@ def test_import_geojson_from_url(page, live_server, tilelayer):
     page.route("https://remote.org/data.json", handle)
     page.goto(f"{live_server.url}/map/new/")
     expect(page.locator(".leaflet-marker-icon")).to_be_hidden()
-    page.get_by_role("link", name="Import data (Ctrl+I)").click()
+    page.get_by_role("link", name="Import data").click()
     page.get_by_placeholder("Provide an URL here").click()
     page.get_by_placeholder("Provide an URL here").fill("https://remote.org/data.json")
     page.locator("[name=format]").select_option("geojson")
@@ -531,7 +570,7 @@ def test_overpass_import_with_bbox(page, live_server, tilelayer, settings):
         "overpass": {"url": "https://my.overpass.io/interpreter"}
     }
     page.goto(f"{live_server.url}/map/new/")
-    page.get_by_role("link", name="Import data (Ctrl+I)").click()
+    page.get_by_role("link", name="Import data").click()
     page.get_by_role("button", name="Overpass").click()
     page.get_by_placeholder("amenity=drinking_water").fill("building")
     page.get_by_role("button", name="Choose this data").click()
@@ -540,6 +579,66 @@ def test_overpass_import_with_bbox(page, live_server, tilelayer, settings):
     )
 
 
+def test_overpass_import_retains_boundary(page, live_server, tilelayer, settings):
+    settings.UMAP_IMPORTERS = {
+        "overpass": {
+            "url": "https://my.overpass.io/interpreter",
+            "searchUrl": "https://foobar.io/api?q={q}",
+        }
+    }
+
+    def handle(route):
+        route.fulfill(
+            json={
+                "features": [
+                    {
+                        "geometry": {
+                            "coordinates": [3.2394035, 48.4149956],
+                            "type": "Point",
+                        },
+                        "type": "Feature",
+                        "properties": {
+                            "osm_type": "R",
+                            "osm_id": 1393025,
+                            "extent": [3.2290211, 48.4268302, 3.2623032, 48.4041636],
+                            "country": "France",
+                            "osm_key": "place",
+                            "countrycode": "FR",
+                            "osm_value": "village",
+                            "postcode": "77480",
+                            "name": "Bray-sur-Seine",
+                            "county": "Seine-et-Marne",
+                            "state": "Île-de-France",
+                            "type": "city",
+                        },
+                    }
+                ],
+                "type": "FeatureCollection",
+            }
+        )
+
+    # Intercept the route
+    page.route(re.compile("https://foobar.io/api.*"), handle)
+    page.goto(f"{live_server.url}/map/new/")
+    page.get_by_role("link", name="Import data").click()
+    page.get_by_role("button", name="Overpass").click()
+    page.get_by_placeholder("amenity=drinking_water").fill("building")
+    page.get_by_placeholder("Type area name, or let empty").click()
+    page.get_by_placeholder("Type area name, or let empty").press_sequentially("bray")
+    page.get_by_text("Bray-sur-Seine, Seine-et-Marne, Île-de-France, France").click()
+    expect(page.locator("#area")).to_contain_text(
+        "Bray-sur-Seine, Seine-et-Marne, Île-de-France, France"
+    )
+    page.get_by_role("button", name="Choose this data").click()
+    expect(page.get_by_placeholder("Provide an URL here")).to_have_value(
+        "https://my.overpass.io/interpreter?data=[out:json];nwr[building](area:3601393025);out geom;"
+    )
+    page.get_by_role("button", name="Overpass").click()
+    expect(page.locator("#area")).to_contain_text(
+        "Bray-sur-Seine, Seine-et-Marne, Île-de-France, France"
+    )
+
+
 def test_import_from_datasets(page, live_server, tilelayer, settings):
     settings.UMAP_IMPORTERS = {
         "datasets": {
@@ -574,7 +673,7 @@ def test_import_from_datasets(page, live_server, tilelayer, settings):
     page.route("https://remote.org/data.json", handle)
     page.goto(f"{live_server.url}/map/new/")
     expect(page.locator(".leaflet-marker-icon")).to_be_hidden()
-    page.get_by_role("link", name="Import data (Ctrl+I)").click()
+    page.get_by_role("link", name="Import data").click()
     page.get_by_role("button", name="Datasets").click()
     page.get_by_role("dialog").get_by_role("combobox").select_option(
         "https://remote.org/data.json"
@@ -607,3 +706,23 @@ def test_import_osm_relation(tilelayer, live_server, page):
     # A layer and one path has been created
     expect(layers).to_have_count(1)
     expect(paths).to_have_count(1)
+
+
+def test_import_georss_from_textarea(tilelayer, live_server, page):
+    page.goto(f"{live_server.url}/map/new/")
+    page.get_by_title("Open browser").click()
+    layers = page.locator(".umap-browser .datalayer")
+    markers = page.locator(".leaflet-marker-icon")
+    expect(markers).to_have_count(0)
+    expect(layers).to_have_count(0)
+    button = page.get_by_title("Import data")
+    expect(button).to_be_visible()
+    button.click()
+    textarea = page.locator(".umap-upload textarea")
+    path = Path(__file__).parent.parent / "fixtures/test_upload_georss.xml"
+    textarea.fill(path.read_text())
+    page.locator('select[name="format"]').select_option("georss")
+    page.get_by_role("button", name="Import data", exact=True).click()
+    # A layer has been created
+    expect(layers).to_have_count(1)
+    expect(markers).to_have_count(1)

umap/tests/integration/test_owned_map.py

@@ -81,7 +81,7 @@ def test_owner_permissions_form(map, datalayer, live_server, login):
 
 
 def test_map_update_with_editor(map, live_server, login, user):
-    map.edit_status = Map.EDITORS
+    map.edit_status = Map.COLLABORATORS
     map.editors.add(user)
     map.save()
     page = login(user)
@@ -104,7 +104,7 @@ def test_map_update_with_editor(map, live_server, login, user):
 
 
 def test_permissions_form_with_editor(map, datalayer, live_server, login, user):
-    map.edit_status = Map.EDITORS
+    map.edit_status = Map.COLLABORATORS
     map.editors.add(user)
     map.save()
     page = login(user)
@@ -134,22 +134,14 @@ def test_owner_has_delete_map_button(map, live_server, login):
     advanced.click()
     delete = page.get_by_role("button", name="Delete", exact=True)
     expect(delete).to_be_visible()
-    dialog_shown = False
-
-    def handle_dialog(dialog):
-        dialog.accept()
-        nonlocal dialog_shown
-        dialog_shown = True
-
-    page.on("dialog", handle_dialog)
+    delete.click()
     with page.expect_navigation():
-        delete.click()
-    assert dialog_shown
+        page.get_by_role("button", name="OK").click()
     assert Map.objects.all().count() == 0
 
 
 def test_editor_do_not_have_delete_map_button(map, live_server, login, user):
-    map.edit_status = Map.EDITORS
+    map.edit_status = Map.COLLABORATORS
     map.editors.add(user)
     map.save()
     page = login(user)
@@ -249,3 +241,19 @@ def test_can_delete_datalayer(live_server, map, login, datalayer):
     expect(markers).to_have_count(0)
     # FIXME does not work, resolve to 1 element, even if this command is empty:
     expect(layers).to_have_count(0)
+
+
+def test_can_set_team(map, live_server, login, team):
+    map.owner.teams.add(team)
+    map.owner.save()
+    page = login(map.owner)
+    page.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+    edit_permissions = page.get_by_title("Update permissions and editors")
+    edit_permissions.click()
+    page.locator("select[name=team]").select_option(str(team.pk))
+    save = page.get_by_role("button", name="Save")
+    expect(save).to_be_visible()
+    with page.expect_response(re.compile(r".*/update/permissions/.*")):
+        save.click()
+    modified = Map.objects.get(pk=map.pk)
+    assert modified.team == team

umap/tests/integration/test_querystring.py

@@ -33,6 +33,13 @@ def test_datalayers_control(map, live_server, datalayer, page):
     page.goto(f"{live_server.url}{map.get_absolute_url()}?datalayersControl=expanded")
     expect(control).to_be_visible()
     expect(browser).to_be_visible()
+    # Should not override onLoadPanel
+    page.goto(
+        f"{live_server.url}{map.get_absolute_url()}?datalayersControl=expanded&onLoadPanel=caption"
+    )
+    expect(control).to_be_visible()
+    expect(browser).to_be_hidden()
+    expect(page.locator(".umap-caption")).to_be_visible()
 
 
 def test_can_deactivate_wheel_from_query_string(map, live_server, page):

umap/tests/integration/test_team.py

@@ -0,0 +1,47 @@
+import re
+
+import pytest
+
+from umap.models import Team
+
+pytestmark = pytest.mark.django_db
+
+
+def test_can_add_user_to_team(live_server, map, user, team, login):
+    map.owner.teams.add(team)
+    map.owner.save()
+    assert Team.objects.count() == 1
+    page = login(map.owner)
+    with page.expect_navigation():
+        page.get_by_role("link", name="My teams").click()
+    with page.expect_navigation():
+        page.get_by_role("link", name="Edit").click()
+    page.get_by_placeholder("Add user").click()
+    with page.expect_response(re.compile(r".*/agnocomplete/.*")):
+        page.get_by_placeholder("Add user").press_sequentially("joe")
+    page.get_by_text("Joe").click()
+    page.get_by_role("button", name="Save").click()
+    assert Team.objects.count() == 1
+    modified = Team.objects.first()
+    assert user in modified.users.all()
+
+
+def test_can_remove_user_from_team(live_server, map, user, user2, team, login):
+    map.owner.teams.add(team)
+    map.owner.save()
+    user.teams.add(team)
+    user.save()
+    user2.teams.add(team)
+    user2.save()
+    assert Team.objects.count() == 1
+    page = login(map.owner)
+    with page.expect_navigation():
+        page.get_by_role("link", name="My teams").click()
+    with page.expect_navigation():
+        page.get_by_role("link", name="Edit").click()
+    page.locator("li").filter(has_text="Averell").locator(".close").click()
+    page.get_by_role("button", name="Save").click()
+    assert Team.objects.count() == 1
+    modified = Team.objects.first()
+    assert user in modified.users.all()
+    assert user2 not in modified.users.all()

umap/tests/integration/test_tilelayer.py

@@ -16,7 +16,7 @@ def tilelayers():
     TileLayerFactory(
         rank=1,
         name="OpenStreetMap",
-        url_template="https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
+        url_template="https://tile.openstreetmap.org/{z}/{x}/{y}.png",
     )
     TileLayerFactory(
         rank=2,
@@ -76,7 +76,7 @@ def test_map_should_display_first_tilelayer_by_default(
     page.goto(f"{live_server.url}/map/new")
     tiles = page.locator(".leaflet-tile-pane img")
     expect(tiles.first).to_have_attribute(
-        "src", re.compile(r"https://[abc].tile.openstreetmap.org/\d+/\d+/\d+.png")
+        "src", re.compile(r"https://tile.openstreetmap.org/\d+/\d+/\d+.png")
     )
 
 
@@ -122,3 +122,20 @@ def test_can_have_smart_text_in_attribution(tilelayer, map, live_server, page):
     page.goto(f"{live_server.url}{map.get_absolute_url()}")
     expect(page.get_by_text("© OpenStreetMap contributors")).to_be_visible()
     expect(page.get_by_role("link", name="OpenStreetMap")).to_be_visible()
+
+
+def test_map_should_display_a_more_button(map, live_server, tilelayers, page):
+    map.settings["properties"]["tilelayersControl"] = True
+    map.save()
+    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    page.locator(".leaflet-iconLayers").hover()
+    page.get_by_role("button", name="+").click()
+    panel = page.locator(".panel.left.on")
+    expect(panel).to_be_visible()
+    expect(panel.get_by_text("Forte")).to_be_visible()
+    panel.get_by_text("Forte").click()
+    tiles = page.locator(".leaflet-tile-pane img")
+    url_pattern = re.compile(
+        r"https://[abc]{1}.forte.tiles.quaidorsay.fr/fr/\d+/\d+/\d+.png"
+    )
+    expect(tiles.first).to_have_attribute("src", url_pattern)

umap/tests/integration/test_view_marker.py

@@ -19,7 +19,7 @@ DATALAYER_DATA = {
             },
             "geometry": {
                 "type": "Point",
-                "coordinates": [14.6889, 48.5529],
+                "coordinates": [14.6889, 48.5529, 241],
             },
         },
     ],
@@ -79,3 +79,30 @@ def test_should_open_popup_panel_on_click(live_server, map, page, bootstrap):
     # Close popup
     page.locator("#map").click()
     expect(panel).to_be_hidden()
+
+
+def test_extended_properties_in_popup(live_server, map, page, bootstrap):
+    map.settings["properties"]["popupContentTemplate"] = """
+    Rank: {rank}
+    Locale: {locale}
+    Lang: {lang}
+    Lat: {lat}
+    Lon: {lon}
+    Alt: {alt}
+    Zoom: {zoom}
+    Layer: {layer}
+    """
+    map.save()
+    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    expect(page.locator(".umap-icon-active")).to_be_hidden()
+    page.locator(".leaflet-marker-icon").click()
+    expect(page.locator(".umap-icon-active")).to_be_visible()
+    expect(page.locator(".leaflet-popup-content-wrapper")).to_be_visible()
+    expect(page.get_by_text("Rank: 1")).to_be_visible()
+    expect(page.get_by_text("Locale: en")).to_be_visible()
+    expect(page.get_by_text("Lang: en")).to_be_visible()
+    expect(page.get_by_text("Lat: 48.5529")).to_be_visible()
+    expect(page.get_by_text("Lon: 14.6889")).to_be_visible()
+    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()

umap/tests/integration/test_websocket_sync.py

@@ -12,7 +12,7 @@ DATALAYER_UPDATE = re.compile(r".*/datalayer/update/.*")
 
 @pytest.mark.xdist_group(name="websockets")
 def test_websocket_connection_can_sync_markers(
-    context, live_server, websocket_server, tilelayer
+    new_page, live_server, websocket_server, tilelayer
 ):
     map = MapFactory(name="sync", edit_status=Map.ANONYMOUS)
     map.settings["properties"]["syncEnabled"] = True
@@ -20,9 +20,9 @@ def test_websocket_connection_can_sync_markers(
     DataLayerFactory(map=map, data={})
 
     # Create two tabs
-    peerA = context.new_page()
+    peerA = new_page("Page A")
     peerA.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
-    peerB = context.new_page()
+    peerB = new_page("Page B")
     peerB.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
 
     a_marker_pane = peerA.locator(".leaflet-marker-pane > div")
@@ -60,12 +60,12 @@ def test_websocket_connection_can_sync_markers(
     expect(b_marker_pane).to_have_count(2)
 
     # Drag a marker on peer B and check that it moved on peer A
-    a_first_marker.bounding_box() == b_first_marker.bounding_box()
+    assert a_first_marker.bounding_box() == b_first_marker.bounding_box()
     b_old_bbox = b_first_marker.bounding_box()
     b_first_marker.drag_to(b_map_el, target_position={"x": 250, "y": 250})
 
     assert b_old_bbox is not b_first_marker.bounding_box()
-    a_first_marker.bounding_box() == b_first_marker.bounding_box()
+    assert a_first_marker.bounding_box() == b_first_marker.bounding_box()
 
     # Delete a marker from peer A and check it's been deleted on peer B
     a_first_marker.click(button="right")

umap/tests/test_datalayer.py

@@ -101,22 +101,33 @@ def test_should_remove_old_versions_on_save(map, settings):
 
 
 def test_anonymous_cannot_edit_in_editors_mode(datalayer):
-    datalayer.edit_status = DataLayer.EDITORS
+    datalayer.edit_status = DataLayer.COLLABORATORS
     datalayer.save()
     assert not datalayer.can_edit()
 
 
 def test_owner_can_edit_in_editors_mode(datalayer, user):
-    datalayer.edit_status = DataLayer.EDITORS
+    datalayer.edit_status = DataLayer.COLLABORATORS
     datalayer.save()
     assert datalayer.can_edit(datalayer.map.owner)
 
 
-def test_editor_can_edit_in_editors_mode(datalayer, user):
+def test_editor_can_edit_in_collaborators_mode(datalayer, user):
     map = datalayer.map
     map.editors.add(user)
     map.save()
-    datalayer.edit_status = DataLayer.EDITORS
+    datalayer.edit_status = DataLayer.COLLABORATORS
+    datalayer.save()
+    assert datalayer.can_edit(user)
+
+
+def test_team_members_can_edit_in_collaborators_mode(datalayer, user, team):
+    user.teams.add(team)
+    user.save()
+    map = datalayer.map
+    map.team = team
+    map.save()
+    datalayer.edit_status = DataLayer.COLLABORATORS
     datalayer.save()
     assert datalayer.can_edit(user)
 
@@ -170,6 +181,20 @@ def test_editors_cannot_edit_in_inherit_mode_and_map_in_owner_mode(datalayer, us
     assert not datalayer.can_edit(user)
 
 
+def test_team_members_cannot_edit_in_inherit_mode_and_map_in_owner_mode(
+    datalayer, user, team
+):
+    datalayer.edit_status = DataLayer.INHERIT
+    datalayer.save()
+    user.teams.add(team)
+    team.save()
+    map = datalayer.map
+    map.team = team
+    map.edit_status = Map.OWNER
+    map.save()
+    assert not datalayer.can_edit(user)
+
+
 def test_anonymous_cannot_edit_in_inherit_mode_and_map_in_owner_mode(datalayer):
     datalayer.edit_status = DataLayer.INHERIT
     datalayer.save()
@@ -183,7 +208,7 @@ def test_owner_can_edit_in_inherit_mode_and_map_in_editors_mode(datalayer):
     datalayer.edit_status = DataLayer.INHERIT
     datalayer.save()
     map = datalayer.map
-    map.edit_status = Map.EDITORS
+    map.edit_status = Map.COLLABORATORS
     map.save()
     assert datalayer.can_edit(map.owner)
 
@@ -193,7 +218,7 @@ def test_editors_can_edit_in_inherit_mode_and_map_in_editors_mode(datalayer, use
     datalayer.save()
     map = datalayer.map
     map.editors.add(user)
-    map.edit_status = Map.EDITORS
+    map.edit_status = Map.COLLABORATORS
     map.save()
     assert datalayer.can_edit(user)
 
@@ -202,7 +227,7 @@ def test_anonymous_cannot_edit_in_inherit_mode_and_map_in_editors_mode(datalayer
     datalayer.edit_status = DataLayer.INHERIT
     datalayer.save()
     map = datalayer.map
-    map.edit_status = Map.EDITORS
+    map.edit_status = Map.COLLABORATORS
     map.save()
     assert not datalayer.can_edit()
 

umap/tests/test_datalayer_views.py

@@ -379,7 +379,7 @@ def test_owner_can_edit_in_owner_mode(datalayer, client, map, post_data):
 
 def test_editor_can_edit_in_editors_mode(datalayer, client, map, post_data):
     client.login(username=map.owner.username, password="123123")
-    datalayer.edit_status = DataLayer.EDITORS
+    datalayer.edit_status = DataLayer.COLLABORATORS
     datalayer.save()
     url = reverse("datalayer_update", args=(map.pk, datalayer.pk))
     name = "new name"

umap/tests/test_map.py

@@ -43,13 +43,31 @@ def test_editors_cannot_edit_if_status_owner(map, user):
     assert not map.can_edit(user)
 
 
-def test_editors_can_edit_if_status_editors(map, user):
-    map.edit_status = map.EDITORS
+def test_editors_can_edit_if_status_collaborators(map, user):
+    map.edit_status = map.COLLABORATORS
     map.editors.add(user)
     map.save()
     assert map.can_edit(user)
 
 
+def test_team_members_cannot_edit_if_status_owner(map, user, team):
+    user.teams.add(team)
+    user.save()
+    map.edit_status = map.OWNER
+    map.team = team
+    map.save()
+    assert not map.can_edit(user)
+
+
+def test_team_members_can_edit_if_status_collaborators(map, user, team):
+    user.teams.add(team)
+    user.save()
+    map.edit_status = map.COLLABORATORS
+    map.team = team
+    map.save()
+    assert map.can_edit(user)
+
+
 def test_logged_in_user_should_be_allowed_for_anonymous_map_with_anonymous_edit_status(
     map, user, rf
 ):  # noqa
@@ -87,6 +105,14 @@ def test_clone_should_keep_editors(map, user):
     assert user in clone.editors.all()
 
 
+def test_clone_should_keep_team(map, user, team):
+    map.team = team
+    map.save()
+    clone = map.clone()
+    assert map.pk != clone.pk
+    assert clone.team == team
+
+
 def test_clone_should_update_owner_if_passed(map, user):
     clone = map.clone(owner=user)
     assert map.pk != clone.pk
@@ -119,9 +145,9 @@ def test_publicmanager_should_get_only_public_maps(map, user, licence):
 def test_can_change_default_edit_status(user, settings):
     map = MapFactory(owner=user)
     assert map.edit_status == Map.OWNER
-    settings.UMAP_DEFAULT_EDIT_STATUS = Map.EDITORS
+    settings.UMAP_DEFAULT_EDIT_STATUS = Map.COLLABORATORS
     map = MapFactory(owner=user)
-    assert map.edit_status == Map.EDITORS
+    assert map.edit_status == Map.COLLABORATORS
 
 
 def test_can_change_default_share_status(user, settings):