378 lines
22 KiB
Python
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, "download": True,
|
|
}
|
|
assert cem.request("GET", f"/api/v1/cases/{shared['id']}")["rights"] == {
|
|
"read": True, "edit": False, "share": False, "delete": False, "download": True,
|
|
}
|
|
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, "download": True,
|
|
}
|
|
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()
|