Files
tsumugu/backend/tests/test_room_access.py
T
LarsandClaude Sonnet 5.5 e47f50d513
Deploy Development / deploy (push) Successful in 42s
Test Suite / pytest-backend (push) Successful in 4m57s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 21s
Verhindere, dass Raum-Endpunkte verraten, welche Raum-IDs es gibt, und sichere sie mit einem Test gegen Außenstehende ab.
Unbekannte und fremde Räume antworten bei Mitglieder-, Einladungs-, Eigentümer- und Freigabe-Aktionen gleich mit 403. Der neue Test prüft alle Raum-Endpunkte als Außenstehender, Leser und Mitglied.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-21 14:44:30 +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 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 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()