Files
tsumugu/backend/tests/test_room_access.py
T
LarsandClaude Sonnet 5.5 d39c7d7999 Liefere Zähler, Rauminhalt und Teilen im Stapel für die neue Ablage.
Akten und Vorgänge melden Unterakten, Vorgänge und die Räume, mit denen sie geteilt sind, jeweils nur aus Lesbarem. Neue Endpunkte zeigen die Räume als Kacheln, den Inhalt eines Raums und teilen mehrere Einträge auf einmal oder gar nicht. Beim Anlegen lässt sich ein Eintrag gleich in einen Raum legen.

Die lokale Suite läuft mit 148 Tests grün.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-22 11:38:02 +02:00

378 lines
22 KiB
Python

"""Raum als Team: Akten und Vorgänge werden mit Datenräumen geteilt, unabhängig vom Heimatraum."""
from __future__ import annotations
import pytest
from fastapi.testclient import TestClient
from app.auth.accounts import create_account
from tests.support import PASSWORD, Actor, document, matter_of, note_on
def _second_client():
from app.main import app
return TestClient(app)
def _make(db, email: str, name: str):
account = create_account(db, email, name, PASSWORD)
db.commit()
return account
def _actor(client, db, key: str, email: str, *, main: bool = False) -> Actor:
actor = Actor(client if main else _second_client(), email, key.title())
_make(db, actor.email, actor.name)
actor.login()
return actor
def _id(db, email: str) -> str:
row = db.execute("SELECT id FROM auth_accounts WHERE email = %s", (email,)).fetchone()
db.rollback()
return str(row["id"])
def _share(actor: Actor, plural: str, resource_id: str, room: str, access: str = "edit", status: int = 200):
return actor.request("PUT", f"/api/v1/{plural}/{resource_id}/room-share/rooms/{room}", json={"access": access}, status=status)
def _unshare(actor: Actor, plural: str, resource_id: str, room: str, status: int = 204):
return actor.request("DELETE", f"/api/v1/{plural}/{resource_id}/room-share/rooms/{room}", status=status)
@pytest.fixture
def world(client, db):
"""Ada owns the room; Ben is a member, Cem a reader, Dan is outside."""
actors = {
"ada": _actor(client, db, "ada", "ada-raum@example.test", main=True),
"ben": _actor(client, db, "ben", "ben-raum@example.test"),
"cem": _actor(client, db, "cem", "cem-raum@example.test"),
"dan": _actor(client, db, "dan", "dan-raum@example.test"),
}
ada = actors["ada"]
room = ada.request("POST", "/api/v1/rooms", json={"name": "Werkstatt"}, status=201)
assert room["default_visibility"] == "room"
ada.request("POST", f"/api/v1/rooms/{room['id']}/members", json={"email": actors["ben"].email, "role": "member"})
ada.request("POST", f"/api/v1/rooms/{room['id']}/members", json={"email": actors["cem"].email, "role": "reader"})
ada.use_room(room["id"])
actors["room"] = room["id"]
return actors
def test_a_new_entry_follows_the_room_preset_and_rights_follow_the_role(world, db):
ada, ben, cem, dan, room = world["ada"], world["ben"], world["cem"], world["dan"], world["room"]
shared = ada.request("POST", "/api/v1/cases", json={"title": "Gemeinsame Akte"}, status=201)
view = ada.request("GET", f"/api/v1/cases/{shared['id']}/room-share")
assert [(s["room_name"], s["access"]) for s in view["shares"]] == [("Werkstatt", "edit")]
assert ben.request("GET", f"/api/v1/cases/{shared['id']}")["rights"] == {
"read": True, "edit": True, "share": False, "delete": False,
}
assert cem.request("GET", f"/api/v1/cases/{shared['id']}")["rights"] == {
"read": True, "edit": False, "share": False, "delete": False,
}
dan.request("GET", f"/api/v1/cases/{shared['id']}", status=404)
assert "Gemeinsame Akte" in {item["title"] for item in ben.request("GET", "/api/v1/cases")["items"]}
assert dan.request("GET", "/api/v1/cases")["items"] == []
version = ben.request("GET", f"/api/v1/cases/{shared['id']}")["version"]
ben.request("PATCH", f"/api/v1/cases/{shared['id']}", json={"expected_version": version, "title": "Von Ben geändert"})
cem.request("PATCH", f"/api/v1/cases/{shared['id']}", json={"expected_version": version + 1, "title": "Nein"}, status=403)
ben.request("POST", f"/api/v1/cases/{shared['id']}/delete", json={"expected_version": version + 1}, status=403)
ben.request("POST", f"/api/v1/cases/{shared['id']}/grants", json={"email": dan.email, "can_read": True}, status=403)
def test_unsharing_and_leaving_take_the_rights_back_at_once(world, db):
ada, ben, room = world["ada"], world["ben"], world["room"]
case = ada.request("POST", "/api/v1/cases", json={"title": "Zeitweise sichtbar"}, status=201)
ben.request("GET", f"/api/v1/cases/{case['id']}")
_unshare(ada, "cases", case["id"], room)
ben.request("GET", f"/api/v1/cases/{case['id']}", status=404)
_share(ada, "cases", case["id"], room)
ben.request("GET", f"/api/v1/cases/{case['id']}")
ada.request("DELETE", f"/api/v1/rooms/{room}/members/{_id(db, ben.email)}", status=204)
ben.request("GET", f"/api/v1/cases/{case['id']}", status=404)
assert ben.request("GET", "/api/v1/cases")["items"] == []
def test_an_archived_room_shares_nothing_until_it_is_restored(world, db):
ada, ben, room = world["ada"], world["ben"], world["room"]
case = ada.request("POST", "/api/v1/cases", json={"title": "Archivtest"}, status=201)
ben.request("GET", f"/api/v1/cases/{case['id']}")
db.execute("UPDATE data_rooms SET status = 'archived' WHERE id = %s", (room,))
db.commit()
ben.request("GET", f"/api/v1/cases/{case['id']}", status=404)
db.execute("UPDATE data_rooms SET status = 'active' WHERE id = %s", (room,))
db.commit()
ben.request("GET", f"/api/v1/cases/{case['id']}")
def test_the_owner_sees_all_own_entries_whatever_happens_to_the_room(world, db):
ada, ben, room = world["ada"], world["ben"], world["room"]
mine = ada.request("POST", "/api/v1/cases", json={"title": "Meine Akte im Raum"}, status=201)
personal = Actor(ada.client, ada.email, ada.name)
personal_body = personal.login()
personal.request("POST", "/api/v1/cases", json={"title": "Meine persönliche Akte"}, status=201)
# Ben owns an entry filed in the room; Ada, the owner of the room, does not see it.
ben.use_room(room)
bens = ben.request("POST", "/api/v1/cases", json={"title": "Bens Akte"}, status=201)
def titles(actor):
return {item["title"] for item in actor.request("GET", "/api/v1/cases")["items"]}
assert {"Meine Akte im Raum", "Meine persönliche Akte"} <= titles(personal)
assert "Bens Akte" in titles(personal) # shared with the room by the preset
_unshare(ben, "cases", bens["id"], room)
assert "Bens Akte" not in titles(personal)
assert "Bens Akte" in titles(ben)
# Ben leaves the room, the room is archived: he still sees and edits what he owns.
personal.request("DELETE", f"/api/v1/rooms/{room}/members/{_id(db, ben.email)}", status=204)
# Ben's old room headers no longer fit his session; he is told to reload, then lists everything he owns.
assert ben.request("GET", "/api/v1/cases", status=403)["code"] == "scope_changed"
body = ben.request("GET", "/api/v1/auth/session")
assert body["scope"]["kind"] == "personal"
ben.scope, ben.csrf = body["scope"], body["csrf_token"]
assert "Bens Akte" in titles(ben)
ben.request("GET", f"/api/v1/cases/{bens['id']}")
db.execute("UPDATE data_rooms SET status = 'archived' WHERE id = %s", (room,))
db.commit()
assert {"Meine Akte im Raum", "Meine persönliche Akte"} <= titles(personal)
personal.request("GET", f"/api/v1/cases/{mine['id']}")
assert personal_body["account"]["email"] == ada.email
def test_one_member_can_be_excluded(world, db):
ada, ben, cem, dan = world["ada"], world["ben"], world["cem"], world["dan"]
case = ada.request("POST", "/api/v1/cases", json={"title": "Ohne Ben"}, status=201)
view = ada.request("GET", f"/api/v1/cases/{case['id']}/room-share")
assert {(m["display_name"], m["role"]) for m in view["shares"][0]["members"]} == {("Ben", "member"), ("Cem", "reader")}
base = f"/api/v1/cases/{case['id']}/room-share/people"
ada.request("PUT", f"{base}/{_id(db, ben.email)}", json={"excluded": True})
ben.request("GET", f"/api/v1/cases/{case['id']}", status=404)
cem.request("GET", f"/api/v1/cases/{case['id']}")
assert any(m["excluded"] for m in ada.request("GET", f"/api/v1/cases/{case['id']}/room-share")["shares"][0]["members"])
ada.request("PUT", f"{base}/{_id(db, ben.email)}", json={"excluded": False})
ben.request("GET", f"/api/v1/cases/{case['id']}")
ada.request("PUT", f"{base}/{_id(db, ada.email)}", json={"excluded": True}, status=422)
ada.request("PUT", f"{base}/{_id(db, dan.email)}", json={"excluded": True}, status=404)
ben.request("PUT", f"{base}/{_id(db, cem.email)}", json={"excluded": True}, status=404)
def test_contents_follow_the_room_role(world, db):
ada, ben, cem, dan = world["ada"], world["ben"], world["cem"], world["dan"]
case = ada.request("POST", "/api/v1/cases", json={"title": "Akte mit Notiz"}, status=201)
note = note_on(ada, "Notiz in der Akte", "Raumtext", case["id"])
detail = ben.request("GET", f"/api/v1/cases/{case['id']}")
assert any(b["element"]["title"] == "Notiz in der Akte" for b in detail["bindings"])
context = {"kind": "case", "id": case["id"]}
ben.request("PATCH", f"/api/v1/notes/{note['id']}", json={"expected_version": note["version"], "document": document("Von Ben ergänzt"), "context": context})
cem.request("PATCH", f"/api/v1/notes/{note['id']}", json={"expected_version": note["version"] + 1, "document": document("Nein"), "context": context}, status=403)
dan.request("GET", f"/api/v1/cases/{case['id']}", status=404)
assert dan.request("GET", "/api/v1/search", params={"q": "Notiz in der Akte"})["items"] == []
assert any(i["title"] == "Notiz in der Akte" for i in cem.request("GET", "/api/v1/search", params={"q": "Notiz in der Akte"})["items"])
def test_a_standalone_matter_is_shared_like_a_case(world, db):
ada, ben, cem, room = world["ada"], world["ben"], world["cem"], world["room"]
matter = matter_of(ada, "Eigener Vorgang")
assert ben.request("GET", f"/api/v1/matters/{matter['id']}")["rights"]["edit"] is True
assert cem.request("GET", f"/api/v1/matters/{matter['id']}")["rights"] == {
"read": True, "edit": False, "share": False, "delete": False,
}
ben.request("POST", f"/api/v1/matters/{matter['id']}/delete", json={"expected_version": matter["version"]}, status=403)
_unshare(ada, "matters", matter["id"], room)
ben.request("GET", f"/api/v1/matters/{matter['id']}", status=404)
assert "Eigener Vorgang" not in {item["title"] for item in ben.request("GET", "/api/v1/matters")["items"]}
def test_subcases_follow_their_parent(world, db):
ada, ben, room = world["ada"], world["ben"], world["room"]
parent = ada.request("POST", "/api/v1/cases", json={"title": "Eltern"}, status=201)
child = ada.request(
"POST", "/api/v1/cases",
json={"title": "Kind", "parent_case_id": parent["id"], "rights_mode": "inherit_parent"}, status=201,
)
ben.request("GET", f"/api/v1/cases/{child['id']}")
_unshare(ada, "cases", parent["id"], room)
_unshare(ada, "cases", child["id"], room)
ben.request("GET", f"/api/v1/cases/{child['id']}", status=404)
def test_an_entry_in_the_personal_room_can_be_shared_with_a_team(world, db):
ada, ben, dan, room = world["ada"], world["ben"], world["dan"], world["room"]
personal = Actor(ada.client, ada.email, ada.name)
personal.login()
case = personal.request("POST", "/api/v1/cases", json={"title": "Aus dem persönlichen Raum"}, status=201)
assert personal.request("GET", f"/api/v1/cases/{case['id']}/room-share")["shares"] == []
ben.request("GET", f"/api/v1/cases/{case['id']}", status=404)
shared = personal.request("GET", f"/api/v1/cases/{case['id']}/room-share")
assert [item["name"] for item in shared["available"]] == ["Werkstatt"]
_share(personal, "cases", case["id"], room)
ben.request("GET", f"/api/v1/cases/{case['id']}")
dan.request("GET", f"/api/v1/cases/{case['id']}", status=404)
def test_one_matter_goes_to_the_lawyer_and_the_rest_of_the_case_stays_hidden(client, db):
ada = _actor(client, db, "ada", "ada-anwalt@example.test", main=True)
lawyer = _actor(client, db, "anwalt", "anwalt@example.test")
team = ada.request("POST", "/api/v1/rooms", json={"name": "Anwalt Müller", "default_visibility": "private"}, status=201)
ada.request("POST", f"/api/v1/rooms/{team['id']}/members", json={"email": lawyer.email, "role": "member"})
case = ada.request("POST", "/api/v1/cases", json={"title": "Vermietung"}, status=201)
shared = ada.request("POST", "/api/v1/matters", json={"title": "Mietminderung"}, status=201)
hidden = ada.request("POST", "/api/v1/matters", json={"title": "Eigenbedarf intern"}, status=201)
for matter in (shared, hidden):
ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": case["id"]}, status=201)
note_on(ada, "Schreiben des Mieters", "Minderung", case["id"])
_share(ada, "matters", shared["id"], team["id"], access="edit")
lawyer.request("GET", f"/api/v1/cases/{case['id']}", status=404)
assert lawyer.request("GET", "/api/v1/cases")["items"] == []
listed = {item["title"] for item in lawyer.request("GET", "/api/v1/matters")["items"]}
assert listed == {"Mietminderung"}
lawyer.request("GET", f"/api/v1/matters/{hidden['id']}", status=404)
assert lawyer.request("GET", f"/api/v1/matters/{shared['id']}")["rights"]["edit"] is True
def test_the_share_caps_the_role_and_several_rooms_add_up(world, db):
ada, ben, room = world["ada"], world["ben"], world["room"]
other = ada.request("POST", "/api/v1/rooms", json={"name": "Zweites Team", "default_visibility": "private"}, status=201)
ada.request("POST", f"/api/v1/rooms/{other['id']}/members", json={"email": ben.email, "role": "member"})
case = ada.request("POST", "/api/v1/cases", json={"title": "Begrenzt"}, status=201)
_share(ada, "cases", case["id"], room, access="read")
assert ben.request("GET", f"/api/v1/cases/{case['id']}")["rights"]["edit"] is False
_share(ada, "cases", case["id"], other["id"], access="edit")
assert ben.request("GET", f"/api/v1/cases/{case['id']}")["rights"]["edit"] is True
_unshare(ada, "cases", case["id"], other["id"])
assert ben.request("GET", f"/api/v1/cases/{case['id']}")["rights"]["edit"] is False
_unshare(ada, "cases", case["id"], other["id"], status=404)
def test_only_the_owner_shares_and_only_into_rooms_where_he_writes(world, db):
ada, ben, cem, dan, room = world["ada"], world["ben"], world["cem"], world["dan"], world["room"]
case = ada.request("POST", "/api/v1/cases", json={"title": "Nur Ada teilt"}, status=201)
ben.request("PUT", f"/api/v1/cases/{case['id']}/room-share/rooms/{room}", json={"access": "edit"}, status=404)
ben.request("DELETE", f"/api/v1/cases/{case['id']}/room-share/rooms/{room}", status=404)
bens = ben.request("GET", "/api/v1/auth/session") # Ben may share his own entries into rooms he writes in
assert any(r["id"] == room for r in bens["rooms"])
ben.use_room(room)
own = ben.request("POST", "/api/v1/cases", json={"title": "Bens"}, status=201)
# A reader may not share into the room; an outsider cannot even see it.
cem.use_room(room)
cem_own = Actor(cem.client, cem.email, cem.name)
cem_own.login()
mine = cem_own.request("POST", "/api/v1/cases", json={"title": "Von Cem"}, status=201)
cem_own.request("PUT", f"/api/v1/cases/{mine['id']}/room-share/rooms/{room}", json={"access": "edit"}, status=403)
dan_own = Actor(dan.client, dan.email, dan.name)
dan_own.login()
theirs = dan_own.request("POST", "/api/v1/cases", json={"title": "Von Dan"}, status=201)
dan_own.request("PUT", f"/api/v1/cases/{theirs['id']}/room-share/rooms/{room}", json={"access": "edit"}, status=403)
assert own["title"] == "Bens"
def test_leaving_the_team_takes_the_own_shares_along(world, db):
ada, ben, cem, room = world["ada"], world["ben"], world["cem"], world["room"]
ben.use_room(room)
bens = ben.request("POST", "/api/v1/cases", json={"title": "Bens Freigabe"}, status=201)
cem.request("GET", f"/api/v1/cases/{bens['id']}")
ada.request("PATCH", f"/api/v1/rooms/{room}/members/{_id(db, ben.email)}", json={"role": "reader"})
cem.request("GET", f"/api/v1/cases/{bens['id']}", status=404)
ben.request("GET", f"/api/v1/cases/{bens['id']}")
def test_the_bulk_action_and_the_exposure_count_own_entries(world, db):
ada, ben, room = world["ada"], world["ben"], world["room"]
old = ada.request("POST", "/api/v1/cases", json={"title": "Bestand"}, status=201)
db.execute("DELETE FROM room_shares WHERE resource_id = %s", (old["id"],))
db.commit()
ben.request("GET", f"/api/v1/cases/{old['id']}", status=404)
assert ada.request("GET", f"/api/v1/rooms/{room}/exposure")["cases"] == {"room": 0, "private": 1}
assert ada.request("POST", f"/api/v1/rooms/{room}/my-content/visibility", json={"visibility": "room"}) == {"changed": 1}
ben.request("GET", f"/api/v1/cases/{old['id']}")
assert ada.request("GET", f"/api/v1/rooms/{room}/exposure")["cases"] == {"room": 1, "private": 0}
ben.use_room(room)
theirs = ben.request("POST", "/api/v1/cases", json={"title": "Bens"}, status=201)
ada.request("POST", f"/api/v1/rooms/{room}/my-content/visibility", json={"visibility": "private"})
ben.request("GET", f"/api/v1/cases/{old['id']}", status=404)
ben.request("GET", f"/api/v1/cases/{theirs['id']}")
world["dan"].request("GET", f"/api/v1/rooms/{room}/exposure", status=403)
def test_a_room_can_start_without_sharing(client, db):
ada = _actor(client, db, "ada", "ada-start@example.test", main=True)
ben = _actor(client, db, "ben", "ben-start@example.test")
room = ada.request("POST", "/api/v1/rooms", json={"name": "Privat", "default_visibility": "private"}, status=201)
ada.use_room(room["id"])
case = ada.request("POST", "/api/v1/cases", json={"title": "Nur ich"}, status=201)
ada.request("POST", f"/api/v1/rooms/{room['id']}/members", json={"email": ben.email, "role": "member"})
ben.request("GET", f"/api/v1/cases/{case['id']}", status=404)
ada.request("PATCH", f"/api/v1/rooms/{room['id']}", json={"default_visibility": "room"})
other = ada.request("POST", "/api/v1/cases", json={"title": "Jetzt geteilt"}, status=201)
ben.request("GET", f"/api/v1/cases/{other['id']}")
ben.request("PATCH", f"/api/v1/rooms/{room['id']}", json={"default_visibility": "private"}, status=403)
def test_lists_tell_the_owner_what_is_shared_and_rooms_are_managed_from_any_room(world, db):
ada, ben, room = world["ada"], world["ben"], world["room"]
case = ada.request("POST", "/api/v1/cases", json={"title": "Liste"}, status=201)
item = next(i for i in ada.request("GET", "/api/v1/cases")["items"] if i["id"] == case["id"])
assert item["is_owner"] is True and [s["name"] for s in item["shared_with"]] == ["Werkstatt"]
seen = next(i for i in ben.request("GET", "/api/v1/cases")["items"] if i["id"] == case["id"])
assert seen["is_owner"] is False and seen["shared_with"] == []
matter = matter_of(ada, "Listenvorgang")
row = next(i for i in ada.request("GET", "/api/v1/matters")["items"] if i["id"] == matter["id"])
assert row["is_owner"] is True and [s["name"] for s in row["shared_with"]] == ["Werkstatt"]
# The owner manages the team while working in the personal room, without switching.
personal = Actor(ada.client, ada.email, ada.name)
body = personal.login()
assert body["scope"]["kind"] == "personal"
members = personal.request("GET", f"/api/v1/rooms/{room}/members")["items"]
assert {m["role"] for m in members} == {"manager", "member", "reader"}
personal.request("PATCH", f"/api/v1/rooms/{room}/members/{_id(db, ben.email)}", json={"role": "reader"})
personal.request("PATCH", f"/api/v1/rooms/{room}", json={"name": "Werkstatt neu"})
assert [r["name"] for r in personal.request("GET", "/api/v1/rooms")["items"] if r["id"] == room] == ["Werkstatt neu"]
def test_room_endpoints_are_closed_to_outsiders_and_do_not_reveal_which_ids_exist(world, db):
import uuid
ada, ben, cem, dan, room = world["ada"], world["ben"], world["cem"], world["dan"], world["room"]
foreign = str(uuid.uuid4())
dan_id = _id(db, dan.email)
ben_id = _id(db, ben.email)
attempts = [
("GET", "/members", None),
("POST", "/members", {"email": dan.email, "role": "manager"}),
("PATCH", f"/members/{ben_id}", {"role": "manager"}),
("DELETE", f"/members/{ben_id}", None),
("GET", "/invitations", None),
("PATCH", "", {"name": "Übernommen"}),
("POST", "/owner", {"subject_id": dan_id}),
("GET", "/exposure", None),
("POST", "/my-content/visibility", {"visibility": "room"}),
]
for method, suffix, body in attempts:
# Dan is no member, Cem is a reader, Ben a plain member: none of them administers the room.
for actor in (dan, cem, ben):
if method == "GET" and suffix == "/exposure" and actor in (cem, ben):
continue # members may read their own exposure counts
if method == "POST" and suffix == "/my-content/visibility" and actor is ben:
continue # members may share their own entries
actor.request(method, f"/api/v1/rooms/{room}{suffix}", json=body, status=403)
# A room that does not exist answers like a room that is closed to the caller.
dan.request(method, f"/api/v1/rooms/{foreign}{suffix.replace(ben_id, dan_id)}", json=body, status=403)
dan.request("POST", "/api/v1/invitations", json={"email": "x@example.test", "room_id": room}, status=403)
dan.request("POST", "/api/v1/invitations", json={"email": "x@example.test", "room_id": foreign}, status=403)
dan.request("GET", "/api/v1/admin/rooms", status=403)
dan.request("POST", f"/api/v1/admin/rooms/{room}/owner", json={"email": dan.email}, status=403)
dan.request("GET", "/api/v1/admin/events", status=403)
# Nothing changed.
members = ada.request("GET", f"/api/v1/rooms/{room}/members")["items"]
assert {m["email"]: m["role"] for m in members}[ben.email] == "member"
assert dan.email not in {m["email"] for m in members}
assert db.execute("SELECT name FROM data_rooms WHERE id = %s", (room,)).fetchone()["name"] == "Werkstatt"
db.rollback()