The OSINT investigator's workbench. One case, one folder, every tool. Local-first: your media and your investigations never leave your machine.
JavaScript
"""Personal layers keep their markers separate from the case's places."""
import io
import json
from pathlib import Path
import pytest
from azimut import layout
from azimut.engine import bundles, layerediting, maplayers, workqueue
from azimut.workspace import Case
from test_map_layers import dressed_kmz
from mediafixture import _frame_of, _index, _points, _save_proof, _upload
@pytest.fixture
def owner(client):
return client.post("/api/cases", json={"name": "Personal layers"}).json()["id"]
def create(client, owner, title="Working map"):
response = client.post(f"/api/cases/{owner}/map-layers/editable", json={"title": title})
assert response.status_code == 200, response.text
return response.json()
def marker(client, owner, row, **changes):
response = client.post(f"/api/cases/{owner}/map-layers/{row['name']}/markers",
json={"lat": 48.85, "lon": 2.35, **changes})
assert response.status_code == 200, response.text
return response.json()["marker"]
def read(client, owner, row):
response = client.get(f"/api/cases/{owner}/map-layers/{row['name']}/edit")
assert response.status_code == 200, response.text
return response.json()
def places(owner):
return [entity for entity in Case.open(owner).list_entities() if entity["type"] == "place"]
def layer_url(owner, row):
return f"/api/cases/{owner}/map-layers/{row['name']}"
def at(entity):
"""A link request for an entity at its own point."""
return {"id": entity["id"], "lat": entity["attrs"]["lat"], "lon": entity["attrs"]["lon"]}
def test_dragging_features_reorders_a_block_and_moves_it_without_changing_case_places(client, owner):
row = create(client, owner)
url = layer_url(owner, row)
points = [marker(client, owner, row, name=name) for name in ("One", "Two", "Three", "Four")]
keys = [point["properties"]["key"] for point in points]
place = client.post(f"{url}/markers/{keys[1]}/place").json()["place"]
group = read(client, owner, row)["groups"][0]["id"]
other = client.post(f"{url}/groups", json={"name": "Other"}).json()["group"]
moved = client.post(f"{url}/features/order", json={"keys": [keys[0]], "group": group, "before": keys[3]})
assert moved.status_code == 200, moved.text
assert [feature["properties"]["key"] for feature in reversed(moved.json()["document"]["features"])] == [keys[0], keys[3], keys[2], keys[1]]
# Selection click order does not reverse the visual order of the dragged block.
moved = client.post(f"{url}/features/order", json={"keys": [keys[1], keys[0]], "group": other["id"]})
assert moved.status_code == 200, moved.text
document = moved.json()["document"]["features"]
block = [feature for feature in reversed(document) if feature["properties"]["group"] == other["id"]]
assert [feature["properties"]["key"] for feature in block] == [keys[0], keys[1]]
for feature in document:
original = points[keys.index(feature["properties"]["key"])]
assert feature["geometry"] == original["geometry"]
assert feature["properties"]["colour"] == original["properties"]["colour"]
assert next(feature for feature in document if feature["properties"]["key"] == keys[1])["properties"]["entity_id"] == place["id"]
assert Case.open(owner).get_entity(place["id"]) == place
@pytest.mark.parametrize("changes", [
{"keys": []}, {"keys": ["missing"]}, {"keys": ["first", "first"]},
{"group": "missing"}, {"before": "first"}, {"before": "missing"}, {"before": "elsewhere"},
])
def test_feature_drops_validate_the_whole_request_before_writing(client, owner, changes):
row = create(client, owner)
url = layer_url(owner, row)
first = marker(client, owner, row)
other = client.post(f"{url}/groups", json={"name": "Other"}).json()["group"]
elsewhere = marker(client, owner, row, group=other["id"])
before = read(client, owner, row)
group = before["groups"][0]["id"]
replacements = {"first": first["properties"]["key"], "elsewhere": elsewhere["properties"]["key"]}
body = {"keys": [replacements["first"]], "group": group, "before": None, **changes}
body["keys"] = [replacements.get(key, key) for key in body["keys"]]
body["before"] = replacements.get(body["before"], body["before"])
assert client.post(f"{url}/features/order", json=body).status_code == 422
assert read(client, owner, row) == before
def test_layer_details_and_feature_order_restore_on_discard(client, owner):
response = client.post(f"/api/cases/{owner}/map-layers/editable", json={"title": "Original", "description": "Initial note"})
assert response.status_code == 200
row = response.json()
url = layer_url(owner, row)
points = [marker(client, owner, row, name=name) for name in ("First", "Second")]
baseline = read(client, owner, row)
session = client.post(f"{url}/edit").json()
changed = client.patch(f"{url}/edit", json={"title": " Renamed ", "description": " Context\nSecond line "})
assert changed.status_code == 200, changed.text
assert changed.json()["layer"]["title"] == "Renamed"
assert changed.json()["layer"]["description"] == "Context\nSecond line"
assert changed.json()["layer"]["name"] == row["name"]
case = Case.open(owner)
entity = case.find_entity(attr="spec", value=layout.layer_spec_rel(row["name"]))
assert entity["label"] == "Renamed"
changed = client.post(f"{url}/features/order", json={"keys": [points[0]["properties"]["key"]],
"group": baseline["groups"][0]["id"], "before": points[1]["properties"]["key"]}).json()
assert changed["layer"]["edit_changed"] is True
restored = client.post(f"{url}/edit/finish", json={"token": session["checkpoint"],
"revision": changed["layer"]["edit_revision"], "discard": True})
assert restored.status_code == 200, restored.text
assert restored.json()["document"] == baseline["document"]
assert restored.json()["layer"]["title"] == "Original"
assert restored.json()["layer"]["description"] == "Initial note"
assert Case.open(owner).get_entity(entity["id"])["label"] == "Original"
assert client.patch(f"{url}/edit", json={"description": ""}).json()["layer"]["description"] == ""
@pytest.mark.parametrize("changes", [{"title": " "}, {"title": ""}, {"title": "x" * 201}, {"description": "x" * 4001}])
def test_layer_details_reject_invalid_values_without_changing_the_layer(client, owner, changes):
row = create(client, owner)
before = read(client, owner, row)
assert client.patch(f"{layer_url(owner, row)}/edit", json=changes).status_code == 422
assert read(client, owner, row) == before
def test_old_edit_checkpoint_keeps_its_name_when_discarded(client, owner):
row = create(client, owner)
url = layer_url(owner, row)
client.post(f"{url}/edit")
case = Case.open(owner)
spec = maplayers._read_spec(case, row["name"])
for field in ("title", "description"):
spec["edit_checkpoint"]["before"].pop(field, None)
maplayers._write_spec(case, row["name"], spec)
current = read(client, owner, row)
assert current["layer"]["edit_changed"] is False
restored = client.post(f"{url}/edit/finish", json={"token": current["checkpoint"],
"revision": current["layer"]["edit_revision"], "discard": True})
assert restored.status_code == 200, restored.text
assert restored.json()["layer"]["title"] == row["title"]
def test_feature_edits_keep_a_label_changed_from_the_case_board(client, owner):
row = create(client, owner)
case = Case.open(owner)
entity = case.find_entity(attr="spec", value=layout.layer_spec_rel(row["name"]))
case.update_entity(entity["id"], {"label": "Board label"})
marker(client, owner, row)
assert Case.open(owner).get_entity(entity["id"])["label"] == "Board label"
assert client.patch(f"{layer_url(owner, row)}/edit", json={"description": "Context"}).status_code == 200
assert Case.open(owner).get_entity(entity["id"])["label"] == "Board label"
def test_group_styles_override_without_destroying_individual_styles(client, owner):
row = create(client, owner)
point = marker(client, owner, row, colour="#d55e00", symbol="star")
url = layer_url(owner, row)
group = client.post(f"{url}/groups", json={"name": "Checked"}).json()["group"]
key = point["properties"]["key"]
response = client.patch(f"{url}/markers/{key}", json={"group": group["id"]})
assert response.status_code == 200
changed = client.patch(f"{url}/groups/{group['id']}",
json={"colour": "#009e73", "symbol": "circle"})
assert changed.status_code == 200
drawn = client.get(f"{url}/data").json()["features"][0]["properties"]
assert (drawn["category"], drawn["colour"], drawn["symbol"]) == ("Checked", "#009e73", "circle")
own = read(client, owner, row)["document"]["features"][0]["properties"]
assert (own["colour"], own["symbol"]) == ("#d55e00", "star")
client.patch(f"{url}/groups/{group['id']}", json={"mode": "individual", "name": "Reviewed"})
drawn = client.get(f"{url}/data").json()["features"][0]["properties"]
assert (drawn["category"], drawn["colour"], drawn["symbol"]) == ("Reviewed", "#d55e00", "star")
assert places(owner) == []
def test_a_group_with_one_colour_keeps_each_feature_icon(client, owner):
row = create(client, owner)
url = layer_url(owner, row)
group = client.post(f"{url}/groups", json={"name": "Side A"}).json()["group"]
star = marker(client, owner, row, colour="#d55e00", symbol="star", group=group["id"])
marker(client, owner, row, colour="#009e73", symbol="circle", group=group["id"])
changed = client.patch(f"{url}/groups/{group['id']}", json={"mode": "colour", "colour": "#cc79a7", "symbol": "flag"})
assert changed.status_code == 200, changed.text
drawn = sorted((f["properties"]["colour"], f["properties"]["symbol"]) for f in client.get(f"{url}/data").json()["features"])
assert drawn == [("#cc79a7", "circle"), ("#cc79a7", "star")]
own = {f["properties"]["symbol"]: f["properties"]["colour"] for f in read(client, owner, row)["document"]["features"]}
assert own == {"star": "#d55e00", "circle": "#009e73"}
legend = next(entry for entry in client.get(f"{url}/edit").json()["layer"]["categories"] if entry["name"] == "Side A")
assert legend["colour"] == "#cc79a7" and "symbol" not in legend
# other tools offer the styles as drawn: each icon, in the group's colour
styles = next(one for one in client.get(f"/api/cases/{owner}/layer-targets").json() if one["name"] == row["name"])["styles"]
assert {"symbol": "star", "colour": "#cc79a7"} in styles
# ungrouped, the features keep the colour they were drawn in
kept = client.delete(f"{url}/groups/{group['id']}").json()["document"]["features"]
assert {f["properties"]["key"]: f["properties"]["colour"] for f in kept}[star["properties"]["key"]] == "#cc79a7"
def test_an_edit_leaves_the_drawing_the_map_reads_next_already_made(client, owner, monkeypatch):
from azimut.engine import layerediting
row = create(client, owner)
url = layer_url(owner, row)
marker(client, owner, row)
shape = client.post(f"{url}/shapes", json={"geometry": {"type": "LineString", "coordinates": [[2, 48], [3, 49]]}})
assert shape.status_code == 200, shape.text
# the shape added answers alone, as a marker does, not with the whole layer
assert set(shape.json()) == {"layer", "marker", "key", "groups", "icons"}
assert shape.json()["marker"]["properties"]["key"] == shape.json()["key"]
drawn = []
monkeypatch.setattr(layerediting, "drawing", lambda *args, **kwargs: drawn.append(1) or pytest.fail("drawn again"))
features = client.get(f"{url}/data").json()["features"]
assert [f["geometry"]["type"] for f in features] == ["Point", "LineString"] and drawn == []
def test_removing_a_group_keeps_its_features_and_case_memberships(client, owner):
row = create(client, owner)
url = layer_url(owner, row)
group = client.post(f"{url}/groups", json={"name": "Checked"}).json()["group"]
point = marker(client, owner, row, group=group["id"])
key = point["properties"]["key"]
place = client.post(f"{url}/markers/{key}/place").json()["place"]
client.patch(f"{url}/groups/{group['id']}", json={"colour": "#009e73"})
answer = client.delete(f"{url}/groups/{group['id']}")
assert answer.status_code == 200
kept = answer.json()["document"]["features"][0]["properties"]
assert kept["key"] == key and kept["entity_id"] == place["id"]
assert kept["colour"] == "#009e73"
assert len(answer.json()["groups"]) == 1
last = answer.json()["groups"][0]["id"]
assert client.delete(f"{url}/groups/{last}").status_code == 422
def test_undoing_a_batch_after_its_group_was_removed_rehomes_the_features(client, owner):
row = create(client, owner)
url = layer_url(owner, row)
group = client.post(f"{url}/groups", json={"name": "Temporary"}).json()["group"]
points = [marker(client, owner, row, group=group["id"]) for _ in range(2)]
removed = client.post(f"{url}/selection", json={"keys": [point["properties"]["key"] for point in points], "remove": True})
assert removed.status_code == 200, removed.text
remaining = client.delete(f"{url}/groups/{group['id']}").json()["groups"][0]
restored = client.post(f"{url}/selection/{removed.json()['batch']}/restore")
assert restored.status_code == 200, restored.text
assert len(restored.json()["groups"]) == 1
assert all(feature["properties"]["group"] == remaining["id"] for feature in restored.json()["document"]["features"])
def test_reusing_case_places_in_two_layers_does_not_duplicate_or_restyle_the_place(client, owner):
case = Case.open(owner)
place = case.add_entity("place", "Existing gate", attrs={"lat": 48.85, "lon": 2.35}, by="test")
first, second = create(client, owner, "First"), create(client, owner, "Second")
for row in (first, second):
url = layer_url(owner, row)
answer = client.post(f"{url}/links", json={"items": [at(place), at(place)]})
assert answer.status_code == 200, answer.text
assert len(answer.json()["document"]["features"]) == 1
client.post(f"{url}/links", json={"items": [at(place)]})
assert len(read(client, owner, row)["document"]["features"]) == 1
own = read(client, owner, first)["document"]["features"][0]
client.patch(f"{layer_url(owner, first)}/markers/{own['properties']['key']}",
json={"name": "My gate", "colour": "#d55e00"})
assert read(client, owner, second)["document"]["features"][0]["properties"]["name"] == "Existing gate"
assert places(owner) == [place]
def test_batch_place_attachment_is_atomic_when_one_place_has_no_coordinates(client, owner):
case = Case.open(owner)
valid = case.add_entity("place", "Located", attrs={"lat": 48, "lon": 2}, by="test")
invalid = case.add_entity("place", "Unknown", by="test")
row = create(client, owner)
response = client.post(f"{layer_url(owner, row)}/links", json={"items": [at(valid), {"id": invalid["id"], "lat": 0, "lon": 0}]})
assert response.status_code == 422
assert read(client, owner, row)["document"]["features"] == []
def test_removing_and_undoing_membership_keeps_place_and_relations(client, owner):
row = create(client, owner)
point = marker(client, owner, row, name="Gate", symbol="star")
other = marker(client, owner, row, name="Other", lat=49)
url = layer_url(owner, row)
key = point["properties"]["key"]
place = client.post(f"{url}/markers/{key}/place").json()["place"]
case = Case.open(owner)
note = case.add_entity("note", "A linked note", by="test")
case.add_link(note["id"], place["id"], "related-to", by="test")
before = case.list_links()
answer = client.delete(f"{url}/markers/{key}")
assert answer.status_code == 200
assert [f["properties"]["key"] for f in answer.json()["document"]["features"]] == [other["properties"]["key"]]
assert places(owner) == [place] and case.list_links() == before
restored = client.post(f"{url}/markers/{key}/restore").json()["document"]["features"]
assert restored[0]["properties"]["key"] == key
assert restored[0]["properties"]["entity_id"] == place["id"]
assert restored[0]["properties"]["symbol"] == "star"
assert client.post(f"{url}/markers/{key}/restore").status_code == 422
def test_place_usage_and_trash_restore_keep_layer_coordinates_and_refresh_membership(client, owner):
case = Case.open(owner)
place = case.add_entity("place", "Shared gate", attrs={"lat": 48.85, "lon": 2.35}, by="test")
note = case.add_entity("note", "Related finding", by="test")
case.add_link(note["id"], place["id"], "related-to", by="test")
rows = [create(client, owner, title) for title in ("First", "Second")]
for row in rows:
client.post(f"{layer_url(owner, row)}/links", json={"items": [at(place)]})
client.get(f"{layer_url(owner, row)}/data")
before = read(client, owner, rows[0])["layer"]["sha256"]
usage = client.get(f"/api/cases/{owner}/map-layers/places/{place['id']}/usage").json()
assert {row["title"] for row in usage["layers"]} == {"First", "Second"}
assert usage["related"] == [{"id": note["id"], "label": note["label"], "type": "note"}]
removed = client.delete(f"/api/cases/{owner}/entities/{place['id']}").json()
for row in rows:
drawn = client.get(f"{layer_url(owner, row)}/data").json()["features"][0]
assert drawn["geometry"]["coordinates"] == [2.35, 48.85]
assert "entity_id" not in drawn["properties"]
assert read(client, owner, rows[0])["layer"]["sha256"] != before
client.post(f"/api/cases/{owner}/trash/{removed['trash']}/restore")
for row in rows:
assert client.get(f"{layer_url(owner, row)}/data").json()["features"][0]["properties"]["entity_id"] == place["id"]
assert case.list_links()[0]["to"] == place["id"]
@pytest.mark.parametrize("changes", [{"mode": "by-secret"}, {"colour": "red"}, {"symbol": "script"}])
def test_invalid_group_styles_do_not_write(client, owner, changes):
row = create(client, owner)
group = read(client, owner, row)["groups"][0]
before = read(client, owner, row)
assert client.patch(f"{layer_url(owner, row)}/groups/{group['id']}", json=changes).status_code == 422
assert read(client, owner, row) == before
def test_icon_palette_matches_the_frontend_and_all_round_icons_are_persisted(client, owner):
palette = json.loads((Path(__file__).parents[1] / "frontend/src/lib/map/layerSymbols.json").read_text())
assert {entry["id"] for entry in palette} == set(layerediting.SYMBOLS)
row = create(client, owner)
for symbol in layerediting.SYMBOLS:
marker(client, owner, row, symbol=symbol, colour="#009e73")
drawn = client.get(f"{layer_url(owner, row)}/data").json()["features"]
assert {f["properties"]["symbol"] for f in drawn} == set(layerediting.SYMBOLS)
def test_marker_names_do_not_repeat_after_removal(client, owner):
row = create(client, owner)
first = marker(client, owner, row)
second = marker(client, owner, row)
client.delete(f"{layer_url(owner, row)}/markers/{first['properties']['key']}")
third = marker(client, owner, row)
assert [first["properties"]["name"], second["properties"]["name"], third["properties"]["name"]] == [
"Marker 1", "Marker 2", "Marker 3",
]
def test_empty_group_visibility_survives_style_edits_and_adding_shows_the_new_point(client, owner):
row = create(client, owner)
url = layer_url(owner, row)
group = read(client, owner, row)["groups"][0]
hidden = client.patch(url, json={"hidden": [group["name"]]})
assert hidden.json()["hidden"] == [group["name"]]
styled = client.patch(f"{url}/groups/{group['id']}", json={"colour": "#009e73"})
assert styled.json()["layer"]["hidden"] == [group["name"]]
marker(client, owner, row, group=group["id"])
assert read(client, owner, row)["layer"]["hidden"] == []
def test_empty_layer_is_saved_and_drawable_without_a_place(client, owner, monkeypatch):
monkeypatch.setattr(maplayers, "fetch", lambda *a: pytest.fail("unexpected network"))
row = create(client, owner)
assert row["editable"] is True and row["features"] == 0
assert read(client, owner, row)["document"]["features"] == []
data = client.get(f"/api/cases/{owner}/map-layers/{row['name']}/data").json()
assert data["features"] == []
assert places(owner) == []
assert [e["type"] for e in Case.open(owner).list_entities()] == ["map-layer"]
def test_repeated_clicks_save_distinct_markers_and_rebuild_stale_cache(client, owner):
row = create(client, owner)
url = f"/api/cases/{owner}/map-layers/{row['name']}/data"
client.get(url) # prime an empty cache
first = marker(client, owner, row, name="North gate", colour="#d55e00", symbol="star")
second = marker(client, owner, row, lat=48.86)
data = client.get(url).json()
assert len(data["features"]) == 2
assert first["properties"]["key"] != second["properties"]["key"]
assert data["features"][0]["properties"]["symbol"] == "star"
assert data["features"][0]["properties"]["colour"] == "#d55e00"
assert places(owner) == []
@pytest.mark.parametrize("changes", [
{"lat": 91}, {"lon": 181}, {"lat": "nan"}, {"lon": "inf"},
{"colour": "red"}, {"symbol": "remote.svg"}, {"name": "x" * 301},
])
def test_invalid_marker_is_refused_before_any_write(client, owner, changes):
row = create(client, owner)
response = client.post(f"/api/cases/{owner}/map-layers/{row['name']}/markers",
json={"lat": 48.85, "lon": 2.35, **changes})
assert response.status_code == 422
assert read(client, owner, row)["document"]["features"] == []
def test_kmz_working_copy_keeps_source_icons_and_groups_offline(client, owner, monkeypatch):
data = dressed_kmz()
monkeypatch.setattr(maplayers, "fetch", lambda *a: pytest.fail("unexpected network"))
response = client.post(f"/api/cases/{owner}/map-layers/editable/upload",
files={"file": ("source.kmz", io.BytesIO(data))})
assert response.status_code == 200, response.text
row = response.json()
assert row["editable"] and row["icons"] == 1 and row["features"] == 2
assert row["origin"]["source"]["name"] == "source.kmz"
assert row["origin"]["sha256"] == maplayers.digest(data)
case = Case.open(owner)
assert case.resolve_inside(layout.layer_snapshot_rel(row["name"])).read_bytes() == data
feature = read(client, owner, row)["document"]["features"][0]
assert feature["properties"]["category"] == "Checkpoints"
icon = feature["properties"]["icon"]
assert client.get(f"/api/cases/{owner}/map-layers/{row['name']}/icons/{icon}").status_code == 200
marker(client, owner, row)
assert case.resolve_inside(layout.layer_snapshot_rel(row["name"])).read_bytes() == data
assert places(owner) == []
def test_copying_a_followed_layer_preserves_snapshot_and_never_refreshes(client, owner, monkeypatch):
monkeypatch.setattr(maplayers, "fetch", lambda *a: (dressed_kmz(), "source.kmz"))
source = client.post(f"/api/cases/{owner}/map-layers",
json={"url": "https://example.test/map.kmz"}).json()
monkeypatch.setattr(maplayers, "fetch", lambda *a: pytest.fail("unexpected refresh"))
response = client.post(f"/api/cases/{owner}/map-layers/{source['name']}/editable-copy",
json={"title": "My copy"})
assert response.status_code == 200, response.text
row = response.json()
marker(client, owner, row)
assert client.get(f"/api/cases/{owner}/map-layers/{source['name']}").json()["features"] == 2
assert row["origin"]["source"]["url"] == "https://example.test/map.kmz"
assert row["refresh"] == {} and not row["stale"]
assert client.post(f"/api/cases/{owner}/map-layers/{row['name']}/refresh").status_code == 422
assert places(owner) == []
def test_my_maps_link_is_read_once_into_a_personal_layer(client, owner, monkeypatch):
link = "https://www.google.com/maps/d/edit?mid=1AbC-d_E&usp=sharing"
asked = []
monkeypatch.setattr(maplayers, "fetch", lambda url: (asked.append(url), (dressed_kmz(), "Front.kmz"))[1])
response = client.post(f"/api/cases/{owner}/map-layers/editable/link",
json={"url": link, "title": "Front", "description": "Imported"})
assert response.status_code == 200, response.text
row = response.json()
assert asked == [link]
assert row["editable"] and row["title"] == "Front" and row["features"] == 2 and row["icons"] == 1
assert row["origin"]["source"]["kind"] == "my_maps" and row["origin"]["source"]["url"] == link
monkeypatch.setattr(maplayers, "fetch", lambda *a: pytest.fail("the link is not followed"))
assert row["refresh"] == {} and not row["stale"]
assert client.post(f"/api/cases/{owner}/map-layers/{row['name']}/refresh").status_code == 422
marker(client, owner, row)
assert len(read(client, owner, row)["document"]["features"]) == 3
assert places(owner) == []
@pytest.mark.parametrize("url", ["https://example.test/map.kml", "https://www.google.com/maps/@48.8,2.3,12z"])
def test_a_link_that_is_not_a_my_maps_is_refused_before_any_fetch(client, owner, monkeypatch, url):
monkeypatch.setattr(maplayers, "fetch", lambda *a: pytest.fail("unexpected network"))
response = client.post(f"/api/cases/{owner}/map-layers/editable/link", json={"url": url})
assert response.status_code == 422
assert "My Maps" in response.json()["detail"]
assert client.get(f"/api/cases/{owner}/map-layers").json() == []
def test_edit_routes_refuse_to_change_an_imported_source(client, owner):
source = client.post(f"/api/cases/{owner}/map-layers/upload",
files={"file": ("source.kmz", io.BytesIO(dressed_kmz()))}).json()
response = client.post(f"/api/cases/{owner}/map-layers/{source['name']}/markers",
json={"lat": 48.85, "lon": 2.35})
assert response.status_code == 422
assert "editable copy" in response.json()["detail"]
def test_selected_marker_is_edited_without_changing_its_identity_or_creating_places(client, owner):
row = create(client, owner)
first = marker(client, owner, row)
key = first["properties"]["key"]
response = client.patch(f"/api/cases/{owner}/map-layers/{row['name']}/markers/{key}",
json={"name": "Tower", "colour": "#cc79a7", "symbol": "flag"})
assert response.status_code == 200
edited = read(client, owner, row)["document"]["features"][0]
assert edited["properties"]["key"] == key
assert edited["properties"]["name"] == "Tower"
assert edited["properties"]["symbol"] == "flag"
assert places(owner) == []
def test_promoting_a_marker_is_explicit_and_idempotent(client, owner):
row = create(client, owner)
first = marker(client, owner, row, name="Tower")
url = f"/api/cases/{owner}/map-layers/{row['name']}/markers/{first['properties']['key']}/place"
assert places(owner) == []
one = client.post(url, json={}).json()
two = client.post(url, json={}).json()
assert one["place"]["id"] == two["place"]["id"]
assert len(places(owner)) == 1
assert one["place"]["label"] == "Tower"
assert one["place"]["attrs"]["layer_origin"]["feature"] == first["properties"]["key"]
assert read(client, owner, row)["document"]["features"][0]["properties"]["entity_id"] == one["place"]["id"]
def test_promotion_reuses_an_existing_case_place_without_renaming_it(client, owner):
existing = client.post(f"/api/cases/{owner}/satellite/place",
json={"lat": 48.85, "lon": 2.35, "title": "Established place"}).json()
row = create(client, owner)
first = marker(client, owner, row, name="My label")
promoted = client.post(f"/api/cases/{owner}/map-layers/{row['name']}/markers/{first['properties']['key']}/place",
json={}).json()["place"]
assert promoted["id"] == existing["id"] and promoted["label"] == "Established place"
assert len(places(owner)) == 1
@pytest.mark.parametrize("coordinates", [[181, 48], [2, 91], ["invalid", 48], [2]])
def test_promotion_refuses_invalid_imported_coordinates_without_creating_places(client, owner, coordinates):
row = create(client, owner)
first = marker(client, owner, row)
case = Case.open(owner)
spec = maplayers._read_spec(case, row["name"])
spec["document"]["features"][0]["geometry"]["coordinates"] = coordinates
maplayers._write_spec(case, row["name"], spec)
response = client.post(
f"/api/cases/{owner}/map-layers/{row['name']}/markers/{first['properties']['key']}/place",
json={},
)
assert response.status_code == 422
assert places(owner) == []
def test_layer_trash_round_trip_preserves_edits_without_deleting_promoted_places(client, owner):
row = create(client, owner)
feature = marker(client, owner, row, symbol="circle")
promoted = client.post(f"/api/cases/{owner}/map-layers/{row['name']}/markers/{feature['properties']['key']}/place",
json={}).json()["place"]
before = read(client, owner, row)["document"]
result = client.delete(f"/api/cases/{owner}/map-layers/{row['name']}").json()
assert Case.open(owner).get_entity(promoted["id"]) is not None
response = client.post(f"/api/cases/{owner}/trash/{result['trash']}/restore")
assert response.status_code == 200
assert read(client, owner, row)["document"] == before
drawn = client.get(f"/api/cases/{owner}/map-layers/{row['name']}/data").json()["features"]
assert drawn == [{**feature, "properties": {**feature["properties"], "icon_scale": 1, "stroke_width": 2}}
for feature in before["features"]]
def test_deleting_a_promoted_place_keeps_the_marker_and_proof_based_media_location(client, owner):
source = _upload(client, owner, "source.png")
frame = _frame_of(owner, source)
_save_proof(client, owner, "Located source", [frame], coords={"lat": 48.85, "lon": 2.35})
row = create(client, owner)
feature = marker(client, owner, row)
saved = client.post(
f"/api/cases/{owner}/map-layers/{row['name']}/markers/{feature['properties']['key']}/place",
json={},
).json()["place"]
assert _points(_index(client, owner), source) == [(48.85, 2.35)]
usage = client.get(f"/api/cases/{owner}/map-layers/places/{saved['id']}/usage").json()
assert any(item["type"] == "proof" for item in usage["related"])
response = client.delete(f"/api/cases/{owner}/entities/{saved['id']}")
assert response.status_code == 200
kept = read(client, owner, row)["document"]["features"][0]
assert "entity_id" not in kept["properties"]
assert kept["geometry"]["coordinates"] == [2.35, 48.85]
assert _points(_index(client, owner), source) == [(48.85, 2.35)]
restored = client.post(f"/api/cases/{owner}/trash/{response.json()['trash']}/restore")
assert restored.status_code == 200
assert read(client, owner, row)["document"]["features"][0]["properties"]["entity_id"] == saved["id"]
assert _points(_index(client, owner), source) == [(48.85, 2.35)]
def test_bundle_round_trip_rebuilds_the_working_copy_and_keeps_its_original(client, owner, monkeypatch):
monkeypatch.setattr(workqueue, "start_workers", False)
data = dressed_kmz()
row = client.post(f"/api/cases/{owner}/map-layers/editable/upload",
files={"file": ("source.kmz", io.BytesIO(data))}).json()
marker(client, owner, row, name="New marker", symbol="flag")
before = read(client, owner, row)["document"]
case = Case.open(owner)
job = bundles.queue_export(case)
workqueue.drain(case)
imported, import_job = bundles.queue_import(Path(job["payload"]["output"]))
workqueue.drain(imported)
imported = Case.open(imported.id)
assert imported.get_job(import_job["id"])["state"] == "ready"
assert read(client, imported.id, row)["document"] == before
assert imported.resolve_inside(layout.layer_snapshot_rel(row["name"])).read_bytes() == data
cache = maplayers.drawing(imported, row["name"])
drawn = {f["properties"]["key"]: f for f in json.loads(cache.read_text())["features"]}
assert len(drawn) == len(before["features"])
for feature in before["features"]:
rendered = drawn[feature["properties"]["key"]]
assert rendered["geometry"] == feature["geometry"]
assert rendered["properties"]["name"] == feature["properties"]["name"]
assert rendered["properties"]["icon_scale"] == 1
def finish_edit(client, url, *, discard=False, token=None, revision=None):
live = client.get(f"{url}/edit").json()
return client.post(f"{url}/edit/finish", json={
"token": token or live["checkpoint"], "revision": revision or live["layer"]["edit_revision"],
"discard": discard,
})
def test_group_size_and_order_control_the_drawing_without_changing_case_places(client, owner):
row = create(client, owner)
url = layer_url(owner, row)
first = marker(client, owner, row, name="First")
group = client.post(f"{url}/groups", json={"name": "Second"}).json()["group"]
second = marker(client, owner, row, name="Second", group=group["id"])
first_group = first["properties"]["group"]
response = client.patch(f"{url}/groups/{group['id']}", json={"size": 2.25})
assert response.status_code == 200
assert client.post(f"{url}/groups/order", json={"ids": [group["id"], first_group]}).status_code == 200
drawn = client.get(f"{url}/data").json()["features"]
assert [f["properties"]["key"] for f in drawn] == [first["properties"]["key"], second["properties"]["key"]]
assert drawn[-1]["properties"]["icon_scale"] == 2.25
# Size also applies to a group with individual colours and symbols.
client.patch(f"{url}/groups/{group['id']}", json={"mode": "individual"})
assert client.get(f"{url}/data").json()["features"][-1]["properties"]["icon_scale"] == 2.25
before = read(client, owner, row)
for ids in ([first_group], [first_group, first_group], [first_group, "unknown"]):
assert client.post(f"{url}/groups/order", json={"ids": ids}).status_code == 422
assert read(client, owner, row) == before
assert places(owner) == []
@pytest.mark.parametrize("size", [0, 0.49, 3.01, "invalid"])
def test_group_size_is_bounded_at_the_edge(client, owner, size):
row = create(client, owner)
group = read(client, owner, row)["groups"][0]
before = read(client, owner, row)
assert client.patch(f"{layer_url(owner, row)}/groups/{group['id']}", json={"size": size}).status_code == 422
assert read(client, owner, row) == before
def test_back_restores_groups_points_visibility_and_removals_but_keeps_explicit_case_places(client, owner):
row = create(client, owner)
url = layer_url(owner, row)
point = marker(client, owner, row, name="Original")
before = read(client, owner, row)
start = client.post(f"{url}/edit", json={}).json()
assert start["checkpoint"] and not start["layer"]["edit_changed"]
key = point["properties"]["key"]
client.delete(f"{url}/markers/{key}")
added = marker(client, owner, row, name="Separate case place")
saved = client.post(f"{url}/markers/{added['properties']['key']}/place").json()["place"]
group = client.post(f"{url}/groups", json={"name": "New group"}).json()["group"]
client.patch(f"{url}/groups/{group['id']}", json={"size": 3})
client.patch(url, json={"hidden": ["Features"]})
assert read(client, owner, row)["layer"]["edit_changed"]
restored = finish_edit(client, url, discard=True)
assert restored.status_code == 200, restored.text
assert restored.json()["document"] == before["document"]
assert restored.json()["groups"] == before["groups"]
assert restored.json()["layer"]["hidden"] == before["layer"]["hidden"]
assert restored.json()["checkpoint"] is None
assert not restored.json()["layer"]["edit_changed"]
assert Case.open(owner).get_entity(saved["id"])
assert client.post(f"{url}/markers/{key}/restore").status_code == 422
def test_done_commits_the_current_work_and_starts_a_fresh_checkpoint_next_time(client, owner):
row = create(client, owner)
url = layer_url(owner, row)
original = client.post(f"{url}/edit", json={}).json()["checkpoint"]
point = marker(client, owner, row)
response = finish_edit(client, url)
assert response.status_code == 200
assert response.json()["document"]["features"][0]["properties"]["key"] == point["properties"]["key"]
assert response.json()["checkpoint"] is None
new = client.post(f"{url}/edit", json={}).json()
assert new["checkpoint"] != original
assert not new["layer"]["edit_changed"]
def test_stale_discard_refuses_to_overwrite_newer_work(client, owner):
row = create(client, owner)
url = layer_url(owner, row)
start = client.post(f"{url}/edit", json={}).json()
marker(client, owner, row)
before = read(client, owner, row)
response = finish_edit(client, url, discard=True, revision=start["layer"]["edit_revision"])
assert response.status_code == 422
assert read(client, owner, row) == before
assert finish_edit(client, url, discard=True, token="a" * 32).status_code == 422
LINE = {"type": "LineString", "coordinates": [[2, 48], [2.1, 48.1]]}
AREA = {"type": "Polygon", "coordinates": [[[2, 48], [2.1, 48], [2.1, 48.1], [2, 48]]]}
@pytest.mark.parametrize("geometry", [LINE, AREA])
def test_drawn_shapes_can_be_edited_removed_and_discarded(client, owner, geometry):
row = create(client, owner)
url = layer_url(owner, row)
response = client.post(f"{url}/shapes", json={"geometry": geometry, "name": "Working shape"})
assert response.status_code == 200, response.text
feature = response.json()["marker"]
key = feature["properties"]["key"]
assert feature["geometry"] == geometry
client.post(f"{url}/edit", json={})
changed = json.loads(json.dumps(geometry))
if geometry["type"] == "LineString":
changed["coordinates"][1][0] = 2.2
else:
changed["coordinates"][0][1][0] = 2.2
edited = client.patch(f"{url}/markers/{key}", json={"geometry": changed})
assert edited.status_code == 200
assert edited.json()["marker"]["geometry"] == changed
assert client.post(f"{url}/markers/{key}/place").status_code == 422
client.delete(f"{url}/markers/{key}")
assert read(client, owner, row)["document"]["features"] == []
assert client.post(f"{url}/markers/{key}/restore").status_code == 200
assert finish_edit(client, url, discard=True).json()["document"]["features"][0]["geometry"] == geometry
assert places(owner) == []
def test_a_marker_on_a_case_place_follows_it_until_unlinked(client, owner):
"""Its point is the place's: moving the place moves it, and moving it alone
is refused until it stops following. The place never moves with it."""
row = create(client, owner)
url = layer_url(owner, row)
point = marker(client, owner, row)
key = point["properties"]["key"]
place = client.post(f"{url}/markers/{key}/place").json()["place"]
moved = {"type": "Point", "coordinates": [3, 49]}
response = client.patch(f"{url}/markers/{key}", json={"geometry": moved})
assert response.status_code == 422
assert "unlink" in response.json()["detail"]
case = Case.open(owner)
case.update_entity(place["id"], {"attrs": {**place["attrs"], "lat": 48.9, "lon": 2.4}})
assert client.get(f"{url}/data").json()["features"][0]["geometry"]["coordinates"] == [2.4, 48.9]
unlinked = client.patch(f"{url}/markers/{key}", json={"unlink": True})
assert unlinked.status_code == 200, unlinked.text
assert "entity_id" not in unlinked.json()["marker"]["properties"]
assert unlinked.json()["marker"]["geometry"]["coordinates"] == [2.4, 48.9]
response = client.patch(f"{url}/markers/{key}", json={"geometry": moved})
assert response.status_code == 200
assert response.json()["marker"]["geometry"] == moved
assert Case.open(owner).get_entity(place["id"])["attrs"]["lat"] == 48.9
@pytest.mark.parametrize("geometry", [
{"type": "LineString", "coordinates": [[2, 48]]},
{"type": "LineString", "coordinates": [[2, 48], [2, 48]]},
{"type": "Polygon", "coordinates": [[[2, 48], [3, 48], [3, 49]]]},
{"type": "Polygon", "coordinates": [[[2, 48], [2, 48], [2, 48], [2, 48]]]},
{"type": "LineString", "coordinates": [[181, 48], [2, 48]]},
{"type": "LineString", "coordinates": [[2, 91], [2, 48]]},
{"type": "LineString", "coordinates": [[True, 48], [2, 48]]},
{"type": "LineString", "coordinates": [["2", 48], [2, 48]]},
{"type": "Polygon", "coordinates": ["invalid"]},
{"type": "Unknown", "coordinates": [[2, 48], [2, 49]]},
])
def test_invalid_geometry_is_refused_without_writing(client, owner, geometry):
row = create(client, owner)
url = layer_url(owner, row)
point = marker(client, owner, row)
before = read(client, owner, row)
assert client.post(f"{url}/shapes", json={"geometry": geometry}).status_code == 422
assert client.patch(f"{url}/markers/{point['properties']['key']}", json={"geometry": geometry}).status_code == 422
assert read(client, owner, row) == before
def test_geometry_limits_and_type_changes_are_refused(client, owner):
row = create(client, owner)
url = layer_url(owner, row)
point = marker(client, owner, row)
assert client.patch(f"{url}/markers/{point['properties']['key']}", json={"geometry": LINE}).status_code == 422
assert client.post(f"{url}/shapes", json={"geometry": {"type": "LineString", "coordinates": [[2, 48]] * 4097}}).status_code == 422
def test_lines_and_areas_are_numbered_apart_in_a_first_group_named_for_both(client, owner):
row = create(client, owner)
url = layer_url(owner, row)
def named(geometry, **extra):
answer = client.post(f"{url}/shapes", json={"geometry": geometry, **extra}).json()
return answer["marker"]["properties"]["name"]
assert [named(LINE), named(AREA), named(LINE)] == ["Line 1", "Area 1", "Line 2"]
# a name given by hand that reads like the next one is not given twice
assert named(AREA, name="Area 4") == "Area 4"
assert named(AREA) == "Area 5"
assert [group["name"] for group in read(client, owner, row)["groups"]] == ["Features"]
def test_active_edit_checkpoint_survives_a_case_bundle(client, owner, monkeypatch):
monkeypatch.setattr(workqueue, "start_workers", False)
row = create(client, owner)
url = layer_url(owner, row)
client.post(f"{url}/edit", json={})
client.post(f"{url}/shapes", json={"geometry": AREA})
case = Case.open(owner)
job = bundles.queue_export(case)
workqueue.drain(case)
imported, import_job = bundles.queue_import(Path(job["payload"]["output"]))
workqueue.drain(imported)
imported = Case.open(imported.id)
assert imported.get_job(import_job["id"])["state"] == "ready"
new_url = layer_url(imported.id, row)
assert client.post(f"{new_url}/edit", json={}).json()["layer"]["edit_changed"]
assert finish_edit(client, new_url, discard=True).json()["document"]["features"] == []
def test_selection_edits_are_atomic_and_keep_case_places(client, owner):
row = create(client, owner)
first = marker(client, owner, row, name="First")
second = marker(client, owner, row, name="Second", lon=179)
url = layer_url(owner, row)
place = client.post(f"{url}/markers/{first['properties']['key']}/place").json()["place"]
keys = [first["properties"]["key"], second["properties"]["key"]]
before = read(client, owner, row)
for body in ({"keys": keys, "offset": [2, 0]}, {"keys": [keys[0], "missing"], "remove": True},
{"keys": [keys[0], keys[0]], "changes": {"colour": "#009e73"}},
{"keys": keys, "changes": {"group": "missing"}}):
response = client.post(f"{url}/selection", json=body)
assert response.status_code == 422, response.text
assert read(client, owner, row) == before
moved = client.post(f"{url}/selection", json={"keys": keys, "offset": [-1, 1],
"changes": {"colour": "#009e73", "symbol": "badge-tank"}})
assert moved.status_code == 200, moved.text
# the marker on the case place stays on it; the other one moves
assert [f["geometry"]["coordinates"] for f in moved.json()["document"]["features"]] == [[2.35, 48.85], [178, 49.85]]
assert moved.json()["kept"] == 1
assert all(f["properties"]["symbol"] == "badge-tank" for f in moved.json()["document"]["features"])
assert Case.open(owner).get_entity(place["id"])["attrs"]["lat"] == 48.85
removed = client.post(f"{url}/selection", json={"keys": keys, "remove": True})
assert removed.status_code == 200
assert removed.json()["document"]["features"] == []
batch = removed.json()["batch"]
restored = client.post(f"{url}/selection/{batch}/restore")
assert restored.status_code == 200
assert [f["properties"]["key"] for f in restored.json()["document"]["features"]] == keys
assert client.post(f"{url}/selection/{batch}/restore").status_code == 422
assert len(places(owner)) == 1
@pytest.mark.parametrize("stroke", [0, 0.49, 12.1, "invalid"])
def test_group_line_width_is_bounded(client, owner, stroke):
row = create(client, owner)
url = layer_url(owner, row)
group = read(client, owner, row)["groups"][0]
assert client.patch(f"{url}/groups/{group['id']}", json={"stroke": stroke}).status_code == 422
assert read(client, owner, row)["groups"][0]["stroke"] == 2
def test_group_line_width_reaches_drawn_shapes(client, owner):
row = create(client, owner)
url = layer_url(owner, row)
group = read(client, owner, row)["groups"][0]
client.post(f"{url}/shapes", json={"geometry": {"type": "LineString", "coordinates": [[2, 48], [3, 49]]}})
assert client.patch(f"{url}/groups/{group['id']}", json={"stroke": 5.5}).status_code == 200
assert client.get(f"{url}/data").json()["features"][0]["properties"]["stroke_width"] == 5.5
def test_a_feature_carries_its_own_look_and_how_sure_it_is(client, owner):
"""Width, dash, arrow, fill, size and its name on the map, each cleared by sending nothing."""
row = create(client, owner)
url = layer_url(owner, row)
line = client.post(f"{url}/shapes", json={"geometry": {"type": "LineString", "coordinates": [[2.3, 48.8], [2.4, 48.9]]},
"line_width": 5, "line_dash": "dashed", "line_arrow": "end", "confidence": "claimed",
"credit": "GeoConfirmed — geoconfirmed.org"})
assert line.status_code == 200, line.text
key = line.json()["key"]
drawn = client.get(f"{url}/data").json()["features"][0]["properties"]
assert (drawn["stroke_width"], drawn["line_dash"], drawn["line_arrow"], drawn["confidence"]) == (5, "dashed", "end", "claimed")
assert drawn["credit"] == "GeoConfirmed — geoconfirmed.org"
cleared = client.patch(f"{url}/markers/{key}", json={"line_dash": None, "line_width": None, "label": "on", "label_size": 14})
assert cleared.status_code == 200, cleared.text
drawn = client.get(f"{url}/data").json()["features"][0]["properties"]
assert "line_dash" not in drawn and drawn["stroke_width"] == 2 and drawn["show_label"] is True and drawn["label_size"] == 14
for wrong in ({"line_dash": "wavy"}, {"line_width": 40}, {"confidence": "maybe"}, {"area_fill": "plaid"}):
assert client.patch(f"{url}/markers/{key}", json=wrong).status_code == 422
def test_a_group_lends_its_look_to_features_that_set_none(client, owner):
row = create(client, owner)
url = layer_url(owner, row)
area = client.post(f"{url}/shapes", json={"geometry": {"type": "Polygon", "coordinates": [[[2.3, 48.8], [2.4, 48.8], [2.4, 48.9], [2.3, 48.8]]]}})
own = client.post(f"{url}/shapes", json={"geometry": {"type": "Polygon", "coordinates": [[[2.5, 48.8], [2.6, 48.8], [2.6, 48.9], [2.5, 48.8]]]},
"area_fill": "none"})
group = read(client, owner, row)["groups"][0]["id"]
assert client.patch(f"{url}/groups/{group}", json={"area_fill": "hatch", "line_dash": "dotted"}).status_code == 200
drawn = {feature["properties"]["key"]: feature["properties"] for feature in client.get(f"{url}/data").json()["features"]}
assert drawn[area.json()["key"]]["area_fill"] == "hatch"
assert drawn[own.json()["key"]]["area_fill"] == "none"
# null clears a group's look
assert client.patch(f"{url}/groups/{group}", json={"area_fill": None}).status_code == 200
drawn = {feature["properties"]["key"]: feature["properties"] for feature in client.get(f"{url}/data").json()["features"]}
assert "area_fill" not in drawn[area.json()["key"]]
def test_revert_puts_features_back_and_drops_the_ones_an_edit_made(client, owner):
"""The editor's undo and redo: whole features back by their key, new ones out."""
row = create(client, owner)
url = layer_url(owner, row)
first = marker(client, owner, row, name="Depot")
before = read(client, owner, row)["document"]["features"][0]
client.patch(f"{url}/markers/{first['properties']['key']}", json={"name": "Moved depot"})
second = marker(client, owner, row, name="Bridge")
answer = client.post(f"{url}/revert", json={"put": [before], "drop": [second["properties"]["key"]]})
assert answer.status_code == 200, answer.text
features = read(client, owner, row)["document"]["features"]
assert [feature["properties"]["name"] for feature in features] == ["Depot"]
# a feature put back after it was removed comes back with its key
client.delete(f"{url}/markers/{first['properties']['key']}")
assert client.post(f"{url}/revert", json={"put": [before], "drop": []}).status_code == 200
assert read(client, owner, row)["document"]["features"][0]["properties"]["key"] == first["properties"]["key"]
# what is put back is checked as a drawn feature is
broken = {**before, "geometry": {"type": "Point", "coordinates": [500, 48]}}
assert client.post(f"{url}/revert", json={"put": [broken], "drop": []}).status_code == 422
assert client.post(f"{url}/revert", json={"put": [{"geometry": before["geometry"], "properties": {}}], "drop": []}).status_code == 422
def test_revert_brings_back_a_group_an_edit_took_out_and_takes_out_one_it_made(client, owner):
"""Undoing Ungroup puts the group back where it stood, its look kept, before its features return to it."""
row = create(client, owner)
url = layer_url(owner, row)
made = client.post(f"{url}/groups", json={"name": "Strikes"}).json()["group"]
assert client.patch(f"{url}/groups/{made['id']}", json={"colour": "#d55e00", "labels": True, "events": True, "line_dash": "dotted"}).status_code == 200
client.post(f"{url}/groups", json={"name": "Later"})
point = marker(client, owner, row, name="Hit", group=made["id"])
before = read(client, owner, row)
group = next(one for one in before["groups"] if one["id"] == made["id"])
feature = next(one for one in before["document"]["features"] if one["properties"]["key"] == point["properties"]["key"])
assert client.delete(f"{url}/groups/{made['id']}").status_code == 200
answer = client.post(f"{url}/revert", json={"put": [feature], "drop": [], "groups": [{**group, "at": 1}], "drop_groups": []})
assert answer.status_code == 200, answer.text
after = read(client, owner, row)
assert [one["name"] for one in after["groups"]] == ["Features", "Strikes", "Later"]
back = after["groups"][1]
assert (back["id"], back["colour"], back["labels"], back["events"], back["line_dash"]) == (made["id"], "#d55e00", True, True, "dotted")
assert after["document"]["features"][0]["properties"]["group"] == made["id"]
# its redo takes it out again; a group of the same name meanwhile is refused rather than doubled
assert client.post(f"{url}/revert", json={"put": [], "drop": [], "drop_groups": [made["id"]]}).status_code == 200
after = read(client, owner, row)
assert [one["name"] for one in after["groups"]] == ["Features", "Later"]
assert after["document"]["features"][0]["properties"]["group"] == after["groups"][0]["id"]
client.post(f"{url}/groups", json={"name": "Strikes"})
refused = client.post(f"{url}/revert", json={"put": [], "drop": [], "groups": [{**group, "at": 1}]})
assert refused.status_code == 422 and "Strikes" in refused.text
# the last group stays, whatever an undo asks
only = read(client, owner, row)["groups"]
client.post(f"{url}/revert", json={"put": [], "drop": [], "drop_groups": [one["id"] for one in only]})
assert len(read(client, owner, row)["groups"]) == 1
# a group put back is checked as an edit would check it
assert client.post(f"{url}/revert", json={"put": [], "drop": [], "groups": [{**group, "id": "x", "name": "Other", "colour": "red"}]}).status_code == 422