Deploy Development / deploy (push) Failing after 40s
Testdaten entstehen nur dort und werden danach entfernt, damit Dev und Produktion sie nicht behalten. Co-authored-by: Cursor <cursoragent@cursor.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"}, 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"}
|