Files
tsumugu/backend/tests/test_export.py
T
LarsandCursor 2b23992a1a
Deploy Development / deploy (push) Successful in 28s
Test Suite / pytest-backend (push) Failing after 1m38s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 9s
Ordne Anlagen und Belege im Übergabepaket pro Hauptschriftstück zu.
Statt gemeinsamem anlagen-arbeitsstand und Datumsordnern auf Kapitel-Ebene liegen zugeordnete Dateien unter Dokumentname/Anlagen bzw. Belege, damit mehrere Schreiben im gleichen Kapitel vollständig und eindeutig exportiert werden.

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

909 lines
34 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])
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"):
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)
schrift_names = [name for name in names if name.startswith("02 Schrift/")]
assert schrift_names == ["02 Schrift/schreiben.pdf"]
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("/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("/heiz.pdf"))
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_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,
)
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 "Erstes Schreiben/Erstes Schreiben/Anlagen/" in name.replace("\\", "/")]
second_paths = [name for name in names if "Zweites Schreiben/Zweites Schreiben/Anlagen/" in name.replace("\\", "/")]
assert sorted(name.rsplit("/", 1)[-1] for name in first_paths) == ["a1.pdf", "a2.pdf"]
assert sorted(name.rsplit("/", 1)[-1] for name in second_paths) == ["a1.pdf", "b1.pdf"]
assert any("Erstes Schreiben/Erstes Schreiben/Belege/" in name.replace("\\", "/") for name in names)
assert not any(name.replace("\\", "/").startswith("01 Schriftwechsel/2026-04") for name in names)