Files
tsumugu/backend/tests/test_order.py
T
LarsandCursor 52bda91aad
Deploy Development / deploy (push) Successful in 22s
Test Suite / pytest-backend (push) Successful in 51s
Test Suite / smoke-dev (push) Successful in 1s
Test Suite / frontend-build (push) Successful in 6s
Ordne Akten und Vorgaenge nach fachlichem Datum oder eigener Reihenfolge und mache den Inhalt zur Arbeitsansicht.
Co-authored-by: Cursor <cursoragent@cursor.com>
2026-10-17 09:36:48 +02:00

372 lines
15 KiB
Python

"""Persistent content order, fachliche dates and context limits."""
from __future__ import annotations
from tests.support import Actor, binding_for, case_of, document, grant, matter_of, register
def _note(actor: Actor, title: str, container: dict, *, kind: str = "matter", document_on: str | None = None) -> None:
body = {
"title": title,
"document": document(title),
"context": {"kind": kind, "id": container["id"]},
}
if document_on:
body["dates"] = {"document_on": document_on}
actor.request("POST", "/api/v1/notes", json=body, status=201)
def _matter(actor: Actor, matter_id: str) -> dict:
return actor.request("GET", f"/api/v1/matters/{matter_id}")
def _titles(detail: dict) -> list[str]:
return [item["element"]["title"] for item in detail["bindings"]]
def test_date_order_keeps_undated_last_and_ignores_recorded_time(client, db):
ada = Actor(client, "ada-order@example.test", "Ada Ordnung")
register(db, ada.email, ada.name)
ada.login()
matter = matter_of(ada, "Fristenmappe")
dates = ["2024-05-02", "2020-01-01", "2024-05-02", "2022-07-07", "2023-03-03", "2021-02-02"]
for index, day in enumerate(dates):
_note(ada, f"D{index}-{day}", matter, document_on=day)
_note(ada, "Ohne-A", matter)
_note(ada, "Ohne-B", matter)
detail = _matter(ada, matter["id"])
titles = _titles(detail)
assert titles[:6] == ["D1-2020-01-01", "D5-2021-02-02", "D3-2022-07-07", "D4-2023-03-03", "D0-2024-05-02", "D2-2024-05-02"]
assert titles[6:] == ["Ohne-A", "Ohne-B"]
assert all(item["element"]["dates"]["document_on"] is None for item in detail["bindings"] if item["element"]["title"].startswith("Ohne"))
ada.request(
"PATCH",
f"/api/v1/matters/{matter['id']}/content-order",
json={"expected_version": detail["version"], "mode": "date", "direction": "desc"},
)
descending = _titles(_matter(ada, matter["id"]))
assert descending[:6] == ["D0-2024-05-02", "D2-2024-05-02", "D4-2023-03-03", "D3-2022-07-07", "D5-2021-02-02", "D1-2020-01-01"]
assert descending[6:] == ["Ohne-A", "Ohne-B"]
def test_custom_order_survives_reload_login_and_date_mode(client, db):
ada = Actor(client, "ada-seq@example.test", "Ada Folge")
register(db, ada.email, ada.name)
ada.login()
matter = matter_of(ada, "Reihenfolge")
for title, day in (("Alpha", "2020-01-01"), ("Beta", "2021-01-01"), ("Gamma", "2022-01-01")):
_note(ada, title, matter, document_on=day)
detail = _matter(ada, matter["id"])
ada.request(
"PATCH",
f"/api/v1/matters/{matter['id']}/content-order",
json={"expected_version": detail["version"], "mode": "position", "direction": "asc"},
)
detail = _matter(ada, matter["id"])
ids = [binding_for(detail, name)["id"] for name in ("Gamma", "Alpha", "Beta")]
ada.request(
"POST",
f"/api/v1/matters/{matter['id']}/bindings/order",
json={"expected_version": detail["version"], "binding_ids": ids},
)
ada.login()
restored = _matter(ada, matter["id"])
assert _titles(restored) == ["Gamma", "Alpha", "Beta"]
ada.request(
"PATCH",
f"/api/v1/matters/{matter['id']}/content-order",
json={"expected_version": restored["version"], "mode": "date", "direction": "asc"},
)
dated = _matter(ada, matter["id"])
assert _titles(dated) == ["Alpha", "Beta", "Gamma"]
ada.request(
"PATCH",
f"/api/v1/matters/{matter['id']}/content-order",
json={"expected_version": dated["version"], "mode": "position", "direction": "asc"},
)
assert _titles(_matter(ada, matter["id"])) == ["Gamma", "Alpha", "Beta"]
_note(ada, "Delta", matter)
assert _titles(_matter(ada, matter["id"]))[-1] == "Delta"
def test_same_element_has_independent_positions(client, db):
ada = Actor(client, "ada-two@example.test", "Ada Zwei")
register(db, ada.email, ada.name)
ada.login()
left = case_of(ada, "Akte A")
right = case_of(ada, "Akte B")
ada.request(
"POST",
"/api/v1/notes",
json={"title": "Gemeinsam", "document": document("Wort"), "context": {"kind": "case", "id": left["id"]}},
status=201,
)
ada.request(
"POST",
"/api/v1/notes",
json={"title": "Nur A", "document": document("A"), "context": {"kind": "case", "id": left["id"]}},
status=201,
)
ada.request(
"POST",
"/api/v1/notes",
json={"title": "Nur B", "document": document("B"), "context": {"kind": "case", "id": right["id"]}},
status=201,
)
shared = binding_for(ada.request("GET", f"/api/v1/cases/{left['id']}"), "Gemeinsam")
ada.request(
"POST",
"/api/v1/bindings",
json={
"element_id": shared["element"]["id"],
"source_context": {"kind": "case", "id": left["id"]},
"target": {"kind": "case", "id": right["id"]},
},
status=201,
)
for case in (left, right):
detail = ada.request("GET", f"/api/v1/cases/{case['id']}")
ada.request(
"PATCH",
f"/api/v1/cases/{case['id']}/content-order",
json={"expected_version": detail["version"], "mode": "position", "direction": "asc"},
)
left_detail = ada.request("GET", f"/api/v1/cases/{left['id']}")
right_detail = ada.request("GET", f"/api/v1/cases/{right['id']}")
ada.request(
"POST",
f"/api/v1/cases/{left['id']}/bindings/order",
json={
"expected_version": left_detail["version"],
"binding_ids": [binding_for(left_detail, "Gemeinsam")["id"], binding_for(left_detail, "Nur A")["id"]],
},
)
ada.request(
"POST",
f"/api/v1/cases/{right['id']}/bindings/order",
json={
"expected_version": right_detail["version"],
"binding_ids": [binding_for(right_detail, "Nur B")["id"], binding_for(right_detail, "Gemeinsam")["id"]],
},
)
assert _titles(ada.request("GET", f"/api/v1/cases/{left['id']}")) == ["Gemeinsam", "Nur A"]
assert _titles(ada.request("GET", f"/api/v1/cases/{right['id']}")) == ["Nur B", "Gemeinsam"]
left_note = binding_for(ada.request("GET", f"/api/v1/cases/{left['id']}"), "Gemeinsam")
ada.request(
"POST",
f"/api/v1/bindings/{left_note['id']}/annotations",
json={"body": "Nur in A"},
status=201,
)
right_note = binding_for(ada.request("GET", f"/api/v1/cases/{right['id']}"), "Gemeinsam")
assert right_note["annotations"] == []
assert left_note["element"]["id"] == right_note["element"]["id"]
def test_chapters_and_contained_matters_stay_distinct(client, db):
ada = Actor(client, "ada-chap@example.test", "Ada Kapitel")
register(db, ada.email, ada.name)
ada.login()
case = case_of(ada, "Sammelakte")
matter = matter_of(ada, "Enthaltener Vorgang")
ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": case["id"]}, status=201)
chapter = ada.request("POST", f"/api/v1/cases/{case['id']}/chapters", json={"title": "Belege"}, status=201)
ada.request(
"POST",
"/api/v1/notes",
json={
"title": "Im Kapitel",
"document": document("kapitel"),
"context": {"kind": "case", "id": case["id"]},
"chapter_id": chapter["id"],
"dates": {"document_on": "2021-01-01"},
},
status=201,
)
ada.request(
"POST",
"/api/v1/notes",
json={"title": "Ohne Kapitel", "document": document("lose"), "context": {"kind": "case", "id": case["id"]}},
status=201,
)
_note(ada, "Im Vorgang", matter, document_on="2019-01-01")
detail = ada.request("GET", f"/api/v1/cases/{case['id']}")
ada.request(
"PATCH",
f"/api/v1/cases/{case['id']}/content-order",
json={"expected_version": detail["version"], "mode": "date", "direction": "desc"},
)
detail = ada.request("GET", f"/api/v1/cases/{case['id']}")
direct = {item["element"]["title"]: item["chapter_id"] for item in detail["bindings"]}
assert direct["Im Kapitel"] == chapter["id"]
assert direct["Ohne Kapitel"] is None
assert [item["element"]["title"] for item in detail["bindings"]] == ["Im Kapitel", "Ohne Kapitel"]
assert detail["contained"][0]["title"] == "Enthaltener Vorgang"
assert detail["contained"][0]["bindings"][0]["element"]["title"] == "Im Vorgang"
assert "Im Vorgang" not in direct
def test_course_is_not_a_copy_of_the_audit_log(client, db):
ada = Actor(client, "ada-course@example.test", "Ada Verlauf")
register(db, ada.email, ada.name)
ada.login()
matter = matter_of(ada, "Verlauf")
created = ada.request(
"POST",
"/api/v1/notes",
json={
"title": "Schreiben",
"document": document("Text"),
"context": {"kind": "matter", "id": matter["id"]},
"dates": {"document_on": "2024-04-04"},
},
status=201,
)
ada.request(
"PATCH",
f"/api/v1/elements/{created['id']}/dates",
json={"expected_version": created["version"], "document_on": "2024-04-05", "context": {"kind": "matter", "id": matter["id"]}},
)
course = ada.request("GET", f"/api/v1/matters/{matter['id']}/course")
audit = ada.request("GET", f"/api/v1/matters/{matter['id']}/chronology")
assert [item["title"] for item in course["items"]] == ["Schreiben"]
assert course["items"][0]["document_on"] == "2024-04-05"
assert "recorded_at" not in course["items"][0]
assert len(audit["items"]) > len(course["items"])
def test_reorder_rejects_readers_foreign_ids_and_conflicts(client, db):
ada = Actor(client, "ada-guard@example.test", "Ada Schutz")
ben = Actor(client, "ben-guard@example.test", "Ben Schutz")
register(db, ada.email, ada.name)
register(db, ben.email, ben.name)
ada.login()
matter = matter_of(ada, "Geschützt")
hidden_case = case_of(ada, "Verborgene Akte")
for title in ("Sichtbar", "Verborgen"):
_note(ada, title, matter)
detail = _matter(ada, matter["id"])
ada.request(
"PATCH",
f"/api/v1/matters/{matter['id']}/content-order",
json={"expected_version": detail["version"], "mode": "position", "direction": "asc"},
)
ada.request(
"POST",
f"/api/v1/matters/{matter['id']}/grants",
json={"email": ben.email, "can_read": True, "can_edit": False, "can_share": False},
status=201,
)
ben.login()
ben_view = _matter(ben, matter["id"])
ben.request(
"POST",
f"/api/v1/matters/{matter['id']}/bindings/order",
json={"expected_version": ben_view["version"], "binding_ids": [item["id"] for item in ben_view["bindings"]]},
status=403,
)
ben.request("GET", f"/api/v1/cases/{hidden_case['id']}", status=404)
ada.login()
ada_view = _matter(ada, matter["id"])
visible_id = binding_for(ada_view, "Sichtbar")["id"]
ada.request(
"POST",
f"/api/v1/matters/{matter['id']}/bindings/order",
json={"expected_version": ada_view["version"], "binding_ids": [visible_id]},
status=422,
)
ada.request(
"POST",
"/api/v1/notes",
json={"title": "Fremd", "document": document("x"), "context": {"kind": "case", "id": hidden_case["id"]}},
status=201,
)
foreign = binding_for(ada.request("GET", f"/api/v1/cases/{hidden_case['id']}"), "Fremd")
ada.request(
"POST",
f"/api/v1/matters/{matter['id']}/bindings/order",
json={"expected_version": ada_view["version"], "binding_ids": [foreign["id"], visible_id]},
status=404,
)
hidden = binding_for(ada_view, "Verborgen")
ada.request(
"PUT",
"/api/v1/exceptions",
json={
"resource_kind": "element",
"resource_id": hidden["element"]["id"],
"context": {"kind": "matter", "id": matter["id"]},
"remove_read": True,
},
)
masked = _matter(ada, matter["id"])
assert _titles(masked) == ["Sichtbar"]
ada.request(
"POST",
f"/api/v1/matters/{matter['id']}/bindings/order",
json={"expected_version": masked["version"], "binding_ids": [binding_for(masked, "Sichtbar")["id"]]},
)
conflict = ada.request(
"POST",
f"/api/v1/matters/{matter['id']}/bindings/order",
json={"expected_version": masked["version"], "binding_ids": [binding_for(masked, "Sichtbar")["id"]]},
status=409,
)
assert conflict["detail"] == "Der Stand hat sich geändert. Bitte neu laden."
kept = db.execute("SELECT id FROM bindings WHERE id = %s", (hidden["id"],)).fetchone()
assert kept is not None
ben.login()
assert "Verborgen" not in str(_matter(ben, matter["id"]))
def test_existing_position_mode_is_not_rewritten(client, db):
ada = Actor(client, "ada-keep@example.test", "Ada Bestand")
register(db, ada.email, ada.name)
ada.login()
room = ada.scope["id"]
row = db.execute(
"""
INSERT INTO cases (home_scope_id, owner_subject_id, created_by, title, rights_mode)
VALUES (%s, (SELECT id FROM auth_accounts WHERE email = %s), (SELECT id FROM auth_accounts WHERE email = %s), 'Altakte', 'explicit')
RETURNING id
""",
(room, ada.email, ada.email),
).fetchone()
db.commit()
detail = ada.request("GET", f"/api/v1/cases/{row['id']}")
assert detail["content_order"] == "position"
assert detail["content_order_dir"] == "asc"
def test_direct_matter_trail_invents_no_case(client, db):
ada = Actor(client, "ada-trail@example.test", "Ada Pfad")
ben = Actor(client, "ben-trail@example.test", "Ben Pfad")
register(db, ada.email, ada.name)
register(db, ben.email, ben.name)
ada.login()
parent = case_of(ada, "Vermietung")
child = ada.request(
"POST",
"/api/v1/cases",
json={"title": "Wohnung", "parent_case_id": parent["id"], "rights_mode": "explicit"},
status=201,
)
matter = matter_of(ada, "Nebenkosten")
other = case_of(ada, "Geheim")
ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": child["id"]}, status=201)
ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": other["id"]}, status=201)
grant(ada, child["id"], ben.email)
ben.login()
opened = ben.request("GET", f"/api/v1/matters/{matter['id']}?context_kind=case&context_id={child['id']}")
labels = [item["label"] for item in opened["trail"]]
assert labels[0] == "Akten"
assert "Wohnung" in labels
assert "Nebenkosten" in labels
assert "Vermietung" not in labels
assert "Geheim" not in labels
assert all(item["title"] != "Geheim" for item in opened["case_links"])
ada.login()
direct = ada.request("GET", f"/api/v1/matters/{matter['id']}")
assert direct["trail"][0]["label"] == "Vorgänge"
assert "Vermietung" not in [item["label"] for item in direct["trail"]]