Jeder Datenraum hat einen Eigentümer, der Verwalter bleibt, den Raum übertragen kann und im Notfall vom Betreiber ersetzt wird. Neue Akten und Vorgänge folgen der Voreinstellung des Raums: Bei "im Raum teilen" lesen Leser sie und bearbeiten Mitglieder und Verwalter; Weitergeben und Löschen bleiben beim Owner, der eine Akte privat stellen oder einzelne Personen ausnehmen kann. Bestehende Akten bleiben privat. Beim ersten weiteren Mitglied zeigt die Oberfläche, was sichtbar wird. Das Löschen von Akte und Vorgang verlangt jetzt den Owner statt nur das Bearbeitungsrecht und schließt damit R-01. Die Rechte der Raumfreigabe gelten nur bei aktivem Raum, aktiver Mitgliedschaft und aktivem Konto. Die lokale Suite läuft mit 128 Tests grün, der Frontend-Build und 19 Node-Tests ebenfalls. Die Oberfläche wurde noch nicht im Browser bedient. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
298 lines
12 KiB
Python
298 lines
12 KiB
Python
"""T-ISO, T-SHARE, T-CONTEXT, T-DETACH, T-GRANT and the personal-room boundary."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
|
|
from app.access.policy import SHARED_NOTICE
|
|
from tests.support import Actor, bind_to, case_of, document, grant, note_on, register, texts
|
|
|
|
|
|
def test_manager_does_not_read_a_personal_case(client, db):
|
|
register(db, "ada@example.test", "Ada")
|
|
register(db, "ben@example.test", "Ben")
|
|
ada = Actor(client, "ada@example.test", "Ada")
|
|
ada.login()
|
|
private = case_of(ada, "Persoenliche Akte")
|
|
room = ada.request("POST", "/api/v1/rooms", json={"name": "Haushalt", "default_visibility": "private"}, status=201)
|
|
ada.request("POST", f"/api/v1/rooms/{room['id']}/members", json={"email": "ben@example.test", "role": "manager"})
|
|
ben = Actor(client, "ben@example.test", "Ben")
|
|
ben.login()
|
|
ben.use_room(room["id"])
|
|
ben.request("GET", f"/api/v1/cases/{private['id']}", status=404)
|
|
|
|
|
|
def test_t_iso_hides_unshared_case_note_file_search_and_chronology(client, db):
|
|
register(db, "ada@example.test", "Ada")
|
|
register(db, "ben@example.test", "Ben")
|
|
ada = Actor(client, "ada@example.test", "Ada")
|
|
ada.login()
|
|
case_a = case_of(ada, "Akte A Isoliert")
|
|
case_b = case_of(ada, "Akte B Isoliert")
|
|
shared = note_on(ada, "Gemeinsame Notiz", "Sichtbar in B", case_a["id"])
|
|
bind_to(ada, shared["id"], case_a["id"], case_b["id"])
|
|
note_on(ada, "Private Notiz", "Isolierwort bleibt in A", case_a["id"])
|
|
upload = ada.request(
|
|
"POST",
|
|
"/api/v1/files",
|
|
data={"title": "Geheimes Schreiben", "context_kind": "case", "context_id": case_a["id"]},
|
|
files={"upload": ("schreiben.pdf", b"%PDF-1.1\ntrailer<</Root 1 0 R>>\n%%EOF\n", "application/pdf")},
|
|
status=201,
|
|
)
|
|
grant(ada, case_b["id"], "ben@example.test", edit=False)
|
|
|
|
ben = Actor(client, "ben@example.test", "Ben")
|
|
ben.login()
|
|
ben.request("GET", f"/api/v1/cases/{case_a['id']}", status=404)
|
|
visible = ben.request("GET", f"/api/v1/cases/{case_b['id']}")
|
|
assert "Gemeinsame Notiz" in texts(visible)
|
|
assert "Private Notiz" not in texts(visible)
|
|
assert "Isolierwort" not in json.dumps(visible)
|
|
|
|
hidden = ben.request("GET", "/api/v1/search", params={"q": "Isolierwort"})
|
|
assert hidden["items"] == []
|
|
ada.login()
|
|
found = ada.request("GET", "/api/v1/search", params={"q": "Isolierwort"})
|
|
assert any(item["title"] == "Private Notiz" for item in found["items"])
|
|
|
|
ben.login()
|
|
download = ben.request(
|
|
"GET",
|
|
f"/api/v1/files/{upload['id']}/content",
|
|
params={"context_kind": "case", "context_id": case_a["id"]},
|
|
status=404,
|
|
)
|
|
assert download["detail"] == "Der Eintrag ist nicht vorhanden."
|
|
assert "schreiben" not in json.dumps(download).casefold()
|
|
chronology = ben.request("GET", f"/api/v1/cases/{case_b['id']}/chronology")
|
|
blob = json.dumps(chronology)
|
|
assert "Private Notiz" not in blob
|
|
assert "Isolierwort" not in blob
|
|
assert "Geheimes Schreiben" not in blob
|
|
|
|
|
|
def test_t_share_text_annotation_and_hidden_binding_count(client, db):
|
|
register(db, "ada@example.test", "Ada")
|
|
register(db, "ben@example.test", "Ben")
|
|
ada = Actor(client, "ada@example.test", "Ada")
|
|
ada.login()
|
|
case_a = case_of(ada, "Akte Anteil A")
|
|
case_b = case_of(ada, "Akte Anteil B")
|
|
case_c = case_of(ada, "Akte Verborgen")
|
|
created = note_on(ada, "Geteilte Notiz", "Erster Text", case_a["id"])
|
|
bound = bind_to(ada, created["id"], case_a["id"], case_b["id"])
|
|
bind_to(ada, created["id"], case_a["id"], case_c["id"])
|
|
ada.request(
|
|
"POST",
|
|
f"/api/v1/bindings/{bound['id']}/annotations",
|
|
params={"context_kind": "case", "context_id": case_b["id"]},
|
|
json={"body": "Nur in B vermerkt"},
|
|
status=201,
|
|
)
|
|
changed = ada.request(
|
|
"PATCH",
|
|
f"/api/v1/notes/{created['id']}",
|
|
json={
|
|
"expected_version": created["version"],
|
|
"document": document("Gleicher Text"),
|
|
"context": {"kind": "case", "id": case_a["id"]},
|
|
},
|
|
)
|
|
from_b = ada.request(
|
|
"PATCH",
|
|
f"/api/v1/notes/{created['id']}",
|
|
json={
|
|
"expected_version": changed["version"],
|
|
"document": document("Von beiden Seiten"),
|
|
"context": {"kind": "case", "id": case_b["id"]},
|
|
},
|
|
)
|
|
seen_a = texts(ada.request("GET", f"/api/v1/cases/{case_a['id']}"))
|
|
seen_b = ada.request("GET", f"/api/v1/cases/{case_b['id']}")
|
|
assert seen_a["Geteilte Notiz"] == "Von beiden Seiten"
|
|
assert texts(seen_b)["Geteilte Notiz"] == "Von beiden Seiten"
|
|
assert "Nur in B vermerkt" not in json.dumps(ada.request("GET", f"/api/v1/cases/{case_a['id']}"))
|
|
assert "Nur in B vermerkt" in json.dumps(seen_b)
|
|
assert from_b["notice"] == SHARED_NOTICE
|
|
|
|
grant(ada, case_b["id"], "ben@example.test", edit=True)
|
|
plain = note_on(ada, "Nur B", "Kontrolltext", case_b["id"])
|
|
ben = Actor(client, "ben@example.test", "Ben")
|
|
ben.login()
|
|
hidden = ben.request(
|
|
"PATCH",
|
|
f"/api/v1/notes/{created['id']}",
|
|
json={
|
|
"expected_version": from_b["version"],
|
|
"document": document("Ben aendert"),
|
|
"context": {"kind": "case", "id": case_b["id"]},
|
|
},
|
|
)
|
|
only_b = ben.request(
|
|
"PATCH",
|
|
f"/api/v1/notes/{plain['id']}",
|
|
json={
|
|
"expected_version": plain["version"],
|
|
"document": document("Kontrolltext neu"),
|
|
"context": {"kind": "case", "id": case_b["id"]},
|
|
},
|
|
)
|
|
|
|
def shape(payload: dict) -> dict:
|
|
return {
|
|
"notice": payload["notice"],
|
|
"count": len(payload["visible_bindings"]),
|
|
"names": sorted(item["context_title"] for item in payload["visible_bindings"]),
|
|
}
|
|
|
|
assert shape(hidden) == shape(only_b)
|
|
assert shape(hidden)["names"] == ["Akte Anteil B"]
|
|
assert "Akte Verborgen" not in json.dumps(hidden)
|
|
assert hidden["notice"] == SHARED_NOTICE
|
|
|
|
ada.login()
|
|
readonly = case_of(ada, "Akte Nur Lesen")
|
|
locked = note_on(ada, "Geschuetzte Notiz", "Unveraendert", readonly["id"])
|
|
grant(ada, readonly["id"], "ben@example.test", edit=False)
|
|
ben.login()
|
|
ben.request(
|
|
"PATCH",
|
|
f"/api/v1/notes/{locked['id']}",
|
|
json={
|
|
"expected_version": locked["version"],
|
|
"document": document("Darf nicht"),
|
|
"context": {"kind": "case", "id": readonly["id"]},
|
|
},
|
|
status=403,
|
|
)
|
|
ada.login()
|
|
assert texts(ada.request("GET", f"/api/v1/cases/{readonly['id']}"))["Geschuetzte Notiz"] == "Unveraendert"
|
|
|
|
|
|
def test_t_context_uses_only_the_requested_case(client, db):
|
|
register(db, "ada@example.test", "Ada")
|
|
register(db, "ben@example.test", "Ben")
|
|
ada = Actor(client, "ada@example.test", "Ada")
|
|
ada.login()
|
|
case_a = case_of(ada, "Kontext A")
|
|
case_b = case_of(ada, "Kontext B")
|
|
case_c = case_of(ada, "Kontext Fremd")
|
|
matter = ada.request("POST", "/api/v1/matters", json={"title": "Gleicher Vorgang"}, status=201)
|
|
version = matter["version"]
|
|
ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": case_a["id"]}, status=201)
|
|
ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": case_b["id"]}, status=201)
|
|
again = ada.request("GET", f"/api/v1/matters/{matter['id']}")
|
|
assert again["version"] == version
|
|
grant(ada, case_a["id"], "ben@example.test", edit=True)
|
|
grant(ada, case_b["id"], "ben@example.test", edit=False)
|
|
grant(ada, case_c["id"], "ben@example.test", edit=True)
|
|
|
|
ben = Actor(client, "ben@example.test", "Ben")
|
|
ben.login()
|
|
ben.request("GET", f"/api/v1/matters/{matter['id']}", status=404)
|
|
ben.request("PATCH", f"/api/v1/matters/{matter['id']}", json={"expected_version": version, "title": "Ohne Kontext"}, status=404)
|
|
ben.request(
|
|
"GET",
|
|
f"/api/v1/matters/{matter['id']}",
|
|
params={"context_kind": "case", "context_id": case_c["id"]},
|
|
status=404,
|
|
)
|
|
ben.request("GET", f"/api/v1/matters/{matter['id']}/chronology", status=404)
|
|
opened = ben.request(
|
|
"GET",
|
|
f"/api/v1/matters/{matter['id']}",
|
|
params={"context_kind": "case", "context_id": case_a["id"]},
|
|
)
|
|
assert opened["rights"]["edit"] is True
|
|
read_only = ben.request(
|
|
"GET",
|
|
f"/api/v1/matters/{matter['id']}",
|
|
params={"context_kind": "case", "context_id": case_b["id"]},
|
|
)
|
|
assert read_only["rights"]["read"] is True
|
|
assert read_only["rights"]["edit"] is False
|
|
ben.request(
|
|
"PATCH",
|
|
f"/api/v1/matters/{matter['id']}",
|
|
json={"expected_version": version, "title": "Aus B", "context": {"kind": "case", "id": case_b["id"]}},
|
|
status=403,
|
|
)
|
|
renamed = ben.request(
|
|
"PATCH",
|
|
f"/api/v1/matters/{matter['id']}",
|
|
json={"expected_version": version, "title": "Aus A", "context": {"kind": "case", "id": case_a["id"]}},
|
|
)
|
|
assert renamed["title"] == "Aus A"
|
|
chronology = ben.request(
|
|
"GET",
|
|
f"/api/v1/matters/{matter['id']}/chronology",
|
|
params={"context_kind": "case", "context_id": case_a["id"]},
|
|
)
|
|
assert chronology["items"]
|
|
|
|
|
|
def test_t_detach_keeps_the_other_binding(client, db):
|
|
register(db, "ada@example.test", "Ada")
|
|
register(db, "ben@example.test", "Ben")
|
|
ada = Actor(client, "ada@example.test", "Ada")
|
|
ada.login()
|
|
case_a = case_of(ada, "Akte Bleibt")
|
|
case_b = case_of(ada, "Akte Loesen")
|
|
created = note_on(ada, "Notiz Bleibt", "Inhalt bleibt", case_a["id"])
|
|
bound = bind_to(ada, created["id"], case_a["id"], case_b["id"])
|
|
grant(ada, case_b["id"], "ben@example.test", edit=True)
|
|
ben = Actor(client, "ben@example.test", "Ben")
|
|
ben.login()
|
|
ben.request(
|
|
"DELETE",
|
|
f"/api/v1/bindings/{bound['id']}",
|
|
params={"context_kind": "case", "context_id": case_b["id"]},
|
|
status=204,
|
|
)
|
|
ben_view = ben.request("GET", f"/api/v1/cases/{case_b['id']}")
|
|
assert "Notiz Bleibt" not in texts(ben_view)
|
|
ada.login()
|
|
kept = ada.request("GET", f"/api/v1/cases/{case_a['id']}")
|
|
assert texts(kept)["Notiz Bleibt"] == "Inhalt bleibt"
|
|
|
|
|
|
def test_t_grant_edit_does_not_create_a_new_binding(client, db):
|
|
register(db, "ada@example.test", "Ada")
|
|
register(db, "ben@example.test", "Ben")
|
|
ada = Actor(client, "ada@example.test", "Ada")
|
|
ada.login()
|
|
source = case_of(ada, "Akte Quelle")
|
|
created = note_on(ada, "Nicht weiterreichen", "Bleibt hier", source["id"])
|
|
grant(ada, source["id"], "ben@example.test", edit=True, share=False)
|
|
ben = Actor(client, "ben@example.test", "Ben")
|
|
ben.login()
|
|
target = case_of(ben, "Akte Ziel")
|
|
ben.request(
|
|
"POST",
|
|
"/api/v1/bindings",
|
|
json={
|
|
"element_id": created["id"],
|
|
"source_context": {"kind": "case", "id": source["id"]},
|
|
"target": {"kind": "case", "id": target["id"]},
|
|
},
|
|
status=403,
|
|
)
|
|
assert "Nicht weiterreichen" not in texts(ben.request("GET", f"/api/v1/cases/{target['id']}"))
|
|
|
|
|
|
def test_matter_without_a_case_and_same_version_in_two_cases(client, db):
|
|
register(db, "ada@example.test", "Ada")
|
|
ada = Actor(client, "ada@example.test", "Ada")
|
|
ada.login()
|
|
alone = ada.request("POST", "/api/v1/matters", json={"title": "Ohne Akte"}, status=201)
|
|
detail = ada.request("GET", f"/api/v1/matters/{alone['id']}")
|
|
assert detail["case_links"] == []
|
|
first = case_of(ada, "Erste Akte")
|
|
second = case_of(ada, "Zweite Akte")
|
|
version = alone["version"]
|
|
ada.request("POST", f"/api/v1/matters/{alone['id']}/case-links", json={"case_id": first["id"]}, status=201)
|
|
ada.request("POST", f"/api/v1/matters/{alone['id']}/case-links", json={"case_id": second["id"]}, status=201)
|
|
linked = ada.request("GET", f"/api/v1/matters/{alone['id']}")
|
|
assert linked["version"] == version
|
|
assert {item["title"] for item in linked["case_links"]} == {"Erste Akte", "Zweite Akte"}
|