Files
tsumugu/backend/tests/test_owner_sources.py
T
LarsandCursor 75a3949f7c
Deploy Development / deploy (push) Successful in 26s
Test Suite / pytest-backend (push) Successful in 1m51s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 9s
Erlaube berechtigten Konten, verknüpfte Originale über die Zugänge des Owners zu lesen.
Co-authored-by: Cursor <cursoragent@cursor.com>
2026-10-18 21:47:30 +02:00

452 lines
17 KiB
Python

"""Granted readers see linked originals only through the owner's stored connector."""
from __future__ import annotations
import json
import app.sources as sources
from tests.support import ORIGIN, Actor, register
OWNER_TOKEN = "owner-paperless-token"
GRANTEE_TOKEN = "grantee-paperless-token"
OWNER_MAIL = "owner-postfach-geheim"
GRANTEE_MAIL = "grantee-postfach-geheim"
UNAVAILABLE = "Das Original ist über die Freigabe nicht abrufbar."
class RecordingIMAP:
logins: list[str] = []
fetches: list[int] = []
def __init__(self, *args, **kwargs):
pass
def login(self, username, secret):
RecordingIMAP.logins.append(secret)
return "OK", [b"logged"]
def list(self):
return "OK", [b'(\\HasNoChildren) "/" "INBOX"']
def select(self, mailbox, readonly=False):
return "OK", [b"5"]
def uid(self, command, *args):
if command == "SEARCH":
return "OK", [b""]
uid = int(args[0])
spec = " ".join(str(part) for part in args[1:])
if "BODY.PEEK[]" in spec:
RecordingIMAP.fetches.append(uid)
raw = (
f"From: Ada Beispiel <ada@example.test>\r\n"
f"To: Kanzlei <kanzlei@example.test>\r\n"
f"Subject: Nachricht {uid}\r\n"
f"Date: Thu, 02 May 2024 08:00:00 +0000\r\n"
f"Message-ID: <{uid}@example.test>\r\n"
f"MIME-Version: 1.0\r\n"
f'Content-Type: multipart/mixed; boundary="grenze"\r\n'
f"\r\n"
f"--grenze\r\n"
f"Content-Type: text/plain; charset=utf-8\r\n"
f"\r\n"
f"Bitte die Einwendung pruefen.\r\n"
f"--grenze\r\n"
f"Content-Type: application/pdf\r\n"
f'Content-Disposition: attachment; filename="einwendung.pdf"\r\n'
f"\r\n"
f"%PDF\r\n"
f"--grenze--\r\n"
).encode()
return "OK", [(b"rfc822", raw)]
return "OK", [(b"body", b"From: Ada\r\n"), b")"]
def logout(self):
return "BYE", [b""]
def _reset_imap():
RecordingIMAP.logins = []
RecordingIMAP.fetches = []
def _paperless(actor: Actor, token: str, name: str) -> str:
return actor.request(
"POST",
"/api/v1/connectors",
json={"kind": "paperless", "name": name, "base_url": "https://paper.example.test", "token": token},
status=201,
)["id"]
def _mailbox(actor: Actor, password: str, name: str) -> str:
return actor.request(
"POST",
"/api/v1/connectors",
json={
"kind": "imap",
"name": name,
"host": "imap.example.test",
"port": 993,
"username": f"{name}@example.test",
"password": password,
"security": "ssl",
},
status=201,
)["id"]
def _raw(actor: Actor, path: str):
return actor.client.get(
path,
headers={
"Origin": ORIGIN,
"X-CSRF-Token": actor.csrf,
"X-Scope-Kind": actor.scope["kind"],
"X-Scope-Id": actor.scope["id"],
},
)
def _grant(actor: Actor, kind: str, resource_id: str, email: str, **flags):
body = {"email": email, "can_read": True, "can_edit": False, "can_share": False, "use_owner_sources": False}
body.update(flags)
return actor.request("POST", f"/api/v1/{kind}/{resource_id}/grants", json=body, status=201)
def _events(db):
return db.execute(
"""
SELECT action, result, detail
FROM domain_events
WHERE action = 'source_read_mediated'
ORDER BY occurred_at, id
"""
).fetchall()
def test_owner_alone_sets_source_access_and_a_delegate_cannot_change_it(client, db):
ada = Actor(client, "ada-flag@example.test", "Ada Flag")
ben = Actor(client, "ben-flag@example.test", "Ben Flag")
cleo = Actor(client, "cleo-flag@example.test", "Cleo Flag")
register(db, ada.email, ada.name)
register(db, ben.email, ben.name)
register(db, cleo.email, cleo.name)
ada.login()
case = ada.request("POST", "/api/v1/cases", json={"title": "Streit"}, status=201)
_grant(ada, "cases", case["id"], ben.email, can_share=True, use_owner_sources=True)
ada_view = ada.request("GET", f"/api/v1/cases/{case['id']}")
ben_grant = next(item for item in ada_view["grants"] if item["email"] == ben.email)
assert ben_grant["use_owner_sources"] is True
ben.login()
_grant(ben, "cases", case["id"], cleo.email, use_owner_sources=True)
ada.login()
after_delegate = ada.request("GET", f"/api/v1/cases/{case['id']}")
cleo_grant = next(item for item in after_delegate["grants"] if item["email"] == cleo.email)
assert cleo_grant["use_owner_sources"] is False
_grant(ada, "cases", case["id"], cleo.email, use_owner_sources=True)
ben.login()
_grant(ben, "cases", case["id"], cleo.email, can_share=True, use_owner_sources=False)
ada.login()
kept = ada.request("GET", f"/api/v1/cases/{case['id']}")
cleo_grant = next(item for item in kept["grants"] if item["email"] == cleo.email)
assert cleo_grant["can_share"] is True
assert cleo_grant["use_owner_sources"] is True
_grant(ada, "cases", case["id"], cleo.email, use_owner_sources=False)
cleared = ada.request("GET", f"/api/v1/cases/{case['id']}")
cleo_grant = next(item for item in cleared["grants"] if item["email"] == cleo.email)
assert cleo_grant["use_owner_sources"] is False
def test_grantee_reads_linked_originals_only_through_the_owner(client, db, monkeypatch):
calls = []
def fake_file(base, token, path, max_bytes=40 * 1024 * 1024):
calls.append({"token": token, "path": path})
if path.endswith("/preview/"):
return (b"%PDF-1.4\nverknuepft\n", "application/pdf", "vertrag.pdf")
return None
def fake_get(base, token, path, params):
calls.append({"token": token, "path": path, "query": params.get("query")})
if token == OWNER_TOKEN:
return {"count": 1, "results": [{"id": 15, "title": "Geheimes Archivdokument", "created": "2026-01-01"}]}
return {"count": 0, "results": []}
monkeypatch.setattr(sources, "_paperless_file", fake_file)
monkeypatch.setattr(sources, "_paperless_get", fake_get)
monkeypatch.setattr(sources, "_paperless_metadata", lambda *args, **kwargs: None)
monkeypatch.setattr(sources.imaplib, "IMAP4_SSL", RecordingIMAP)
_reset_imap()
ada = Actor(client, "ada-quelle@example.test", "Ada Quelle")
ben = Actor(client, "ben-quelle@example.test", "Ben Quelle")
register(db, ada.email, ada.name)
register(db, ben.email, ben.name)
ada.login()
paper = _paperless(ada, OWNER_TOKEN, "Ada Archiv")
mailbox = _mailbox(ada, OWNER_MAIL, "Ada Post")
case = ada.request("POST", "/api/v1/cases", json={"title": "Akte"}, status=201)
matter = ada.request("POST", "/api/v1/matters", json={"title": "Vorgang"}, status=201)
other = ada.request("POST", "/api/v1/matters", json={"title": "Fremder Vorgang"}, status=201)
document = ada.request(
"POST",
"/api/v1/external-refs",
json={
"title": "Vertrag",
"source": "paperless",
"external_id": "15",
"context": {"kind": "case", "id": case["id"]},
"detail": {"connector_id": paper, "correspondent": "Hausverwaltung"},
},
status=201,
)
letter = ada.request(
"POST",
"/api/v1/external-refs",
json={
"title": "Einwendung",
"source": "imap",
"external_id": "<2@example.test>",
"context": {"kind": "matter", "id": matter["id"]},
"detail": {
"connector_id": mailbox,
"mailbox": "INBOX",
"uid": 2,
"direction": "in",
"message_from": "Hausverwaltung",
},
},
status=201,
)
owner_file = _raw(ada, f"/api/v1/external-refs/{document['id']}/content?context_kind=case&context_id={case['id']}")
assert owner_file.status_code == 200
assert owner_file.content.startswith(b"%PDF")
assert calls[-1]["token"] == OWNER_TOKEN
assert "/api/documents/15/" in calls[-1]["path"]
owner_mail = ada.request(
"GET",
f"/api/v1/external-refs/{letter['id']}/mail",
params={"context_kind": "matter", "context_id": matter["id"]},
)
assert "Einwendung" in owner_mail["text"]
assert OWNER_MAIL in RecordingIMAP.logins
calls.clear()
_reset_imap()
ben.login()
_paperless(ben, GRANTEE_TOKEN, "Ben Archiv")
_mailbox(ben, GRANTEE_MAIL, "Ben Post")
ada.login()
_grant(ada, "cases", case["id"], ben.email)
_grant(ada, "matters", matter["id"], ben.email)
_grant(ada, "matters", other["id"], ben.email, use_owner_sources=True)
ben.login()
shown = ben.request("GET", f"/api/v1/matters/{matter['id']}")
visible = next(item for item in shown["bindings"] if item["element"]["title"] == "Einwendung")
detail = visible["element"]["external"]["detail"]
assert detail["direction"] == "in"
assert detail["message_from"] == "Hausverwaltung"
assert "connector_id" not in detail
assert "mailbox" not in detail
assert "uid" not in detail
assert "external_id" not in visible["element"]["external"]
dumped = json.dumps(shown)
assert OWNER_MAIL not in dumped
assert OWNER_TOKEN not in dumped
assert "imap.example.test" not in dumped
assert mailbox not in dumped
hidden = ben.request(
"GET",
f"/api/v1/external-refs/{document['id']}/content",
params={"context_kind": "case", "context_id": case["id"], "document": "999"},
status=422,
)
assert hidden["detail"] == UNAVAILABLE
assert calls == []
missed = ben.request(
"GET",
f"/api/v1/external-refs/{letter['id']}/mail",
params={"context_kind": "matter", "context_id": matter["id"], "uid": "9", "mailbox": "Geheim"},
status=422,
)
assert missed["detail"] == UNAVAILABLE
assert RecordingIMAP.logins == []
assert RecordingIMAP.fetches == []
ada.login()
_grant(ada, "cases", case["id"], ben.email, use_owner_sources=True)
_grant(ada, "matters", matter["id"], ben.email, use_owner_sources=True)
ben.login()
opened = _raw(
ben,
f"/api/v1/external-refs/{document['id']}/content?context_kind=case&context_id={case['id']}&document=999",
)
assert opened.status_code == 200
assert opened.content.startswith(b"%PDF")
assert opened.headers["x-content-type-options"] == "nosniff"
assert opened.headers["cache-control"] == "private, no-store"
assert opened.headers["referrer-policy"] == "no-referrer"
assert calls == [{"token": OWNER_TOKEN, "path": "/api/documents/15/preview/"}]
assert GRANTEE_TOKEN not in json.dumps(calls)
search = ben.request("GET", "/api/v1/sources/paperless/documents", params={"q": "Geheim"})
assert "Geheimes Archivdokument" not in json.dumps(search)
assert all(item["token"] != OWNER_TOKEN for item in calls if "query" in item)
mail = ben.request(
"GET",
f"/api/v1/external-refs/{letter['id']}/mail",
params={"context_kind": "matter", "context_id": matter["id"], "uid": "9", "connector_id": paper},
)
assert mail["text"] == "Bitte die Einwendung pruefen."
assert mail["attachments"][0]["filename"] == "einwendung.pdf"
assert RecordingIMAP.logins == [OWNER_MAIL]
assert RecordingIMAP.fetches == [2]
original = _raw(
ben,
f"/api/v1/external-refs/{letter['id']}/mail/original?context_kind=matter&context_id={matter['id']}",
)
assert original.status_code == 200
assert b"Message-ID: <2@example.test>" in original.content
attachment = _raw(
ben,
f"/api/v1/external-refs/{letter['id']}/mail/attachments/0?context_kind=matter&context_id={matter['id']}",
)
assert attachment.status_code == 200
assert attachment.content.startswith(b"%PDF")
assert attachment.headers["content-disposition"].startswith("inline;")
assert GRANTEE_MAIL not in RecordingIMAP.logins
page = ben.request("GET", f"/api/v1/matters/{matter['id']}/chronology")
chronology = json.dumps(page)
assert "source_read_mediated" in [item["action"] for item in page["items"]]
assert "Verknüpftes Original gelesen" in [item["label"] for item in page["items"]]
assert mailbox not in chronology
assert OWNER_MAIL not in chronology
quiet = len(RecordingIMAP.logins)
ben.request("GET", "/api/v1/sources/imap/mailboxes", params={"connector_id": mailbox}, status=404)
ben.request(
"GET",
f"/api/v1/external-refs/{letter['id']}/mail",
params={"context_kind": "matter", "context_id": other["id"]},
status=404,
)
ada.login()
ada.request(
"PUT",
"/api/v1/exceptions",
json={
"resource_kind": "element",
"resource_id": letter["id"],
"context": {"kind": "matter", "id": matter["id"]},
"remove_read": True,
},
)
grant_id = next(item["id"] for item in ada.request("GET", f"/api/v1/cases/{case['id']}")["grants"])
ben.login()
ben.request(
"GET",
f"/api/v1/external-refs/{letter['id']}/mail",
params={"context_kind": "matter", "context_id": matter["id"]},
status=404,
)
assert len(RecordingIMAP.logins) == quiet
ada.login()
ada.request("DELETE", f"/api/v1/grants/{grant_id}", status=204)
ben.login()
ben.request(
"GET",
f"/api/v1/external-refs/{document['id']}/content",
params={"context_kind": "case", "context_id": case["id"]},
status=404,
)
assert len(RecordingIMAP.logins) == quiet
assert [item["token"] for item in calls if "query" not in item] == [OWNER_TOKEN]
rows = _events(db)
blob = json.dumps(rows, default=str)
assert OWNER_TOKEN not in blob
assert OWNER_MAIL not in blob
assert "Bitte die Einwendung" not in blob
assert "imap.example.test" not in blob
assert any(row["result"] == "ok" and row["detail"]["source"] == "paperless" for row in rows)
assert any(row["result"] == "ok" and row["detail"]["connector_id"] == mailbox for row in rows)
def test_deleted_or_foreign_connector_is_not_used(client, db, monkeypatch):
calls = []
monkeypatch.setattr(
sources,
"_paperless_file",
lambda *args, **kwargs: calls.append("paperless") or (b"%PDF-1.4\n", "application/pdf", "x.pdf"),
)
monkeypatch.setattr(sources.imaplib, "IMAP4_SSL", RecordingIMAP)
_reset_imap()
ada = Actor(client, "ada-weg@example.test", "Ada Weg")
ben = Actor(client, "ben-weg@example.test", "Ben Weg")
cleo = Actor(client, "cleo-weg@example.test", "Cleo Weg")
register(db, ada.email, ada.name)
register(db, ben.email, ben.name)
register(db, cleo.email, cleo.name)
ada.login()
paper = _paperless(ada, OWNER_TOKEN, "Ada Archiv")
ben.login()
foreign = _mailbox(ben, GRANTEE_MAIL, "Ben Post")
ada.login()
matter = ada.request("POST", "/api/v1/matters", json={"title": "Vorgang"}, status=201)
document = ada.request(
"POST",
"/api/v1/external-refs",
json={
"title": "Scan",
"source": "paperless",
"external_id": "15",
"context": {"kind": "matter", "id": matter["id"]},
"detail": {"connector_id": paper},
},
status=201,
)
foreign_mail = ada.request(
"POST",
"/api/v1/external-refs",
json={
"title": "Fremde Quelle",
"source": "imap",
"external_id": "<2@example.test>",
"context": {"kind": "matter", "id": matter["id"]},
"detail": {"connector_id": foreign, "mailbox": "INBOX", "uid": 2},
},
status=201,
)
_grant(ada, "matters", matter["id"], cleo.email, use_owner_sources=True)
ada.request("DELETE", f"/api/v1/connectors/{paper}", status=204)
cleo.login()
blocked = cleo.request(
"GET",
f"/api/v1/external-refs/{document['id']}/content",
params={"context_kind": "matter", "context_id": matter["id"]},
status=422,
)
assert blocked["detail"] == UNAVAILABLE
assert "paper.example.test" not in blocked["detail"]
assert calls == []
refused = cleo.request(
"GET",
f"/api/v1/external-refs/{foreign_mail['id']}/mail",
params={"context_kind": "matter", "context_id": matter["id"]},
status=422,
)
assert refused["detail"] == UNAVAILABLE
assert RecordingIMAP.logins == []
rows = _events(db)
assert rows
assert all(row["result"] == "unavailable" for row in rows)
assert OWNER_TOKEN not in json.dumps(rows, default=str)
assert GRANTEE_MAIL not in json.dumps(rows, default=str)