Files
tsumugu/backend/tests/test_export.py
T
LarsandCursor 60a76803e1
Deploy Development / deploy (push) Successful in 27s
Test Suite / pytest-backend (push) Failing after 1m45s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 9s
Passe Export-Tests an TOC-Anker und nummerierte Pfade an.
Links in der Übersicht dürfen Fragment-Anker nutzen; Pfadassertions und Versionsstände folgen der einheitlichen Nummerierung und der Auswahl nur exportierbarer Blattknoten.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-10-18 15:09:05 +02:00

1067 lines
40 KiB
Python

"""Handover package: hierarchy, complete mail, source identity, rights, failures."""
from __future__ import annotations
import io
import json
import zipfile
from email.message import EmailMessage
from urllib.parse import unquote, urljoin
import pytest
from app.core.errors import Problem
from app.mailpack import choose_message, parse_mail
from app.sources import pull_paperless_original
from tests.support import ORIGIN, Actor, document, grant, register
PDF_A = b"%PDF-1.4\n1 0 obj<<>>endobj\ntrailer<<>>\n%%EOF\nA\n"
PDF_B = b"%PDF-1.4\n2 0 obj<<>>endobj\ntrailer<<>>\n%%EOF\nB\n"
PDF_C = b"%PDF-1.4\n3 0 obj<<>>endobj\ntrailer<<>>\n%%EOF\nC\n"
def _eml(message_id: str, body: str, attachments: list[tuple[str, bytes]], subject: str = "Schreiben") -> bytes:
message = EmailMessage()
message["Subject"] = subject
message["From"] = "kanzlei@example.test"
message["To"] = "ada@example.test"
message["Message-ID"] = message_id
message["Date"] = "Thu, 12 Mar 2026 10:00:00 +0100"
message.set_content(body)
for name, data in attachments:
message.add_attachment(data, maintype="application", subtype="pdf", filename=name)
return message.as_bytes()
def _walk(node):
yield node
for child in node.get("children") or []:
yield from _walk(child)
def _parents(node, parent=None, found=None):
found = found if found is not None else {}
found[node["id"]] = parent
for child in node.get("children") or []:
_parents(child, node, found)
return found
def _under(node_id: str, title: str, parents: dict) -> bool:
current = parents.get(node_id)
while current is not None:
if current.get("title") == title:
return True
current = parents.get(current["id"])
return False
def _post_zip(actor: Actor, matter_id: str, body: dict):
headers = {
"Origin": ORIGIN,
"X-CSRF-Token": actor.csrf,
"Content-Type": "application/json",
"X-Scope-Kind": actor.scope["kind"],
"X-Scope-Id": actor.scope["id"],
}
return actor.client.post(f"/api/v1/matters/{matter_id}/export", json=body, headers=headers)
def _archive(blob: bytes) -> zipfile.ZipFile:
return zipfile.ZipFile(io.BytesIO(blob))
def _joined(archive: zipfile.ZipFile) -> str:
parts = []
for name in archive.namelist():
parts.append(name)
if name.endswith((".md", ".html", ".eml")):
parts.append(archive.read(name).decode("utf-8", errors="replace"))
return "\n".join(parts)
def _links_resolve(archive: zipfile.ZipFile) -> None:
html = archive.read("index.html").decode("utf-8")
names = set(archive.namelist())
for chunk in html.split('href="')[1:]:
href = unquote(chunk.split('"', 1)[0])
if href.startswith("#"):
continue
assert href in names, href
for name in archive.namelist():
if not name.endswith(".md"):
continue
text = archive.read(name).decode("utf-8")
base = name.rsplit("/", 1)[0] + "/" if "/" in name else ""
for chunk in text.split("](")[1:]:
href = unquote(chunk.split(")", 1)[0])
if href.startswith("http") or href.startswith("#"):
continue
target = urljoin(base, href)
assert target in names, (name, href, target)
def test_duplicate_attachments_stay_distinct_and_identity_is_exact():
raw = _eml("<same@example.test>", "Volltext", [("lage.pdf", PDF_A), ("lage.pdf", PDF_B)])
parsed = parse_mail(raw)
assert [item.filename for item in parsed.attachments] == ["lage.pdf", "lage (2).pdf"]
assert parsed.attachments[0].data == PDF_A
assert parsed.attachments[1].data == PDF_B
assert parsed.text == "Volltext"
right = _eml("<right@example.test>", "richtig", [])
wrong = _eml("<wrong@example.test>", "falsch", [])
assert choose_message(right, [wrong], "<right@example.test>") == right
assert choose_message(wrong, [right], "<right@example.test>") == right
with pytest.raises(Exception, match="mehrdeutig"):
choose_message(wrong, [right, right], "<right@example.test>")
with pytest.raises(Exception, match="nicht eindeutig"):
choose_message(wrong, [], "uid:INBOX:4")
bare = _eml("", "ohne id", [])
# A message built without Message-ID still matches a stored uid fallback.
assert choose_message(bare, [], "uid:INBOX:4") == bare
def test_paperless_original_never_uses_preview(monkeypatch):
calls = []
def fake_file(base, token, path, max_bytes=40 * 1024 * 1024):
calls.append(path)
return None
monkeypatch.setattr("app.sources._paperless_file", fake_file)
monkeypatch.setattr("app.sources._paperless_metadata", lambda *args, **kwargs: None)
with pytest.raises(Problem, match="gibt es in Paperless nicht"):
pull_paperless_original("http://paper.example", "token", "15", 1000)
assert calls == ["/api/documents/15/download/"]
def test_handover_package_follows_the_confirmed_selection(client, db, monkeypatch):
raw = _eml(
"<export-brief@example.test>",
"Der vollständige Brieftext bleibt erhalten.",
[("lage.pdf", PDF_A), ("lage.pdf", PDF_B)],
)
monkeypatch.setattr("app.retrieval.pull_rfc822", lambda *args, **kwargs: raw)
monkeypatch.setattr(
"app.retrieval.pull_paperless_original",
lambda *args, **kwargs: (PDF_B, "application/pdf", "archiv.pdf"),
)
ada = Actor(client, "ada-export@example.test", "Ada Export")
register(db, ada.email, ada.name)
ada.login()
matter = ada.request("POST", "/api/v1/matters", json={"title": "Schaden"}, status=201)
vertrag = ada.request("POST", f"/api/v1/matters/{matter['id']}/chapters", json={"title": "Vertrag"}, status=201)
schrift = ada.request("POST", f"/api/v1/matters/{matter['id']}/chapters", json={"title": "Schrift"}, status=201)
note = ada.request(
"POST",
"/api/v1/notes",
json={
"title": "Vertragnotiz",
"document": document("Nur der Vertrag"),
"context": {"kind": "matter", "id": matter["id"]},
"chapter_id": vertrag["id"],
},
status=201,
)
ada.request(
"POST",
"/api/v1/files",
data={"title": "Einzeldatei", "context_kind": "matter", "context_id": matter["id"], "chapter_id": vertrag["id"]},
files={"upload": ("einzel.pdf", PDF_C, "application/pdf")},
status=201,
)
ada.request(
"POST",
"/api/v1/files",
data={"title": "Schreiben-Datei", "context_kind": "matter", "context_id": matter["id"], "chapter_id": schrift["id"]},
files={"upload": ("schreiben.pdf", PDF_C, "application/pdf")},
status=201,
)
ada.request(
"POST",
"/api/v1/notes",
json={
"title": "Randnotiz",
"document": document("Randwort bleibt draussen"),
"context": {"kind": "matter", "id": matter["id"]},
"chapter_id": schrift["id"],
},
status=201,
)
child = ada.request(
"POST",
"/api/v1/matters",
json={"title": "Nebenpunkt", "parent_matter_id": matter["id"]},
status=201,
)
ada.request(
"POST",
"/api/v1/notes",
json={
"title": "Teilnotiz",
"document": document("Im Teilvorgang"),
"context": {"kind": "matter", "id": child["id"]},
},
status=201,
)
mailbox = ada.request(
"POST",
"/api/v1/connectors",
json={
"kind": "imap",
"name": "Postfach",
"host": "mail.example.test",
"username": "ada",
"password": "secret-pass",
},
status=201,
)
ada.request(
"POST",
"/api/v1/connectors",
json={
"kind": "paperless",
"name": "Archiv",
"base_url": "http://paper.example",
"token": "paperless-token",
},
status=201,
)
ada.request(
"POST",
"/api/v1/external-refs",
json={
"title": "Schreiben mit Anlagen",
"source": "imap",
"external_id": "<export-brief@example.test>",
"context": {"kind": "matter", "id": matter["id"]},
"detail": {"connector_id": mailbox["id"], "mailbox": "INBOX", "uid": 9},
},
status=201,
)
ada.request(
"POST",
"/api/v1/external-refs",
json={
"title": "Archivstück",
"source": "paperless",
"external_id": "15",
"context": {"kind": "matter", "id": matter["id"]},
"chapter_id": vertrag["id"],
},
status=201,
)
ada.request(
"POST",
"/api/v1/files",
data={"title": "Gespiegelte Anlage", "context_kind": "matter", "context_id": matter["id"]},
files={"upload": ("lage.pdf", PDF_A, "application/pdf")},
status=201,
)
ada.request(
"POST",
"/api/v1/files",
data={"title": "Nur der Name", "context_kind": "matter", "context_id": matter["id"]},
files={"upload": ("lage.pdf", PDF_C, "application/pdf")},
status=201,
)
first = ada.request(
"POST",
"/api/v1/notes",
json={
"title": "Anschreiben",
"document": document("Erstes Schreiben"),
"context": {"kind": "matter", "id": matter["id"]},
"communication_direction": "in",
"dates": {"document_on": "2026-03-12"},
},
status=201,
)
reply = ada.request(
"POST",
"/api/v1/notes",
json={
"title": "Antwort",
"document": document("Spätere Antwort"),
"context": {"kind": "matter", "id": matter["id"]},
"communication_direction": "out",
"dates": {"document_on": "2026-05-18"},
},
status=201,
)
ada.request(
"POST",
f"/api/v1/elements/{reply['id']}/references",
json={"refers_to_element_id": first["id"], "context": {"kind": "matter", "id": matter["id"]}},
status=204,
)
foreign_parent = ada.request("POST", "/api/v1/matters", json={"title": "Fremder Rahmen"}, status=201)
foreign = ada.request(
"POST",
"/api/v1/matters",
json={"title": "Fremder Vorgang", "parent_matter_id": foreign_parent["id"]},
status=201,
)
ada.request(
"POST",
"/api/v1/notes",
json={
"title": "Fremdtext",
"document": document("Nicht mitnehmen"),
"context": {"kind": "matter", "id": foreign["id"]},
},
status=201,
)
ada.request(
"POST",
f"/api/v1/matters/{matter['id']}/cross-links",
json={
"target_matter_id": foreign["id"],
"target_context": {"kind": "matter", "id": foreign_parent["id"]},
},
status=201,
)
detail = ada.request("GET", f"/api/v1/matters/{matter['id']}")
note_binding = next(item["id"] for item in detail["bindings"] if item["element"]["title"] == "Vertragnotiz")
ada.request(
"POST",
f"/api/v1/bindings/{note_binding}/annotations",
json={"body": "Kontextvermerk speziell"},
status=201,
)
tree = ada.request("GET", f"/api/v1/matters/{matter['id']}/export-tree")["tree"]
flat = list(_walk(tree))
parents = _parents(tree)
assert "Fremdtext" not in json.dumps(tree)
by_title = {}
for node in flat:
by_title.setdefault(node["title"], []).append(node)
schrift_ids = {
node["id"]
for node in flat
if node["kind"] in {"binding", "annotation"} and _under(node["id"], "Schrift", parents)
}
selected = {node["id"] for node in flat if node["kind"] in {"binding", "annotation"} and node["exportable"]}
selected -= schrift_ids
selected.add(next(node["id"] for node in by_title["Schreiben-Datei"]))
mirrored = next(node["id"] for node in by_title["Gespiegelte Anlage"])
name_only = next(node["id"] for node in by_title["Nur der Name"])
selected.discard(mirrored)
selected.discard(name_only)
body = {"context": {"kind": "matter", "id": matter["id"]}, "selected": sorted(selected)}
review = ada.request("POST", f"/api/v1/matters/{matter['id']}/export/review", json=body)
assert review["ready"] is True
assert any("bleibt Bestandteil" in item["message"] for item in review["notices"])
assert all("Nur der Name" not in item["message"] for item in review["notices"])
response = _post_zip(ada, matter["id"], body)
assert response.status_code == 200, response.text
archive = _archive(response.content)
names = archive.namelist()
assert "index.html" in names and "inhalt.md" in names
assert any(name.startswith("01 Vertrag/") for name in names)
assert any("02 Schrift/01 Schreiben-Datei/Schreiben-Datei.pdf" in name.replace("\\", "/") for name in names)
assert any("Nebenpunkt" in name and name.endswith("Teilnotiz.md") for name in names)
mail_names = [name for name in names if "Schreiben mit Anlagen" in name]
assert any(name.endswith("/nachricht.eml") for name in mail_names)
assert sorted(name.rsplit("/", 1)[-1] for name in mail_names if "/anlagen/" in name) == ["lage (2).pdf", "lage.pdf"]
assert archive.read(next(name for name in mail_names if name.endswith("/anlagen/lage.pdf"))) == PDF_A
assert archive.read(next(name for name in mail_names if name.endswith("/anlagen/lage (2).pdf"))) == PDF_B
whole = _joined(archive)
assert "Der vollständige Brieftext bleibt erhalten." in whole
assert "Randwort bleibt draussen" not in whole
assert "Gespiegelte Anlage" not in whole
assert "Fremdtext" not in whole
assert "bleibt Bestandteil" in whole
note_file = next(name for name in names if name.endswith("/01 Vertragnotiz/Vertragnotiz.md"))
annotation_file = next(name for name in names if "Anmerkung zu Vertragnotiz" in name)
assert "Kontextvermerk speziell" not in archive.read(note_file).decode("utf-8")
assert "Kontextvermerk speziell" in archive.read(annotation_file).decode("utf-8")
assert "Anschreiben" in whole and "Antwort auf" in whole
assert "Erzeugt am" in archive.read("index.html").decode("utf-8")
assert "Fachdatum: 2026-03-12" in whole
assert "Nur der Vertrag" in whole
_links_resolve(archive)
reply_only = {
"context": body["context"],
"selected": [node["id"] for node in by_title["Antwort"]],
}
narrowed = _post_zip(ada, matter["id"], reply_only)
assert narrowed.status_code == 200, narrowed.text
assert "Anschreiben" not in _joined(_archive(narrowed.content))
changed = ada.request(
"PATCH",
f"/api/v1/notes/{note['id']}",
json={
"expected_version": note["version"],
"document": document("Neutext der Notiz"),
"context": {"kind": "matter", "id": matter["id"]},
},
)
ada.request(
"POST",
"/api/v1/notes",
json={
"title": "Später ergänzt",
"document": document("Darf nicht still hinein"),
"context": {"kind": "matter", "id": matter["id"]},
},
status=201,
)
assert "Neutext der Notiz" not in whole
assert "Später ergänzt" not in whole
again = _post_zip(ada, matter["id"], body)
assert again.status_code == 200, again.text
second = _joined(_archive(again.content))
assert "Neutext der Notiz" in second
assert "Später ergänzt" not in second
assert changed["version"] == note["version"] + 1
def test_export_names_gaps_and_hides_unreadable_counterparts(client, db, monkeypatch):
ada = Actor(client, "ada-gap@example.test", "Ada Gap")
ben = Actor(client, "ben-gap@example.test", "Ben Gap")
register(db, ada.email, ada.name)
register(db, ben.email, ben.name)
ada.login()
case = ada.request("POST", "/api/v1/cases", json={"title": "Freigabeakte"}, status=201)
matter = ada.request("POST", "/api/v1/matters", json={"title": "Geteilt"}, status=201)
ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": case["id"]}, status=201)
visible = ada.request(
"POST",
"/api/v1/notes",
json={"title": "Sichtbare Notiz", "document": document("Sichtbar"), "context": {"kind": "matter", "id": matter["id"]}},
status=201,
)
hidden = ada.request(
"POST",
"/api/v1/notes",
json={"title": "GeheimtitelXQ", "document": document("Verborgen"), "context": {"kind": "matter", "id": matter["id"]}},
status=201,
)
ada.request(
"POST",
f"/api/v1/elements/{visible['id']}/references",
json={"refers_to_element_id": hidden["id"], "context": {"kind": "matter", "id": matter["id"]}},
status=204,
)
ada.request(
"PUT",
"/api/v1/exceptions",
json={
"resource_kind": "element",
"resource_id": hidden["id"],
"context": {"kind": "case", "id": case["id"]},
"remove_read": True,
},
)
first = ada.request(
"POST",
"/api/v1/connectors",
json={"kind": "imap", "name": "Alt", "host": "mail.example.test", "username": "ada", "password": "secret-pass"},
status=201,
)
second = ada.request(
"POST",
"/api/v1/connectors",
json={"kind": "imap", "name": "Neu", "host": "mail.example.test", "username": "ada", "password": "secret-pass"},
status=201,
)
ada.request(
"POST",
"/api/v1/external-refs",
json={
"title": "Verwaiste Post",
"source": "imap",
"external_id": "<stored@example.test>",
"context": {"kind": "matter", "id": matter["id"]},
"detail": {"connector_id": first["id"], "mailbox": "INBOX", "uid": 3},
},
status=201,
)
ada.request("DELETE", f"/api/v1/connectors/{first['id']}", status=204)
ada.request(
"POST",
"/api/v1/connectors",
json={"kind": "imap", "name": "Weiter", "host": "mail.example.test", "username": "ada", "password": "secret-pass"},
status=201,
)
calls = []
def pull(*args, **kwargs):
calls.append(args)
return _eml("<stored@example.test>", "darf nicht ersatzweise kommen", [])
monkeypatch.setattr("app.retrieval.pull_rfc822", pull)
context = {"kind": "case", "id": case["id"]}
tree = ada.request(
"GET",
f"/api/v1/matters/{matter['id']}/export-tree",
params={"context_kind": "case", "context_id": case["id"]},
)["tree"]
assert "GeheimtitelXQ" not in json.dumps(tree)
leaves = [node for node in _walk(tree) if node["kind"] in {"binding", "annotation"}]
visible_node = next(node for node in leaves if node["title"] == "Sichtbare Notiz")
orphan = next(node for node in leaves if node["title"] == "Verwaiste Post")
review = ada.request(
"POST",
f"/api/v1/matters/{matter['id']}/export/review",
json={"context": context, "selected": [visible_node["id"], orphan["id"]]},
)
assert review["ready"] is False
assert any(item["code"] == "reference" for item in review["issues"])
assert any(item["code"] == "missing" for item in review["issues"])
blob = json.dumps(review)
assert "GeheimtitelXQ" not in blob
assert calls == []
assert second["id"] not in blob
failed = _post_zip(ada, matter["id"], {"context": context, "selected": [visible_node["id"], orphan["id"]]})
assert failed.status_code == 422
assert "GeheimtitelXQ" not in failed.text
assert failed.headers["content-type"].startswith("application/problem+json") or "problem" in failed.headers["content-type"]
ambiguous = ada.request(
"POST",
"/api/v1/external-refs",
json={
"title": "Ohne Zugang",
"source": "imap",
"external_id": "<offen@example.test>",
"context": {"kind": "matter", "id": matter["id"]},
"detail": {"mailbox": "INBOX", "uid": 8},
},
status=201,
)
del ambiguous
tree = ada.request(
"GET",
f"/api/v1/matters/{matter['id']}/export-tree",
params={"context_kind": "case", "context_id": case["id"]},
)["tree"]
open_mail = next(node for node in _walk(tree) if node["title"] == "Ohne Zugang")
pending = ada.request(
"POST",
f"/api/v1/matters/{matter['id']}/export/review",
json={"context": context, "selected": [open_mail["id"]]},
)
assert pending["issues"][0]["code"] == "ambiguous"
assert {item["name"] for item in pending["issues"][0]["choices"]} == {"Neu", "Weiter"}
monkeypatch.setattr("app.retrieval.EXPORT_BYTE_LIMIT", 40)
huge = _eml("<offen@example.test>", "GEKÜRZT-VERBOTEN " * 20, [])
monkeypatch.setattr("app.retrieval.pull_rfc822", lambda *args, **kwargs: huge)
assigned = ada.request(
"POST",
f"/api/v1/matters/{matter['id']}/export/review",
json={"context": context, "selected": [open_mail["id"]], "assignments": {open_mail["id"]: second["id"]}},
)
assert assigned["issues"][0]["code"] == "too_large"
assert "GEKÜRZT-VERBOTEN" not in json.dumps(assigned)
wrong = _eml("<andere@example.test>", "FALSCHE-NACHRICHT", [])
monkeypatch.setattr("app.retrieval.EXPORT_BYTE_LIMIT", 80 * 1024 * 1024)
monkeypatch.setattr("app.retrieval.pull_rfc822", lambda *args, **kwargs: wrong)
identity = ada.request(
"POST",
f"/api/v1/matters/{matter['id']}/export/review",
json={"context": context, "selected": [open_mail["id"]], "assignments": {open_mail["id"]: second["id"]}},
)
assert identity["issues"][0]["code"] == "identity"
assert "FALSCHE-NACHRICHT" not in json.dumps(identity)
blocked = _post_zip(
ada,
matter["id"],
{"context": context, "selected": [open_mail["id"]], "assignments": {open_mail["id"]: second["id"]}},
)
assert blocked.status_code == 422
assert "FALSCHE-NACHRICHT" not in blocked.text
grant(ada, case["id"], ben.email, share=False)
ben.login()
ben_tree = ben.request(
"GET",
f"/api/v1/matters/{matter['id']}/export-tree",
params={"context_kind": "case", "context_id": case["id"]},
)["tree"]
assert "GeheimtitelXQ" not in json.dumps(ben_tree)
shared = next(node for node in _walk(ben_tree) if node["title"] == "Sichtbare Notiz")
assert shared["exportable"] is False
denied = ben.request(
"POST",
f"/api/v1/matters/{matter['id']}/export/review",
json={"context": context, "selected": [shared["id"]]},
)
assert denied["issues"][0]["code"] == "rights"
ada.login()
owner_direct = ada.request("GET", f"/api/v1/matters/{matter['id']}")
hidden_binding = next(item["id"] for item in owner_direct["bindings"] if item["element"]["title"] == "GeheimtitelXQ")
ben.login()
missing = ben.request(
"POST",
f"/api/v1/matters/{matter['id']}/export/review",
json={"context": context, "selected": [f"binding:{hidden_binding}"]},
status=422,
)
assert "GeheimtitelXQ" not in json.dumps(missing)
assert "unbekannten oder nicht sichtbaren" in missing["detail"]
def test_nested_chapter_export_keeps_path_and_complete_mail(client, db, monkeypatch):
raw = _eml(
"<nested-mail@example.test>",
"Die Antwort bleibt vollständig.",
[("lage.pdf", PDF_A), ("konto.pdf", PDF_B)],
)
monkeypatch.setattr("app.retrieval.pull_rfc822", lambda *args, **kwargs: raw)
ada = Actor(client, "ada-nested-export@example.test", "Ada Verschachtelt")
register(db, ada.email, ada.name)
ada.login()
matter = ada.request("POST", "/api/v1/matters", json={"title": "Nebenkosten"}, status=201)
root = ada.request(
"POST",
f"/api/v1/matters/{matter['id']}/chapters",
json={"title": "Nebenkostenabrechnung 2025"},
status=201,
)
sent = ada.request(
"POST",
f"/api/v1/matters/{matter['id']}/chapters",
json={"title": "Übermittelte Abrechnungsunterlagen", "parent_chapter_id": root["id"]},
status=201,
)
receipts = ada.request(
"POST",
f"/api/v1/matters/{matter['id']}/chapters",
json={"title": "Einzelbelege", "parent_chapter_id": sent["id"]},
status=201,
)
skipped = ada.request(
"POST",
f"/api/v1/matters/{matter['id']}/chapters",
json={"title": "../Nicht/mitnehmen", "parent_chapter_id": root["id"]},
status=201,
)
ada.request(
"POST",
"/api/v1/notes",
json={
"title": "Anschreiben",
"document": document("Anschreiben bleibt"),
"context": {"kind": "matter", "id": matter["id"]},
"chapter_id": sent["id"],
},
status=201,
)
ada.request(
"POST",
"/api/v1/files",
data={
"title": "Heizkostenbeleg",
"context_kind": "matter",
"context_id": matter["id"],
"chapter_id": receipts["id"],
},
files={"upload": ("heiz.pdf", PDF_A, "application/pdf")},
status=201,
)
ada.request(
"POST",
"/api/v1/files",
data={
"title": "Hausmeisterbeleg",
"context_kind": "matter",
"context_id": matter["id"],
"chapter_id": receipts["id"],
},
files={"upload": ("haus.pdf", PDF_C, "application/pdf")},
status=201,
)
ada.request(
"POST",
"/api/v1/notes",
json={
"title": "Rückfrage",
"document": document("Direkt im Elternkapitel"),
"context": {"kind": "matter", "id": matter["id"]},
"chapter_id": root["id"],
},
status=201,
)
ada.request(
"POST",
"/api/v1/notes",
json={
"title": "Ausgelassen",
"document": document("Geschwister bleibt draussen"),
"context": {"kind": "matter", "id": matter["id"]},
"chapter_id": skipped["id"],
},
status=201,
)
ada.request(
"POST",
"/api/v1/files",
data={
"title": "Gespiegelte Anlage",
"context_kind": "matter",
"context_id": matter["id"],
"chapter_id": skipped["id"],
},
files={"upload": ("konto.pdf", PDF_B, "application/pdf")},
status=201,
)
mailbox = ada.request(
"POST",
"/api/v1/connectors",
json={
"kind": "imap",
"name": "Postfach",
"host": "mail.example.test",
"username": "ada",
"password": "secret-pass",
},
status=201,
)
ada.request(
"POST",
"/api/v1/external-refs",
json={
"title": "Antwort des Vermieters",
"source": "imap",
"external_id": "<nested-mail@example.test>",
"context": {"kind": "matter", "id": matter["id"]},
"chapter_id": root["id"],
"detail": {"connector_id": mailbox["id"], "mailbox": "INBOX", "uid": 4},
},
status=201,
)
tree = ada.request("GET", f"/api/v1/matters/{matter['id']}/export-tree")["tree"]
flat = list(_walk(tree))
parents = _parents(tree)
einzel = next(node for node in flat if node["title"] == "Einzelbelege")
assert einzel["label"] == "Unterkapitel"
assert parents[einzel["id"]]["title"] == "Übermittelte Abrechnungsunterlagen"
leaves = [node["id"] for node in flat if node["kind"] in {"binding", "annotation"} and node["exportable"]]
hidden = {
node["id"]
for node in flat
if node["kind"] in {"binding", "annotation"}
and (
_under(node["id"], "Einzelbelege", parents)
or _under(node["id"], "../Nicht/mitnehmen", parents)
)
}
kept = next(node["id"] for node in flat if node["title"] == "Heizkostenbeleg")
selected = [item for item in leaves if item not in hidden or item == kept]
body = {"context": {"kind": "matter", "id": matter["id"]}, "selected": selected}
review = ada.request("POST", f"/api/v1/matters/{matter['id']}/export/review", json=body)
assert review["ready"] is True
reviewed = [item["title"] for item in review["entries"]]
assert "Heizkostenbeleg" in reviewed
assert "Hausmeisterbeleg" not in reviewed
assert "Ausgelassen" not in reviewed
assert "Anschreiben" in reviewed
assert any("bleibt Bestandteil" in item["message"] for item in review["notices"])
response = _post_zip(ada, matter["id"], body)
assert response.status_code == 200, response.text
names = _archive(response.content).namelist()
heating = next(
name
for name in names
if name.endswith("/Heizkostenbeleg.pdf") and "Einzelbelege" in name and "Heizkostenbeleg" in name
)
assert heating.startswith(
"01 Nebenkostenabrechnung 2025/02 Übermittelte Abrechnungsunterlagen/01 Einzelbelege/"
)
assert any(
name.startswith("01 Nebenkostenabrechnung 2025/01 ") and "Antwort des Vermieters" in name
for name in names
)
assert not any("Hausmeister" in name or name.endswith("/haus.pdf") for name in names)
assert not any(name.startswith("02 ") and "Nicht" in name for name in names)
assert any("Antwort des Vermieters" in name and name.endswith("/anlagen/lage.pdf") for name in names)
assert any("Antwort des Vermieters" in name and name.endswith("/anlagen/konto.pdf") for name in names)
overview = _archive(response.content).read("inhalt.md").decode("utf-8")
assert overview.index("Anschreiben") < overview.index("Heizkostenbeleg")
assert "Hausmeisterbeleg" not in overview
assert "Ausgelassen" not in overview
def test_chapter_entries_share_one_numbering_sequence(client, db, monkeypatch):
ada = Actor(client, "ada-numbering@example.test", "Ada Numbering")
register(db, ada.email, ada.name)
ada.login()
matter = ada.request("POST", "/api/v1/matters", json={"title": "Nummernfolge"}, status=201)
chapter = ada.request(
"POST",
f"/api/v1/matters/{matter['id']}/chapters",
json={"title": "Post"},
status=201,
)
ada.request(
"POST",
"/api/v1/notes",
json={
"title": "Erste Notiz",
"document": document("Notiztext"),
"context": {"kind": "matter", "id": matter["id"]},
"chapter_id": chapter["id"],
},
status=201,
)
mailbox = ada.request(
"POST",
"/api/v1/connectors",
json={
"kind": "imap",
"name": "Postfach",
"host": "mail.example.test",
"username": "ada",
"password": "secret-pass",
},
status=201,
)
raw = _eml("<nummern@example.test>", "Mailtext", [("lage.pdf", PDF_A)])
ada.request(
"POST",
"/api/v1/external-refs",
json={
"title": "Zweite E-Mail",
"source": "imap",
"external_id": "<nummern@example.test>",
"context": {"kind": "matter", "id": matter["id"]},
"chapter_id": chapter["id"],
"detail": {"connector_id": mailbox["id"], "mailbox": "INBOX", "uid": 3},
},
status=201,
)
ada.request(
"POST",
"/api/v1/files",
data={
"title": "Drittes Dokument",
"context_kind": "matter",
"context_id": matter["id"],
"chapter_id": chapter["id"],
},
files={"upload": ("drittes.pdf", PDF_C, "application/pdf")},
status=201,
)
monkeypatch.setattr("app.retrieval.pull_rfc822", lambda *args, **kwargs: raw)
tree = ada.request("GET", f"/api/v1/matters/{matter['id']}/export-tree")["tree"]
exportable = {"binding", "annotation", "attachment", "dispatch_item", "evidence"}
selected = [node["id"] for node in _walk(tree) if node["exportable"] and node["kind"] in exportable]
response = _post_zip(ada, matter["id"], {"context": {"kind": "matter", "id": matter["id"]}, "selected": selected})
assert response.status_code == 200, response.text
names = [name.replace("\\", "/") for name in _archive(response.content).namelist()]
assert any(name.endswith("01 Post/01 Erste Notiz/Erste Notiz.md") for name in names)
assert any("01 Post/02 Zweite E-Mail/nachricht.eml" in name for name in names)
assert any(name.endswith("01 Post/03 Drittes Dokument/Drittes Dokument.pdf") for name in names)
def test_correspondence_attachments_stay_under_each_host_in_one_chapter(client, db):
ada = Actor(client, "ada-host-bundle@example.test", "Ada Host Bundle")
register(db, ada.email, ada.name)
ada.login()
matter = ada.request("POST", "/api/v1/matters", json={"title": "Gemeinsames Kapitel"}, status=201)
chapter = ada.request(
"POST",
f"/api/v1/matters/{matter['id']}/chapters",
json={"title": "Schriftwechsel"},
status=201,
)
first = ada.request(
"POST",
"/api/v1/notes",
json={
"title": "Erstes Schreiben",
"document": document("Text eins"),
"context": {"kind": "matter", "id": matter["id"]},
"chapter_id": chapter["id"],
},
status=201,
)
second = ada.request(
"POST",
"/api/v1/notes",
json={
"title": "Zweites Schreiben",
"document": document("Text zwei"),
"context": {"kind": "matter", "id": matter["id"]},
"chapter_id": chapter["id"],
},
status=201,
)
att_a1 = ada.request(
"POST",
"/api/v1/files",
data={"title": "Anlage A1", "context_kind": "matter", "context_id": matter["id"]},
files={"upload": ("a1.pdf", PDF_A, "application/pdf")},
status=201,
)
att_a2 = ada.request(
"POST",
"/api/v1/files",
data={"title": "Anlage A2", "context_kind": "matter", "context_id": matter["id"]},
files={"upload": ("a2.pdf", PDF_B, "application/pdf")},
status=201,
)
att_b1 = ada.request(
"POST",
"/api/v1/files",
data={"title": "Anlage B1", "context_kind": "matter", "context_id": matter["id"]},
files={"upload": ("b1.pdf", PDF_C, "application/pdf")},
status=201,
)
att_b2 = ada.request(
"POST",
"/api/v1/files",
data={"title": "Anlage B2", "context_kind": "matter", "context_id": matter["id"]},
files={"upload": ("a1.pdf", PDF_A, "application/pdf")},
status=201,
)
receipt = ada.request(
"POST",
"/api/v1/notes",
json={
"title": "Einlieferungsbeleg",
"document": document("Eingeliefert"),
"context": {"kind": "matter", "id": matter["id"]},
"dates": {"document_on": "2026-04-01"},
},
status=201,
)
detail = ada.request("GET", f"/api/v1/matters/{matter['id']}")
host_a = next(item for item in detail["bindings"] if item["element"]["title"] == "Erstes Schreiben")
host_b = next(item for item in detail["bindings"] if item["element"]["title"] == "Zweites Schreiben")
ada.request(
"POST",
f"/api/v1/elements/{first['id']}/attachments",
json={
"expected_version": host_a["element"]["version"],
"context": {"kind": "matter", "id": matter["id"]},
"attachment_element_ids": [att_a1["id"], att_a2["id"]],
"fold": "attachment",
},
status=201,
)
ada.request(
"POST",
f"/api/v1/elements/{second['id']}/attachments",
json={
"expected_version": host_b["element"]["version"],
"context": {"kind": "matter", "id": matter["id"]},
"attachment_element_ids": [att_b1["id"], att_b2["id"]],
"fold": "attachment",
},
status=201,
)
host_a = next(
item for item in ada.request("GET", f"/api/v1/matters/{matter['id']}")["bindings"]
if item["element"]["title"] == "Erstes Schreiben"
)
ada.request(
"POST",
f"/api/v1/elements/{first['id']}/dispatches",
json={
"expected_version": host_a["element"]["version"],
"context": {"kind": "matter", "id": matter["id"]},
"channel": "post",
"sent_on": "2026-04-02",
"counterpart": "Post",
"attachment_element_ids": [],
"evidence": [{"element_id": receipt["id"], "role": "submission", "fold": "keep"}],
},
status=201,
)
tree = ada.request("GET", f"/api/v1/matters/{matter['id']}/export-tree")["tree"]
selected = [
node["id"]
for node in _walk(tree)
if node["kind"] in {"binding", "attachment", "evidence"} and node["exportable"]
]
response = _post_zip(ada, matter["id"], {"context": {"kind": "matter", "id": matter["id"]}, "selected": selected})
assert response.status_code == 200, response.text
names = _archive(response.content).namelist()
assert not any("anlagen-arbeitsstand" in name.lower() for name in names)
first_paths = [name for name in names if "/01 Erstes Schreiben/Anlagen/" in name.replace("\\", "/")]
second_paths = [name for name in names if "/02 Zweites Schreiben/Anlagen/" in name.replace("\\", "/")]
assert sorted(name.rsplit("/", 1)[-1] for name in first_paths) == ["Anlage A1.pdf", "Anlage A2.pdf"]
assert sorted(name.rsplit("/", 1)[-1] for name in second_paths) == ["Anlage B1.pdf", "Anlage B2.pdf"]
assert any("/01 Erstes Schreiben/Belege/" in name.replace("\\", "/") for name in names)
assert not any(name.replace("\\", "/").startswith("01 Schriftwechsel/2026-04") for name in names)
overview_md = _archive(response.content).read("inhalt.md").decode("utf-8")
overview_html = _archive(response.content).read("index.html").decode("utf-8")
assert "#### Anlagen" in overview_md
assert "Anlage A1" in overview_md
assert "entry-group" in overview_html and "Anlagen" in overview_html
def test_export_warns_when_assigned_attachment_is_not_shareable(client, db):
ada = Actor(client, "ada-share-gap@example.test", "Ada Share Gap")
register(db, ada.email, ada.name)
ada.login()
matter = ada.request("POST", "/api/v1/matters", json={"title": "Anlagenfreigabe"}, status=201)
letter = ada.request(
"POST",
"/api/v1/notes",
json={"title": "Schreiben", "document": document("Text"), "context": {"kind": "matter", "id": matter["id"]}},
status=201,
)
open_att = ada.request(
"POST",
"/api/v1/files",
data={"title": "Offene Anlage", "context_kind": "matter", "context_id": matter["id"]},
files={"upload": ("offen.pdf", PDF_A, "application/pdf")},
status=201,
)
closed_att = ada.request(
"POST",
"/api/v1/files",
data={"title": "Gesperrte Anlage", "context_kind": "matter", "context_id": matter["id"]},
files={"upload": ("gesperrt.pdf", PDF_B, "application/pdf")},
status=201,
)
detail = ada.request("GET", f"/api/v1/matters/{matter['id']}")
host = next(item for item in detail["bindings"] if item["element"]["title"] == "Schreiben")
ada.request(
"POST",
f"/api/v1/elements/{letter['id']}/attachments",
json={
"expected_version": host["element"]["version"],
"context": {"kind": "matter", "id": matter["id"]},
"attachment_element_ids": [open_att["id"], closed_att["id"]],
"fold": "attachment",
},
status=201,
)
ada.request(
"PUT",
"/api/v1/exceptions",
json={
"resource_kind": "element",
"resource_id": closed_att["id"],
"context": {"kind": "matter", "id": matter["id"]},
"remove_share": True,
},
)
tree = ada.request("GET", f"/api/v1/matters/{matter['id']}/export-tree")["tree"]
selected = [node["id"] for node in _walk(tree) if node["exportable"] and node["kind"] in {"binding", "attachment"}]
review = ada.request(
"POST",
f"/api/v1/matters/{matter['id']}/export/review",
json={"context": {"kind": "matter", "id": matter["id"]}, "selected": selected},
)
assert review["ready"] is True
assert any("nicht freigegeben" in item["message"] for item in review["notices"])
response = _post_zip(
ada,
matter["id"],
{"context": {"kind": "matter", "id": matter["id"]}, "selected": selected},
)
assert response.status_code == 200, response.text
names = _archive(response.content).namelist()
anlagen = [
name
for name in names
if "Schreiben" in name and name.replace("\\", "/").endswith("/Anlagen/Offene Anlage.pdf")
]
assert len(anlagen) == 1