umap-project 2.7.2__py3-none-any.whl → 2.8.0__py3-none-any.whl

umap/tests/integration/test_view_polyline.py

@@ -1,3 +1,5 @@
+from pathlib import Path
+
 import pytest
 from playwright.sync_api import expect
 
@@ -49,3 +51,258 @@ def test_should_open_popup_on_click(live_server, map, page, bootstrap):
     # Close popup
     page.locator("#map").click()
     expect(line).to_have_attribute("stroke-opacity", "0.5")
+
+
+def test_can_use_measure_on_name(live_server, map, page):
+    data = {
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "type": "Feature",
+                "properties": {"name": "linestring"},
+                "geometry": {
+                    "type": "LineString",
+                    "coordinates": [
+                        [11.25, 53.585984],
+                        [10.151367, 52.975108],
+                    ],
+                },
+            },
+            {
+                "type": "Feature",
+                "properties": {"name": "multilinestring"},
+                "geometry": {
+                    "type": "MultiLineString",
+                    "coordinates": [[[8, 53], [13, 52]], [[12, 51], [15, 52]]],
+                },
+            },
+        ],
+    }
+    map.settings["properties"]["labelKey"] = "{name} ({measure})"
+    map.settings["properties"]["onLoadPanel"] = "databrowser"
+    map.save()
+    DataLayerFactory(map=map, data=data)
+    page.goto(f"{live_server.url}{map.get_absolute_url()}#6/10/50")
+    expect(page.get_by_text("linestring (99.7 km)")).to_be_visible()
+    expect(page.get_by_text("multilinestring (592 km)")).to_be_visible()
+
+
+def test_can_use_gain_and_loss(live_server, map, page):
+    data = {
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "LineString",
+                    "coordinates": [
+                        [8.420888, 39.327819, 12.1],
+                        [8.420915, 39.327745, 12.9],
+                        [8.420906, 39.327543, 14.8],
+                        [8.420876, 39.327312, 17],
+                        [8.420754, 39.327023, 16.8],
+                        [8.420609, 39.326776, 16.6],
+                        [8.42051, 39.326467, 16.4],
+                        [8.420409, 39.326254, 16.3],
+                        [8.420367, 39.326108, 16.2],
+                        [8.420287, 39.326044, 16.2],
+                        [8.420294, 39.325794, 15.1],
+                        [8.419974, 39.325549, 12.5],
+                        [8.419887, 39.325508, 11.9],
+                        [8.419702, 39.325343, 10.3],
+                        [8.419574, 39.325289, 9.4],
+                        [8.41943, 39.325183, 8.2],
+                        [8.419393, 39.325127, 7.8],
+                        [8.419297, 39.325108, 7.2],
+                        [8.419179, 39.325014, 6.2],
+                        [8.419179, 39.324979, 6.1],
+                        [8.419179, 39.324979, 6.1],
+                        [8.419182, 39.324653, 6],
+                        [8.419129, 39.324508, 5.9],
+                        [8.419074, 39.324482, 5.9],
+                        [8.419007, 39.324362, 5.8],
+                        [8.418957, 39.324324, 5.8],
+                        [8.418944, 39.324291, 5.8],
+                        [8.418947, 39.324233, 5.8],
+                        [8.418967, 39.324196, 5.7],
+                        [8.41895, 39.324126, 5.6],
+                        [8.418838, 39.323996, 5.4],
+                        [8.418814, 39.323774, 5],
+                        [8.418931, 39.323546, 10.1],
+                        [8.41896, 39.323444, 12.3],
+                        [8.418971, 39.323232, 16.9],
+                        [8.419068, 39.322974, 13.5],
+                        [8.41914, 39.322946, 12.7],
+                        [8.419245, 39.322895, 12.3],
+                        [8.419342, 39.322857, 11.9],
+                        [8.419492, 39.322855, 11.3],
+                        [8.419591, 39.322768, 11.1],
+                        [8.419672, 39.322724, 11],
+                        [8.419776, 39.322704, 10.9],
+                        [8.419823, 39.322711, 10.8],
+                        [8.41971, 39.322631, 8.5],
+                        [8.419668, 39.322581, 7.3],
+                        [8.419653, 39.322537, 6.3],
+                        [8.419628, 39.32243, 5.3],
+                        [8.419629, 39.322384, 5.4],
+                        [8.419656, 39.322346, 5.5],
+                        [8.419703, 39.322304, 5.6],
+                        [8.419802, 39.322305, 5.7],
+                        [8.419868, 39.32228, 5.8],
+                        [8.419994, 39.322223, 6.1],
+                        [8.420066, 39.322174, 6.2],
+                        [8.42013, 39.32211, 6.4],
+                        [8.420142, 39.322013, 6.5],
+                        [8.420167, 39.321924, 6.7],
+                        [8.420188, 39.321788, 7],
+                        [8.420269, 39.32165, 7.3],
+                        [8.420342, 39.321625, 7.4],
+                        [8.420427, 39.321609, 7.5],
+                        [8.420645, 39.321582, 7.8],
+                        [8.420753, 39.321699, 8.1],
+                        [8.420881, 39.321801, 8.4],
+                        [8.421082, 39.321898, 8.7],
+                        [8.421184, 39.321868, 8.9],
+                        [8.421351, 39.321877, 9.1],
+                        [8.421451, 39.321834, 8.2],
+                        [8.421545, 39.321811, 7.5],
+                        [8.421815, 39.321691, 5.1],
+                        [8.421877, 39.321632, 4.3],
+                        [8.42196, 39.321602, 3.7],
+                        [8.422083, 39.321621, 4.5],
+                        [8.422462, 39.321579, 8.7],
+                        [8.422875, 39.321691, 13.5],
+                        [8.423069, 39.321732, 15.7],
+                        [8.423231, 39.321687, 17.6],
+                        [8.423405, 39.321726, 19.6],
+                        [8.423626, 39.321719, 22.1],
+                        [8.424103, 39.321776, 27.4],
+                        [8.424214, 39.321746, 28.7],
+                        [8.424402, 39.321632, 27.5],
+                        [8.424486, 39.321559, 26.8],
+                        [8.424524, 39.321501, 26.3],
+                        [8.424916, 39.321097, 22.6],
+                        [8.424969, 39.321007, 21.9],
+                        [8.425387, 39.320766, 19],
+                        [8.425489, 39.320645, 20.4],
+                        [8.425621, 39.320556, 22.1],
+                        [8.425699, 39.320574, 22.8],
+                        [8.425774, 39.320511, 23.9],
+                        [8.425831, 39.320336, 19.6],
+                        [8.425822, 39.32021, 16.1],
+                        [8.42575, 39.320086, 12.4],
+                        [8.425788, 39.320004, 10],
+                        [8.425946, 39.319822, 10.7],
+                        [8.426039, 39.319781, 11],
+                        [8.426264, 39.319776, 11.8],
+                        [8.426305, 39.319718, 12],
+                        [8.426362, 39.319433, 6.8],
+                        [8.426414, 39.31936, 5.3],
+                        [8.426422, 39.319161, 1.6],
+                        [8.426449, 39.319085, 0.2],
+                        [8.426568, 39.31904, 0.4],
+                        [8.426608, 39.318981, 1.8],
+                        [8.426714, 39.318923, 3.8],
+                        [8.427072, 39.318862, 9.6],
+                        [8.427204, 39.31886, 11.7],
+                        [8.427359, 39.318896, 14.3],
+                        [8.427434, 39.31895, 15.9],
+                        [8.427519, 39.318968, 17.3],
+                        [8.427558, 39.318972, 18.4],
+                        [8.427616, 39.318991, 19.2],
+                        [8.427685, 39.319082, 21.3],
+                        [8.42773, 39.31921, 25.1],
+                        [8.427914, 39.319306, 29.9],
+                        [8.42849, 39.319358, 46.7],
+                        [8.429645, 39.319309, 79.8],
+                        [8.430532, 39.319314, 85],
+                        [8.430582, 39.319297, 85.2],
+                        [8.430808, 39.319195, 84.8],
+                        [8.43098, 39.319076, 84.5],
+                        [8.431138, 39.318999, 84.2],
+                        [8.431283, 39.318985, 84],
+                        [8.431288, 39.318946, 84.8],
+                        [8.431373, 39.318825, 87.6],
+                        [8.431411, 39.318796, 87.9],
+                        [8.431678, 39.318827, 87.1],
+                        [8.431773, 39.318752, 88.3],
+                        [8.431854, 39.318552, 90.7],
+                        [8.431832, 39.31847, 91.7],
+                        [8.431959, 39.318284, 94.1],
+                        [8.431968, 39.318034, 97],
+                        [8.43207, 39.31791, 98.7],
+                        [8.432118, 39.317736, 100.8],
+                        [8.432263, 39.317582, 103],
+                        [8.432291, 39.317263, 106.7],
+                        [8.432279, 39.316848, 111.5],
+                        [8.432358, 39.31652, 115.3],
+                        [8.432327, 39.316486, 115.8],
+                        [8.432336, 39.316437, 116.4],
+                        [8.432287, 39.316409, 116.4],
+                        [8.432257, 39.316391, 116.2],
+                        [8.432179, 39.316251, 115.4],
+                        [8.432156, 39.316183, 115.6],
+                        [8.43223, 39.316138, 116.5],
+                        [8.43223, 39.316043, 117.7],
+                        [8.432274, 39.315918, 119.4],
+                        [8.432254, 39.315799, 121],
+                        [8.432377, 39.315713, 122.6],
+                        [8.43248, 39.315542, 125.1],
+                        [8.43257, 39.315451, 126],
+                        [8.432652, 39.315352, 127],
+                        [8.432724, 39.315291, 127.7],
+                        [8.432779, 39.315208, 128.5],
+                        [8.432863, 39.315109, 129.5],
+                        [8.432945, 39.315038, 130.3],
+                        [8.433002, 39.315014, 130.7],
+                        [8.433092, 39.315007, 131.3],
+                        [8.43318, 39.315012, 131.9],
+                        [8.433295, 39.315111, 133],
+                        [8.433346, 39.315126, 133.4],
+                        [8.43338, 39.315113, 133.6],
+                        [8.433404, 39.31509, 133.8],
+                        [8.433408, 39.315058, 132.4],
+                        [8.433422, 39.31498, 131.6],
+                        [8.43347, 39.314876, 130.3],
+                        [8.433562, 39.314771, 128.2],
+                        [8.433817, 39.314543, 123],
+                        [8.434004, 39.314434, 119.9],
+                        [8.434262, 39.314344, 121.2],
+                        [8.434729, 39.314236, 123.9],
+                        [8.435085, 39.31388, 127.2],
+                        [8.435254, 39.313808, 128.4],
+                        [8.435388, 39.313779, 128.4],
+                        [8.435547, 39.313774, 129.9],
+                        [8.4357, 39.313825, 131.6],
+                        [8.435802, 39.313882, 132.8],
+                        [8.435866, 39.313979, 134.1],
+                        [8.435902, 39.314064, 135.2],
+                        [8.435973, 39.314103, 136],
+                        [8.436062, 39.314107, 136.9],
+                        [8.436143, 39.314101, 137.7],
+                        [8.436215, 39.313989, 137.7],
+                        [8.436162, 39.313752, 137.5],
+                        [8.436209, 39.313402, 137.2],
+                        [8.436413, 39.313182, 137],
+                        [8.436559, 39.313127, 136.9],
+                        [8.43664, 39.313115, 136.8],
+                        [8.436682, 39.313058, 137.7],
+                        [8.436798, 39.312789, 139.1],
+                        [8.436706, 39.312486, 140.7],
+                        [8.436703, 39.312448, 141],
+                    ],
+                },
+                "properties": {"name": "some track"},
+                "id": "MzMTI",
+            }
+        ],
+        "_umap_options": {"popupContentTemplate": "{name}\n⭧ {gain} m\n⭨ {loss} m"},
+    }
+    DataLayerFactory(map=map, data=data)
+    page.goto(
+        f"{live_server.url}{map.get_absolute_url()}?onLoadPanel=databrowser#16/39.3201/8.4278"
+    )
+    # We can't make PW to click on the path, so let's use the browser for that
+    page.get_by_text("some track").click()
+    expect(page.get_by_text("⭧ 211 m")).to_be_visible()
+    expect(page.get_by_text("⭨ 82 m")).to_be_visible()

umap/tests/integration/test_websocket_sync.py

@@ -3,7 +3,7 @@ import re
 import pytest
 from playwright.sync_api import expect
 
-from umap.models import Map
+from umap.models import DataLayer, Map
 
 from ..base import DataLayerFactory, MapFactory
 
@@ -161,7 +161,7 @@ def test_websocket_connection_can_sync_polygons(
 
 @pytest.mark.xdist_group(name="websockets")
 def test_websocket_connection_can_sync_map_properties(
-    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
@@ -169,9 +169,9 @@ def test_websocket_connection_can_sync_map_properties(
     DataLayerFactory(map=map, data={})
 
     # Create two tabs
-    peerA = context.new_page()
+    peerA = new_page()
     peerA.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
-    peerB = context.new_page()
+    peerB = new_page()
     peerB.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
 
     # Name change is synced
@@ -193,7 +193,7 @@ def test_websocket_connection_can_sync_map_properties(
 
 @pytest.mark.xdist_group(name="websockets")
 def test_websocket_connection_can_sync_datalayer_properties(
-    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
@@ -201,9 +201,9 @@ def test_websocket_connection_can_sync_datalayer_properties(
     DataLayerFactory(map=map, data={})
 
     # Create two tabs
-    peerA = context.new_page()
+    peerA = new_page()
     peerA.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
-    peerB = context.new_page()
+    peerB = new_page()
     peerB.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
 
     # Layer addition, name and type are synced
@@ -215,7 +215,7 @@ def test_websocket_connection_can_sync_datalayer_properties(
     peerA.locator("body").press("Escape")
 
     peerB.get_by_role("link", name="Manage layers").click()
-    peerB.get_by_role("button", name="Edit").first.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")
 
@@ -267,7 +267,7 @@ def test_websocket_connection_can_sync_cloned_polygons(
     b_polygon = peerB.locator("path")
 
     # Clone on peer B and save
-    b_polygon.click(button="right")
+    b_polygon.click(button="right", delay=200)
     peerB.get_by_role("button", name="Clone this feature").click()
 
     expect(peerB.locator("path")).to_have_count(2)
@@ -343,3 +343,75 @@ def test_websocket_connection_can_sync_late_joining_peer(
 
     # Clean up: close edit mode
     peerB.locator("body").press("Escape")
+
+
+@pytest.mark.xdist_group(name="websockets")
+def test_should_sync_datalayers(new_page, live_server, websocket_server, tilelayer):
+    map = MapFactory(name="sync", edit_status=Map.ANONYMOUS)
+    map.settings["properties"]["syncEnabled"] = True
+    map.save()
+
+    assert not DataLayer.objects.count()
+
+    # Create two tabs
+    peerA = new_page("Page A")
+    peerA.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+    peerB = new_page("Page B")
+    peerB.goto(f"{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="Add a layer").click()
+
+    # Check layer has been sync to peerB
+    peerB.get_by_role("button", name="Open browser").click()
+    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.locator("#map").click()
+
+    # Check marker is visible from peerB
+    expect(peerB.locator(".leaflet-marker-icon")).to_be_visible()
+
+    # Save layer to the server
+    with peerA.expect_response(re.compile(".*/datalayer/create/.*")):
+        peerA.get_by_role("button", name="Save").click()
+
+    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="Add a layer").click()
+    peerA.get_by_role("link", 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()
+    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.locator("#map").click()
+    peerB.locator('input[name="name"]').fill("marker from peerB")
+
+    # Save from peer B
+    with peerB.expect_response(re.compile(".*/datalayer/create/.*")):
+        peerB.get_by_role("button", name="Save").click()
+
+    assert DataLayer.objects.count() == 2
+
+    # Check this new marker is visible from peerA
+    peerA.get_by_role("button", name="Open browser").click()
+    peerA.locator(".panel.left").get_by_role("button", name="Show/hide layer").nth(
+        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()
+
+    assert DataLayer.objects.count() == 2

umap/tests/test_dashboard.py

@@ -0,0 +1,82 @@
+import pytest
+from django.contrib.auth import get_user_model
+from django.urls import reverse
+
+from umap.models import Map
+
+from .base import MapFactory, UserFactory
+
+User = get_user_model()
+
+pytestmark = pytest.mark.django_db
+
+
+def test_user_dashboard_is_restricted_to_logged_in(client):
+    response = client.get(reverse("user_dashboard"))
+    assert response.status_code == 302
+    assert response["Location"] == "/en/login/?next=/en/me"
+
+
+def test_user_dashboard_display_user_maps(client, map):
+    client.login(username=map.owner.username, password="123123")
+    response = client.get(reverse("user_dashboard"))
+    assert response.status_code == 200
+    body = response.content.decode()
+    assert map.name in body
+    assert f"{map.get_absolute_url()}?edit" in body
+    assert f"{map.get_absolute_url()}?share" in body
+    assert f"/map/{map.pk}/download" in body
+    assert "Everyone (public)" in body
+    assert "Owner only" in body
+
+
+def test_user_dashboard_do_not_display_blocked_user_maps(client, map):
+    map.share_status = Map.BLOCKED
+    map.save()
+    client.login(username=map.owner.username, password="123123")
+    response = client.get(reverse("user_dashboard"))
+    assert response.status_code == 200
+    body = response.content.decode()
+    assert map.name not in body
+
+
+def test_user_dashboard_do_not_display_deleted_user_maps(client, map):
+    map.share_status = Map.DELETED
+    map.save()
+    client.login(username=map.owner.username, password="123123")
+    response = client.get(reverse("user_dashboard"))
+    assert response.status_code == 200
+    body = response.content.decode()
+    assert map.name not in body
+
+
+@pytest.mark.parametrize("share_status", [Map.DRAFT, Map.PRIVATE, Map.PUBLIC, Map.OPEN])
+def test_user_dashboard_display_user_team_maps(client, map, team, user, share_status):
+    user.teams.add(team)
+    user.save()
+    map.team = team
+    map.share_status = share_status
+    map.save()
+    assert map.owner != user
+    client.login(username=user.username, password="123123")
+    response = client.get(reverse("user_dashboard"))
+    assert response.status_code == 200
+    body = response.content.decode()
+    assert map.name in body
+    assert map.get_absolute_url() in body
+
+
+def test_user_dashboard_display_user_maps_distinct(client, map):
+    # cf https://github.com/umap-project/umap/issues/1325
+    anonymap = MapFactory(name="Map witout owner should not appear")
+    user1 = UserFactory(username="user1")
+    user2 = UserFactory(username="user2")
+    map.editors.add(user1)
+    map.editors.add(user2)
+    map.save()
+    client.login(username=map.owner.username, password="123123")
+    response = client.get(reverse("user_dashboard"))
+    assert response.status_code == 200
+    body = response.content.decode()
+    assert body.count(f'<a href="/en/map/test-map_{map.pk}">test map</a>') == 1
+    assert body.count(anonymap.name) == 0

umap/tests/test_datalayer.py

@@ -22,10 +22,11 @@ def test_datalayers_should_be_ordered_by_rank(map, datalayer):
     assert list(map.datalayer_set.all()) == [c1, c2, c3, c4, datalayer]
 
 
-def test_upload_to(map, datalayer):
+def test_upload_to(map):
     map.pk = 302
-    datalayer.pk = 17
-    assert datalayer.upload_to().startswith("datalayer/2/0/302/17_")
+    map.save()
+    datalayer = DataLayerFactory(map=map)
+    assert datalayer.geojson.name.startswith(f"datalayer/2/0/302/{datalayer.pk}_")
 
 
 def test_save_should_use_pk_as_name(map, datalayer):
@@ -65,7 +66,7 @@ def test_clone_should_clone_geojson_too(datalayer):
 def test_should_remove_old_versions_on_save(map, settings):
     datalayer = DataLayerFactory(uuid="0f1161c0-c07f-4ba4-86c5-8d8981d8a813", old_id=17)
     settings.UMAP_KEEP_VERSIONS = 3
-    root = Path(datalayer.storage_root())
+    root = Path(datalayer.geojson.storage._base_path(datalayer))
     before = len(datalayer.geojson.storage.listdir(root)[1])
     newer = f"{datalayer.pk}_1440924889.geojson"
     medium = f"{datalayer.pk}_1440923687.geojson"
@@ -273,9 +274,8 @@ def test_anonymous_can_edit_in_inherit_mode_and_map_in_public_mode(
 
 
 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())
+    root = Path(datalayer.geojson.storage._base_path(datalayer))
     before = len(datalayer.geojson.storage.listdir(root)[1])
     other = "123456_1440918637.geojson"
     files = [
@@ -292,4 +292,3 @@ def test_should_remove_all_versions_on_delete(map, settings):
     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_datalayer_s3.py

@@ -0,0 +1,135 @@
+import json
+import os
+
+import boto3
+import pytest
+from botocore.errorfactory import ClientError
+from django.core.files.base import ContentFile
+from django.core.files.storage import storages
+from moto import mock_aws
+
+from umap.models import DataLayer
+
+from .base import DataLayerFactory
+
+pytestmark = pytest.mark.django_db
+
+
+@pytest.fixture(scope="module", autouse=True)
+def patch_storage():
+    """Mocked AWS Credentials for moto."""
+    os.environ["AWS_ACCESS_KEY_ID"] = "testing"
+    os.environ["AWS_SECRET_ACCESS_KEY"] = "testing"
+    os.environ["AWS_SECURITY_TOKEN"] = "testing"
+    os.environ["AWS_SESSION_TOKEN"] = "testing"
+    os.environ["AWS_DEFAULT_REGION"] = "us-east-1"
+    before = DataLayer.geojson.field.storage
+
+    DataLayer.geojson.field.storage = storages.create_storage(
+        {
+            "BACKEND": "umap.storage.s3.S3DataStorage",
+            "OPTIONS": {
+                "access_key": "testing",
+                "secret_key": "testing",
+                "bucket_name": "umap",
+                "region_name": "us-east-1",
+            },
+        }
+    )
+    yield
+    DataLayer.geojson.field.storage = before
+
+
+@pytest.fixture(scope="module", autouse=True)
+def mocked_aws():
+    """
+    Mock all AWS interactions
+    Requires you to create your own boto3 clients
+    """
+    with mock_aws():
+        client = boto3.client("s3", region_name="us-east-1")
+        client.create_bucket(Bucket="umap")
+        client.put_bucket_versioning(
+            Bucket="umap", VersioningConfiguration={"Status": "Enabled"}
+        )
+        yield
+
+
+def test_can_create_datalayer(map, datalayer):
+    other = DataLayerFactory(map=map)
+    assert datalayer.geojson.name == f"{datalayer.pk}.geojson"
+    assert other.geojson.name == f"{other.pk}.geojson"
+
+
+def test_clone_should_return_new_instance(map, datalayer):
+    clone = datalayer.clone()
+    assert datalayer.pk != clone.pk
+    assert datalayer.name == clone.name
+    assert datalayer.map == clone.map
+    assert datalayer.geojson != clone.geojson
+    assert datalayer.geojson.name != clone.geojson.name
+    assert clone.geojson.name == f"{clone.pk}.geojson"
+
+
+def test_update_should_add_version(map, datalayer):
+    assert len(datalayer.versions) == 1
+    datalayer.geojson = ContentFile("{}", "foo.json")
+    datalayer.save()
+    assert len(datalayer.versions) == 2
+
+
+def test_get_version(map, datalayer):
+    assert len(datalayer.versions) == 1
+    datalayer.geojson = ContentFile(b'{"foo": "bar"}', "foo.json")
+    datalayer.save()
+    assert len(datalayer.versions) == 2
+    latest = datalayer.versions[0]["ref"]
+    version = datalayer.get_version(latest)
+    assert json.loads(version) == {"foo": "bar"}
+    older = datalayer.versions[1]["ref"]
+    version = datalayer.get_version(older)
+    assert json.loads(version) == {
+        "_umap_options": {
+            "browsable": True,
+            "displayOnLoad": True,
+            "name": "test datalayer",
+        },
+        "features": [
+            {
+                "geometry": {
+                    "coordinates": [
+                        14.68896484375,
+                        48.55297816440071,
+                    ],
+                    "type": "Point",
+                },
+                "properties": {
+                    "_umap_options": {
+                        "color": "DarkCyan",
+                        "iconClass": "Ball",
+                    },
+                    "description": "Da place anonymous again 755",
+                    "name": "Here",
+                },
+                "type": "Feature",
+            },
+        ],
+        "type": "FeatureCollection",
+    }
+
+    latest = datalayer.reference_version
+    version = datalayer.get_version(latest)
+    assert json.loads(version) == {"foo": "bar"}
+
+
+def test_delete_datalayer_should_delete_all_versions(datalayer):
+    # create a new version
+    datalayer.geojson = ContentFile('{"foo": "bar"}', "foo.json")
+    datalayer.save()
+    s3_key = datalayer.geojson.name
+    datalayer.delete()
+    with pytest.raises(ClientError):
+        datalayer.geojson.storage.connection.meta.client.get_object(
+            Bucket="umap",
+            Key=s3_key,
+        )