Files
tsumugu/backend/tests/test_connector_basis.py
T
LarsandCursor c3a07cee64
Deploy Development / deploy (push) Successful in 28s
Test Suite / pytest-backend (push) Failing after 2m11s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 10s
Stelle bestehende Quellzuordnungen wieder her und halte Connectoren beim eigenen Konto.
Co-authored-by: Cursor <cursoragent@cursor.com>
2026-10-19 16:58:50 +02:00

540 lines
20 KiB
Python

"""Section A: source binding and the storage port, with today's behaviour kept."""
from __future__ import annotations
import hashlib
import json
from pathlib import Path
from uuid import uuid4
import pytest
from app.core.errors import Problem
from app.media.port import (
LEGACY_GENERATION,
LocalAdapter,
MemoryAdapter,
check_object_key,
instance_for_write,
publish,
read_clear_bytes,
)
from app.sourcebind import backfill_source_bindings
from tests.support import ORIGIN, Actor, register
PDF = b"%PDF-1.4\n1 0 obj<<>>endobj\ntrailer<<>>\n%%EOF\n"
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 _case(actor: Actor) -> dict:
return actor.request("POST", "/api/v1/cases", json={"title": "Bestand"}, status=201)
def _paperless(actor: Actor, name: str, token: str) -> str:
row = actor.request(
"POST",
"/api/v1/connectors",
json={"kind": "paperless", "name": name, "base_url": "https://paper.example.test", "token": token},
status=201,
)
return row["id"]
def _link(actor: Actor, case_id: str, connector_id: str | None, external_id: str, title: str) -> str:
body = {
"title": title,
"source": "paperless",
"external_id": external_id,
"context": {"kind": "case", "id": case_id},
}
if connector_id:
body["detail"] = {"connector_id": connector_id}
created = actor.request("POST", "/api/v1/external-refs", json=body, status=201)
return created["id"]
def test_storage_adapters_roundtrip_and_reject_escape(tmp_path):
payload = b"opaque-bytes"
key = str(uuid4())
revision = "rev-1"
for adapter in (LocalAdapter(tmp_path), MemoryAdapter()):
publish(adapter, key, payload)
assert adapter.open(key) == payload
assert adapter.describe(key)["byte_size"] == len(payload)
assert adapter.open(key) == payload
assert revision == "rev-1"
memory = MemoryAdapter()
memory.fail_put = True
with pytest.raises(Problem) as failed:
publish(memory, str(uuid4()), payload)
assert failed.value.code == "storage_unavailable"
assert memory._items == {}
with pytest.raises(Problem):
check_object_key("../secret")
with pytest.raises(Problem):
check_object_key("/etc/passwd")
with pytest.raises(Problem):
LocalAdapter(tmp_path).open("dispatch/../../" + str(uuid4()))
def test_changed_root_does_not_retarget_legacy(db, database):
legacy = db.execute(
"SELECT id, root_path FROM storage_instances WHERE generation = %s",
(LEGACY_GENERATION,),
).fetchone()
key = str(uuid4())
original = b"%PDF-legacy-root"
publish(LocalAdapter(legacy["root_path"]), key, original)
other = Path(database.media_root).parent / f"other-root-{uuid4().hex}"
other.mkdir()
moved = instance_for_write(db, str(other))
assert moved["id"] != legacy["id"]
assert moved["generation"] != LEGACY_GENERATION
publish(LocalAdapter(moved["root_path"]), key, b"%PDF-other-root")
seen = read_clear_bytes(
db,
instance_id=legacy["id"],
generation=LEGACY_GENERATION,
object_key=key,
media_root=str(other),
protection_profile="legacy-plaintext",
expected_sha256=None,
)
assert seen == original
db.rollback()
def test_existing_file_keeps_id_bytes_and_revision(client, db):
register(db, "ada-file@example.test", "Ada File")
ada = Actor(client, "ada-file@example.test", "Ada File")
ada.login()
case = _case(ada)
upload = ada.request(
"POST",
"/api/v1/files",
data={"title": "Scan", "context_kind": "case", "context_id": case["id"]},
files={"upload": ("scan.pdf", PDF, "application/pdf")},
status=201,
)
stored = db.execute(
"""
SELECT a.id, a.object_key, a.content_revision, a.storage_generation, a.protection_profile,
s.root_path
FROM media_assets a
JOIN storage_instances s ON s.id = a.storage_instance_id
WHERE a.element_id = %s
""",
(upload["id"],),
).fetchone()
assert stored["protection_profile"] == "legacy-plaintext"
assert stored["object_key"] == str(stored["id"])
assert Path(stored["root_path"]) == Path(client.app.state.settings.media_root).resolve()
assert stored["storage_generation"]
first = stored["content_revision"]
opened = _raw(ada, f"/api/v1/files/{upload['id']}/content")
assert opened.status_code == 200
assert opened.content == PDF
again = db.execute(
"SELECT content_revision FROM media_assets WHERE element_id = %s",
(upload["id"],),
).fetchone()
assert again["content_revision"] == first
refused = ada.client.patch(
f"/api/v1/notes/{upload['id']}",
json={"expected_version": 1, "document": {"version": 1, "blocks": [{"type": "paragraph", "text": "nein"}]}},
headers={
"Origin": ORIGIN,
"X-CSRF-Token": ada.csrf,
"X-Scope-Kind": ada.scope["kind"],
"X-Scope-Id": ada.scope["id"],
},
)
assert refused.status_code == 422
assert refused.json()["code"] == "unsupported"
def test_two_paperless_instances_stay_bound_when_order_changes(client, db, monkeypatch):
register(db, "ada-two@example.test", "Ada Two")
ada = Actor(client, "ada-two@example.test", "Ada Two")
ada.login()
case = _case(ada)
older = _paperless(ada, "Zweitens", "token-older")
newer = _paperless(ada, "Erstens", "token-newer")
assert older != newer
def fake_bytes(row, document_id):
return f"%PDF-{row['secret']}-{document_id}\n".encode(), "application/pdf", "dokument.pdf"
monkeypatch.setattr("app.sources._paperless_bytes", fake_bytes)
left = _link(ada, case["id"], older, "15", "Altbestand")
right = _link(ada, case["id"], newer, "15", "Zweiter Bestand")
db.execute("UPDATE connectors SET created_at = now() - interval '2 days' WHERE id = %s", (newer,))
db.execute("UPDATE connectors SET created_at = now() WHERE id = %s", (older,))
db.commit()
assert _raw(ada, f"/api/v1/external-refs/{left}/content").content.startswith(b"%PDF-token-older-15")
assert _raw(ada, f"/api/v1/external-refs/{right}/content").content.startswith(b"%PDF-token-newer-15")
calls = []
def fake_get(*args, **kwargs):
calls.append(args)
return {"results": [{"id": 15, "title": "Treffer", "created": "2024-01-02"}]}
monkeypatch.setattr("app.sources._paperless_get", fake_get)
headers = {
"Origin": ORIGIN,
"X-CSRF-Token": ada.csrf,
"X-Scope-Kind": ada.scope["kind"],
"X-Scope-Id": ada.scope["id"],
}
refused = ada.client.get("/api/v1/sources/paperless/documents", params={"q": "Treffer"}, headers=headers)
assert refused.status_code == 422
assert calls == []
found = ada.request(
"GET",
"/api/v1/sources/paperless/documents",
params={"q": "Treffer", "connector_id": older},
)
assert found["items"][0]["title"] == "Treffer"
assert found["connector_id"] == older
assert found["capabilities"]["search"]["correspondent"] is False
assert "correspondent" in found["unsupported"]
filtered = ada.client.get(
"/api/v1/sources/paperless/documents",
params={"q": "Treffer", "connector_id": older, "correspondent": "Haus"},
headers=headers,
)
assert filtered.status_code == 422
assert filtered.json()["code"] == "unsupported"
assert "Haus" not in json.dumps(filtered.json())
def test_ambiguous_legacy_stays_until_assignment(client, db, monkeypatch):
register(db, "ada-old@example.test", "Ada Old")
ada = Actor(client, "ada-old@example.test", "Ada Old")
ada.login()
case = _case(ada)
loose = _link(ada, case["id"], None, "15", "Ohne Instanz")
_paperless(ada, "Alpha", "token-alpha")
second = _paperless(ada, "Beta", "token-beta")
db.execute(
"""
UPDATE external_references
SET connector_id = NULL, resolution = 'unresolved', detail = '{}'::jsonb
WHERE element_id = %s
""",
(loose,),
)
backfill_source_bindings(db)
state = db.execute(
"SELECT connector_id, resolution FROM external_references WHERE element_id = %s",
(loose,),
).fetchone()
db.commit()
assert state["resolution"] == "ambiguous"
assert state["connector_id"] is None
opened = ada.request("GET", f"/api/v1/cases/{case['id']}")
assert opened["bindings"][0]["element"]["id"] == loose
assert opened["bindings"][0]["element"]["preview"]["media"] == "unassigned"
blocked = _raw(ada, f"/api/v1/external-refs/{loose}/content")
assert blocked.status_code == 422
assert "eindeutiger Zugang" in blocked.json()["detail"]
def fake_bytes(row, document_id):
del document_id
return f"%PDF-{row['secret']}\n".encode(), "application/pdf", "dokument.pdf"
monkeypatch.setattr("app.sources._paperless_bytes", fake_bytes)
ada.request(
"POST",
f"/api/v1/external-refs/{loose}/assignment",
json={"connector_id": second},
)
_paperless(ada, "Gamma", "token-gamma")
assert _raw(ada, f"/api/v1/external-refs/{loose}/content").content.startswith(b"%PDF-token-beta")
def test_legacy_stock_rebinds_and_case_and_matter_open(client, db, monkeypatch):
from app.sourceregistry import get_source, unregister_source
register(db, "ada-keep@example.test", "Ada Keep")
ada = Actor(client, "ada-keep@example.test", "Ada Keep")
ada.login()
case = _case(ada)
matter = ada.request("POST", "/api/v1/matters", json={"title": "Bestand"}, status=201)
kept = _paperless(ada, "Archiv", "token-kept")
case_ref = _link(ada, case["id"], None, "15", "Vertragsakte")
matter_ref = ada.request(
"POST",
"/api/v1/external-refs",
json={
"title": "Vertragsvorgang",
"source": "paperless",
"external_id": "16",
"context": {"kind": "matter", "id": matter["id"]},
},
status=201,
)["id"]
db.execute(
"""
UPDATE external_references
SET connector_id = NULL, resolution = 'unresolved', detail = '{}'::jsonb
WHERE element_id IN (%s, %s)
""",
(case_ref, matter_ref),
)
db.commit()
unregister_source("paperless")
unregister_source("imap")
assert get_source("paperless") is None
try:
backfill_source_bindings(db)
db.commit()
for element_id in (case_ref, matter_ref):
state = db.execute(
"SELECT connector_id::text AS connector_id, resolution FROM external_references WHERE element_id = %s",
(element_id,),
).fetchone()
assert state["resolution"] == "bound"
assert state["connector_id"] == kept
assert get_source("paperless") is not None
case_page = ada.request("GET", f"/api/v1/cases/{case['id']}")
matter_page = ada.request("GET", f"/api/v1/matters/{matter['id']}")
assert case_page["bindings"][0]["element"]["preview"]["available"] is True
assert case_page["bindings"][0]["element"]["preview"]["media"] == "pdf"
assert matter_page["bindings"][0]["element"]["preview"]["available"] is True
monkeypatch.setattr(
"app.sources._paperless_bytes",
lambda row, document_id: (f"%PDF-{row['secret']}-{document_id}\n".encode(), "application/pdf", "dokument.pdf"),
)
assert _raw(ada, f"/api/v1/external-refs/{case_ref}/content").content.startswith(b"%PDF-token-kept-15")
assert _raw(ada, f"/api/v1/external-refs/{matter_ref}/content").content.startswith(b"%PDF-token-kept-16")
finally:
from app.sources import _install_sources
_install_sources()
def test_connectors_remain_with_their_account(client, db, monkeypatch):
calls = []
monkeypatch.setattr(
"app.sources._paperless_get",
lambda *args, **kwargs: calls.append(args) or {"results": []},
)
register(db, "ada-own@example.test", "Ada Own")
register(db, "ben-own@example.test", "Ben Own")
ada = Actor(client, "ada-own@example.test", "Ada Own")
ben = Actor(client, "ben-own@example.test", "Ben Own")
ada.login()
ada_paper = _paperless(ada, "Ada Archiv", "token-ada")
ben.login()
ben_paper = _paperless(ben, "Ben Archiv", "token-ben")
listed = ben.request("GET", "/api/v1/connectors")
ids = {item["id"] for item in listed["items"]}
assert ben_paper in ids
assert ada_paper not in ids
assert all(item["name"] != "Ada Archiv" for item in listed["items"])
ben.request("POST", f"/api/v1/connectors/{ada_paper}/probe", status=404)
ben.request(
"GET",
"/api/v1/sources/paperless/documents",
params={"q": "fremd", "connector_id": ada_paper},
status=404,
)
assert calls == []
ada.login()
own = {item["id"] for item in ada.request("GET", "/api/v1/connectors")["items"]}
assert ada_paper in own
assert ben_paper not in own
def test_locked_profile_serves_metadata_not_cleartext(client, db):
register(db, "ada-lock@example.test", "Ada Lock")
ada = Actor(client, "ada-lock@example.test", "Ada Lock")
ada.login()
case = _case(ada)
upload = ada.request(
"POST",
"/api/v1/files",
data={"title": "Geschuetzt", "context_kind": "case", "context_id": case["id"]},
files={"upload": ("geheim.pdf", PDF, "application/pdf")},
status=201,
)
dummy = b"cipher-dummy-not-clear"
asset = db.execute(
"SELECT id, object_key, storage_instance_id FROM media_assets WHERE element_id = %s",
(upload["id"],),
).fetchone()
root = db.execute(
"SELECT root_path FROM storage_instances WHERE id = %s",
(asset["storage_instance_id"],),
).fetchone()["root_path"]
path = Path(root) / asset["object_key"]
path.write_bytes(dummy)
db.execute(
"""
UPDATE media_assets
SET protection_profile = 'client-encrypted',
key_responsibility = 'client',
sha256 = %s
WHERE element_id = %s
""",
(hashlib.sha256(dummy).hexdigest(), upload["id"]),
)
db.commit()
detail = ada.request("GET", f"/api/v1/cases/{case['id']}")
rendered = json.dumps(detail)
assert "client-encrypted" in rendered
assert "Geschuetzt" in rendered
assert dummy.decode() not in rendered
opened = _raw(ada, f"/api/v1/files/{upload['id']}/content")
assert opened.status_code == 422
assert opened.json()["code"] == "unsupported"
assert path.read_bytes() == dummy
def test_credential_update_keeps_the_instance(client, db):
register(db, "ada-key@example.test", "Ada Key")
ada = Actor(client, "ada-key@example.test", "Ada Key")
ada.login()
first = _paperless(ada, "Archiv", "token-first-1")
second = _paperless(ada, "Anderes Archiv", "token-second-2")
renewed = ada.request(
"PATCH",
f"/api/v1/connectors/{first}",
json={"kind": "paperless", "name": "Archiv", "base_url": "https://paper.example.test", "token": "token-renewed"},
)
assert renewed["id"] == first
secrets = {
str(row["id"]): row["secret"]
for row in db.execute("SELECT id, secret FROM connectors").fetchall()
}
assert secrets[first] == "token-renewed"
assert secrets[second] == "token-second-2"
caps = ada.request("GET", "/api/v1/sources/capabilities")
assert caps["editors"]["note"] is True
assert caps["editors"]["markdown_file"] is False
assert caps["protection_profiles"]["client-encrypted"] == "locked"
paperless = next(item for item in caps["sources"] if item["kind"] == "paperless")
assert paperless["search"]["query"] is True
assert paperless["edit_content"] is False
def test_legacy_reference_stays_bound_and_foreign_connectors_stay_hidden(client, db, database, monkeypatch):
"""A startup without loaded modules must still keep the one existing connection."""
from app.db.migrate import _prepare_source_storage
from app.sourceregistry import unregister_source
from app.sources import _install_sources
def fake_bytes(row, document_id):
del document_id
return f"%PDF-{row['secret']}\n".encode(), "application/pdf", "dokument.pdf"
monkeypatch.setattr("app.sources._paperless_bytes", fake_bytes)
register(db, "ada-legacy@example.test", "Ada Legacy")
register(db, "ben-legacy@example.test", "Ben Legacy")
ada = Actor(client, "ada-legacy@example.test", "Ada Legacy")
ben = Actor(client, "ben-legacy@example.test", "Ben Legacy")
ada.login()
case = _case(ada)
matter = ada.request("POST", "/api/v1/matters", json={"title": "Altbestand"}, status=201)
connector = _paperless(ada, "Archiv", "token-legacy")
case_ref = _link(ada, case["id"], None, "15", "Akte")
matter_ref = ada.request(
"POST",
"/api/v1/external-refs",
json={
"title": "Vorgang",
"source": "paperless",
"external_id": "16",
"context": {"kind": "matter", "id": matter["id"]},
},
status=201,
)["id"]
db.execute(
"""
UPDATE external_references
SET connector_id = NULL, resolution = 'unresolved', detail = '{}'::jsonb
WHERE element_id IN (%s, %s)
""",
(case_ref, matter_ref),
)
db.commit()
opened = ada.request("GET", f"/api/v1/cases/{case['id']}")
shown = next(item["element"] for item in opened["bindings"] if item["element"]["id"] == case_ref)
assert shown["preview"]["media"] == "pdf"
assert shown["preview"]["available"] is True
assert _raw(ada, f"/api/v1/external-refs/{case_ref}/content?context_kind=case&context_id={case['id']}").content.startswith(
b"%PDF-token-legacy"
)
matter_view = ada.request("GET", f"/api/v1/matters/{matter['id']}")
matter_element = next(item["element"] for item in matter_view["bindings"] if item["element"]["id"] == matter_ref)
assert matter_element["preview"]["media"] == "pdf"
unregister_source("paperless")
unregister_source("imap")
try:
_prepare_source_storage(database)
finally:
_install_sources()
state = db.execute(
"SELECT connector_id::text AS connector_id, resolution FROM external_references WHERE element_id = %s",
(case_ref,),
).fetchone()
assert state["connector_id"] == connector
assert state["resolution"] == "bound"
ben.login()
own = _paperless(ben, "Bens Archiv", "token-ben")
listed = {item["id"] for item in ben.request("GET", "/api/v1/connectors")["items"]}
assert listed == {own}
ben.request("POST", f"/api/v1/connectors/{connector}/probe", status=404)
ben.request(
"GET",
"/api/v1/sources/paperless/documents",
params={"q": "Alt", "connector_id": connector},
status=404,
)
ada.login()
ada.request(
"POST",
f"/api/v1/matters/{matter['id']}/grants",
json={"email": ben.email, "can_read": True, "can_edit": False, "can_share": False, "use_owner_sources": False},
status=201,
)
ben.login()
shared = ben.request("GET", f"/api/v1/matters/{matter['id']}")
shared_element = next(item["element"] for item in shared["bindings"] if item["element"]["id"] == matter_ref)
assert "connector_id" not in shared_element["external"]["detail"]
assert "external_id" not in shared_element["external"]
blocked = _raw(
ben,
f"/api/v1/external-refs/{matter_ref}/content?context_kind=matter&context_id={matter['id']}",
)
assert blocked.status_code == 422
ada.login()
ada.request(
"POST",
f"/api/v1/matters/{matter['id']}/grants",
json={"email": ben.email, "can_read": True, "can_edit": False, "can_share": False, "use_owner_sources": True},
status=201,
)
ben.login()
allowed = _raw(
ben,
f"/api/v1/external-refs/{matter_ref}/content?context_kind=matter&context_id={matter['id']}",
)
assert allowed.status_code == 200
assert allowed.content.startswith(b"%PDF-token-legacy")