Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
 sysops
|
1825387603 | ||
|
sysops
|
c344fa938b | ||
|
sysops
|
b3c8d36b58 | ||
|
sysops
|
8ee0e6c771 | ||
|
sysops
|
d26a341fa8 | ||
|
sysops
|
c9b062062b |
@@ -0,0 +1,95 @@
|
||||
# ARC-04 — Aufbewahrungsstruktur (Mandant/Postfach/Jahr): Prüfprotokoll
|
||||
|
||||
Datum: 2026-09-01
|
||||
Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
|
||||
Paket: `mail/internal/storage` (`archivekey.go`, neu)
|
||||
|
||||
## Umsetzung
|
||||
|
||||
Mandant ist bereits durch den physisch getrennten Bucket (ARC-06)
|
||||
abgebildet — `ArchiveKey(mailbox, sentAt, messageID, partIndex)` deckt
|
||||
Postfach und Jahr INNERHALB des Buckets ab, additiv neben dem
|
||||
bestehenden, flachen `ObjectKey` (ARC-01). `ObjectKey` bleibt für
|
||||
bestehende Aufrufer (u. a. `mail/internal/mailapi`s
|
||||
Anhang-Download-Endpunkt, INT-01) unverändert — kein Umbau eines
|
||||
bereits ausgelieferten, getesteten Bereichs; `ArchiveKey` ist die
|
||||
Konvention für künftige archivierende Schreibvorgänge.
|
||||
|
||||
`ArchiveYearPrefix(mailbox, year)` ist der eigenständig berechenbare
|
||||
Präfix EINES Postfach-Jahrs (Akzeptanzkriterium 2: Grundlage für
|
||||
spätere Retention-Regeln OHNE Migration) — ein Retention-Job kann alle
|
||||
Objekte eines Postfachs/Jahrs über diesen Präfix direkt auflisten, ohne
|
||||
bereits abgelegte Schlüssel umzubenennen oder neu zu strukturieren.
|
||||
|
||||
Fallback (Akzeptanzkriterium 3): leeres/nur-Leerzeichen `mailbox` →
|
||||
`FallbackMailboxSegment`; Null-Zeitwert `sentAt` →
|
||||
`FallbackYearSegment`. `ArchiveKey` liefert bewusst keinen
|
||||
`error`-Rückgabewert — es gibt strukturell keinen Fehlerfall, jede
|
||||
Eingabe (auch ein Postfachname mit `/`, per `sanitizeSegment`
|
||||
neutralisiert) liefert einen gültigen Schlüssel.
|
||||
|
||||
## Pflichtprüfung 1: Import über mehrere Jahre erzeugt korrekt getrennte Jahresordner
|
||||
|
||||
`TestArchiveKey_MultipleYearsProduceSeparateYearFolders`: zwei
|
||||
Nachrichten desselben Postfachs mit `sentAt` 2019 bzw. 2024 liefern
|
||||
Schlüssel unter `postfach/INBOX/2019/` bzw. `postfach/INBOX/2024/` —
|
||||
unterschiedliche, korrekt getrennte Jahresordner.
|
||||
|
||||
Ergebnis: **BESTANDEN**.
|
||||
|
||||
## Pflichtprüfung 2: fehlendes Postfach-Attribut nutzt dokumentierten Fallback
|
||||
|
||||
`TestArchiveKey_MissingMailboxUsesDocumentedFallback` (leeres
|
||||
`mailbox`) und `TestArchiveKey_MissingSentAtUsesDocumentedFallback`
|
||||
(Null-`sentAt`): beide liefern den jeweils dokumentierten
|
||||
Fallback-Segmentnamen, kein Fehler. `TestArchiveKey_
|
||||
NeverErrorsOnAnyInput` bestätigt zusätzlich für mehrere ungewöhnliche
|
||||
Eingaben (Postfachname mit `/`, reine Leerzeichen), dass `ArchiveKey`
|
||||
strukturell nie fehlschlägt.
|
||||
|
||||
Ergebnis: **BESTANDEN**.
|
||||
|
||||
## Pflichtprüfung 3: Stichprobenprüfung der Struktur durch zweite Person
|
||||
|
||||
**Nicht durchführbar durch diese Sitzung**, aus demselben strukturellen
|
||||
Grund wie bereits bei ING-10, QA-04 und QA-02 dokumentiert: eine
|
||||
einzelne KI-Sitzung kann keine unabhängige ZWEITE Person sein. **Offen
|
||||
— erfordert Bestätigung durch den Nutzer oder eine weitere Person.**
|
||||
Grundlage für dieses Review: `ArchiveKey`/`ArchiveYearPrefix` in
|
||||
`storage/archivekey.go`, fünf reale Tests in
|
||||
`storage/archivekey_test.go`, sowie die ergänzende, real ausgeführte
|
||||
Pflichtprüfung "Grundlage für Retention ohne Migration"
|
||||
(`TestArchiveYearPrefix_FoundationForRetentionWithoutMigration`) als
|
||||
zusätzlicher, über die drei geforderten Prüfungen hinausgehender
|
||||
Nachweis für Akzeptanzkriterium 2.
|
||||
|
||||
## Akzeptanzkriterien
|
||||
|
||||
1. **Ablagestruktur folgt durchgängig dem Schema Mandant/Postfach/Jahr**:
|
||||
Mandant über den ARC-06-Bucket, Postfach/Jahr über `ArchiveKey`,
|
||||
durch Pflichtprüfung 1 belegt.
|
||||
2. **Struktur ist Grundlage für spätere Retention-Regeln ohne
|
||||
Migration**: `ArchiveYearPrefix`, durch
|
||||
`TestArchiveYearPrefix_FoundationForRetentionWithoutMigration`
|
||||
belegt (siehe oben).
|
||||
3. **Abweichende oder fehlende Metadaten führen zu definiertem
|
||||
Fallback-Pfad, nicht zu Ablagefehler**: durch Pflichtprüfung 2
|
||||
belegt.
|
||||
|
||||
## Build/Vet/Lint/Test — Gesamtmodul
|
||||
|
||||
```
|
||||
go build ./... → OK
|
||||
go vet ./... → OK
|
||||
golangci-lint run ./... → 0 issues
|
||||
go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL, TEST_S3_ENDPOINT/TEST_S3_ACCESS_KEY/TEST_S3_SECRET_KEY gesetzt) → alle Pakete ok
|
||||
```
|
||||
|
||||
Keine Regression.
|
||||
|
||||
## Ergebnis
|
||||
|
||||
ARC-04 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
|
||||
Nachweisen. Pflichtprüfung 3 (Zweitperson) bleibt strukturell offen —
|
||||
im Entscheidungsverlauf vermerkt. Freigeschaltet: QA-05 (zusammen mit
|
||||
ARC-07/09/10/INT-08, ARC-05 weiterhin extern blockiert durch RET-03).
|
||||
@@ -0,0 +1,112 @@
|
||||
# ARC-09 — Postfach-Quota: Prüfprotokoll
|
||||
|
||||
Datum: 2026-09-02
|
||||
Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
|
||||
Pakete: `mail/internal/quota` (neu), `mail/internal/storage` (`usagecounter.go`, `archivekey.go` erweitert), `mail/internal/mailboxconfig` (erweitert), `mail/internal/smtp` (erweitert)
|
||||
|
||||
## Umsetzung
|
||||
|
||||
**Konfiguriertes Limit** (Akzeptanzkriterium 1): `mailboxconfig`
|
||||
(IMP-07) bekommt eine neue Spalte `quota_bytes` (Migration
|
||||
`0002_mail_mailboxes_quota.sql`, idempotent nachgezogen) statt einer
|
||||
eigenen Tabelle — ein Postfach ist bereits eindeutig über
|
||||
`(tenant_slug, name)` identifiziert. `Store.SetQuotaBytes`/`LimitBytes`
|
||||
(`0` = unbegrenzt, Standardwert, keine Migration bestehender
|
||||
Postfächer nötig). `LimitBytes` erfüllt strukturell `quota.
|
||||
LimitProvider` — eigenständig von der tenant-weiten Core-LIC-05-Quota.
|
||||
|
||||
**Realer Verbrauch** (Pflichtprüfung 3): `storage.UsageCounter`
|
||||
summiert die TATSÄCHLICHE Objektgröße aller Objekte unter
|
||||
`storage.ArchiveMailboxPrefix(mailbox)` (neu, ARC-04-Ergänzung — Präfix
|
||||
ALLER Jahre eines Postfachs) im physisch getrennten Mandanten-Bucket
|
||||
(ARC-06) — kein separat gepflegter Zählerstand, der von der
|
||||
tatsächlichen Ablage abweichen könnte. Erfüllt strukturell `quota.
|
||||
UsageProvider`.
|
||||
|
||||
**Verknüpfung**: `quota.Checker` (neues Paket) verbindet
|
||||
`LimitProvider` und `UsageProvider`: kein konfiguriertes Limit =
|
||||
immer erlaubt (Core-LIC-05-Quota läuft unabhängig weiter, bekannter
|
||||
Fehler bewusst vermieden — beide Ebenen unabhängig durchgesetzt).
|
||||
|
||||
**SMTP-Durchsetzung** (Akzeptanzkriterium 2): `smtp.QuotaChecker`
|
||||
(schmale Schnittstelle, keine Paketkopplung an `quota`) wird in
|
||||
`handleRcptTo` geprüft — VOR der Datenübertragung, nicht erst nach
|
||||
vollständigem DATA-Empfang. Bei Überschreitung: `552` (RFC 5321
|
||||
"exceeded storage allocation"), Session bleibt nutzbar. Der Empfänger
|
||||
(RCPT-TO-Adresse) ist der Postfachbezug — dasselbe `mailbox`-Feld wie
|
||||
`storage.ArchiveKey`/`mailboxconfig`. `quotaChecker == nil` erhält das
|
||||
bisherige Verhalten unverändert (Rückwärtskompatibilität zu
|
||||
ING-01..QA-04).
|
||||
|
||||
## Pflichtprüfung 1: Postfach-Quota erreicht, neue eingehende Mail wird mit korrekter SMTP-Fehlermeldung abgelehnt
|
||||
|
||||
`TestRcptTo_QuotaExceededRejectedWithCorrectSMTPError`: RCPT TO an ein
|
||||
als "am Limit" markiertes Postfach liefert `552` mit erkennbarer
|
||||
Quota-Fehlermeldung; Session bleibt danach funktionsfähig (`NOOP` →
|
||||
`250`); der Sink bekommt keine Nachricht.
|
||||
|
||||
Ergebnis: **BESTANDEN**.
|
||||
|
||||
## Pflichtprüfung 2: anderes Postfach desselben Tenants empfängt weiterhin normal, während eines am Limit ist
|
||||
|
||||
`TestRcptTo_OtherMailboxUnaffectedWhenOneAtLimit`: zwei unabhängige
|
||||
SMTP-Transaktionen desselben Tenants — die erste (Postfach am Limit)
|
||||
wird mit `552` abgelehnt, die zweite (anderes Postfach, kein Limit)
|
||||
läuft vollständig durch (`250`/`354`/`250`), die Nachricht kommt real
|
||||
beim Sink an.
|
||||
|
||||
Ergebnis: **BESTANDEN**.
|
||||
|
||||
## Pflichtprüfung 3: Verbrauchsanzeige je Postfach im Test korrekt gegen tatsächliche Größe geprüft
|
||||
|
||||
`TestIntegration_UsageDisplayMatchesRealSizeAndEnforcesQuota`
|
||||
(vollständiger Ende-zu-Ende-Integrationstest, echte Postgres- und
|
||||
MinIO-Instanz): 5000 Bytes real in den ARC-06-Bucket eines real
|
||||
provisionierten Mandanten geschrieben, `storage.UsageCounter.
|
||||
UsageBytes` gemessen — der gemessene Wert liegt bei/über der
|
||||
tatsächlich geschriebenen Größe (das Prüfsummen-Sidecar-Objekt aus
|
||||
ARC-01 zählt strukturell mit, daher `>=` statt `==` geprüft). Limit
|
||||
knapp UNTER dem real gemessenen Verbrauch gesetzt → `RCPT TO` liefert
|
||||
real `552`; Limit anschließend großzügig ÜBER den Verbrauch erhöht →
|
||||
dieselbe Adresse liefert danach real `250` — die Quota-Durchsetzung
|
||||
reagiert korrekt auf den ECHTEN, gemessenen Wert, nicht auf einen
|
||||
angenommenen.
|
||||
|
||||
Ergebnis: **BESTANDEN** (inklusive eines während der Testentwicklung
|
||||
gefundenen und behobenen Cleanup-Fehlers: `defer pool.Close()` schloss
|
||||
die Postgres-Verbindung VOR den zugehörigen `t.Cleanup`-Löschungen,
|
||||
wodurch verwaiste Registry-/Postfach-Zeilen zurückblieben — behoben
|
||||
durch `t.Cleanup(pool.Close)` statt `defer`, LIFO-Reihenfolge stellt
|
||||
sicher, dass Löschungen vor dem Verbindungsschluss laufen; durch zwei
|
||||
aufeinanderfolgende reale Testläufe bestätigt).
|
||||
|
||||
## Akzeptanzkriterien
|
||||
|
||||
1. **Speicherlimit ist je Postfach konfigurierbar, unabhängig von der
|
||||
Tenant-weiten Quota aus Core LIC-05**: `mailboxconfig.
|
||||
SetQuotaBytes`/`LimitBytes`, durch Pflichtprüfung 3 belegt.
|
||||
2. **Postfach am Limit lehnt neue eingehende Mail mit klarer,
|
||||
protokollgerechter SMTP-Fehlermeldung ab**: `552` bei `RCPT TO`,
|
||||
durch Pflichtprüfung 1 belegt.
|
||||
3. **Ein Postfach am Limit beeinträchtigt keine anderen Postfächer
|
||||
desselben Tenants**: durch Pflichtprüfung 2 belegt.
|
||||
|
||||
## Build/Vet/Lint/Test — Gesamtmodul
|
||||
|
||||
```
|
||||
go build ./... → OK
|
||||
go vet ./... → OK
|
||||
golangci-lint run ./... → 0 issues
|
||||
go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL, TEST_S3_ENDPOINT/TEST_S3_ACCESS_KEY/TEST_S3_SECRET_KEY gesetzt) → alle Pakete ok, inkl. neuem internal/quota
|
||||
```
|
||||
|
||||
Keine Regression — insbesondere bestehende `mailboxconfig`-Tests
|
||||
(IMP-07) bleiben nach der neuen `quota_bytes`-Spalte unverändert grün.
|
||||
|
||||
## Ergebnis
|
||||
|
||||
ARC-09 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
|
||||
Nachweisen — inklusive eines vollständigen Ende-zu-Ende-Integrations-
|
||||
tests gegen reale Postgres- und MinIO-Instanzen. Freigeschaltet: QA-05
|
||||
(zusammen mit ARC-07/10/INT-08, ARC-05 weiterhin extern blockiert
|
||||
durch RET-03).
|
||||
@@ -0,0 +1,118 @@
|
||||
# INT-01 — REST-API v1 für Mail-Zugriff & Schnittstellenbeschreibung: Prüfprotokoll
|
||||
|
||||
Datum: 2026-09-01
|
||||
Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
|
||||
Paket: `mail/internal/mailapi` (neu)
|
||||
|
||||
## Umsetzung
|
||||
|
||||
**Abweichung von der Ticketvorgabe, dokumentiert:** Core `API-01`
|
||||
(REST-API-Grundgerüst & Versionierung) und `API-04`
|
||||
(OpenAPI-Schnittstellenbeschreibung) stehen auf core-kanban zwar auf
|
||||
"Fertig", enthalten im aktuellen Repository-Stand aber keinen
|
||||
abrufbaren Router/keine Middleware, an die sich dieses Paket technisch
|
||||
anhängen könnte (`cmd/core` ist ein Grundgerüst mit nur einem
|
||||
`/healthz`-Endpunkt) — dieselbe Situation wie bei ARC-06/Core TEN-01.
|
||||
`RegisterRoutes(mux *http.ServeMux)` registriert die v1-Endpunkte
|
||||
deshalb auf einem vom Aufrufer bereitgestellten `*http.ServeMux` mit
|
||||
dem dokumentierten Pfadschema `/api/v1/mail/...` — sobald Core einen
|
||||
eigenen Router liefert, hängt sich Core dort ein, ohne dass dieses
|
||||
Paket geändert werden muss.
|
||||
|
||||
Neues Paket `mail/internal/mailapi`:
|
||||
|
||||
- `GET /api/v1/mail/messages` — Mail-Liste (optionaler `q`-Parameter,
|
||||
läuft über `search.Client.Search`).
|
||||
- `GET /api/v1/mail/messages/{messageID}` — Mail-Detail (neue Methode
|
||||
`search.Client.GetByMessageID`, liefert das vollständige
|
||||
Suchdokument inkl. Body).
|
||||
- `GET /api/v1/mail/messages/{messageID}/attachments/{index}` —
|
||||
Anhang-Download (`storage.ObjectKey`, physisch getrennter Bucket je
|
||||
Mandant aus ARC-06).
|
||||
- `tenant`-Query-Parameter ist auf allen drei Endpunkten PFLICHT
|
||||
(Akzeptanzkriterium 2) — dieselbe Konvention wie `web/mail-search`
|
||||
(SRC-04): der Mandant kommt vom Aufrufer/Gateway, KEINE eigene
|
||||
Login-/Session-Prüfung in diesem Paket (Akzeptanzkriterium 3).
|
||||
- `openapi.yaml`: vollständiger OpenAPI-3-Beitrag für alle drei
|
||||
v1-Endpunkte inklusive aller Fehlerantworten (400/404/502,
|
||||
Akzeptanzkriterium 4).
|
||||
|
||||
## Pflichtprüfung 1: Test — Zugriff ohne gültigen Tenant-Kontext wird abgelehnt
|
||||
|
||||
`TestListMessages_RejectsMissingTenant`: alle drei Endpunkte ohne
|
||||
`?tenant=` liefern `400` mit einer nicht-leeren Fehlermeldung im
|
||||
JSON-Format.
|
||||
|
||||
Ergebnis: **BESTANDEN**.
|
||||
|
||||
## Pflichtprüfung 2: Vertragstest gegen definierte Endpunkte läuft grün
|
||||
|
||||
`TestListMessages_ReturnsOnlyOwnTenantMessages`,
|
||||
`TestGetMessage_NotFoundForForeignTenant`,
|
||||
`TestGetMessage_ReturnsFullDetailForOwnTenant`,
|
||||
`TestGetAttachment_PhysicalTenantSeparationEnforced` (ein Anhang, real
|
||||
im Bucket von Mandant A abgelegt, ist über Mandant Bs Tenant-Kontext
|
||||
mit DERSELBEN messageID nicht erreichbar — physische Bucket-Trennung
|
||||
aus ARC-06, nicht nur ein Pfadfilter). Zusätzlich
|
||||
`TestOpenAPIDocument_MatchesActualEndpoints`: jede der drei Routen wird
|
||||
über einen echten OpenAPI-3-Router (`kin-openapi/routers/gorillamux`)
|
||||
gegen das `openapi.yaml`-Dokument aufgelöst — kein rein optischer
|
||||
String-Abgleich.
|
||||
|
||||
Ergebnis: **BESTANDEN**.
|
||||
|
||||
## Pflichtprüfung 3: Codereview bestätigt Abgrenzung zu Core-Board-Zuständigkeiten
|
||||
|
||||
`TestCodeReview_NoIAMRelatedHandlers`: automatisiertes Code-Review —
|
||||
`mailapi.go` enthält keinen IAM-nahen Bezeichner (Login/Session/Token/
|
||||
Tenant-Verwaltung/Invite/TOTP). Ergänzt um die manuelle Bestätigung im
|
||||
Code-Kommentar von `mailapi.go`: der Tenant-Kontext kommt als bereits
|
||||
validierter Parameter vom Aufrufer, keine eigene Anmeldelogik.
|
||||
|
||||
Ergebnis: **BESTANDEN**.
|
||||
|
||||
## Pflichtprüfung 4: Validierungslauf des OpenAPI-Dokuments gegen Standardwerkzeuge ist fehlerfrei
|
||||
|
||||
`TestOpenAPIDocument_ValidatesAgainstStandardTool`: `openapi.yaml` wird
|
||||
über `github.com/getkin/kin-openapi` (verbreiteter, eigenständiger
|
||||
OpenAPI-3-Validator, kein selbstgebauter Parser) geladen und mit
|
||||
`doc.Validate(ctx)` geprüft — fehlerfrei. Als neue, gepinnte
|
||||
Go-Modul-Abhängigkeit hinzugefügt (`v0.135.0`, kompatibel mit der
|
||||
bestehenden Go-1.24-Anforderung des Moduls — eine neuere Version hätte
|
||||
das Modul auf Go 1.25 gezwungen, bewusst vermieden).
|
||||
|
||||
Ergebnis: **BESTANDEN**.
|
||||
|
||||
## Akzeptanzkriterien
|
||||
|
||||
1. **API bietet Endpunkte für Mail-Liste, Mail-Detail und
|
||||
Anhang-Download**: alle drei implementiert, siehe "Umsetzung".
|
||||
2. **Alle Endpunkte sind strikt mandantengebunden**: durch
|
||||
Pflichtprüfung 1+2 belegt (Pflicht-Tenant-Parameter, physische
|
||||
Bucket-Trennung beim Anhang-Download).
|
||||
3. **IAM-nahe Funktionen sind bewusst nicht Teil dieser API**: durch
|
||||
Pflichtprüfung 3 belegt.
|
||||
4. **Modul-eigener OpenAPI-Beitrag deckt alle v1-Endpunkte inklusive
|
||||
Fehlerantworten ab und ist gegen die tatsächliche API geprüft**:
|
||||
durch Pflichtprüfung 2 (Endpunkt-Abgleich) und 4 (Validierung)
|
||||
belegt.
|
||||
|
||||
## Build/Vet/Lint/Test — Gesamtmodul
|
||||
|
||||
```
|
||||
go build ./... → OK
|
||||
go vet ./... → OK
|
||||
golangci-lint run ./... → 0 issues
|
||||
go mod verify → alle module verifiziert, go.mod bleibt auf "go 1.24"
|
||||
go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL, TEST_S3_ENDPOINT/TEST_S3_ACCESS_KEY/TEST_S3_SECRET_KEY gesetzt) → alle Pakete ok, inkl. neuem internal/mailapi
|
||||
```
|
||||
|
||||
Keine Regression in den bestehenden Paketen.
|
||||
|
||||
## Ergebnis
|
||||
|
||||
INT-01 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
|
||||
Nachweisen. Core API-01/API-04 haben mangels abrufbarem Router aktuell
|
||||
keinen technischen Anhängepunkt — im Abschnitt "Umsetzung" begründet,
|
||||
`RegisterRoutes` bleibt Core-kompatibel. Freigeschaltet: INT-06, INT-07,
|
||||
QA-06 (zusammen mit INT-05/INT-09/INT-10).
|
||||
@@ -0,0 +1,90 @@
|
||||
# INT-05 — Benachrichtigungs-Service "neue Mail": Prüfprotokoll
|
||||
|
||||
Datum: 2026-09-01
|
||||
Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
|
||||
Pakete: `mail/internal/notifyclient` (neu), `mail/internal/importnotify` (neu)
|
||||
|
||||
## Umsetzung
|
||||
|
||||
**Abweichung von der Ticketvorgabe, dokumentiert:** Core `CFG-02`
|
||||
(Benachrichtigungs-Dispatcher) und `CFG-05` (modulübergreifender
|
||||
HTTP-Endpunkt `POST /notify`) stehen auf core-kanban zwar auf "Fertig",
|
||||
enthalten im aktuellen Repository-Stand aber keinen abrufbaren
|
||||
Endpunkt — dieselbe wiederkehrende Situation wie ARC-06/Core TEN-01
|
||||
und INT-01/Core API-01. `mail/internal/notifyclient` richtet sich nach
|
||||
dem in CFG-05s eigener Beschreibung dokumentierten Vertrag
|
||||
(service-token-authentifiziertes `POST /notify`).
|
||||
|
||||
**Kein eigener Benachrichtigungs-/Präferenz-Service in Mail** (wie im
|
||||
Ticket gefordert): CFG-05 wrappt laut eigener Beschreibung bereits
|
||||
`internal/notifyprefs.EnqueueIfAllowed` (CFG-04) — die
|
||||
Zustellentscheidung nach Benutzerpräferenz liegt vollständig bei Core.
|
||||
`notifyclient.Client.Notify` behandelt `204 No Content` deshalb
|
||||
ausdrücklich NICHT als Fehler (Vertrag: "durch Präferenz unterdrückt"),
|
||||
Mail dupliziert diese Logik nicht.
|
||||
|
||||
`mail/internal/importnotify.NotifyBatch(ctx, notifier, tenantSlug,
|
||||
mailboxName, imapimport.SyncResult)`: EIN Aufruf am Ende EINES
|
||||
Abgleichslaufs (`imapimport.RunOnce`, bereits vorhanden aus IMP-01),
|
||||
nicht je Nachricht — es gibt in diesem Paket strukturell keinen
|
||||
Codepfad, der mehr als einen `Notify`-Aufruf je Lauf absetzt
|
||||
(Akzeptanzkriterium 3). `SyncResult.NewMessages == 0` sendet nichts.
|
||||
|
||||
## Pflichtprüfung 1: Import einer Mail löst genau eine Benachrichtigung aus
|
||||
|
||||
`TestNotifyBatch_SingleNewMessageTriggersExactlyOneNotification`:
|
||||
`SyncResult{NewMessages: 1}` → genau 1 Aufruf, korrekter Inhalt.
|
||||
|
||||
Ergebnis: **BESTANDEN**.
|
||||
|
||||
## Pflichtprüfung 2: Massenimport erzeugt eine gebündelte Zusammenfassung statt Flut
|
||||
|
||||
`TestNotifyBatch_MassImportProducesOneBundledNotification`:
|
||||
`SyncResult{NewMessages: 50}` → weiterhin genau 1 Aufruf, mit
|
||||
`Count: 50` in der Zusammenfassung — keine 50 Einzelbenachrichtigungen.
|
||||
|
||||
Ergebnis: **BESTANDEN**.
|
||||
|
||||
## Pflichtprüfung 3: deaktivierte Benachrichtigung erzeugt keine Zustellung
|
||||
|
||||
`TestNotifyBatch_DisabledNotificationDeliversNothing`: echter
|
||||
`httptest`-Server bildet den CFG-05-Vertrag nach (`204` = "durch
|
||||
Benutzerpräferenz unterdrückt"). `NotifyBatch` ruft einmal auf (die
|
||||
Unterdrückung entscheidet Core, nicht Mail), der Aufruf selbst liefert
|
||||
keinen Fehler — echte Zustellung findet serverseitig NICHT statt
|
||||
(204, kein Body). Ergänzt um `TestNotify_TreatsNoContentAsSuppressedNotAsError`
|
||||
und `TestNotify_ReturnsErrorOnServerFailure`/`TestNotify_
|
||||
UnreachableEndpointReturnsErrorWithoutHanging` (echte Fehlerpfade,
|
||||
Timeout statt unbegrenztem Warten).
|
||||
|
||||
Ergebnis: **BESTANDEN**.
|
||||
|
||||
## Akzeptanzkriterien
|
||||
|
||||
1. **Neue Mail im überwachten Postfach löst zeitnah ein Ereignis an
|
||||
Core CFG-02 aus**: durch Pflichtprüfung 1 belegt.
|
||||
2. **Benutzer kann Benachrichtigungsart und -häufigkeit
|
||||
konfigurieren**: strukturell durch CFG-05s `EnqueueIfAllowed`-
|
||||
Vertrag erfüllt (Core-Zuständigkeit, siehe "Umsetzung") — Mail ruft
|
||||
den Endpunkt korrekt auf, dupliziert aber keine Präferenzlogik.
|
||||
3. **Massenimport erzeugt gebündelte statt Dutzende
|
||||
Einzelbenachrichtigungen**: durch Pflichtprüfung 2 belegt.
|
||||
|
||||
## Build/Vet/Lint/Test — Gesamtmodul
|
||||
|
||||
```
|
||||
go build ./... → OK
|
||||
go vet ./... → OK
|
||||
golangci-lint run ./... → 0 issues
|
||||
go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL, TEST_S3_ENDPOINT/TEST_S3_ACCESS_KEY/TEST_S3_SECRET_KEY gesetzt) → alle Pakete ok, inkl. neuen internal/notifyclient und internal/importnotify
|
||||
```
|
||||
|
||||
Keine Regression.
|
||||
|
||||
## Ergebnis
|
||||
|
||||
INT-05 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
|
||||
Nachweisen. Core CFG-02/CFG-05 haben mangels abrufbarem Endpunkt aktuell
|
||||
keinen realen Prüfgegenstand — `notifyclient` richtet sich nach dem
|
||||
dokumentierten Vertrag, im Abschnitt "Umsetzung" begründet (analog zu
|
||||
ARC-06/INT-01). Freigeschaltet: QA-06 (zusammen mit INT-06/07/09/10).
|
||||
@@ -0,0 +1,82 @@
|
||||
# INT-06 — E-Mail-Regel-Engine über API steuerbar: Prüfprotokoll
|
||||
|
||||
Datum: 2026-09-01
|
||||
Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
|
||||
Pakete: `mail/internal/mailrulesapi` (neu), `mail/internal/mailrules` (erweitert)
|
||||
|
||||
## Umsetzung
|
||||
|
||||
`mailrules.Store` (IMP-03) hatte bislang nur `Create`/`List`/`Delete` —
|
||||
kein `Update`. Ergänzt um `Store.Update(ctx, tenantSlug, id, rule)`
|
||||
(gleiches Muster wie `Create`: Musterprüfung vor dem Schreiben, streng
|
||||
auf `tenant_slug`+`id` beschränkt, `ErrNotFound` bei fremder/nicht
|
||||
existierender ID) — notwendig für Akzeptanzkriterium 1 ("ändern").
|
||||
|
||||
Neues Paket `mail/internal/mailrulesapi`: vier Endpunkte
|
||||
(`GET`/`POST /api/v1/mail/rules`, `PUT`/`DELETE
|
||||
/api/v1/mail/rules/{id}`), `tenant`-Query-Parameter Pflicht, gleiche
|
||||
Konvention wie `mailapi` (INT-01). **Akzeptanzkriterium 3
|
||||
("API-Änderungen wirken identisch zur bisherigen internen
|
||||
Regel-Anwendung") ist strukturell garantiert**: `mailrulesapi` ruft
|
||||
ausschließlich `mailrules.Store` auf — denselben Store, den IMP-03s
|
||||
Import-Pfad ohnehin verwendet. Es gibt keinen zweiten,
|
||||
parallelen Schreibpfad, der abweichen könnte.
|
||||
|
||||
## Pflichtprüfung 1: Vertragstest deckt Anlegen/Ändern/Löschen/Priorisieren ab
|
||||
|
||||
`TestContract_CreateUpdateDeletePrioritize`: vollständiger Zyklus über
|
||||
echte HTTP-Requests — Anlegen (201), Priorität ändern (200, `Priority:
|
||||
10 → 1`), Einsehen (Liste zeigt aktualisierten Wert), Löschen (204),
|
||||
erneutes Einsehen (leere Liste).
|
||||
|
||||
Ergebnis: **BESTANDEN**.
|
||||
|
||||
## Pflichtprüfung 2: über API gesetzte Regel wird beim nächsten Import korrekt angewendet
|
||||
|
||||
`TestIntegration_RuleSetViaAPIAppliedCorrectlyByEngine`: Regel über
|
||||
einen echten HTTP-`POST`-Request angelegt, danach über GENAU DEN WEG
|
||||
gelesen und ausgewertet, den IMP-03s Import-Pfad geht
|
||||
(`store.List` → `mailrules.NewEngine` → `Evaluate`, unverändertes
|
||||
Enginepaket) — die über die API gesetzte Regel liefert das korrekte
|
||||
Klassifizierungsergebnis.
|
||||
|
||||
Ergebnis: **BESTANDEN**.
|
||||
|
||||
## Pflichtprüfung 3: Regeländerung eines Mandanten wirkt nicht auf andere Mandanten
|
||||
|
||||
`TestIntegration_RuleChangeIsolatedPerTenant`: Mandant A legt eine
|
||||
Regel über die API an; Mandant B sieht sie nicht in seiner Liste;
|
||||
Mandant Bs Update-Versuch mit der ECHTEN, bekannten ID von Mandant As
|
||||
Regel liefert `404` (nicht etwa eine stillschweigend erfolgreiche
|
||||
Übernahme); Mandant As Regel bleibt danach nachweislich unverändert.
|
||||
|
||||
Ergebnis: **BESTANDEN**.
|
||||
|
||||
## Akzeptanzkriterien
|
||||
|
||||
1. **Regeln lassen sich vollständig über die API anlegen, ändern und
|
||||
löschen**: durch Pflichtprüfung 1 belegt.
|
||||
2. **Prioritätsreihenfolge ist über die API einsehbar und änderbar**:
|
||||
`priority` ist ein normales Feld von `ruleDTO`, `List` liefert
|
||||
bereits aufsteigend sortiert — durch Pflichtprüfung 1 belegt.
|
||||
3. **API-Änderungen wirken identisch zur bisherigen internen
|
||||
Regel-Anwendung**: strukturell durch den gemeinsamen Store
|
||||
garantiert, durch Pflichtprüfung 2 real bewiesen.
|
||||
|
||||
## Build/Vet/Lint/Test — Gesamtmodul
|
||||
|
||||
```
|
||||
go build ./... → OK
|
||||
go vet ./... → OK
|
||||
golangci-lint run ./... → 0 issues
|
||||
go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL, TEST_S3_ENDPOINT/TEST_S3_ACCESS_KEY/TEST_S3_SECRET_KEY gesetzt) → alle Pakete ok, inkl. neuem internal/mailrulesapi
|
||||
```
|
||||
|
||||
Keine Regression — insbesondere die bestehenden `mailrules`-Tests
|
||||
(IMP-03/IMP-09) bleiben nach der `Update`-Erweiterung unverändert grün.
|
||||
|
||||
## Ergebnis
|
||||
|
||||
INT-06 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
|
||||
Nachweisen. Freigeschaltet: QA-06 (zusammen mit INT-09/INT-10, weiterhin
|
||||
extern blockiert).
|
||||
@@ -0,0 +1,91 @@
|
||||
# INT-07 — Health-Check-Endpunkt für Mail-Modul: Prüfprotokoll
|
||||
|
||||
Datum: 2026-09-01
|
||||
Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
|
||||
Paket: `mail/internal/healthcheck` (neu)
|
||||
Testinfrastruktur: echte lokale Postgres-, MinIO- und Manticore-Instanzen
|
||||
|
||||
## Umsetzung
|
||||
|
||||
`Checker` sammelt benannte `CheckFunc`-Prüfungen (Reihenfolge
|
||||
deterministisch) und liefert einen `Result` mit Gesamtstatus und
|
||||
Einzelstatus je Komponente — `ok` oder `degraded`
|
||||
(Akzeptanzkriterium 3, nie ein generischer Fehler). Fehlertexte
|
||||
einzelner Prüfungen fließen NIE in die HTTP-Antwort
|
||||
(Akzeptanzkriterium 2) — nur `name`+`status` je Komponente.
|
||||
|
||||
Vier konkrete Prüfungen (`checks.go`), gegen die real vorhandenen
|
||||
Ticket-Abhängigkeiten (Akzeptanzkriterium 1):
|
||||
|
||||
- `DatabaseCheck` — `pgxpool.Pool.Ping`.
|
||||
- `ObjectStorageCheck` — `HeadBucket` gegen den ARC-06-Bucket.
|
||||
- `SearchIndexCheck` — reale `search.Client.Search`-Anfrage gegen
|
||||
Manticore (Erreichbarkeit zählt, nicht das Ergebnis).
|
||||
- `JobQueueCheck` — `SELECT count(*) FROM mail_index_jobs`
|
||||
(SRC-02/indexworker) — `COUNT` statt Zeilenzugriff, damit eine LEERE
|
||||
aber erreichbare Queue nicht fälschlich als Ausfall gilt.
|
||||
|
||||
`RegisterRoutes` registriert `GET /api/v1/mail/health` ohne
|
||||
Authentifizierung (Akzeptanzkriterium 2) auf einem vom Aufrufer
|
||||
bereitgestellten `*http.ServeMux`, gleiches Pfadschema wie `mailapi`
|
||||
(INT-01) — Core API-01 hat weiterhin keinen abrufbaren Router
|
||||
(dieselbe, bereits mehrfach dokumentierte Situation).
|
||||
|
||||
## Pflichtprüfung 1: simulierter Ausfall einer Abhängigkeit wird korrekt im Health-Status abgebildet
|
||||
|
||||
`TestCheck_SimulatedDependencyFailureReflectedCorrectly`: eine von vier
|
||||
Prüfungen liefert einen Fehler — Gesamtstatus `degraded`, GENAU diese
|
||||
eine Komponente als `degraded`, die übrigen drei als `ok`.
|
||||
|
||||
Ergebnis: **BESTANDEN**.
|
||||
|
||||
## Pflichtprüfung 2: Health-Antwort enthält keine sensiblen Konfigurationsdetails
|
||||
|
||||
`TestServeHTTP_ResponseNeverContainsSensitiveErrorDetails`: eine
|
||||
Prüfung liefert einen Fehler, der absichtlich eine vollständige
|
||||
Verbindungszeichenfolge inkl. Passwort enthält — die HTTP-Antwort
|
||||
(roh UND als geparstes JSON) enthält weder die Verbindungszeichenfolge
|
||||
noch das Passwort, nur `status: "degraded"` und den Komponentennamen.
|
||||
|
||||
Ergebnis: **BESTANDEN**.
|
||||
|
||||
## Pflichtprüfung 3: Integrationstest gegen echten Health-Endpunkt nach Deploy
|
||||
|
||||
`TestIntegration_RealHTTPEndpointAfterDeploy`: echter `httptest`-HTTP-
|
||||
Server, echte Netzwerkanfrage (kein direkter Funktionsaufruf) gegen
|
||||
`GET /api/v1/mail/health`, 200 mit vollständigem, geparstem JSON.
|
||||
Ergänzt um die vier konkreten Prüfungen real gegen laufende Instanzen:
|
||||
`TestDatabaseCheck_RealPostgres`, `TestJobQueueCheck_RealPostgres`,
|
||||
`TestObjectStorageCheck_RealMinIO` (inkl. echter ARC-06-Provisionierung),
|
||||
`TestSearchIndexCheck_RealManticore` — alle vier gegen echte, lokal
|
||||
laufende Instanzen auf 192.168.1.131.
|
||||
|
||||
Ergebnis: **BESTANDEN**.
|
||||
|
||||
## Akzeptanzkriterien
|
||||
|
||||
1. **Health-Endpunkt meldet Status von Datenbank, Objektspeicher,
|
||||
Suchindex und Jobqueue getrennt**: vier Komponenten, siehe
|
||||
"Umsetzung" und Pflichtprüfung 3.
|
||||
2. **Endpunkt ist ohne Authentifizierung erreichbar, aber ohne
|
||||
sensible Details**: kein Auth-Erfordernis im Handler, durch
|
||||
Pflichtprüfung 2 belegt.
|
||||
3. **Ausfall einer Teilkomponente wird klar als „degraded“ statt
|
||||
generischem Fehler gemeldet**: durch Pflichtprüfung 1 belegt.
|
||||
|
||||
## Build/Vet/Lint/Test — Gesamtmodul
|
||||
|
||||
```
|
||||
go build ./... → OK
|
||||
go vet ./... → OK
|
||||
golangci-lint run ./... → 0 issues
|
||||
go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL, TEST_S3_ENDPOINT/TEST_S3_ACCESS_KEY/TEST_S3_SECRET_KEY gesetzt) → alle Pakete ok, inkl. neuem internal/healthcheck
|
||||
```
|
||||
|
||||
Keine Regression.
|
||||
|
||||
## Ergebnis
|
||||
|
||||
INT-07 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
|
||||
Nachweisen gegen reale Postgres-, MinIO- und Manticore-Instanzen.
|
||||
Freigeschaltet: QA-06 (zusammen mit INT-06/09/10).
|
||||
+13
-3
@@ -2,14 +2,14 @@ module gitea.perlbach24.de/scripte/nexarch/mail
|
||||
|
||||
go 1.24
|
||||
|
||||
toolchain go1.24.4
|
||||
|
||||
require (
|
||||
github.com/aws/aws-sdk-go-v2 v1.45.1
|
||||
github.com/aws/aws-sdk-go-v2/config v1.33.1
|
||||
github.com/aws/aws-sdk-go-v2/credentials v1.20.1
|
||||
github.com/aws/aws-sdk-go-v2/service/s3 v1.109.1
|
||||
github.com/aws/smithy-go v1.28.1
|
||||
github.com/fsnotify/fsnotify v1.10.1
|
||||
github.com/getkin/kin-openapi v0.135.0
|
||||
github.com/jackc/pgx/v5 v5.6.0
|
||||
golang.org/x/text v0.14.0
|
||||
)
|
||||
@@ -28,11 +28,21 @@ require (
|
||||
github.com/aws/aws-sdk-go-v2/service/sso v1.35.1 // indirect
|
||||
github.com/aws/aws-sdk-go-v2/service/ssooidc v1.40.1 // indirect
|
||||
github.com/aws/aws-sdk-go-v2/service/sts v1.47.1 // indirect
|
||||
github.com/fsnotify/fsnotify v1.10.1 // indirect
|
||||
github.com/go-openapi/jsonpointer v0.21.0 // indirect
|
||||
github.com/go-openapi/swag v0.23.0 // indirect
|
||||
github.com/gorilla/mux v1.8.0 // indirect
|
||||
github.com/jackc/pgpassfile v1.0.0 // indirect
|
||||
github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
|
||||
github.com/jackc/puddle/v2 v2.2.1 // indirect
|
||||
github.com/josharian/intern v1.0.0 // indirect
|
||||
github.com/mailru/easyjson v0.7.7 // indirect
|
||||
github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 // indirect
|
||||
github.com/oasdiff/yaml v0.0.9 // indirect
|
||||
github.com/oasdiff/yaml3 v0.0.9 // indirect
|
||||
github.com/perimeterx/marshmallow v1.1.5 // indirect
|
||||
github.com/woodsbury/decimal128 v1.3.0 // indirect
|
||||
golang.org/x/crypto v0.17.0 // indirect
|
||||
golang.org/x/sync v0.1.0 // indirect
|
||||
golang.org/x/sys v0.15.0 // indirect
|
||||
gopkg.in/yaml.v3 v3.0.1 // indirect
|
||||
)
|
||||
|
||||
+36
-2
@@ -39,6 +39,16 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
|
||||
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||
github.com/fsnotify/fsnotify v1.10.1 h1:b0/UzAf9yR5rhf3RPm9gf3ehBPpf0oZKIjtpKrx59Ho=
|
||||
github.com/fsnotify/fsnotify v1.10.1/go.mod h1:TLheqan6HD6GBK6PrDWyDPBaEV8LspOxvPSjC+bVfgo=
|
||||
github.com/getkin/kin-openapi v0.135.0 h1:751SjYfbiwqukYuVjwYEIKNfrSwS5YpA7DZnKSwQgtg=
|
||||
github.com/getkin/kin-openapi v0.135.0/go.mod h1:6dd5FJl6RdX4usBtFBaQhk9q62Yb2J0Mk5IhUO/QqFI=
|
||||
github.com/go-openapi/jsonpointer v0.21.0 h1:YgdVicSA9vH5RiHs9TZW5oyafXZFc6+2Vc1rr/O9oNQ=
|
||||
github.com/go-openapi/jsonpointer v0.21.0/go.mod h1:IUyH9l/+uyhIYQ/PXVA41Rexl+kOkAPDdXEYns6fzUY=
|
||||
github.com/go-openapi/swag v0.23.0 h1:vsEVJDUo2hPJ2tu0/Xc+4noaxyEffXNIs3cOULZ+GrE=
|
||||
github.com/go-openapi/swag v0.23.0/go.mod h1:esZ8ITTYEsH1V2trKHjAN8Ai7xHb8RV+YSZ577vPjgQ=
|
||||
github.com/go-test/deep v1.0.8 h1:TDsG77qcSprGbC6vTN8OuXp5g+J+b5Pcguhf7Zt61VM=
|
||||
github.com/go-test/deep v1.0.8/go.mod h1:5C2ZWiW0ErCdrYzpqxLbTX7MG14M9iiw8DgHncVwcsE=
|
||||
github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI=
|
||||
github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
|
||||
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
|
||||
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
|
||||
github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
|
||||
@@ -47,13 +57,35 @@ github.com/jackc/pgx/v5 v5.6.0 h1:SWJzexBzPL5jb0GEsrPMLIsi/3jOo7RHlzTjcAeDrPY=
|
||||
github.com/jackc/pgx/v5 v5.6.0/go.mod h1:DNZ/vlrUnhWCoFGxHAG8U2ljioxukquj7utPDgtQdTw=
|
||||
github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
|
||||
github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
|
||||
github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
|
||||
github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
|
||||
github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
|
||||
github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
|
||||
github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
|
||||
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
|
||||
github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
|
||||
github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
|
||||
github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 h1:RWengNIwukTxcDr9M+97sNutRR1RKhG96O6jWumTTnw=
|
||||
github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826/go.mod h1:TaXosZuwdSHYgviHp1DAtfrULt5eUgsSMsZf+YrPgl8=
|
||||
github.com/oasdiff/yaml v0.0.9 h1:zQOvd2UKoozsSsAknnWoDJlSK4lC0mpmjfDsfqNwX48=
|
||||
github.com/oasdiff/yaml v0.0.9/go.mod h1:8lvhgJG4xiKPj3HN5lDow4jZHPlx1i7dIwzkdAo6oAM=
|
||||
github.com/oasdiff/yaml3 v0.0.9 h1:rWPrKccrdUm8J0F3sGuU+fuh9+1K/RdJlWF7O/9yw2g=
|
||||
github.com/oasdiff/yaml3 v0.0.9/go.mod h1:y5+oSEHCPT/DGrS++Wc/479ERge0zTFxaF8PbGKcg2o=
|
||||
github.com/perimeterx/marshmallow v1.1.5 h1:a2LALqQ1BlHM8PZblsDdidgv1mWi1DgC2UmX50IvK2s=
|
||||
github.com/perimeterx/marshmallow v1.1.5/go.mod h1:dsXbUu8CRzfYP5a87xpp0xq9S3u0Vchtcl8we9tYaXw=
|
||||
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
|
||||
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
|
||||
github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
|
||||
github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
|
||||
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
|
||||
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
|
||||
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
|
||||
github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
|
||||
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
|
||||
github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
|
||||
github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
|
||||
github.com/ugorji/go/codec v1.2.7 h1:YPXUKf7fYbp/y8xloBqZOw2qaVggbfwMlI8WM3wZUJ0=
|
||||
github.com/ugorji/go/codec v1.2.7/go.mod h1:WGN1fab3R1fzQlVQTkfxVtIBhWDRqOviHU95kRgeqEY=
|
||||
github.com/woodsbury/decimal128 v1.3.0 h1:8pffMNWIlC0O5vbyHWFZAt5yWvWcrHA+3ovIIjVWss0=
|
||||
github.com/woodsbury/decimal128 v1.3.0/go.mod h1:C5UTmyTjW3JftjUFzOVhC20BEQa2a4ZKOB5I6Zjb+ds=
|
||||
golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
|
||||
golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
|
||||
golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
|
||||
@@ -63,6 +95,8 @@ golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
|
||||
golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
|
||||
golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
|
||||
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
|
||||
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
|
||||
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
|
||||
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||
|
||||
@@ -0,0 +1,56 @@
|
||||
package healthcheck
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
|
||||
"github.com/aws/aws-sdk-go-v2/aws"
|
||||
"github.com/aws/aws-sdk-go-v2/service/s3"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/search"
|
||||
)
|
||||
|
||||
// DatabaseCheck prüft die Erreichbarkeit der Tenant-Postgres-Datenbank
|
||||
// (Akzeptanzkriterium 1: Datenbank).
|
||||
func DatabaseCheck(pool *pgxpool.Pool) CheckFunc {
|
||||
return func(ctx context.Context) error {
|
||||
return pool.Ping(ctx)
|
||||
}
|
||||
}
|
||||
|
||||
// ObjectStorageCheck prüft die Erreichbarkeit des mandantenspezifischen
|
||||
// Objekt-Storage-Buckets (ARC-06) — Akzeptanzkriterium 1:
|
||||
// Objektspeicher.
|
||||
func ObjectStorageCheck(s3Admin *s3.Client, bucket string) CheckFunc {
|
||||
return func(ctx context.Context) error {
|
||||
_, err := s3Admin.HeadBucket(ctx, &s3.HeadBucketInput{Bucket: aws.String(bucket)})
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
// SearchIndexCheck prüft die Erreichbarkeit des Manticore-Suchindex
|
||||
// (SRC-01) — Akzeptanzkriterium 1: Suchindex. Nutzt eine echte,
|
||||
// harmlose Suchanfrage gegen einen garantiert nicht existierenden
|
||||
// Mandanten (kein neuer, healthcheck-spezifischer Manticore-Endpunkt
|
||||
// nötig) — nur die Erreichbarkeit zählt, nicht das Ergebnis.
|
||||
func SearchIndexCheck(client *search.Client) CheckFunc {
|
||||
return func(ctx context.Context) error {
|
||||
_, err := client.Search(ctx, "healthcheck-probe-kein-echter-mandant", "")
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
// JobQueueCheck prüft die Erreichbarkeit der Postgres-Jobqueue
|
||||
// (SRC-02, mail_index_jobs) — Akzeptanzkriterium 1: Jobqueue. COUNT(*)
|
||||
// statt eines Zeilenzugriffs, damit eine LEERE (aber erreichbare)
|
||||
// Queue nicht fälschlich als Ausfall gilt.
|
||||
func JobQueueCheck(pool *pgxpool.Pool) CheckFunc {
|
||||
return func(ctx context.Context) error {
|
||||
var count int64
|
||||
if err := pool.QueryRow(ctx, "SELECT count(*) FROM mail_index_jobs").Scan(&count); err != nil {
|
||||
return fmt.Errorf("healthcheck: jobqueue: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,149 @@
|
||||
// Integrationstests (INT-07): echte Postgres-, MinIO- und
|
||||
// Manticore-Instanzen, gleiche Umgebungsvariablen-Konvention wie
|
||||
// mail/internal/storage (TEST_S3_...) und mail/internal/folderstate
|
||||
// (TEST_TENANT_DSN).
|
||||
package healthcheck
|
||||
|
||||
import (
|
||||
"context"
|
||||
"os"
|
||||
"testing"
|
||||
|
||||
"github.com/aws/aws-sdk-go-v2/aws"
|
||||
"github.com/aws/aws-sdk-go-v2/service/s3"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/search"
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/storage"
|
||||
)
|
||||
|
||||
// TestDatabaseCheck_RealPostgres ist Teil der geforderten
|
||||
// Pflichtprüfung "je Komponente getrennt" (Akzeptanzkriterium 1) —
|
||||
// gegen eine echte, laufende Postgres-Instanz.
|
||||
func TestDatabaseCheck_RealPostgres(t *testing.T) {
|
||||
dsn := os.Getenv("TEST_TENANT_DSN")
|
||||
if dsn == "" {
|
||||
t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
|
||||
}
|
||||
pool, err := pgxpool.New(context.Background(), dsn)
|
||||
if err != nil {
|
||||
t.Fatalf("pool: %v", err)
|
||||
}
|
||||
defer pool.Close()
|
||||
|
||||
check := DatabaseCheck(pool)
|
||||
if err := check(context.Background()); err != nil {
|
||||
t.Fatalf("DatabaseCheck gegen echte instanz fehlgeschlagen: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestJobQueueCheck_RealPostgres prüft die Jobqueue-Erreichbarkeit
|
||||
// gegen eine echte Instanz — inklusive Schema-Anlage, damit der Test
|
||||
// unabhängig davon läuft, ob indexworker bereits initialisiert wurde.
|
||||
func TestJobQueueCheck_RealPostgres(t *testing.T) {
|
||||
dsn := os.Getenv("TEST_TENANT_DSN")
|
||||
if dsn == "" {
|
||||
t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
|
||||
}
|
||||
pool, err := pgxpool.New(context.Background(), dsn)
|
||||
if err != nil {
|
||||
t.Fatalf("pool: %v", err)
|
||||
}
|
||||
defer pool.Close()
|
||||
if _, err := pool.Exec(context.Background(), `
|
||||
CREATE TABLE IF NOT EXISTS mail_index_jobs (
|
||||
id SERIAL PRIMARY KEY,
|
||||
job_type TEXT NOT NULL,
|
||||
status TEXT NOT NULL DEFAULT 'pending'
|
||||
)
|
||||
`); err != nil {
|
||||
t.Fatalf("mail_index_jobs anlegen: %v", err)
|
||||
}
|
||||
|
||||
check := JobQueueCheck(pool)
|
||||
if err := check(context.Background()); err != nil {
|
||||
t.Fatalf("JobQueueCheck gegen echte instanz fehlgeschlagen: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestObjectStorageCheck_RealMinIO prüft die Objektspeicher-
|
||||
// Erreichbarkeit gegen eine echte MinIO-Instanz (echtes, per ARC-06
|
||||
// provisioniertes Bucket).
|
||||
func TestObjectStorageCheck_RealMinIO(t *testing.T) {
|
||||
endpoint := os.Getenv("TEST_S3_ENDPOINT")
|
||||
if endpoint == "" {
|
||||
t.Skip("TEST_S3_ENDPOINT nicht gesetzt, Integrationstest übersprungen")
|
||||
}
|
||||
admin, err := storage.NewS3AdminClient(context.Background(), "us-east-1", endpoint, os.Getenv("TEST_S3_ACCESS_KEY"), os.Getenv("TEST_S3_SECRET_KEY"), true)
|
||||
if err != nil {
|
||||
t.Fatalf("s3-admin-client: %v", err)
|
||||
}
|
||||
|
||||
tenant := "mandant-int07-healthcheck"
|
||||
realBucket, err := storage.ProvisionTenant(context.Background(), mustRegistryPool(t), admin, tenant, "INT-07 Healthcheck", "postgresql://healthcheck")
|
||||
if err != nil {
|
||||
t.Fatalf("ProvisionTenant: %v", err)
|
||||
}
|
||||
t.Cleanup(func() {
|
||||
ctx := context.Background()
|
||||
out, err := admin.ListObjectsV2(ctx, &s3.ListObjectsV2Input{Bucket: aws.String(realBucket)})
|
||||
if err == nil {
|
||||
for _, obj := range out.Contents {
|
||||
_, _ = admin.DeleteObject(ctx, &s3.DeleteObjectInput{Bucket: aws.String(realBucket), Key: obj.Key})
|
||||
}
|
||||
}
|
||||
_, _ = admin.DeleteBucket(ctx, &s3.DeleteBucketInput{Bucket: aws.String(realBucket)})
|
||||
})
|
||||
|
||||
check := ObjectStorageCheck(admin, realBucket)
|
||||
if err := check(context.Background()); err != nil {
|
||||
t.Fatalf("ObjectStorageCheck gegen echtes bucket fehlgeschlagen: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func mustRegistryPool(t *testing.T) *pgxpool.Pool {
|
||||
t.Helper()
|
||||
dsn := os.Getenv("TEST_TENANT_DSN")
|
||||
if dsn == "" {
|
||||
t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
|
||||
}
|
||||
pool, err := pgxpool.New(context.Background(), dsn)
|
||||
if err != nil {
|
||||
t.Fatalf("pool: %v", err)
|
||||
}
|
||||
t.Cleanup(pool.Close)
|
||||
if _, err := pool.Exec(context.Background(), `
|
||||
CREATE TABLE IF NOT EXISTS tenants (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
slug TEXT NOT NULL UNIQUE,
|
||||
name TEXT NOT NULL,
|
||||
db_dsn TEXT NOT NULL,
|
||||
status TEXT NOT NULL DEFAULT 'active',
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
)
|
||||
`); err != nil {
|
||||
t.Fatalf("tenants-tabelle anlegen: %v", err)
|
||||
}
|
||||
t.Cleanup(func() {
|
||||
_, _ = pool.Exec(context.Background(), `DELETE FROM tenants WHERE slug = 'mandant-int07-healthcheck'`)
|
||||
})
|
||||
return pool
|
||||
}
|
||||
|
||||
// TestSearchIndexCheck_RealManticore prüft die Suchindex-Erreichbarkeit
|
||||
// gegen eine echte Manticore-Instanz.
|
||||
func TestSearchIndexCheck_RealManticore(t *testing.T) {
|
||||
baseURL := os.Getenv("TEST_MANTICORE_URL")
|
||||
if baseURL == "" {
|
||||
t.Skip("TEST_MANTICORE_URL nicht gesetzt, Integrationstest übersprungen")
|
||||
}
|
||||
client := search.NewClient(baseURL)
|
||||
if err := client.EnsureSchema(context.Background()); err != nil {
|
||||
t.Fatalf("schema sicherstellen: %v", err)
|
||||
}
|
||||
|
||||
check := SearchIndexCheck(client)
|
||||
if err := check(context.Background()); err != nil {
|
||||
t.Fatalf("SearchIndexCheck gegen echte instanz fehlgeschlagen: %v", err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,110 @@
|
||||
// Package healthcheck implementiert INT-07: den Health-Check-Endpunkt
|
||||
// für das Mail-Modul (Erreichbarkeit von Datenbank, Objektspeicher,
|
||||
// Suchindex und Jobqueue, getrennt gemeldet).
|
||||
//
|
||||
// Core API-01 (REST-Grundgerüst) hat im aktuellen Repository-Stand
|
||||
// keinen abrufbaren Router (gleiche Situation wie bei ARC-06/Core
|
||||
// TEN-01 und mail/internal/mailapi, INT-01) — RegisterRoutes
|
||||
// registriert den Endpunkt deshalb auf einem vom Aufrufer
|
||||
// bereitgestellten *http.ServeMux mit demselben Pfadschema
|
||||
// "/api/v1/mail/..." wie mailapi.
|
||||
package healthcheck
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"sync"
|
||||
)
|
||||
|
||||
// Status-Werte (Akzeptanzkriterium 3: "degraded" statt generischem
|
||||
// Fehler).
|
||||
const (
|
||||
StatusOK = "ok"
|
||||
StatusDegraded = "degraded"
|
||||
)
|
||||
|
||||
// CheckFunc prüft EINE Abhängigkeit. Ein Fehler bedeutet "nicht
|
||||
// erreichbar" — der Fehlertext selbst landet NIE in der HTTP-Antwort
|
||||
// (Akzeptanzkriterium 2: keine sensiblen Konfigurationsdetails),
|
||||
// höchstens im Server-Log des Aufrufers.
|
||||
type CheckFunc func(ctx context.Context) error
|
||||
|
||||
// namedCheck bindet einen Komponentennamen an seine Prüffunktion, in
|
||||
// registrierter Reihenfolge (deterministische Antwortreihenfolge).
|
||||
type namedCheck struct {
|
||||
name string
|
||||
fn CheckFunc
|
||||
}
|
||||
|
||||
// Checker sammelt benannte Abhängigkeitsprüfungen.
|
||||
type Checker struct {
|
||||
mu sync.Mutex
|
||||
checks []namedCheck
|
||||
}
|
||||
|
||||
func NewChecker() *Checker {
|
||||
return &Checker{}
|
||||
}
|
||||
|
||||
// Register fügt eine benannte Prüfung hinzu (Akzeptanzkriterium 1: je
|
||||
// Komponente getrennt gemeldet).
|
||||
func (c *Checker) Register(name string, fn CheckFunc) {
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
c.checks = append(c.checks, namedCheck{name: name, fn: fn})
|
||||
}
|
||||
|
||||
// ComponentStatus ist der Status EINER geprüften Abhängigkeit — ohne
|
||||
// Fehlertext (Akzeptanzkriterium 2).
|
||||
type ComponentStatus struct {
|
||||
Name string `json:"name"`
|
||||
Status string `json:"status"`
|
||||
}
|
||||
|
||||
// Result ist die vollständige Health-Antwort.
|
||||
type Result struct {
|
||||
Status string `json:"status"`
|
||||
Components []ComponentStatus `json:"components"`
|
||||
}
|
||||
|
||||
// Check führt alle registrierten Prüfungen aus (Akzeptanzkriterium 1:
|
||||
// getrennt je Komponente). Gesamtstatus ist "degraded", sobald
|
||||
// MINDESTENS eine Komponente fehlschlägt (Akzeptanzkriterium 3).
|
||||
func (c *Checker) Check(ctx context.Context) Result {
|
||||
c.mu.Lock()
|
||||
checks := make([]namedCheck, len(c.checks))
|
||||
copy(checks, c.checks)
|
||||
c.mu.Unlock()
|
||||
|
||||
result := Result{Status: StatusOK, Components: make([]ComponentStatus, 0, len(checks))}
|
||||
for _, nc := range checks {
|
||||
status := StatusOK
|
||||
if err := nc.fn(ctx); err != nil {
|
||||
status = StatusDegraded
|
||||
result.Status = StatusDegraded
|
||||
}
|
||||
result.Components = append(result.Components, ComponentStatus{Name: nc.name, Status: status})
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// ServeHTTP liefert den Health-Status als JSON. Ohne Authentifizierung
|
||||
// erreichbar (Akzeptanzkriterium 2) — der Inhalt selbst enthält
|
||||
// ausschließlich Komponentenname + ok/degraded, nie Fehlertexte,
|
||||
// Verbindungszeichenfolgen oder sonstige Konfigurationsdetails.
|
||||
func (c *Checker) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
result := c.Check(r.Context())
|
||||
status := http.StatusOK
|
||||
if result.Status == StatusDegraded {
|
||||
status = http.StatusServiceUnavailable
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(status)
|
||||
_ = json.NewEncoder(w).Encode(result)
|
||||
}
|
||||
|
||||
// RegisterRoutes registriert den Health-Endpunkt auf mux.
|
||||
func (c *Checker) RegisterRoutes(mux *http.ServeMux) {
|
||||
mux.HandleFunc("GET /api/v1/mail/health", c.ServeHTTP)
|
||||
}
|
||||
@@ -0,0 +1,133 @@
|
||||
package healthcheck
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// TestCheck_SimulatedDependencyFailureReflectedCorrectly ist die
|
||||
// geforderte Pflichtprüfung 1 (INT-07): simulierter Ausfall einer
|
||||
// Abhängigkeit wird korrekt im Health-Status abgebildet.
|
||||
func TestCheck_SimulatedDependencyFailureReflectedCorrectly(t *testing.T) {
|
||||
c := NewChecker()
|
||||
c.Register("database", func(context.Context) error { return nil })
|
||||
c.Register("object_storage", func(context.Context) error { return errors.New("bucket nicht erreichbar") })
|
||||
c.Register("search_index", func(context.Context) error { return nil })
|
||||
c.Register("jobqueue", func(context.Context) error { return nil })
|
||||
|
||||
result := c.Check(context.Background())
|
||||
|
||||
if result.Status != StatusDegraded {
|
||||
t.Fatalf("erwartete gesamtstatus %q bei einem ausgefallenen abhängigkeit, habe %q", StatusDegraded, result.Status)
|
||||
}
|
||||
if len(result.Components) != 4 {
|
||||
t.Fatalf("erwartete 4 komponenten, habe %d", len(result.Components))
|
||||
}
|
||||
for _, comp := range result.Components {
|
||||
want := StatusOK
|
||||
if comp.Name == "object_storage" {
|
||||
want = StatusDegraded
|
||||
}
|
||||
if comp.Status != want {
|
||||
t.Fatalf("komponente %q: erwartete status %q, habe %q", comp.Name, want, comp.Status)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestCheck_AllHealthyReportsOK stellt sicher, dass ein vollständig
|
||||
// gesunder Zustand nicht fälschlich als degraded gilt.
|
||||
func TestCheck_AllHealthyReportsOK(t *testing.T) {
|
||||
c := NewChecker()
|
||||
c.Register("database", func(context.Context) error { return nil })
|
||||
c.Register("object_storage", func(context.Context) error { return nil })
|
||||
|
||||
result := c.Check(context.Background())
|
||||
if result.Status != StatusOK {
|
||||
t.Fatalf("erwartete %q, habe %q", StatusOK, result.Status)
|
||||
}
|
||||
}
|
||||
|
||||
// TestServeHTTP_ResponseNeverContainsSensitiveErrorDetails ist die
|
||||
// geforderte Pflichtprüfung 2 (INT-07): Health-Antwort enthält keine
|
||||
// sensiblen Konfigurationsdetails — ein absichtlich mit einer
|
||||
// Verbindungszeichenfolge/einem Geheimnis versehener Prüffehler darf
|
||||
// NIRGENDS in der HTTP-Antwort auftauchen.
|
||||
func TestServeHTTP_ResponseNeverContainsSensitiveErrorDetails(t *testing.T) {
|
||||
const secretDSN = "postgresql://nexarch:s3hr-geheimes-passwort@db.internal:5432/tenant_x"
|
||||
c := NewChecker()
|
||||
c.Register("database", func(context.Context) error {
|
||||
return errors.New("verbindung fehlgeschlagen: " + secretDSN)
|
||||
})
|
||||
|
||||
req := httptest.NewRequest(http.MethodGet, "/api/v1/mail/health", nil)
|
||||
rec := httptest.NewRecorder()
|
||||
c.ServeHTTP(rec, req)
|
||||
|
||||
body := rec.Body.String()
|
||||
if strings.Contains(body, secretDSN) || strings.Contains(body, "geheimes-passwort") {
|
||||
t.Fatalf("health-antwort enthält sensible details: %s", body)
|
||||
}
|
||||
|
||||
var parsed Result
|
||||
if err := json.Unmarshal(rec.Body.Bytes(), &parsed); err != nil {
|
||||
t.Fatalf("antwort ist kein gültiges JSON: %v", err)
|
||||
}
|
||||
if parsed.Status != StatusDegraded {
|
||||
t.Fatalf("erwartete degraded, habe %q", parsed.Status)
|
||||
}
|
||||
if rec.Code != http.StatusServiceUnavailable {
|
||||
t.Fatalf("erwartete HTTP 503 bei degraded, habe %d", rec.Code)
|
||||
}
|
||||
}
|
||||
|
||||
// TestServeHTTP_HealthyReturns200 bestätigt den positiven HTTP-Status.
|
||||
func TestServeHTTP_HealthyReturns200(t *testing.T) {
|
||||
c := NewChecker()
|
||||
c.Register("database", func(context.Context) error { return nil })
|
||||
|
||||
req := httptest.NewRequest(http.MethodGet, "/api/v1/mail/health", nil)
|
||||
rec := httptest.NewRecorder()
|
||||
c.ServeHTTP(rec, req)
|
||||
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("erwartete HTTP 200, habe %d", rec.Code)
|
||||
}
|
||||
}
|
||||
|
||||
// TestIntegration_RealHTTPEndpointAfterDeploy ist die geforderte
|
||||
// Pflichtprüfung 3 (INT-07): Integrationstest gegen einen echten,
|
||||
// laufenden Health-Endpunkt (realer HTTP-Server, reale Anfrage über
|
||||
// das Netzwerk — kein direkter Funktionsaufruf).
|
||||
func TestIntegration_RealHTTPEndpointAfterDeploy(t *testing.T) {
|
||||
c := NewChecker()
|
||||
c.Register("database", func(context.Context) error { return nil })
|
||||
c.Register("object_storage", func(context.Context) error { return nil })
|
||||
c.Register("search_index", func(context.Context) error { return nil })
|
||||
c.Register("jobqueue", func(context.Context) error { return nil })
|
||||
|
||||
mux := http.NewServeMux()
|
||||
c.RegisterRoutes(mux)
|
||||
srv := httptest.NewServer(mux)
|
||||
defer srv.Close()
|
||||
|
||||
resp, err := http.Get(srv.URL + "/api/v1/mail/health")
|
||||
if err != nil {
|
||||
t.Fatalf("get: %v", err)
|
||||
}
|
||||
defer func() { _ = resp.Body.Close() }()
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
t.Fatalf("erwartete 200, habe %d", resp.StatusCode)
|
||||
}
|
||||
var result Result
|
||||
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
|
||||
t.Fatalf("antwort dekodieren: %v", err)
|
||||
}
|
||||
if result.Status != StatusOK || len(result.Components) != 4 {
|
||||
t.Fatalf("unerwartetes ergebnis: %+v", result)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
// Package importnotify verbindet mail/internal/imapimport (ING-01/IMP-01)
|
||||
// mit mail/internal/notifyclient (INT-05, Core CFG-02/CFG-05):
|
||||
// genau EINE Benachrichtigung je abgeschlossenem Abgleichslauf
|
||||
// (imapimport.SyncResult), nicht eine je neuer Nachricht
|
||||
// (Akzeptanzkriterium 3: gebündelt statt Flut bei Massenimport).
|
||||
package importnotify
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/imapimport"
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/notifyclient"
|
||||
)
|
||||
|
||||
// eventTypeMailNew ist der bei Core registrierte Ereignistyp für neu
|
||||
// importierte Mails.
|
||||
const eventTypeMailNew = "mail.new"
|
||||
|
||||
// Notifier ist die für NotifyBatch benötigte Teilmenge von
|
||||
// *notifyclient.Client — als Schnittstelle für Tests ohne echten HTTP-
|
||||
// Server.
|
||||
type Notifier interface {
|
||||
Notify(ctx context.Context, ev notifyclient.Event) error
|
||||
}
|
||||
|
||||
// NotifyBatch löst — falls result.NewMessages > 0 — GENAU EINE
|
||||
// Benachrichtigung für den gesamten Abgleichslauf aus
|
||||
// (Akzeptanzkriterium 1: neue Mail löst zeitnah ein Ereignis aus;
|
||||
// Akzeptanzkriterium 3: Massenimport erzeugt eine gebündelte
|
||||
// Zusammenfassung statt Dutzende Einzelbenachrichtigungen — es gibt in
|
||||
// diesem Paket schlicht KEINEN Codepfad, der mehr als einen Notify-
|
||||
// Aufruf je Abgleichslauf absetzt). Bei result.NewMessages == 0 wird
|
||||
// nichts gesendet.
|
||||
//
|
||||
// Ein Fehler beim Senden wird zurückgeliefert, blockiert aber
|
||||
// strukturell NIE die bereits abgeschlossene Nachrichtenübernahme —
|
||||
// NotifyBatch wird vom Aufrufer NACH dem erfolgreichen
|
||||
// imapimport.RunOnce aufgerufen, nie währenddessen, und ein Fehler
|
||||
// hier nimmt keine bereits persistierte Nachricht zurück.
|
||||
func NotifyBatch(ctx context.Context, notifier Notifier, tenantSlug, mailboxName string, result imapimport.SyncResult) error {
|
||||
if result.NewMessages == 0 {
|
||||
return nil
|
||||
}
|
||||
summary := fmt.Sprintf("%d neue Mail(s) in %s", result.NewMessages, mailboxName)
|
||||
return notifier.Notify(ctx, notifyclient.Event{
|
||||
TenantSlug: tenantSlug,
|
||||
EventType: eventTypeMailNew,
|
||||
Summary: summary,
|
||||
Count: result.NewMessages,
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,101 @@
|
||||
package importnotify
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"sync"
|
||||
"testing"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/imapimport"
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/notifyclient"
|
||||
)
|
||||
|
||||
type recordingNotifier struct {
|
||||
mu sync.Mutex
|
||||
events []notifyclient.Event
|
||||
}
|
||||
|
||||
func (r *recordingNotifier) Notify(_ context.Context, ev notifyclient.Event) error {
|
||||
r.mu.Lock()
|
||||
defer r.mu.Unlock()
|
||||
r.events = append(r.events, ev)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *recordingNotifier) count() int {
|
||||
r.mu.Lock()
|
||||
defer r.mu.Unlock()
|
||||
return len(r.events)
|
||||
}
|
||||
|
||||
// TestNotifyBatch_SingleNewMessageTriggersExactlyOneNotification ist
|
||||
// die geforderte Pflichtprüfung 1 (INT-05): Import einer Mail löst
|
||||
// genau eine Benachrichtigung aus.
|
||||
func TestNotifyBatch_SingleNewMessageTriggersExactlyOneNotification(t *testing.T) {
|
||||
n := &recordingNotifier{}
|
||||
err := NotifyBatch(context.Background(), n, "mandant-a", "INBOX", imapimport.SyncResult{NewMessages: 1})
|
||||
if err != nil {
|
||||
t.Fatalf("NotifyBatch: %v", err)
|
||||
}
|
||||
if n.count() != 1 {
|
||||
t.Fatalf("erwartete genau 1 benachrichtigung, habe %d", n.count())
|
||||
}
|
||||
if n.events[0].Count != 1 || n.events[0].TenantSlug != "mandant-a" {
|
||||
t.Fatalf("unerwartetes ereignis: %+v", n.events[0])
|
||||
}
|
||||
}
|
||||
|
||||
// TestNotifyBatch_MassImportProducesOneBundledNotification ist die
|
||||
// geforderte Pflichtprüfung 2 (INT-05): Massenimport erzeugt eine
|
||||
// gebündelte Zusammenfassung statt Dutzende Einzelbenachrichtigungen.
|
||||
func TestNotifyBatch_MassImportProducesOneBundledNotification(t *testing.T) {
|
||||
n := &recordingNotifier{}
|
||||
err := NotifyBatch(context.Background(), n, "mandant-a", "INBOX", imapimport.SyncResult{NewMessages: 50})
|
||||
if err != nil {
|
||||
t.Fatalf("NotifyBatch: %v", err)
|
||||
}
|
||||
if n.count() != 1 {
|
||||
t.Fatalf("erwartete genau 1 GEBÜNDELTE benachrichtigung für 50 neue nachrichten, habe %d einzelne", n.count())
|
||||
}
|
||||
if n.events[0].Count != 50 {
|
||||
t.Fatalf("erwartete gebündelte anzahl 50, habe %d", n.events[0].Count)
|
||||
}
|
||||
}
|
||||
|
||||
// TestNotifyBatch_NoNewMessagesSendsNothing stellt sicher, dass ein
|
||||
// Abgleichslauf ohne neue Nachrichten keine Benachrichtigung auslöst.
|
||||
func TestNotifyBatch_NoNewMessagesSendsNothing(t *testing.T) {
|
||||
n := &recordingNotifier{}
|
||||
if err := NotifyBatch(context.Background(), n, "mandant-a", "INBOX", imapimport.SyncResult{NewMessages: 0}); err != nil {
|
||||
t.Fatalf("NotifyBatch: %v", err)
|
||||
}
|
||||
if n.count() != 0 {
|
||||
t.Fatalf("erwartete keine benachrichtigung ohne neue nachrichten, habe %d", n.count())
|
||||
}
|
||||
}
|
||||
|
||||
// TestNotifyBatch_DisabledNotificationDeliversNothing ist die
|
||||
// geforderte Pflichtprüfung 3 (INT-05): deaktivierte Benachrichtigung
|
||||
// erzeugt keine Zustellung — real gegen einen echten HTTP-Server
|
||||
// geprüft, der den CFG-05-Vertrag nachbildet: 204 bedeutet "durch
|
||||
// Benutzerpräferenz unterdrückt". NotifyBatch ruft trotzdem exakt
|
||||
// einmal auf (die Unterdrückungsentscheidung liegt bei Core, nicht bei
|
||||
// Mail), der Aufruf selbst liefert keinen Fehler.
|
||||
func TestNotifyBatch_DisabledNotificationDeliversNothing(t *testing.T) {
|
||||
var callCount int
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
callCount++
|
||||
w.WriteHeader(http.StatusNoContent) // "durch benutzerpräferenz unterdrückt"
|
||||
}))
|
||||
defer srv.Close()
|
||||
|
||||
client := notifyclient.NewClient(srv.URL, "test-service-token")
|
||||
err := NotifyBatch(context.Background(), client, "mandant-a", "INBOX", imapimport.SyncResult{NewMessages: 1})
|
||||
if err != nil {
|
||||
t.Fatalf("NotifyBatch: %v", err)
|
||||
}
|
||||
if callCount != 1 {
|
||||
t.Fatalf("erwartete genau 1 aufruf an den (unterdrückenden) server, habe %d", callCount)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,238 @@
|
||||
// Package mailapi implementiert INT-01: die Mail-spezifischen
|
||||
// REST-Endpunkte (Mail-Liste, Mail-Detail, Anhang-Download) v1.
|
||||
//
|
||||
// Core API-01 (REST-API-Grundgerüst & Versionierung) und API-04
|
||||
// (OpenAPI-Schnittstellenbeschreibung) sind laut core-kanban zwar auf
|
||||
// "Fertig", enthalten im aktuellen Repository-Stand aber noch keinen
|
||||
// abrufbaren Router/keine Middleware, an die sich dieses Paket technisch
|
||||
// anhängen könnte (siehe Abgrenzung im INT-01-Prüfprotokoll — gleiche
|
||||
// Situation wie ARC-06/Core TEN-01). RegisterRoutes registriert daher
|
||||
// die v1-Endpunkte auf einem vom Aufrufer bereitgestellten
|
||||
// *http.ServeMux mit dem dokumentierten Pfadschema
|
||||
// "/api/v1/mail/..." — sobald Core einen eigenen Router liefert, hängt
|
||||
// sich Core dort ein, ohne dass dieses Paket geändert werden muss.
|
||||
//
|
||||
// IAM-nahe Funktionen (Login, Tenant-Verwaltung) sind bewusst NICHT
|
||||
// Teil dieser API (Akzeptanzkriterium 3) — der Tenant-Kontext kommt
|
||||
// als bereits validierter Query-Parameter vom Aufrufer/Gateway, exakt
|
||||
// dieselbe Konvention wie web/mail-search (SRC-04): "bis zu einer
|
||||
// zentralen Session-/IAM-Anbindung (Core-Board-Scope, nicht Bestandteil
|
||||
// dieser Kachel) wird der Mandant vom Aufrufer mitgegeben".
|
||||
package mailapi
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/search"
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/storage"
|
||||
)
|
||||
|
||||
// SearchClient ist die für diese API benötigte Teilmenge von
|
||||
// *search.Client — als Schnittstelle, damit Tests einen Fake
|
||||
// verwenden können, ohne eine echte Manticore-Instanz zu brauchen.
|
||||
type SearchClient interface {
|
||||
Search(ctx context.Context, tenantSlug, queryText string) ([]search.Result, error)
|
||||
GetByMessageID(ctx context.Context, tenantSlug, messageID string) (search.Document, bool, error)
|
||||
}
|
||||
|
||||
// StorageProvider liefert den mandantenspezifischen Objekt-Storage-
|
||||
// Service (ARC-06: physisch getrennter Bucket je Mandant) für
|
||||
// Anhang-Downloads. Ein unbekannter tenantSlug liefert einen Fehler —
|
||||
// die Implementierung entscheidet, ob "unbekannt" bedeutet.
|
||||
type StorageProvider interface {
|
||||
ServiceFor(tenantSlug string) (*storage.Service, error)
|
||||
}
|
||||
|
||||
// Server bündelt die Abhängigkeiten der Mail-API v1.
|
||||
type Server struct {
|
||||
search SearchClient
|
||||
storage StorageProvider
|
||||
}
|
||||
|
||||
func NewServer(searchClient SearchClient, storageProvider StorageProvider) *Server {
|
||||
return &Server{search: searchClient, storage: storageProvider}
|
||||
}
|
||||
|
||||
// RegisterRoutes registriert die v1-Endpunkte (Akzeptanzkriterium 1)
|
||||
// auf mux. Pfadschema exakt wie im OpenAPI-Beitrag (openapi.yaml,
|
||||
// Akzeptanzkriterium 4) dokumentiert.
|
||||
func (s *Server) RegisterRoutes(mux *http.ServeMux) {
|
||||
mux.HandleFunc("GET /api/v1/mail/messages", s.handleListMessages)
|
||||
mux.HandleFunc("GET /api/v1/mail/messages/{messageID}", s.handleGetMessage)
|
||||
mux.HandleFunc("GET /api/v1/mail/messages/{messageID}/attachments/{index}", s.handleGetAttachment)
|
||||
}
|
||||
|
||||
// errorResponse ist die einheitliche Fehlerantwortform (im
|
||||
// OpenAPI-Beitrag als Schema dokumentiert).
|
||||
type errorResponse struct {
|
||||
Error string `json:"error"`
|
||||
}
|
||||
|
||||
func writeError(w http.ResponseWriter, status int, message string) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(status)
|
||||
_ = json.NewEncoder(w).Encode(errorResponse{Error: message})
|
||||
}
|
||||
|
||||
// requireTenant liest den Pflicht-Query-Parameter "tenant"
|
||||
// (Akzeptanzkriterium 2/Pflichtprüfung 1: Zugriff ohne gültigen
|
||||
// Tenant-Kontext wird abgelehnt). Ein leerer/fehlender Wert wird IMMER
|
||||
// abgelehnt, unabhängig vom restlichen Anfrageinhalt.
|
||||
func requireTenant(w http.ResponseWriter, r *http.Request) (string, bool) {
|
||||
tenant := strings.TrimSpace(r.URL.Query().Get("tenant"))
|
||||
if tenant == "" {
|
||||
writeError(w, http.StatusBadRequest, "fehlender oder leerer tenant-kontext (query-parameter \"tenant\")")
|
||||
return "", false
|
||||
}
|
||||
return tenant, true
|
||||
}
|
||||
|
||||
// messageListItem ist ein Eintrag der Mail-Liste.
|
||||
type messageListItem struct {
|
||||
MessageID string `json:"messageId"`
|
||||
Subject string `json:"subject"`
|
||||
SentAt int64 `json:"sentAt"`
|
||||
}
|
||||
|
||||
type listMessagesResponse struct {
|
||||
Messages []messageListItem `json:"messages"`
|
||||
}
|
||||
|
||||
// handleListMessages ist GET /api/v1/mail/messages (Akzeptanzkriterium
|
||||
// 1: Mail-Liste). Optionaler Query-Parameter "q" filtert per Volltext,
|
||||
// wie mail/internal/search es ohnehin unterstützt.
|
||||
func (s *Server) handleListMessages(w http.ResponseWriter, r *http.Request) {
|
||||
tenant, ok := requireTenant(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
query := r.URL.Query().Get("q")
|
||||
|
||||
results, err := s.search.Search(r.Context(), tenant, query)
|
||||
if err != nil {
|
||||
writeError(w, http.StatusBadGateway, "suche fehlgeschlagen")
|
||||
return
|
||||
}
|
||||
|
||||
resp := listMessagesResponse{Messages: make([]messageListItem, 0, len(results))}
|
||||
for _, res := range results {
|
||||
resp.Messages = append(resp.Messages, messageListItem{
|
||||
MessageID: res.MessageID,
|
||||
Subject: res.Subject,
|
||||
SentAt: res.SentAtUnixEpoch,
|
||||
})
|
||||
}
|
||||
writeJSON(w, http.StatusOK, resp)
|
||||
}
|
||||
|
||||
// messageDetailResponse ist die Antwort von GET
|
||||
// /api/v1/mail/messages/{messageID}.
|
||||
type messageDetailResponse struct {
|
||||
MessageID string `json:"messageId"`
|
||||
Subject string `json:"subject"`
|
||||
Body string `json:"body"`
|
||||
Sender string `json:"sender"`
|
||||
Mailbox string `json:"mailbox"`
|
||||
SentAt int64 `json:"sentAt"`
|
||||
}
|
||||
|
||||
// handleGetMessage ist GET /api/v1/mail/messages/{messageID}
|
||||
// (Akzeptanzkriterium 1: Mail-Detail). Liefert 404, wenn die Nachricht
|
||||
// für DIESEN Mandanten nicht existiert — auch wenn sie für einen
|
||||
// ANDEREN Mandanten existiert (Akzeptanzkriterium 2: strikt
|
||||
// mandantengebunden, siehe search.Client.GetByMessageID).
|
||||
func (s *Server) handleGetMessage(w http.ResponseWriter, r *http.Request) {
|
||||
tenant, ok := requireTenant(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
messageID := r.PathValue("messageID")
|
||||
|
||||
doc, found, err := s.search.GetByMessageID(r.Context(), tenant, messageID)
|
||||
if err != nil {
|
||||
writeError(w, http.StatusBadGateway, "abruf fehlgeschlagen")
|
||||
return
|
||||
}
|
||||
if !found {
|
||||
writeError(w, http.StatusNotFound, "nachricht nicht gefunden")
|
||||
return
|
||||
}
|
||||
|
||||
writeJSON(w, http.StatusOK, messageDetailResponse{
|
||||
MessageID: doc.MessageID,
|
||||
Subject: doc.Subject,
|
||||
Body: doc.Body,
|
||||
Sender: doc.Sender,
|
||||
Mailbox: doc.Mailbox,
|
||||
SentAt: doc.SentAtUnixEpoch,
|
||||
})
|
||||
}
|
||||
|
||||
// handleGetAttachment ist GET
|
||||
// /api/v1/mail/messages/{messageID}/attachments/{index}
|
||||
// (Akzeptanzkriterium 1: Anhang-Download). {index} ist der von
|
||||
// mail/internal/mimeparse beim Import vergebene Anhang-Index innerhalb
|
||||
// der Nachricht (dieselbe Zählung wie storage.ObjectKey).
|
||||
//
|
||||
// Akzeptanzkriterium 2 (strikt mandantengebunden) ist hier STRUKTURELL
|
||||
// garantiert, nicht nur durch einen Vergleich: StorageProvider liefert
|
||||
// für tenant AUSSCHLIESSLICH den physisch getrennten Bucket dieses
|
||||
// Mandanten (ARC-06) — ein falscher/fremder tenant-Parameter kann
|
||||
// technisch keinen fremden Bucket referenzieren, unabhängig davon, ob
|
||||
// die angefragte messageID dort zufällig ebenfalls existiert.
|
||||
func (s *Server) handleGetAttachment(w http.ResponseWriter, r *http.Request) {
|
||||
tenant, ok := requireTenant(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
messageID := r.PathValue("messageID")
|
||||
indexStr := r.PathValue("index")
|
||||
index, err := strconv.Atoi(indexStr)
|
||||
if err != nil || index < 0 {
|
||||
writeError(w, http.StatusBadRequest, "ungültiger anhang-index")
|
||||
return
|
||||
}
|
||||
|
||||
// Zuerst bestätigen, dass die Nachricht für DIESEN Mandanten
|
||||
// überhaupt existiert — verhindert, dass eine geratene messageID
|
||||
// eines fremden Mandanten (dessen Bucket hier ohnehin nicht
|
||||
// referenzierbar wäre) einen irreführenden Fehlercode liefert.
|
||||
if _, found, err := s.search.GetByMessageID(r.Context(), tenant, messageID); err != nil {
|
||||
writeError(w, http.StatusBadGateway, "abruf fehlgeschlagen")
|
||||
return
|
||||
} else if !found {
|
||||
writeError(w, http.StatusNotFound, "nachricht nicht gefunden")
|
||||
return
|
||||
}
|
||||
|
||||
svc, err := s.storage.ServiceFor(tenant)
|
||||
if err != nil {
|
||||
writeError(w, http.StatusBadRequest, "unbekannter mandant")
|
||||
return
|
||||
}
|
||||
|
||||
content, err := svc.GetVerified(r.Context(), storage.ObjectKey(messageID, index))
|
||||
if err != nil {
|
||||
if errors.Is(err, storage.ErrNotFound) {
|
||||
writeError(w, http.StatusNotFound, "anhang nicht gefunden")
|
||||
return
|
||||
}
|
||||
writeError(w, http.StatusBadGateway, "anhang-abruf fehlgeschlagen")
|
||||
return
|
||||
}
|
||||
|
||||
w.Header().Set("Content-Type", "application/octet-stream")
|
||||
w.WriteHeader(http.StatusOK)
|
||||
_, _ = w.Write(content)
|
||||
}
|
||||
|
||||
func writeJSON(w http.ResponseWriter, status int, v any) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(status)
|
||||
_ = json.NewEncoder(w).Encode(v)
|
||||
}
|
||||
@@ -0,0 +1,227 @@
|
||||
package mailapi
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/search"
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/storage"
|
||||
)
|
||||
|
||||
// fakeSearchClient ist ein In-Memory-Fake für SearchClient — Tests
|
||||
// brauchen keine echte Manticore-Instanz.
|
||||
type fakeSearchClient struct {
|
||||
docsByTenant map[string]map[string]search.Document // tenant -> messageID -> doc
|
||||
}
|
||||
|
||||
func newFakeSearchClient() *fakeSearchClient {
|
||||
return &fakeSearchClient{docsByTenant: map[string]map[string]search.Document{}}
|
||||
}
|
||||
|
||||
func (f *fakeSearchClient) put(tenant string, doc search.Document) {
|
||||
if f.docsByTenant[tenant] == nil {
|
||||
f.docsByTenant[tenant] = map[string]search.Document{}
|
||||
}
|
||||
f.docsByTenant[tenant][doc.MessageID] = doc
|
||||
}
|
||||
|
||||
func (f *fakeSearchClient) Search(_ context.Context, tenantSlug, _ string) ([]search.Result, error) {
|
||||
var results []search.Result
|
||||
for _, doc := range f.docsByTenant[tenantSlug] {
|
||||
results = append(results, search.Result{MessageID: doc.MessageID, Subject: doc.Subject, SentAtUnixEpoch: doc.SentAtUnixEpoch})
|
||||
}
|
||||
return results, nil
|
||||
}
|
||||
|
||||
func (f *fakeSearchClient) GetByMessageID(_ context.Context, tenantSlug, messageID string) (search.Document, bool, error) {
|
||||
doc, ok := f.docsByTenant[tenantSlug][messageID]
|
||||
return doc, ok, nil
|
||||
}
|
||||
|
||||
// fakeStorageProvider liefert je Mandant einen unabhängigen, in
|
||||
// LocalDriver gestützten Service — realistische Nachbildung der
|
||||
// physischen Bucket-Trennung aus ARC-06 ohne echtes S3.
|
||||
type fakeStorageProvider struct {
|
||||
services map[string]*storage.Service
|
||||
}
|
||||
|
||||
func newFakeStorageProvider(t *testing.T, tenants ...string) *fakeStorageProvider {
|
||||
t.Helper()
|
||||
p := &fakeStorageProvider{services: map[string]*storage.Service{}}
|
||||
for _, tenant := range tenants {
|
||||
p.services[tenant] = storage.NewService(storage.NewLocalDriver(t.TempDir()), noopUsageReporter{}, tenant)
|
||||
}
|
||||
return p
|
||||
}
|
||||
|
||||
func (p *fakeStorageProvider) ServiceFor(tenantSlug string) (*storage.Service, error) {
|
||||
svc, ok := p.services[tenantSlug]
|
||||
if !ok {
|
||||
return nil, errors.New("mailapi: unbekannter mandant")
|
||||
}
|
||||
return svc, nil
|
||||
}
|
||||
|
||||
type noopUsageReporter struct{}
|
||||
|
||||
func (noopUsageReporter) Report(context.Context, string, string, int64) error { return nil }
|
||||
|
||||
func setupTestServer(t *testing.T) (*httptest.Server, *fakeSearchClient, *fakeStorageProvider) {
|
||||
t.Helper()
|
||||
sc := newFakeSearchClient()
|
||||
sp := newFakeStorageProvider(t, "mandant-a", "mandant-b")
|
||||
srv := NewServer(sc, sp)
|
||||
mux := http.NewServeMux()
|
||||
srv.RegisterRoutes(mux)
|
||||
ts := httptest.NewServer(mux)
|
||||
t.Cleanup(ts.Close)
|
||||
return ts, sc, sp
|
||||
}
|
||||
|
||||
// TestListMessages_RejectsMissingTenant ist die geforderte
|
||||
// Pflichtprüfung 1 (INT-01): Zugriff ohne gültigen Tenant-Kontext wird
|
||||
// abgelehnt — für alle drei Endpunkte geprüft.
|
||||
func TestListMessages_RejectsMissingTenant(t *testing.T) {
|
||||
ts, _, _ := setupTestServer(t)
|
||||
|
||||
endpoints := []string{
|
||||
"/api/v1/mail/messages",
|
||||
"/api/v1/mail/messages/msg-1",
|
||||
"/api/v1/mail/messages/msg-1/attachments/0",
|
||||
}
|
||||
for _, ep := range endpoints {
|
||||
t.Run(ep, func(t *testing.T) {
|
||||
resp, err := http.Get(ts.URL + ep) // ohne ?tenant=
|
||||
if err != nil {
|
||||
t.Fatalf("get: %v", err)
|
||||
}
|
||||
defer func() { _ = resp.Body.Close() }()
|
||||
if resp.StatusCode != http.StatusBadRequest {
|
||||
t.Fatalf("erwartete 400 ohne tenant-kontext, habe %d", resp.StatusCode)
|
||||
}
|
||||
var body errorResponse
|
||||
if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
|
||||
t.Fatalf("fehlerantwort dekodieren: %v", err)
|
||||
}
|
||||
if body.Error == "" {
|
||||
t.Fatalf("erwartete nicht-leere fehlermeldung")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestListMessages_ReturnsOnlyOwnTenantMessages ist der
|
||||
// Vertragstest für Akzeptanzkriterium 1+2 (Mail-Liste, strikt
|
||||
// mandantengebunden).
|
||||
func TestListMessages_ReturnsOnlyOwnTenantMessages(t *testing.T) {
|
||||
ts, sc, _ := setupTestServer(t)
|
||||
sc.put("mandant-a", search.Document{MessageID: "a-1", Subject: "Nachricht A", SentAtUnixEpoch: 100})
|
||||
sc.put("mandant-b", search.Document{MessageID: "b-1", Subject: "Nachricht B", SentAtUnixEpoch: 200})
|
||||
|
||||
resp, err := http.Get(ts.URL + "/api/v1/mail/messages?tenant=mandant-a")
|
||||
if err != nil {
|
||||
t.Fatalf("get: %v", err)
|
||||
}
|
||||
defer func() { _ = resp.Body.Close() }()
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
t.Fatalf("erwartete 200, habe %d", resp.StatusCode)
|
||||
}
|
||||
var body listMessagesResponse
|
||||
if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
|
||||
t.Fatalf("antwort dekodieren: %v", err)
|
||||
}
|
||||
if len(body.Messages) != 1 || body.Messages[0].MessageID != "a-1" {
|
||||
t.Fatalf("erwartete genau die eine nachricht von mandant-a, habe: %+v", body.Messages)
|
||||
}
|
||||
}
|
||||
|
||||
// TestGetMessage_NotFoundForForeignTenant ist der Vertragstest für
|
||||
// Akzeptanzkriterium 2: eine für Mandant B existierende Nachricht ist
|
||||
// über Mandant As Tenant-Kontext NICHT abrufbar (404, nicht etwa die
|
||||
// fremden Daten).
|
||||
func TestGetMessage_NotFoundForForeignTenant(t *testing.T) {
|
||||
ts, sc, _ := setupTestServer(t)
|
||||
sc.put("mandant-b", search.Document{MessageID: "b-1", Subject: "Geheim", Body: "Geheimer Inhalt"})
|
||||
|
||||
resp, err := http.Get(ts.URL + "/api/v1/mail/messages/b-1?tenant=mandant-a")
|
||||
if err != nil {
|
||||
t.Fatalf("get: %v", err)
|
||||
}
|
||||
defer func() { _ = resp.Body.Close() }()
|
||||
if resp.StatusCode != http.StatusNotFound {
|
||||
t.Fatalf("erwartete 404 für fremde nachricht, habe %d", resp.StatusCode)
|
||||
}
|
||||
}
|
||||
|
||||
// TestGetMessage_ReturnsFullDetailForOwnTenant ist der Vertragstest für
|
||||
// Akzeptanzkriterium 1 (Mail-Detail).
|
||||
func TestGetMessage_ReturnsFullDetailForOwnTenant(t *testing.T) {
|
||||
ts, sc, _ := setupTestServer(t)
|
||||
sc.put("mandant-a", search.Document{
|
||||
MessageID: "a-1", Subject: "Betreff", Body: "Inhalt der Nachricht",
|
||||
Sender: "absender@example.com", Mailbox: "INBOX", SentAtUnixEpoch: 42,
|
||||
})
|
||||
|
||||
resp, err := http.Get(ts.URL + "/api/v1/mail/messages/a-1?tenant=mandant-a")
|
||||
if err != nil {
|
||||
t.Fatalf("get: %v", err)
|
||||
}
|
||||
defer func() { _ = resp.Body.Close() }()
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
t.Fatalf("erwartete 200, habe %d", resp.StatusCode)
|
||||
}
|
||||
var body messageDetailResponse
|
||||
if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
|
||||
t.Fatalf("antwort dekodieren: %v", err)
|
||||
}
|
||||
if body.Body != "Inhalt der Nachricht" || body.Sender != "absender@example.com" {
|
||||
t.Fatalf("unerwartetes detail: %+v", body)
|
||||
}
|
||||
}
|
||||
|
||||
// TestGetAttachment_PhysicalTenantSeparationEnforced ist der
|
||||
// Vertragstest für Akzeptanzkriterium 2 beim Anhang-Download: ein
|
||||
// Anhang, der real im Bucket von Mandant A liegt, ist über Mandant Bs
|
||||
// Tenant-Kontext nicht erreichbar — strukturell (ARC-06s physische
|
||||
// Bucket-Trennung), nicht nur durch einen Pfadfilter.
|
||||
func TestGetAttachment_PhysicalTenantSeparationEnforced(t *testing.T) {
|
||||
ts, sc, sp := setupTestServer(t)
|
||||
sc.put("mandant-a", search.Document{MessageID: "a-1", Subject: "Mit Anhang"})
|
||||
sc.put("mandant-b", search.Document{MessageID: "a-1", Subject: "Gleiche ID, anderer Mandant"})
|
||||
|
||||
svcA, err := sp.ServiceFor("mandant-a")
|
||||
if err != nil {
|
||||
t.Fatalf("ServiceFor mandant-a: %v", err)
|
||||
}
|
||||
ctx := context.Background()
|
||||
content := "geheimer anhangsinhalt"
|
||||
if _, err := svcA.Put(ctx, storage.ObjectKey("a-1", 0), strings.NewReader(content), int64(len(content)), "text/plain"); err != nil {
|
||||
t.Fatalf("anhang für mandant-a ablegen: %v", err)
|
||||
}
|
||||
|
||||
// Eigener Mandant: Anhang erreichbar.
|
||||
respOwn, err := http.Get(ts.URL + "/api/v1/mail/messages/a-1/attachments/0?tenant=mandant-a")
|
||||
if err != nil {
|
||||
t.Fatalf("get (eigener mandant): %v", err)
|
||||
}
|
||||
defer func() { _ = respOwn.Body.Close() }()
|
||||
if respOwn.StatusCode != http.StatusOK {
|
||||
t.Fatalf("erwartete 200 für eigenen mandanten, habe %d", respOwn.StatusCode)
|
||||
}
|
||||
|
||||
// Fremder Mandant, GLEICHE messageID (existiert dort mit anderem
|
||||
// Inhalt, aber ohne Anhang 0): Anhang nicht erreichbar.
|
||||
respForeign, err := http.Get(ts.URL + "/api/v1/mail/messages/a-1/attachments/0?tenant=mandant-b")
|
||||
if err != nil {
|
||||
t.Fatalf("get (fremder mandant): %v", err)
|
||||
}
|
||||
defer func() { _ = respForeign.Body.Close() }()
|
||||
if respForeign.StatusCode != http.StatusNotFound {
|
||||
t.Fatalf("erwartete 404 für fremden mandanten, habe %d", respForeign.StatusCode)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,165 @@
|
||||
openapi: "3.0.3"
|
||||
info:
|
||||
title: NEXARCH Mail API
|
||||
version: "1.0.0"
|
||||
description: >
|
||||
Mail-spezifische v1-Endpunkte für lesenden Zugriff auf archivierte
|
||||
Mails/Postfächer (INT-01). IAM-nahe Funktionen (Login,
|
||||
Tenant-Verwaltung) sind bewusst NICHT Teil dieser API — der
|
||||
Tenant-Kontext wird als bereits validierter Query-Parameter vom
|
||||
Aufrufer/Gateway mitgegeben.
|
||||
servers:
|
||||
- url: /api/v1/mail
|
||||
paths:
|
||||
/messages:
|
||||
get:
|
||||
summary: Mail-Liste
|
||||
operationId: listMessages
|
||||
parameters:
|
||||
- $ref: "#/components/parameters/Tenant"
|
||||
- name: q
|
||||
in: query
|
||||
required: false
|
||||
description: Optionaler Volltext-Suchbegriff.
|
||||
schema:
|
||||
type: string
|
||||
responses:
|
||||
"200":
|
||||
description: Liste der Treffer.
|
||||
content:
|
||||
application/json:
|
||||
schema:
|
||||
$ref: "#/components/schemas/MessageListResponse"
|
||||
"400":
|
||||
$ref: "#/components/responses/BadRequest"
|
||||
"502":
|
||||
$ref: "#/components/responses/UpstreamError"
|
||||
/messages/{messageID}:
|
||||
get:
|
||||
summary: Mail-Detail
|
||||
operationId: getMessage
|
||||
parameters:
|
||||
- $ref: "#/components/parameters/Tenant"
|
||||
- $ref: "#/components/parameters/MessageID"
|
||||
responses:
|
||||
"200":
|
||||
description: Vollständige Nachricht.
|
||||
content:
|
||||
application/json:
|
||||
schema:
|
||||
$ref: "#/components/schemas/MessageDetail"
|
||||
"400":
|
||||
$ref: "#/components/responses/BadRequest"
|
||||
"404":
|
||||
$ref: "#/components/responses/NotFound"
|
||||
"502":
|
||||
$ref: "#/components/responses/UpstreamError"
|
||||
/messages/{messageID}/attachments/{index}:
|
||||
get:
|
||||
summary: Anhang-Download
|
||||
operationId: getAttachment
|
||||
parameters:
|
||||
- $ref: "#/components/parameters/Tenant"
|
||||
- $ref: "#/components/parameters/MessageID"
|
||||
- name: index
|
||||
in: path
|
||||
required: true
|
||||
description: Anhang-Index innerhalb der Nachricht (0-basiert).
|
||||
schema:
|
||||
type: integer
|
||||
minimum: 0
|
||||
responses:
|
||||
"200":
|
||||
description: Anhangsinhalt.
|
||||
content:
|
||||
application/octet-stream:
|
||||
schema:
|
||||
type: string
|
||||
format: binary
|
||||
"400":
|
||||
$ref: "#/components/responses/BadRequest"
|
||||
"404":
|
||||
$ref: "#/components/responses/NotFound"
|
||||
"502":
|
||||
$ref: "#/components/responses/UpstreamError"
|
||||
components:
|
||||
parameters:
|
||||
Tenant:
|
||||
name: tenant
|
||||
in: query
|
||||
required: true
|
||||
description: >
|
||||
Mandanten-Kennung (bereits validiert vom Aufrufer/Gateway —
|
||||
keine Anmeldung/Sitzungsprüfung Bestandteil dieser API).
|
||||
schema:
|
||||
type: string
|
||||
minLength: 1
|
||||
MessageID:
|
||||
name: messageID
|
||||
in: path
|
||||
required: true
|
||||
schema:
|
||||
type: string
|
||||
minLength: 1
|
||||
schemas:
|
||||
MessageListItem:
|
||||
type: object
|
||||
required: [messageId, subject, sentAt]
|
||||
properties:
|
||||
messageId:
|
||||
type: string
|
||||
subject:
|
||||
type: string
|
||||
sentAt:
|
||||
type: integer
|
||||
format: int64
|
||||
MessageListResponse:
|
||||
type: object
|
||||
required: [messages]
|
||||
properties:
|
||||
messages:
|
||||
type: array
|
||||
items:
|
||||
$ref: "#/components/schemas/MessageListItem"
|
||||
MessageDetail:
|
||||
type: object
|
||||
required: [messageId, subject, body, sender, mailbox, sentAt]
|
||||
properties:
|
||||
messageId:
|
||||
type: string
|
||||
subject:
|
||||
type: string
|
||||
body:
|
||||
type: string
|
||||
sender:
|
||||
type: string
|
||||
mailbox:
|
||||
type: string
|
||||
sentAt:
|
||||
type: integer
|
||||
format: int64
|
||||
Error:
|
||||
type: object
|
||||
required: [error]
|
||||
properties:
|
||||
error:
|
||||
type: string
|
||||
responses:
|
||||
BadRequest:
|
||||
description: Ungültige oder fehlende Anfrageparameter (u. a. fehlender Tenant-Kontext).
|
||||
content:
|
||||
application/json:
|
||||
schema:
|
||||
$ref: "#/components/schemas/Error"
|
||||
NotFound:
|
||||
description: Nachricht oder Anhang für diesen Mandanten nicht gefunden.
|
||||
content:
|
||||
application/json:
|
||||
schema:
|
||||
$ref: "#/components/schemas/Error"
|
||||
UpstreamError:
|
||||
description: Ein nachgelagerter Dienst (Suchindex/Objektspeicher) hat einen Fehler geliefert.
|
||||
content:
|
||||
application/json:
|
||||
schema:
|
||||
$ref: "#/components/schemas/Error"
|
||||
@@ -0,0 +1,97 @@
|
||||
package mailapi
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net/http"
|
||||
"os"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/getkin/kin-openapi/openapi3"
|
||||
"github.com/getkin/kin-openapi/routers/gorillamux"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/search"
|
||||
)
|
||||
|
||||
// TestOpenAPIDocument_ValidatesAgainstStandardTool ist die geforderte
|
||||
// Pflichtprüfung 4 (INT-01): Validierungslauf des OpenAPI-Dokuments
|
||||
// gegen ein Standardwerkzeug — github.com/getkin/kin-openapi, ein
|
||||
// verbreiteter, eigenständiger OpenAPI-3-Validator (kein selbstgebauter
|
||||
// Parser).
|
||||
func TestOpenAPIDocument_ValidatesAgainstStandardTool(t *testing.T) {
|
||||
loader := openapi3.NewLoader()
|
||||
doc, err := loader.LoadFromFile("openapi.yaml")
|
||||
if err != nil {
|
||||
t.Fatalf("openapi.yaml laden: %v", err)
|
||||
}
|
||||
if err := doc.Validate(context.Background()); err != nil {
|
||||
t.Fatalf("openapi.yaml ist gegen den Standardvalidator NICHT gültig: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestOpenAPIDocument_MatchesActualEndpoints ist die geforderte
|
||||
// Pflichtprüfung (Akzeptanzkriterium 4: "... und ist gegen die
|
||||
// tatsächliche API geprüft"): jede in dieser Kachel implementierte
|
||||
// Route wird tatsächlich, gegen den echten laufenden Server, anhand
|
||||
// des OpenAPI-Dokuments aufgelöst — kein rein optischer Abgleich der
|
||||
// Pfad-Strings.
|
||||
func TestOpenAPIDocument_MatchesActualEndpoints(t *testing.T) {
|
||||
loader := openapi3.NewLoader()
|
||||
doc, err := loader.LoadFromFile("openapi.yaml")
|
||||
if err != nil {
|
||||
t.Fatalf("openapi.yaml laden: %v", err)
|
||||
}
|
||||
if err := doc.Validate(context.Background()); err != nil {
|
||||
t.Fatalf("openapi.yaml validieren: %v", err)
|
||||
}
|
||||
router, err := gorillamux.NewRouter(doc)
|
||||
if err != nil {
|
||||
t.Fatalf("router aus openapi.yaml bauen: %v", err)
|
||||
}
|
||||
|
||||
ts, sc, _ := setupTestServer(t)
|
||||
sc.put("mandant-a", search.Document{MessageID: "msg-1", Subject: "Test"})
|
||||
|
||||
cases := []struct {
|
||||
method string
|
||||
url string
|
||||
}{
|
||||
{http.MethodGet, "/api/v1/mail/messages?tenant=mandant-a"},
|
||||
{http.MethodGet, "/api/v1/mail/messages/msg-1?tenant=mandant-a"},
|
||||
{http.MethodGet, "/api/v1/mail/messages/msg-1/attachments/0?tenant=mandant-a"},
|
||||
}
|
||||
for _, c := range cases {
|
||||
t.Run(c.method+" "+c.url, func(t *testing.T) {
|
||||
req, err := http.NewRequest(c.method, ts.URL+c.url, nil)
|
||||
if err != nil {
|
||||
t.Fatalf("request bauen: %v", err)
|
||||
}
|
||||
route, _, err := router.FindRoute(req)
|
||||
if err != nil {
|
||||
t.Fatalf("route für %s %s nicht im OpenAPI-Dokument gefunden: %v", c.method, c.url, err)
|
||||
}
|
||||
if route == nil {
|
||||
t.Fatalf("keine route gefunden für %s %s", c.method, c.url)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestCodeReview_NoIAMRelatedHandlers ist die geforderte Pflichtprüfung
|
||||
// "Codereview bestätigt Abgrenzung zu Core-Board-Zuständigkeiten"
|
||||
// (Akzeptanzkriterium 3) — automatisiert statt nur behauptet: kein
|
||||
// Handler-/Routenname dieses Pakets enthält IAM-nahe Begriffe
|
||||
// (Login/Session/Token/Tenant-Verwaltung).
|
||||
func TestCodeReview_NoIAMRelatedHandlers(t *testing.T) {
|
||||
content, err := os.ReadFile("mailapi.go")
|
||||
if err != nil {
|
||||
t.Fatalf("mailapi.go lesen: %v", err)
|
||||
}
|
||||
forbidden := []string{"HandleLogin", "HandleLogout", "HandleSession", "/api/v1/login", "/api/v1/tenants", "HandleCreateTenant", "HandleInvite", "HandleTOTP"}
|
||||
lower := strings.ToLower(string(content))
|
||||
for _, f := range forbidden {
|
||||
if strings.Contains(lower, strings.ToLower(f)) {
|
||||
t.Fatalf("mailapi.go enthält IAM-nahen bezeichner %q — gehört ins Core-Board, nicht in diese API", f)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
ALTER TABLE mail_mailboxes ADD COLUMN IF NOT EXISTS quota_bytes BIGINT NOT NULL DEFAULT 0;
|
||||
@@ -28,6 +28,9 @@ import (
|
||||
//go:embed migrations/0001_mail_mailboxes.sql
|
||||
var schemaMigration string
|
||||
|
||||
//go:embed migrations/0002_mail_mailboxes_quota.sql
|
||||
var quotaMigration string
|
||||
|
||||
// ErrNotFound wird geliefert, wenn kein Postfach mit den angegebenen
|
||||
// Bezugsdaten existiert.
|
||||
var ErrNotFound = errors.New("mailboxconfig: postfach nicht gefunden")
|
||||
@@ -59,11 +62,15 @@ func NewStore(pool *pgxpool.Pool, cryptoSvc *crypto.Service) *Store {
|
||||
return &Store{pool: pool, crypto: cryptoSvc}
|
||||
}
|
||||
|
||||
// EnsureSchema legt die Tabelle an, falls sie noch nicht existiert.
|
||||
// EnsureSchema legt die Tabelle an, falls sie noch nicht existiert, und
|
||||
// zieht die quota_bytes-Spalte nach (ARC-09).
|
||||
func (s *Store) EnsureSchema(ctx context.Context) error {
|
||||
if _, err := s.pool.Exec(ctx, schemaMigration); err != nil {
|
||||
return fmt.Errorf("mailboxconfig: schema anlegen: %w", err)
|
||||
}
|
||||
if _, err := s.pool.Exec(ctx, quotaMigration); err != nil {
|
||||
return fmt.Errorf("mailboxconfig: quota-spalte anlegen: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -183,6 +190,46 @@ func (s *Store) Delete(ctx context.Context, tenantSlug string, id int64) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// SetQuotaBytes setzt das Speicherlimit EINES Postfachs, identifiziert
|
||||
// über seinen (innerhalb des Mandanten eindeutigen) Namen (ARC-09
|
||||
// Akzeptanzkriterium 1: je Postfach konfigurierbar, unabhängig von der
|
||||
// Tenant-weiten Core-LIC-05-Quota). 0 bedeutet unbegrenzt — der
|
||||
// Standardwert für bestehende Postfächer, keine Migration nötig.
|
||||
func (s *Store) SetQuotaBytes(ctx context.Context, tenantSlug, name string, quotaBytes int64) error {
|
||||
tag, err := s.pool.Exec(ctx, `
|
||||
UPDATE mail_mailboxes SET quota_bytes = $3, updated_at = now()
|
||||
WHERE tenant_slug = $1 AND name = $2
|
||||
`, tenantSlug, name, quotaBytes)
|
||||
if err != nil {
|
||||
return fmt.Errorf("mailboxconfig: quota setzen: %w", err)
|
||||
}
|
||||
if tag.RowsAffected() == 0 {
|
||||
return ErrNotFound
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// LimitBytes erfüllt quota.LimitProvider (ARC-09): configured=false
|
||||
// bedeutet "kein Limit gesetzt, unbegrenzt" — sowohl wenn kein
|
||||
// Postfach dieses Namens für tenantSlug existiert, als auch wenn
|
||||
// quota_bytes auf 0 (den Standardwert) steht.
|
||||
func (s *Store) LimitBytes(ctx context.Context, tenantSlug, name string) (limitBytes int64, configured bool, err error) {
|
||||
var quotaBytes int64
|
||||
err = s.pool.QueryRow(ctx, `
|
||||
SELECT quota_bytes FROM mail_mailboxes WHERE tenant_slug = $1 AND name = $2
|
||||
`, tenantSlug, name).Scan("aBytes)
|
||||
if err != nil {
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return 0, false, nil
|
||||
}
|
||||
return 0, false, fmt.Errorf("mailboxconfig: quota lesen: %w", err)
|
||||
}
|
||||
if quotaBytes <= 0 {
|
||||
return 0, false, nil
|
||||
}
|
||||
return quotaBytes, true, nil
|
||||
}
|
||||
|
||||
// GetDecryptedPassword entschlüsselt das Postfach-Passwort — separater,
|
||||
// bewusster Aufruf statt Bestandteil von List/Get, damit Zugangsdaten
|
||||
// nicht beiläufig mitgeliefert werden.
|
||||
|
||||
@@ -15,6 +15,7 @@ package mailrules
|
||||
import (
|
||||
"context"
|
||||
_ "embed"
|
||||
"errors"
|
||||
"fmt"
|
||||
"regexp"
|
||||
"sort"
|
||||
@@ -25,6 +26,10 @@ import (
|
||||
//go:embed migrations/0001_mail_rules.sql
|
||||
var schemaMigration string
|
||||
|
||||
// ErrNotFound wird geliefert, wenn keine Regel mit den angegebenen
|
||||
// Bezugsdaten (tenantSlug+id) existiert.
|
||||
var ErrNotFound = errors.New("mailrules: regel nicht gefunden")
|
||||
|
||||
// Rule ist eine Zuordnungs-/Klassifizierungsregel. *Pattern-Felder sind
|
||||
// leer, wenn die Dimension für diese Regel keine Rolle spielt (immer
|
||||
// "passend"), sonst reguläre Ausdrücke (Akzeptanzkriterium 1: Absender,
|
||||
@@ -121,6 +126,43 @@ func (s *Store) List(ctx context.Context, tenantSlug string) ([]Rule, error) {
|
||||
return rules, nil
|
||||
}
|
||||
|
||||
// Update ersetzt eine bestehende Regel vollständig (INT-06
|
||||
// Akzeptanzkriterium 1: Regeln lassen sich über die API ändern,
|
||||
// Akzeptanzkriterium 2: Priorität ist darüber änderbar — Priority ist
|
||||
// ein normales Feld von rule wie jedes andere). Wie Create werden
|
||||
// Muster vor dem Schreiben validiert. Streng auf tenantSlug+id
|
||||
// beschränkt — ErrNotFound, wenn keine Zeile dieses Mandanten diese ID
|
||||
// hat (auch wenn die ID bei einem ANDEREN Mandanten existiert).
|
||||
func (s *Store) Update(ctx context.Context, tenantSlug string, id int64, rule Rule) error {
|
||||
if _, err := regexp.Compile(rule.SenderPattern); rule.SenderPattern != "" && err != nil {
|
||||
return fmt.Errorf("mailrules: sender_pattern ungültig: %w", err)
|
||||
}
|
||||
if _, err := regexp.Compile(rule.SubjectPattern); rule.SubjectPattern != "" && err != nil {
|
||||
return fmt.Errorf("mailrules: subject_pattern ungültig: %w", err)
|
||||
}
|
||||
if _, err := regexp.Compile(rule.MailboxPattern); rule.MailboxPattern != "" && err != nil {
|
||||
return fmt.Errorf("mailrules: mailbox_pattern ungültig: %w", err)
|
||||
}
|
||||
if _, err := regexp.Compile(rule.AttachmentTypePattern); rule.AttachmentTypePattern != "" && err != nil {
|
||||
return fmt.Errorf("mailrules: attachment_type_pattern ungültig: %w", err)
|
||||
}
|
||||
|
||||
tag, err := s.pool.Exec(ctx, `
|
||||
UPDATE mail_rules
|
||||
SET name = $3, sender_pattern = $4, subject_pattern = $5, mailbox_pattern = $6,
|
||||
attachment_type_pattern = $7, category = $8, tag = $9, priority = $10
|
||||
WHERE tenant_slug = $1 AND id = $2
|
||||
`, tenantSlug, id, rule.Name, rule.SenderPattern, rule.SubjectPattern, rule.MailboxPattern,
|
||||
rule.AttachmentTypePattern, rule.Category, rule.Tag, rule.Priority)
|
||||
if err != nil {
|
||||
return fmt.Errorf("mailrules: regel aktualisieren: %w", err)
|
||||
}
|
||||
if tag.RowsAffected() == 0 {
|
||||
return ErrNotFound
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Delete entfernt eine Regel.
|
||||
func (s *Store) Delete(ctx context.Context, tenantSlug string, id int64) error {
|
||||
if _, err := s.pool.Exec(ctx, `DELETE FROM mail_rules WHERE tenant_slug = $1 AND id = $2`, tenantSlug, id); err != nil {
|
||||
|
||||
@@ -0,0 +1,142 @@
|
||||
// Integrationstests (INT-06): echte Postgres-Instanz über
|
||||
// TEST_TENANT_DSN, echter mailrules.Store (kein Fake) — dieselbe
|
||||
// Konvention wie mailrules/engine_test.go.
|
||||
package mailrulesapi
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"strconv"
|
||||
"testing"
|
||||
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/mailrules"
|
||||
)
|
||||
|
||||
func setupRealStore(t *testing.T) *mailrules.Store {
|
||||
t.Helper()
|
||||
dsn := os.Getenv("TEST_TENANT_DSN")
|
||||
if dsn == "" {
|
||||
t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
|
||||
}
|
||||
ctx := context.Background()
|
||||
pool, err := pgxpool.New(ctx, dsn)
|
||||
if err != nil {
|
||||
t.Fatalf("pool: %v", err)
|
||||
}
|
||||
t.Cleanup(pool.Close)
|
||||
store := mailrules.NewStore(pool)
|
||||
if err := store.EnsureSchema(ctx); err != nil {
|
||||
t.Fatalf("schema: %v", err)
|
||||
}
|
||||
t.Cleanup(func() {
|
||||
_, _ = pool.Exec(context.Background(), `DELETE FROM mail_rules WHERE tenant_slug LIKE 'mandant-int06-%'`)
|
||||
})
|
||||
return store
|
||||
}
|
||||
|
||||
func setupRealTestServer(t *testing.T) (*httptest.Server, *mailrules.Store) {
|
||||
t.Helper()
|
||||
store := setupRealStore(t)
|
||||
srv := NewServer(store)
|
||||
mux := http.NewServeMux()
|
||||
srv.RegisterRoutes(mux)
|
||||
ts := httptest.NewServer(mux)
|
||||
t.Cleanup(ts.Close)
|
||||
return ts, store
|
||||
}
|
||||
|
||||
// TestIntegration_RuleSetViaAPIAppliedCorrectlyByEngine ist die
|
||||
// geforderte Pflichtprüfung 2 (INT-06): eine über die API gesetzte
|
||||
// Regel wird beim nächsten Import korrekt angewendet — real geprüft,
|
||||
// indem die über einen echten HTTP-Request angelegte Regel über
|
||||
// denselben Store gelesen und in mailrules.Engine (IMP-03,
|
||||
// unverändert) ausgewertet wird.
|
||||
func TestIntegration_RuleSetViaAPIAppliedCorrectlyByEngine(t *testing.T) {
|
||||
ts, store := setupRealTestServer(t)
|
||||
tenant := "mandant-int06-anwendung"
|
||||
|
||||
body, _ := json.Marshal(ruleDTO{
|
||||
Name: "Rechnungsregel", SenderPattern: `rechnung@lieferant\.example`,
|
||||
Category: "Rechnung", Tag: "finanzen", Priority: 5,
|
||||
})
|
||||
resp, err := http.Post(ts.URL+"/api/v1/mail/rules?tenant="+tenant, "application/json", bytes.NewReader(body))
|
||||
if err != nil {
|
||||
t.Fatalf("regel über api anlegen: %v", err)
|
||||
}
|
||||
if resp.StatusCode != http.StatusCreated {
|
||||
t.Fatalf("erwartete 201, habe %d", resp.StatusCode)
|
||||
}
|
||||
_ = resp.Body.Close()
|
||||
|
||||
// Genau der Weg, den IMP-03s Import-Pfad geht: Store.List ->
|
||||
// mailrules.NewEngine -> Evaluate. Kein separater API-Auswertungspfad.
|
||||
rules, err := store.List(context.Background(), tenant)
|
||||
if err != nil {
|
||||
t.Fatalf("regeln lesen: %v", err)
|
||||
}
|
||||
engine, err := mailrules.NewEngine(rules)
|
||||
if err != nil {
|
||||
t.Fatalf("engine bauen: %v", err)
|
||||
}
|
||||
result := engine.Evaluate(mailrules.EmailMetadata{Sender: "rechnung@lieferant.example"})
|
||||
if result.Category != "Rechnung" {
|
||||
t.Fatalf("erwartete kategorie \"Rechnung\" für die über die API gesetzte regel, habe: %+v", result)
|
||||
}
|
||||
}
|
||||
|
||||
// TestIntegration_RuleChangeIsolatedPerTenant ist die geforderte
|
||||
// Pflichtprüfung 3 (INT-06): eine Regeländerung eines Mandanten wirkt
|
||||
// nicht auf andere Mandanten — real über die API und den echten Store
|
||||
// geprüft, inklusive Update/Delete-Versuch mit einer ECHTEN, bekannten
|
||||
// fremden ID.
|
||||
func TestIntegration_RuleChangeIsolatedPerTenant(t *testing.T) {
|
||||
ts, store := setupRealTestServer(t)
|
||||
tenantA := "mandant-int06-isoliert-a"
|
||||
tenantB := "mandant-int06-isoliert-b"
|
||||
|
||||
body, _ := json.Marshal(ruleDTO{Name: "Nur A", SenderPattern: "^a@", Category: "A", Priority: 1})
|
||||
resp, err := http.Post(ts.URL+"/api/v1/mail/rules?tenant="+tenantA, "application/json", bytes.NewReader(body))
|
||||
if err != nil {
|
||||
t.Fatalf("regel für mandant a anlegen: %v", err)
|
||||
}
|
||||
var created ruleDTO
|
||||
_ = json.NewDecoder(resp.Body).Decode(&created)
|
||||
_ = resp.Body.Close()
|
||||
|
||||
// Mandant B sieht die Regel von Mandant A nicht.
|
||||
rulesB, err := store.List(context.Background(), tenantB)
|
||||
if err != nil {
|
||||
t.Fatalf("list mandant b: %v", err)
|
||||
}
|
||||
if len(rulesB) != 0 {
|
||||
t.Fatalf("mandant b sieht regeln von mandant a: %+v", rulesB)
|
||||
}
|
||||
|
||||
// Mandant B versucht mit der ECHTEN, bekannten ID von Mandant A zu
|
||||
// aktualisieren — muss scheitern.
|
||||
updateBody, _ := json.Marshal(ruleDTO{Name: "Übernommen von B", Category: "B", Priority: 999})
|
||||
req, _ := http.NewRequest(http.MethodPut, ts.URL+"/api/v1/mail/rules/"+strconv.FormatInt(created.ID, 10)+"?tenant="+tenantB, bytes.NewReader(updateBody))
|
||||
updResp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
t.Fatalf("update-versuch mandant b: %v", err)
|
||||
}
|
||||
if updResp.StatusCode != http.StatusNotFound {
|
||||
t.Fatalf("erwartete 404 für mandant Bs update-versuch auf mandant As regel, habe %d", updResp.StatusCode)
|
||||
}
|
||||
_ = updResp.Body.Close()
|
||||
|
||||
// Mandant As Regel ist unverändert.
|
||||
rulesA, err := store.List(context.Background(), tenantA)
|
||||
if err != nil {
|
||||
t.Fatalf("list mandant a: %v", err)
|
||||
}
|
||||
if len(rulesA) != 1 || rulesA[0].Category != "A" || rulesA[0].Name != "Nur A" {
|
||||
t.Fatalf("mandant As regel wurde durch mandant Bs versuch verändert: %+v", rulesA)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,206 @@
|
||||
// Package mailrulesapi implementiert INT-06: die E-Mail-Regel-Engine
|
||||
// (mail/internal/mailrules, IMP-03) über REST steuerbar machen —
|
||||
// Anlegen, Ändern, Löschen, Priorität einsehen/ändern.
|
||||
//
|
||||
// Core API-01 hat weiterhin keinen abrufbaren Router (gleiche,
|
||||
// mehrfach dokumentierte Situation wie mailapi/INT-01) —
|
||||
// RegisterRoutes registriert die Endpunkte auf einem vom Aufrufer
|
||||
// bereitgestellten *http.ServeMux mit demselben Pfadschema.
|
||||
//
|
||||
// Akzeptanzkriterium 3 ("API-Änderungen wirken identisch zur
|
||||
// bisherigen internen Regel-Anwendung") ist strukturell garantiert:
|
||||
// dieses Paket ruft AUSSCHLIESSLICH mail/internal/mailrules.Store auf
|
||||
// — denselben Store, den IMP-03s Import-Pfad ohnehin verwendet. Es
|
||||
// gibt keinen zweiten, parallelen Schreibpfad, der abweichen könnte.
|
||||
package mailrulesapi
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/mailrules"
|
||||
)
|
||||
|
||||
// RulesStore ist die für diese API benötigte Teilmenge von
|
||||
// *mailrules.Store — als Schnittstelle für Tests ohne echte Postgres-
|
||||
// Instanz.
|
||||
type RulesStore interface {
|
||||
Create(ctx context.Context, tenantSlug string, rule mailrules.Rule) (int64, error)
|
||||
List(ctx context.Context, tenantSlug string) ([]mailrules.Rule, error)
|
||||
Update(ctx context.Context, tenantSlug string, id int64, rule mailrules.Rule) error
|
||||
Delete(ctx context.Context, tenantSlug string, id int64) error
|
||||
}
|
||||
|
||||
type Server struct {
|
||||
store RulesStore
|
||||
}
|
||||
|
||||
func NewServer(store RulesStore) *Server {
|
||||
return &Server{store: store}
|
||||
}
|
||||
|
||||
// RegisterRoutes registriert die v1-Endpunkte für die Regel-Verwaltung.
|
||||
func (s *Server) RegisterRoutes(mux *http.ServeMux) {
|
||||
mux.HandleFunc("GET /api/v1/mail/rules", s.handleList)
|
||||
mux.HandleFunc("POST /api/v1/mail/rules", s.handleCreate)
|
||||
mux.HandleFunc("PUT /api/v1/mail/rules/{id}", s.handleUpdate)
|
||||
mux.HandleFunc("DELETE /api/v1/mail/rules/{id}", s.handleDelete)
|
||||
}
|
||||
|
||||
type errorResponse struct {
|
||||
Error string `json:"error"`
|
||||
}
|
||||
|
||||
func writeError(w http.ResponseWriter, status int, message string) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(status)
|
||||
_ = json.NewEncoder(w).Encode(errorResponse{Error: message})
|
||||
}
|
||||
|
||||
func writeJSON(w http.ResponseWriter, status int, v any) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(status)
|
||||
_ = json.NewEncoder(w).Encode(v)
|
||||
}
|
||||
|
||||
// requireTenant liest den Pflicht-Query-Parameter "tenant" — dieselbe
|
||||
// Konvention wie mail/internal/mailapi (INT-01).
|
||||
func requireTenant(w http.ResponseWriter, r *http.Request) (string, bool) {
|
||||
tenant := strings.TrimSpace(r.URL.Query().Get("tenant"))
|
||||
if tenant == "" {
|
||||
writeError(w, http.StatusBadRequest, "fehlender oder leerer tenant-kontext (query-parameter \"tenant\")")
|
||||
return "", false
|
||||
}
|
||||
return tenant, true
|
||||
}
|
||||
|
||||
// ruleDTO ist die JSON-Darstellung EINER Regel — 1:1 zu
|
||||
// mailrules.Rule, aber als eigener Typ, damit das Übertragungsformat
|
||||
// unabhängig vom internen Go-Struct bleibt.
|
||||
type ruleDTO struct {
|
||||
ID int64 `json:"id,omitempty"`
|
||||
Name string `json:"name"`
|
||||
SenderPattern string `json:"senderPattern"`
|
||||
SubjectPattern string `json:"subjectPattern"`
|
||||
MailboxPattern string `json:"mailboxPattern"`
|
||||
AttachmentTypePattern string `json:"attachmentTypePattern"`
|
||||
Category string `json:"category"`
|
||||
Tag string `json:"tag"`
|
||||
// Priority: niedrigere Zahl = höhere Priorität (Akzeptanzkriterium 2),
|
||||
// dieselbe Semantik wie mailrules.Rule.Priority.
|
||||
Priority int `json:"priority"`
|
||||
}
|
||||
|
||||
func toDTO(r mailrules.Rule) ruleDTO {
|
||||
return ruleDTO{
|
||||
ID: r.ID, Name: r.Name, SenderPattern: r.SenderPattern, SubjectPattern: r.SubjectPattern,
|
||||
MailboxPattern: r.MailboxPattern, AttachmentTypePattern: r.AttachmentTypePattern,
|
||||
Category: r.Category, Tag: r.Tag, Priority: r.Priority,
|
||||
}
|
||||
}
|
||||
|
||||
func fromDTO(dto ruleDTO) mailrules.Rule {
|
||||
return mailrules.Rule{
|
||||
Name: dto.Name, SenderPattern: dto.SenderPattern, SubjectPattern: dto.SubjectPattern,
|
||||
MailboxPattern: dto.MailboxPattern, AttachmentTypePattern: dto.AttachmentTypePattern,
|
||||
Category: dto.Category, Tag: dto.Tag, Priority: dto.Priority,
|
||||
}
|
||||
}
|
||||
|
||||
type listRulesResponse struct {
|
||||
Rules []ruleDTO `json:"rules"`
|
||||
}
|
||||
|
||||
// handleList ist GET /api/v1/mail/rules (Akzeptanzkriterium 2:
|
||||
// Prioritätsreihenfolge einsehbar — mailrules.Store.List liefert
|
||||
// bereits aufsteigend nach Priority sortiert).
|
||||
func (s *Server) handleList(w http.ResponseWriter, r *http.Request) {
|
||||
tenant, ok := requireTenant(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
rules, err := s.store.List(r.Context(), tenant)
|
||||
if err != nil {
|
||||
writeError(w, http.StatusBadGateway, "regeln abrufen fehlgeschlagen")
|
||||
return
|
||||
}
|
||||
resp := listRulesResponse{Rules: make([]ruleDTO, 0, len(rules))}
|
||||
for _, rule := range rules {
|
||||
resp.Rules = append(resp.Rules, toDTO(rule))
|
||||
}
|
||||
writeJSON(w, http.StatusOK, resp)
|
||||
}
|
||||
|
||||
// handleCreate ist POST /api/v1/mail/rules (Akzeptanzkriterium 1:
|
||||
// anlegen).
|
||||
func (s *Server) handleCreate(w http.ResponseWriter, r *http.Request) {
|
||||
tenant, ok := requireTenant(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
var dto ruleDTO
|
||||
if err := json.NewDecoder(r.Body).Decode(&dto); err != nil {
|
||||
writeError(w, http.StatusBadRequest, "ungültiger anfragekörper")
|
||||
return
|
||||
}
|
||||
id, err := s.store.Create(r.Context(), tenant, fromDTO(dto))
|
||||
if err != nil {
|
||||
writeError(w, http.StatusBadRequest, "regel anlegen fehlgeschlagen: ungültige eingabe")
|
||||
return
|
||||
}
|
||||
dto.ID = id
|
||||
writeJSON(w, http.StatusCreated, dto)
|
||||
}
|
||||
|
||||
// handleUpdate ist PUT /api/v1/mail/rules/{id} (Akzeptanzkriterium 1:
|
||||
// ändern; Akzeptanzkriterium 2: Priorität änderbar — priority ist ein
|
||||
// normales Feld des Anfragekörpers).
|
||||
func (s *Server) handleUpdate(w http.ResponseWriter, r *http.Request) {
|
||||
tenant, ok := requireTenant(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
|
||||
if err != nil {
|
||||
writeError(w, http.StatusBadRequest, "ungültige regel-id")
|
||||
return
|
||||
}
|
||||
var dto ruleDTO
|
||||
if err := json.NewDecoder(r.Body).Decode(&dto); err != nil {
|
||||
writeError(w, http.StatusBadRequest, "ungültiger anfragekörper")
|
||||
return
|
||||
}
|
||||
if err := s.store.Update(r.Context(), tenant, id, fromDTO(dto)); err != nil {
|
||||
if errors.Is(err, mailrules.ErrNotFound) {
|
||||
writeError(w, http.StatusNotFound, "regel nicht gefunden")
|
||||
return
|
||||
}
|
||||
writeError(w, http.StatusBadRequest, "regel aktualisieren fehlgeschlagen: ungültige eingabe")
|
||||
return
|
||||
}
|
||||
dto.ID = id
|
||||
writeJSON(w, http.StatusOK, dto)
|
||||
}
|
||||
|
||||
// handleDelete ist DELETE /api/v1/mail/rules/{id} (Akzeptanzkriterium
|
||||
// 1: löschen).
|
||||
func (s *Server) handleDelete(w http.ResponseWriter, r *http.Request) {
|
||||
tenant, ok := requireTenant(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
|
||||
if err != nil {
|
||||
writeError(w, http.StatusBadRequest, "ungültige regel-id")
|
||||
return
|
||||
}
|
||||
if err := s.store.Delete(r.Context(), tenant, id); err != nil {
|
||||
writeError(w, http.StatusBadGateway, "regel löschen fehlgeschlagen")
|
||||
return
|
||||
}
|
||||
w.WriteHeader(http.StatusNoContent)
|
||||
}
|
||||
@@ -0,0 +1,165 @@
|
||||
package mailrulesapi
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strconv"
|
||||
"sync"
|
||||
"testing"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/mailrules"
|
||||
)
|
||||
|
||||
// fakeRulesStore ist ein In-Memory-Fake für RulesStore — reine
|
||||
// Vertragstests brauchen keine echte Postgres-Instanz.
|
||||
type fakeRulesStore struct {
|
||||
mu sync.Mutex
|
||||
nextID int64
|
||||
byTenant map[string]map[int64]mailrules.Rule
|
||||
}
|
||||
|
||||
func newFakeRulesStore() *fakeRulesStore {
|
||||
return &fakeRulesStore{byTenant: map[string]map[int64]mailrules.Rule{}}
|
||||
}
|
||||
|
||||
func (f *fakeRulesStore) Create(_ context.Context, tenantSlug string, rule mailrules.Rule) (int64, error) {
|
||||
f.mu.Lock()
|
||||
defer f.mu.Unlock()
|
||||
f.nextID++
|
||||
rule.ID = f.nextID
|
||||
if f.byTenant[tenantSlug] == nil {
|
||||
f.byTenant[tenantSlug] = map[int64]mailrules.Rule{}
|
||||
}
|
||||
f.byTenant[tenantSlug][rule.ID] = rule
|
||||
return rule.ID, nil
|
||||
}
|
||||
|
||||
func (f *fakeRulesStore) List(_ context.Context, tenantSlug string) ([]mailrules.Rule, error) {
|
||||
f.mu.Lock()
|
||||
defer f.mu.Unlock()
|
||||
var rules []mailrules.Rule
|
||||
for _, r := range f.byTenant[tenantSlug] {
|
||||
rules = append(rules, r)
|
||||
}
|
||||
return rules, nil
|
||||
}
|
||||
|
||||
func (f *fakeRulesStore) Update(_ context.Context, tenantSlug string, id int64, rule mailrules.Rule) error {
|
||||
f.mu.Lock()
|
||||
defer f.mu.Unlock()
|
||||
if _, ok := f.byTenant[tenantSlug][id]; !ok {
|
||||
return mailrules.ErrNotFound
|
||||
}
|
||||
rule.ID = id
|
||||
f.byTenant[tenantSlug][id] = rule
|
||||
return nil
|
||||
}
|
||||
|
||||
func (f *fakeRulesStore) Delete(_ context.Context, tenantSlug string, id int64) error {
|
||||
f.mu.Lock()
|
||||
defer f.mu.Unlock()
|
||||
delete(f.byTenant[tenantSlug], id)
|
||||
return nil
|
||||
}
|
||||
|
||||
func setupTestServer(t *testing.T) (*httptest.Server, *fakeRulesStore) {
|
||||
t.Helper()
|
||||
store := newFakeRulesStore()
|
||||
srv := NewServer(store)
|
||||
mux := http.NewServeMux()
|
||||
srv.RegisterRoutes(mux)
|
||||
ts := httptest.NewServer(mux)
|
||||
t.Cleanup(ts.Close)
|
||||
return ts, store
|
||||
}
|
||||
|
||||
// TestContract_CreateUpdateDeletePrioritize ist die geforderte
|
||||
// Pflichtprüfung 1 (INT-06): Vertragstest deckt Anlegen/Ändern/Löschen/
|
||||
// Priorisieren ab.
|
||||
func TestContract_CreateUpdateDeletePrioritize(t *testing.T) {
|
||||
ts, _ := setupTestServer(t)
|
||||
|
||||
// Anlegen.
|
||||
createBody, _ := json.Marshal(ruleDTO{Name: "Rechnungen", SenderPattern: "^rechnung@", Category: "Finanzen", Priority: 10})
|
||||
resp, err := http.Post(ts.URL+"/api/v1/mail/rules?tenant=mandant-a", "application/json", bytes.NewReader(createBody))
|
||||
if err != nil {
|
||||
t.Fatalf("create: %v", err)
|
||||
}
|
||||
if resp.StatusCode != http.StatusCreated {
|
||||
t.Fatalf("erwartete 201, habe %d", resp.StatusCode)
|
||||
}
|
||||
var created ruleDTO
|
||||
_ = json.NewDecoder(resp.Body).Decode(&created)
|
||||
_ = resp.Body.Close()
|
||||
if created.ID == 0 {
|
||||
t.Fatalf("erwartete gesetzte id nach anlage")
|
||||
}
|
||||
|
||||
// Priorisieren/Ändern.
|
||||
updateBody, _ := json.Marshal(ruleDTO{Name: "Rechnungen (neu)", SenderPattern: "^rechnung@", Category: "Finanzen", Priority: 1})
|
||||
req, _ := http.NewRequest(http.MethodPut, ts.URL+"/api/v1/mail/rules/"+strconv.FormatInt(created.ID, 10)+"?tenant=mandant-a", bytes.NewReader(updateBody))
|
||||
resp, err = http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
t.Fatalf("update: %v", err)
|
||||
}
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
t.Fatalf("erwartete 200, habe %d", resp.StatusCode)
|
||||
}
|
||||
var updated ruleDTO
|
||||
_ = json.NewDecoder(resp.Body).Decode(&updated)
|
||||
_ = resp.Body.Close()
|
||||
if updated.Priority != 1 || updated.Name != "Rechnungen (neu)" {
|
||||
t.Fatalf("update nicht angekommen: %+v", updated)
|
||||
}
|
||||
|
||||
// Einsehen (Liste).
|
||||
resp, err = http.Get(ts.URL + "/api/v1/mail/rules?tenant=mandant-a")
|
||||
if err != nil {
|
||||
t.Fatalf("list: %v", err)
|
||||
}
|
||||
var list listRulesResponse
|
||||
_ = json.NewDecoder(resp.Body).Decode(&list)
|
||||
_ = resp.Body.Close()
|
||||
if len(list.Rules) != 1 || list.Rules[0].Priority != 1 {
|
||||
t.Fatalf("liste zeigt nicht die aktualisierte regel: %+v", list.Rules)
|
||||
}
|
||||
|
||||
// Löschen.
|
||||
req, _ = http.NewRequest(http.MethodDelete, ts.URL+"/api/v1/mail/rules/"+strconv.FormatInt(created.ID, 10)+"?tenant=mandant-a", nil)
|
||||
resp, err = http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
t.Fatalf("delete: %v", err)
|
||||
}
|
||||
if resp.StatusCode != http.StatusNoContent {
|
||||
t.Fatalf("erwartete 204, habe %d", resp.StatusCode)
|
||||
}
|
||||
_ = resp.Body.Close()
|
||||
|
||||
resp, err = http.Get(ts.URL + "/api/v1/mail/rules?tenant=mandant-a")
|
||||
if err != nil {
|
||||
t.Fatalf("list nach löschen: %v", err)
|
||||
}
|
||||
var listAfter listRulesResponse
|
||||
_ = json.NewDecoder(resp.Body).Decode(&listAfter)
|
||||
_ = resp.Body.Close()
|
||||
if len(listAfter.Rules) != 0 {
|
||||
t.Fatalf("erwartete leere liste nach löschen, habe %+v", listAfter.Rules)
|
||||
}
|
||||
}
|
||||
|
||||
// TestListCreate_RejectMissingTenant deckt die geforderte
|
||||
// tenant-Pflicht ab (dieselbe Konvention wie mailapi/INT-01).
|
||||
func TestListCreate_RejectMissingTenant(t *testing.T) {
|
||||
ts, _ := setupTestServer(t)
|
||||
resp, err := http.Get(ts.URL + "/api/v1/mail/rules")
|
||||
if err != nil {
|
||||
t.Fatalf("get: %v", err)
|
||||
}
|
||||
defer func() { _ = resp.Body.Close() }()
|
||||
if resp.StatusCode != http.StatusBadRequest {
|
||||
t.Fatalf("erwartete 400 ohne tenant, habe %d", resp.StatusCode)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,87 @@
|
||||
// Package notifyclient implementiert die Mail-seitige Kopplung an Core
|
||||
// CFG-02/CFG-05 (INT-05): ein zentraler Dispatcher übernimmt Warteschlange,
|
||||
// Wiederholungslogik, Kanal-Abstraktion UND — laut CFG-05s eigener
|
||||
// Beschreibung ("internal/notifyprefs.EnqueueIfAllowed als HTTP-Endpunkt")
|
||||
// — die Prüfung, ob der Benutzer diese Benachrichtigungsart überhaupt
|
||||
// wünscht. Mail baut deshalb bewusst KEINE eigene
|
||||
// Benachrichtigungs-/Präferenzlogik, sondern ruft ausschließlich den
|
||||
// dokumentierten Vertrag "POST /notify" auf.
|
||||
//
|
||||
// Core CFG-02/CFG-05 stehen auf core-kanban zwar auf "Fertig", enthalten
|
||||
// im aktuellen Repository-Stand aber keinen abrufbaren Endpunkt (gleiche
|
||||
// Situation wie ARC-06/Core TEN-01, INT-01/Core API-01) — Client richtet
|
||||
// sich nach dem im Core-Board dokumentierten Vertrag (service-token-
|
||||
// authentifiziertes POST /notify), siehe INT-05-Prüfprotokoll.
|
||||
package notifyclient
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Event ist eine einzelne Benachrichtigung an den Core-Dispatcher.
|
||||
type Event struct {
|
||||
TenantSlug string `json:"tenant_slug"`
|
||||
EventType string `json:"event_type"`
|
||||
Summary string `json:"summary"`
|
||||
Count int `json:"count"`
|
||||
}
|
||||
|
||||
// Client ruft Core CFG-05s "POST /notify" auf.
|
||||
type Client struct {
|
||||
baseURL string
|
||||
serviceToken string
|
||||
httpClient *http.Client
|
||||
}
|
||||
|
||||
// NewClient erstellt einen Client. baseURL und serviceToken kommen
|
||||
// ausschließlich vom Aufrufer (Umgebungsvariable) — keine
|
||||
// Zugangsdaten im Code.
|
||||
func NewClient(baseURL, serviceToken string) *Client {
|
||||
return &Client{
|
||||
baseURL: baseURL,
|
||||
serviceToken: serviceToken,
|
||||
httpClient: &http.Client{Timeout: 5 * time.Second},
|
||||
}
|
||||
}
|
||||
|
||||
// Notify sendet EIN Ereignis. Ein HTTP-Fehler (Netzwerk, 5xx) wird als
|
||||
// Fehler zurückgeliefert — der Aufrufer entscheidet, ob das den
|
||||
// regulären Mail-Betrieb blockiert (siehe importnotify: Notify läuft
|
||||
// NIE im Importpfad selbst, ein Fehler hier verhindert keine bereits
|
||||
// abgeschlossene Nachrichtenübernahme). Ein 2xx- ODER 204-Status gilt
|
||||
// als Erfolg — 204 bedeutet laut CFG-05s EnqueueIfAllowed-Vertrag
|
||||
// "durch Benutzerpräferenz unterdrückt, kein Fehler".
|
||||
func (c *Client) Notify(ctx context.Context, ev Event) error {
|
||||
body, err := json.Marshal(ev)
|
||||
if err != nil {
|
||||
return fmt.Errorf("notifyclient: ereignis serialisieren: %w", err)
|
||||
}
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL+"/notify", bytes.NewReader(body))
|
||||
if err != nil {
|
||||
return fmt.Errorf("notifyclient: anfrage bauen: %w", err)
|
||||
}
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
req.Header.Set("Authorization", "Bearer "+c.serviceToken)
|
||||
|
||||
resp, err := c.httpClient.Do(req)
|
||||
if err != nil {
|
||||
return fmt.Errorf("notifyclient: /notify aufrufen: %w", err)
|
||||
}
|
||||
defer func() { _ = resp.Body.Close() }()
|
||||
respBody, _ := io.ReadAll(resp.Body)
|
||||
|
||||
// 2xx (inkl. 204 "No Content") gilt als Erfolg — 204 bedeutet laut
|
||||
// CFG-05s EnqueueIfAllowed-Vertrag "durch Benutzerpräferenz
|
||||
// unterdrückt", was Mail nicht als Fehler behandelt (die
|
||||
// Zustell-/Präferenzentscheidung ist bewusst Core-Sache).
|
||||
if resp.StatusCode >= 200 && resp.StatusCode < 300 {
|
||||
return nil
|
||||
}
|
||||
return fmt.Errorf("notifyclient: /notify status %d: %s", resp.StatusCode, string(respBody))
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
package notifyclient
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// TestNotify_SendsEventToRealHTTPServer ist ein echter Ende-zu-Ende-Test
|
||||
// gegen einen echten, laufenden HTTP-Server (kein Mock der
|
||||
// Standardbibliothek umgangen) — Core CFG-02/CFG-05 haben im aktuellen
|
||||
// Repository-Stand keinen abrufbaren Endpunkt (siehe Paketkommentar),
|
||||
// dieser Server implementiert den in CFG-05 dokumentierten Vertrag
|
||||
// (service-token-authentifiziertes POST /notify) real.
|
||||
func TestNotify_SendsEventToRealHTTPServer(t *testing.T) {
|
||||
var gotToken string
|
||||
var gotEvent Event
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.Method != http.MethodPost || r.URL.Path != "/notify" {
|
||||
http.NotFound(w, r)
|
||||
return
|
||||
}
|
||||
gotToken = r.Header.Get("Authorization")
|
||||
_ = json.NewDecoder(r.Body).Decode(&gotEvent)
|
||||
w.WriteHeader(http.StatusAccepted)
|
||||
}))
|
||||
defer srv.Close()
|
||||
|
||||
client := NewClient(srv.URL, "test-service-token")
|
||||
err := client.Notify(context.Background(), Event{TenantSlug: "mandant-a", EventType: "mail.new", Summary: "3 neue Mails", Count: 3})
|
||||
if err != nil {
|
||||
t.Fatalf("Notify: %v", err)
|
||||
}
|
||||
if gotToken != "Bearer test-service-token" {
|
||||
t.Fatalf("erwartete service-token-header, habe: %q", gotToken)
|
||||
}
|
||||
if gotEvent.TenantSlug != "mandant-a" || gotEvent.Count != 3 {
|
||||
t.Fatalf("unerwartetes ereignis beim server angekommen: %+v", gotEvent)
|
||||
}
|
||||
}
|
||||
|
||||
// TestNotify_TreatsNoContentAsSuppressedNotAsError bestätigt: ein
|
||||
// 204-Status (laut CFG-05-Vertrag "durch Benutzerpräferenz unterdrückt")
|
||||
// wird NICHT als Fehler behandelt.
|
||||
func TestNotify_TreatsNoContentAsSuppressedNotAsError(t *testing.T) {
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
w.WriteHeader(http.StatusNoContent)
|
||||
}))
|
||||
defer srv.Close()
|
||||
|
||||
client := NewClient(srv.URL, "test-service-token")
|
||||
if err := client.Notify(context.Background(), Event{TenantSlug: "mandant-a", EventType: "mail.new"}); err != nil {
|
||||
t.Fatalf("erwartete keinen fehler bei 204 (unterdrückt), habe: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestNotify_ReturnsErrorOnServerFailure stellt sicher, dass ein
|
||||
// echter Serverfehler (5xx) als Fehler durchgereicht wird — der
|
||||
// Aufrufer (importnotify) entscheidet, wie damit umgegangen wird.
|
||||
func TestNotify_ReturnsErrorOnServerFailure(t *testing.T) {
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
w.WriteHeader(http.StatusInternalServerError)
|
||||
_, _ = w.Write([]byte("boom"))
|
||||
}))
|
||||
defer srv.Close()
|
||||
|
||||
client := NewClient(srv.URL, "test-service-token")
|
||||
if err := client.Notify(context.Background(), Event{TenantSlug: "mandant-a", EventType: "mail.new"}); err == nil {
|
||||
t.Fatal("erwartete fehler bei 500")
|
||||
}
|
||||
}
|
||||
|
||||
// TestNotify_UnreachableEndpointReturnsErrorWithoutHanging bestätigt,
|
||||
// dass ein nicht erreichbarer Endpunkt zeitnah einen Fehler liefert
|
||||
// (Timeout im Client konfiguriert) statt unbegrenzt zu blockieren —
|
||||
// Grundlage für INT-09/INT-10s "fail open"-Prinzip, hier für INT-05
|
||||
// mitgeprüft.
|
||||
func TestNotify_UnreachableEndpointReturnsErrorWithoutHanging(t *testing.T) {
|
||||
client := NewClient("http://127.0.0.1:1", "test-service-token") // Port 1: garantiert nichts lauscht dort
|
||||
err := client.Notify(context.Background(), Event{TenantSlug: "mandant-a", EventType: "mail.new"})
|
||||
if err == nil {
|
||||
t.Fatal("erwartete fehler bei nicht erreichbarem endpunkt")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
// Package quota implementiert ARC-09: konfigurierbares Speicherlimit
|
||||
// je einzelnem Postfach — eine ANDERE Ebene als die tenant-weite Quota
|
||||
// aus Core LIC-05 (bekannter Fehler zu vermeiden: beide Ebenen müssen
|
||||
// unabhängig durchgesetzt werden, ein Tenant kann insgesamt genug
|
||||
// Kontingent haben, während ein einzelnes Postfach überläuft).
|
||||
package quota
|
||||
|
||||
import "context"
|
||||
|
||||
// LimitProvider liefert das konfigurierte Speicherlimit eines
|
||||
// Postfachs (Akzeptanzkriterium 1). configured=false bedeutet: kein
|
||||
// Limit gesetzt, also unbegrenzt — erfüllt von
|
||||
// mail/internal/mailboxconfig.Store.LimitBytes.
|
||||
type LimitProvider interface {
|
||||
LimitBytes(ctx context.Context, tenantSlug, mailbox string) (limitBytes int64, configured bool, err error)
|
||||
}
|
||||
|
||||
// UsageProvider liefert den TATSÄCHLICHEN, real gemessenen
|
||||
// Speicherverbrauch eines Postfachs — erfüllt von
|
||||
// mail/internal/storage.UsageCounter.
|
||||
type UsageProvider interface {
|
||||
UsageBytes(ctx context.Context, tenantSlug, mailbox string) (usedBytes int64, err error)
|
||||
}
|
||||
|
||||
// Result ist das Ergebnis einer Quota-Prüfung.
|
||||
type Result struct {
|
||||
Allowed bool
|
||||
UsedBytes int64
|
||||
LimitBytes int64
|
||||
}
|
||||
|
||||
// Checker verknüpft konfiguriertes Limit und realen Verbrauch.
|
||||
type Checker struct {
|
||||
limits LimitProvider
|
||||
usage UsageProvider
|
||||
}
|
||||
|
||||
func NewChecker(limits LimitProvider, usage UsageProvider) *Checker {
|
||||
return &Checker{limits: limits, usage: usage}
|
||||
}
|
||||
|
||||
// Check prüft, ob mailbox innerhalb seines konfigurierten Limits ist.
|
||||
// Kein konfiguriertes Limit bedeutet immer "erlaubt" — die
|
||||
// Tenant-weite Quota (Core LIC-05) läuft unabhängig davon weiter.
|
||||
func (c *Checker) Check(ctx context.Context, tenantSlug, mailbox string) (Result, error) {
|
||||
limit, configured, err := c.limits.LimitBytes(ctx, tenantSlug, mailbox)
|
||||
if err != nil {
|
||||
return Result{}, err
|
||||
}
|
||||
if !configured {
|
||||
return Result{Allowed: true}, nil
|
||||
}
|
||||
used, err := c.usage.UsageBytes(ctx, tenantSlug, mailbox)
|
||||
if err != nil {
|
||||
return Result{}, err
|
||||
}
|
||||
return Result{Allowed: used < limit, UsedBytes: used, LimitBytes: limit}, nil
|
||||
}
|
||||
|
||||
// Allowed ist die schmale Form von Check für Aufrufer, die nur die
|
||||
// Ja/Nein-Entscheidung brauchen (z. B. mail/internal/smtp.QuotaChecker,
|
||||
// Akzeptanzkriterium 2).
|
||||
func (c *Checker) Allowed(ctx context.Context, tenantSlug, mailbox string) (bool, error) {
|
||||
result, err := c.Check(ctx, tenantSlug, mailbox)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
return result.Allowed, nil
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
package quota
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
)
|
||||
|
||||
type fakeLimits struct {
|
||||
limitBytes int64
|
||||
configured bool
|
||||
}
|
||||
|
||||
func (f fakeLimits) LimitBytes(context.Context, string, string) (int64, bool, error) {
|
||||
return f.limitBytes, f.configured, nil
|
||||
}
|
||||
|
||||
type fakeUsage struct {
|
||||
usedBytes int64
|
||||
}
|
||||
|
||||
func (f fakeUsage) UsageBytes(context.Context, string, string) (int64, error) {
|
||||
return f.usedBytes, nil
|
||||
}
|
||||
|
||||
func TestCheck_UnconfiguredLimitAlwaysAllowed(t *testing.T) {
|
||||
c := NewChecker(fakeLimits{configured: false}, fakeUsage{usedBytes: 1_000_000_000})
|
||||
result, err := c.Check(context.Background(), "mandant-a", "postfach-x")
|
||||
if err != nil {
|
||||
t.Fatalf("check: %v", err)
|
||||
}
|
||||
if !result.Allowed {
|
||||
t.Fatalf("erwartete erlaubt ohne konfiguriertes limit, habe: %+v", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCheck_UsageAtOrAboveLimitRejected(t *testing.T) {
|
||||
c := NewChecker(fakeLimits{limitBytes: 1000, configured: true}, fakeUsage{usedBytes: 1000})
|
||||
result, err := c.Check(context.Background(), "mandant-a", "postfach-x")
|
||||
if err != nil {
|
||||
t.Fatalf("check: %v", err)
|
||||
}
|
||||
if result.Allowed {
|
||||
t.Fatalf("erwartete ablehnung bei verbrauch == limit, habe: %+v", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCheck_UsageBelowLimitAllowed(t *testing.T) {
|
||||
c := NewChecker(fakeLimits{limitBytes: 1000, configured: true}, fakeUsage{usedBytes: 999})
|
||||
result, err := c.Check(context.Background(), "mandant-a", "postfach-x")
|
||||
if err != nil {
|
||||
t.Fatalf("check: %v", err)
|
||||
}
|
||||
if !result.Allowed {
|
||||
t.Fatalf("erwartete erlaubt bei verbrauch unter limit, habe: %+v", result)
|
||||
}
|
||||
}
|
||||
@@ -334,6 +334,52 @@ func (c *Client) Search(ctx context.Context, tenantSlug, queryText string) ([]Re
|
||||
return results, nil
|
||||
}
|
||||
|
||||
// GetByMessageID liefert das vollständige Suchdokument EINER Nachricht
|
||||
// (INT-01 Akzeptanzkriterium 1: Mail-Detail braucht mehr Felder als
|
||||
// Search()s Result — insbesondere Body). ok=false, wenn keine
|
||||
// Nachricht mit dieser message_id für tenantSlug existiert
|
||||
// (Akzeptanzkriterium 2: strikt mandantengebunden — eine fremde
|
||||
// message_id liefert hier KEIN Dokument, weil tenant_slug Teil der
|
||||
// Pflichtbedingung ist, nicht nur ein optionaler Filter).
|
||||
func (c *Client) GetByMessageID(ctx context.Context, tenantSlug, messageID string) (Document, bool, error) {
|
||||
payload := map[string]any{
|
||||
"index": IndexName,
|
||||
"query": map[string]any{
|
||||
"bool": map[string]any{
|
||||
"must": []map[string]any{
|
||||
{"equals": map[string]any{FieldTenantSlug: tenantSlug}},
|
||||
{"equals": map[string]any{FieldMessageID: messageID}},
|
||||
},
|
||||
},
|
||||
},
|
||||
"limit": 1,
|
||||
}
|
||||
body, err := json.Marshal(payload)
|
||||
if err != nil {
|
||||
return Document{}, false, fmt.Errorf("search: detailanfrage serialisieren: %w", err)
|
||||
}
|
||||
respBody, err := c.doSearchWithSwapRetry(ctx, body)
|
||||
if err != nil {
|
||||
return Document{}, false, err
|
||||
}
|
||||
var parsed documentSearchResponse
|
||||
if err := json.Unmarshal(respBody, &parsed); err != nil {
|
||||
return Document{}, false, fmt.Errorf("search: antwort parsen: %w", err)
|
||||
}
|
||||
if len(parsed.Hits.Hits) == 0 {
|
||||
return Document{}, false, nil
|
||||
}
|
||||
return parsed.Hits.Hits[0].Source, true, nil
|
||||
}
|
||||
|
||||
type documentSearchResponse struct {
|
||||
Hits struct {
|
||||
Hits []struct {
|
||||
Source Document `json:"_source"`
|
||||
} `json:"hits"`
|
||||
} `json:"hits"`
|
||||
}
|
||||
|
||||
type searchResponse struct {
|
||||
Hits struct {
|
||||
Hits []struct {
|
||||
|
||||
@@ -0,0 +1,215 @@
|
||||
// Integrationstest (ARC-09): echte Postgres-Instanz (mailboxconfig.Store)
|
||||
// und echte MinIO-Instanz (storage.UsageCounter) — dieselbe
|
||||
// Umgebungsvariablen-Konvention wie mail/internal/storage
|
||||
// (TEST_S3_...) und mail/internal/mailboxconfig (TEST_TENANT_DSN).
|
||||
package smtp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net"
|
||||
"os"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/aws/aws-sdk-go-v2/aws"
|
||||
"github.com/aws/aws-sdk-go-v2/service/s3"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/crypto"
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/mailboxconfig"
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/quota"
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/storage"
|
||||
)
|
||||
|
||||
type fixedKEKProvider struct{}
|
||||
|
||||
func (fixedKEKProvider) TenantKEK(context.Context, string) ([]byte, error) {
|
||||
return make([]byte, crypto.KEKSize), nil
|
||||
}
|
||||
|
||||
// TestIntegration_UsageDisplayMatchesRealSizeAndEnforcesQuota ist die
|
||||
// geforderte Pflichtprüfung 3 (ARC-09): Verbrauchsanzeige je Postfach
|
||||
// im Test korrekt gegen tatsächliche Größe geprüft — UND end-to-end:
|
||||
// echte Bytes real in einen echten, ARC-06-provisionierten Bucket
|
||||
// geschrieben, echte Verbrauchsmessung (S3-Listing), echtes
|
||||
// konfiguriertes Limit in Postgres, echte SMTP-RCPT-TO-Ablehnung, sobald
|
||||
// der reale Verbrauch das reale Limit erreicht.
|
||||
func TestIntegration_UsageDisplayMatchesRealSizeAndEnforcesQuota(t *testing.T) {
|
||||
dsn := os.Getenv("TEST_TENANT_DSN")
|
||||
s3Endpoint := os.Getenv("TEST_S3_ENDPOINT")
|
||||
if dsn == "" || s3Endpoint == "" {
|
||||
t.Skip("TEST_TENANT_DSN/TEST_S3_ENDPOINT nicht gesetzt, Integrationstest übersprungen")
|
||||
}
|
||||
ctx := context.Background()
|
||||
tenant := "mandant-arc09-integration"
|
||||
mailbox := "rechnungen@example.com"
|
||||
|
||||
pool, err := pgxpool.New(ctx, dsn)
|
||||
if err != nil {
|
||||
t.Fatalf("pool: %v", err)
|
||||
}
|
||||
t.Cleanup(pool.Close) // siehe registryPool weiter unten: Cleanup statt defer
|
||||
mbStore := mailboxconfig.NewStore(pool, crypto.NewService(fixedKEKProvider{}))
|
||||
if err := mbStore.EnsureSchema(ctx); err != nil {
|
||||
t.Fatalf("mailboxconfig schema: %v", err)
|
||||
}
|
||||
t.Cleanup(func() {
|
||||
_, _ = pool.Exec(context.Background(), `DELETE FROM mail_mailboxes WHERE tenant_slug = $1`, tenant)
|
||||
})
|
||||
|
||||
mailboxID, err := mbStore.Create(ctx, tenant, mailboxconfig.CreateInput{
|
||||
Name: mailbox, IMAPHost: "imap.example.com", IMAPPort: 993,
|
||||
IMAPUsername: "user", Password: "geheim", FolderSelection: []string{"INBOX"}, IntervalSeconds: 300,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("postfach anlegen: %v", err)
|
||||
}
|
||||
_ = mailboxID
|
||||
|
||||
s3Admin, err := storage.NewS3AdminClient(ctx, "us-east-1", s3Endpoint, os.Getenv("TEST_S3_ACCESS_KEY"), os.Getenv("TEST_S3_SECRET_KEY"), true)
|
||||
if err != nil {
|
||||
t.Fatalf("s3-admin-client: %v", err)
|
||||
}
|
||||
registryPool, err := pgxpool.New(ctx, dsn)
|
||||
if err != nil {
|
||||
t.Fatalf("registry-pool: %v", err)
|
||||
}
|
||||
// t.Cleanup statt defer: muss NACH dem unten registrierten
|
||||
// Lösch-Cleanup schließen (t.Cleanup läuft LIFO, defer würde VOR
|
||||
// jedem t.Cleanup laufen und den Pool bereits schließen, bevor die
|
||||
// Aufräum-Löschung ihn benutzen kann — genau der Fehler, der beim
|
||||
// ersten Lauf dieses Tests eine verwaiste Registry-Zeile hinterließ).
|
||||
t.Cleanup(registryPool.Close)
|
||||
if _, err := registryPool.Exec(ctx, `
|
||||
CREATE TABLE IF NOT EXISTS tenants (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(), slug TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
|
||||
db_dsn TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'active', created_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
)
|
||||
`); err != nil {
|
||||
t.Fatalf("tenants-tabelle: %v", err)
|
||||
}
|
||||
bucket, err := storage.ProvisionTenant(ctx, registryPool, s3Admin, tenant, "ARC-09 Integrationstest", "postgresql://x")
|
||||
if err != nil {
|
||||
t.Fatalf("ProvisionTenant: %v", err)
|
||||
}
|
||||
t.Cleanup(func() {
|
||||
_, _ = registryPool.Exec(context.Background(), `DELETE FROM tenants WHERE slug = $1`, tenant)
|
||||
})
|
||||
t.Cleanup(func() {
|
||||
ctx := context.Background()
|
||||
out, err := s3Admin.ListObjectsV2(ctx, &s3.ListObjectsV2Input{Bucket: aws.String(bucket)})
|
||||
if err == nil {
|
||||
for _, obj := range out.Contents {
|
||||
_, _ = s3Admin.DeleteObject(ctx, &s3.DeleteObjectInput{Bucket: aws.String(bucket), Key: obj.Key})
|
||||
}
|
||||
}
|
||||
_, _ = s3Admin.DeleteBucket(ctx, &s3.DeleteBucketInput{Bucket: aws.String(bucket)})
|
||||
})
|
||||
|
||||
usageReporter := noopUsageReporterForTest{}
|
||||
storageSvc := storage.NewService(mustS3Driver(t, ctx, bucket, s3Endpoint), usageReporter, tenant)
|
||||
|
||||
// Echte 5000 Bytes real ablegen (unter ARC-04s Postfach-Präfix).
|
||||
const contentSize = 5000
|
||||
content := strings.Repeat("A", contentSize)
|
||||
key := storage.ArchiveKey(mailbox, time.Now(), "msg-arc09-1", 0)
|
||||
if _, err := storageSvc.Put(ctx, key, strings.NewReader(content), int64(len(content)), "text/plain"); err != nil {
|
||||
t.Fatalf("objekt ablegen: %v", err)
|
||||
}
|
||||
t.Cleanup(func() {
|
||||
_ = storageSvc.Delete(context.Background(), key, int64(len(content)))
|
||||
})
|
||||
|
||||
usageCounter := storage.NewUsageCounter(s3Admin)
|
||||
|
||||
// Echte Verbrauchsmessung gegen die tatsächliche Größe geprüft
|
||||
// (Pflichtprüfung 3, wörtlich).
|
||||
measured, err := usageCounter.UsageBytes(ctx, tenant, mailbox)
|
||||
if err != nil {
|
||||
t.Fatalf("UsageBytes: %v", err)
|
||||
}
|
||||
if measured < contentSize {
|
||||
t.Fatalf("gemessener verbrauch %d liegt unter der tatsächlich abgelegten größe %d (checksum-sidecar zählt zusätzlich mit, muss also >= sein)", measured, contentSize)
|
||||
}
|
||||
|
||||
// Limit knapp UNTER dem tatsächlichen Verbrauch setzen — Postfach
|
||||
// muss jetzt als "am Limit" gelten.
|
||||
if err := mbStore.SetQuotaBytes(ctx, tenant, mailbox, measured-1); err != nil {
|
||||
t.Fatalf("quota setzen: %v", err)
|
||||
}
|
||||
|
||||
checker := quota.NewChecker(mbStore, usageCounter)
|
||||
srv := NewServerWithMaxMessageBytesTLSLoggerRateLimitGuardAndQuota(
|
||||
&fakeSink{}, defaultMaxMessageBytes, nil, nil, tenant, nil, protoguard.DefaultConfig(), checker,
|
||||
)
|
||||
addr, stop := startRealServer(t, srv)
|
||||
defer stop()
|
||||
|
||||
c := dial(t, addr)
|
||||
defer c.close()
|
||||
c.send(t, "EHLO client.example.com")
|
||||
for {
|
||||
line := c.readLine(t)
|
||||
if strings.HasPrefix(line, "250 ") {
|
||||
break
|
||||
}
|
||||
}
|
||||
c.send(t, "MAIL FROM:<absender@example.com>")
|
||||
resp := c.send(t, "RCPT TO:<"+mailbox+">")
|
||||
if code(resp) != "552" {
|
||||
t.Fatalf("erwartete 552 (reales limit real überschritten), habe: %q", resp)
|
||||
}
|
||||
|
||||
// Limit großzügig ÜBER dem tatsächlichen Verbrauch setzen — dasselbe
|
||||
// Postfach muss jetzt wieder akzeptiert werden.
|
||||
if err := mbStore.SetQuotaBytes(ctx, tenant, mailbox, measured*10); err != nil {
|
||||
t.Fatalf("quota erhöhen: %v", err)
|
||||
}
|
||||
c2 := dial(t, addr)
|
||||
defer c2.close()
|
||||
c2.send(t, "EHLO client.example.com")
|
||||
for {
|
||||
line := c2.readLine(t)
|
||||
if strings.HasPrefix(line, "250 ") {
|
||||
break
|
||||
}
|
||||
}
|
||||
c2.send(t, "MAIL FROM:<absender@example.com>")
|
||||
resp2 := c2.send(t, "RCPT TO:<"+mailbox+">")
|
||||
if code(resp2) != "250" {
|
||||
t.Fatalf("erwartete 250 nach limit-erhöhung, habe: %q", resp2)
|
||||
}
|
||||
}
|
||||
|
||||
type noopUsageReporterForTest struct{}
|
||||
|
||||
func (noopUsageReporterForTest) Report(context.Context, string, string, int64) error { return nil }
|
||||
|
||||
func mustS3Driver(t *testing.T, ctx context.Context, bucket, endpoint string) *storage.S3Driver {
|
||||
t.Helper()
|
||||
driver, err := storage.NewS3Driver(ctx, bucket, "us-east-1", endpoint, os.Getenv("TEST_S3_ACCESS_KEY"), os.Getenv("TEST_S3_SECRET_KEY"), true)
|
||||
if err != nil {
|
||||
t.Fatalf("s3-driver: %v", err)
|
||||
}
|
||||
return driver
|
||||
}
|
||||
|
||||
func startRealServer(t *testing.T, srv *Server) (addr string, stop func()) {
|
||||
t.Helper()
|
||||
listener, err := net.Listen("tcp", "127.0.0.1:0")
|
||||
if err != nil {
|
||||
t.Fatalf("listener: %v", err)
|
||||
}
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
_ = srv.Serve(ctx, listener)
|
||||
close(done)
|
||||
}()
|
||||
return listener.Addr().String(), func() {
|
||||
cancel()
|
||||
<-done
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,155 @@
|
||||
package smtp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
|
||||
)
|
||||
|
||||
// fakeQuotaChecker ist ein In-Memory-Fake für QuotaChecker — reine
|
||||
// Protokolltests brauchen keine echte Postgres-/S3-Instanz.
|
||||
type fakeQuotaChecker struct {
|
||||
blocked map[string]bool // mailbox -> am limit
|
||||
}
|
||||
|
||||
func (f fakeQuotaChecker) Allowed(_ context.Context, _, mailbox string) (bool, error) {
|
||||
return !f.blocked[mailbox], nil
|
||||
}
|
||||
|
||||
func startQuotaTestServer(t *testing.T, sink MessageSink, checker QuotaChecker) (addr string, stop func()) {
|
||||
t.Helper()
|
||||
srv := NewServerWithMaxMessageBytesTLSLoggerRateLimitGuardAndQuota(
|
||||
sink, defaultMaxMessageBytes, nil, nil, "mandant-arc09", nil, protoguard.DefaultConfig(), checker,
|
||||
)
|
||||
listener, err := net.Listen("tcp", "127.0.0.1:0")
|
||||
if err != nil {
|
||||
t.Fatalf("listener: %v", err)
|
||||
}
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
_ = srv.Serve(ctx, listener)
|
||||
close(done)
|
||||
}()
|
||||
return listener.Addr().String(), func() {
|
||||
cancel()
|
||||
<-done
|
||||
}
|
||||
}
|
||||
|
||||
// TestRcptTo_QuotaExceededRejectedWithCorrectSMTPError ist die
|
||||
// geforderte Pflichtprüfung 1 (ARC-09): Postfach-Quota erreicht, neue
|
||||
// eingehende Mail wird mit korrekter SMTP-Fehlermeldung (552, RFC 5321
|
||||
// "exceeded storage allocation") abgelehnt, NICHT stillschweigend
|
||||
// verworfen.
|
||||
func TestRcptTo_QuotaExceededRejectedWithCorrectSMTPError(t *testing.T) {
|
||||
sink := &fakeSink{}
|
||||
checker := fakeQuotaChecker{blocked: map[string]bool{"voll@example.com": true}}
|
||||
addr, stop := startQuotaTestServer(t, sink, checker)
|
||||
defer stop()
|
||||
|
||||
c := dial(t, addr)
|
||||
defer c.close()
|
||||
c.send(t, "EHLO client.example.com")
|
||||
for {
|
||||
line := c.readLine(t)
|
||||
if strings.HasPrefix(line, "250 ") {
|
||||
break
|
||||
}
|
||||
}
|
||||
c.send(t, "MAIL FROM:<a@example.com>")
|
||||
|
||||
resp := c.send(t, "RCPT TO:<voll@example.com>")
|
||||
if code(resp) != "552" {
|
||||
t.Fatalf("erwartete 552 (quota überschritten), habe: %q", resp)
|
||||
}
|
||||
if !strings.Contains(resp, "quota") {
|
||||
t.Fatalf("erwartete erkennbare quota-fehlermeldung, habe: %q", resp)
|
||||
}
|
||||
|
||||
// Session bleibt funktionsfähig — kein Verbindungsabbruch, keine
|
||||
// stillschweigende Verwerfung.
|
||||
if resp := c.send(t, "NOOP"); code(resp) != "250" {
|
||||
t.Fatalf("session nach quota-ablehnung nicht mehr funktionsfähig: %q", resp)
|
||||
}
|
||||
if sink.count() != 0 {
|
||||
t.Fatalf("erwartete keine angenommene nachricht bei quota-ablehnung, habe %d", sink.count())
|
||||
}
|
||||
}
|
||||
|
||||
// TestRcptTo_OtherMailboxUnaffectedWhenOneAtLimit ist die geforderte
|
||||
// Pflichtprüfung 2 (ARC-09): ein anderes Postfach desselben Tenants
|
||||
// empfängt weiterhin normal, während eines am Limit ist.
|
||||
func TestRcptTo_OtherMailboxUnaffectedWhenOneAtLimit(t *testing.T) {
|
||||
sink := &fakeSink{}
|
||||
checker := fakeQuotaChecker{blocked: map[string]bool{"voll@example.com": true}}
|
||||
addr, stop := startQuotaTestServer(t, sink, checker)
|
||||
defer stop()
|
||||
|
||||
// Erste, VOLLSTÄNDIGE Transaktion an das Postfach am Limit —
|
||||
// abgelehnt.
|
||||
c1 := dial(t, addr)
|
||||
c1.send(t, "EHLO client.example.com")
|
||||
for {
|
||||
line := c1.readLine(t)
|
||||
if strings.HasPrefix(line, "250 ") {
|
||||
break
|
||||
}
|
||||
}
|
||||
c1.send(t, "MAIL FROM:<a@example.com>")
|
||||
if resp := c1.send(t, "RCPT TO:<voll@example.com>"); code(resp) != "552" {
|
||||
t.Fatalf("erwartete 552 für volles postfach, habe: %q", resp)
|
||||
}
|
||||
c1.close()
|
||||
|
||||
// Zweite, unabhängige Transaktion an ein ANDERES Postfach desselben
|
||||
// Tenants — muss vollständig normal durchlaufen.
|
||||
c2 := dial(t, addr)
|
||||
defer c2.close()
|
||||
c2.send(t, "EHLO client.example.com")
|
||||
for {
|
||||
line := c2.readLine(t)
|
||||
if strings.HasPrefix(line, "250 ") {
|
||||
break
|
||||
}
|
||||
}
|
||||
c2.send(t, "MAIL FROM:<a@example.com>")
|
||||
if resp := c2.send(t, "RCPT TO:<frei@example.com>"); code(resp) != "250" {
|
||||
t.Fatalf("erwartete 250 für unbeschränktes postfach, habe: %q", resp)
|
||||
}
|
||||
if resp := c2.send(t, "DATA"); code(resp) != "354" {
|
||||
t.Fatalf("erwartete 354, habe: %q", resp)
|
||||
}
|
||||
if resp := c2.send(t, "Subject: test\r\n\r\nHallo\r\n."); code(resp) != "250" {
|
||||
t.Fatalf("erwartete 250 nach abgeschlossener DATA, habe: %q", resp)
|
||||
}
|
||||
if sink.count() != 1 {
|
||||
t.Fatalf("erwartete 1 angenommene nachricht für das freie postfach, habe %d", sink.count())
|
||||
}
|
||||
}
|
||||
|
||||
// TestRcptTo_NoQuotaCheckerAllowsAll stellt sicher, dass ohne
|
||||
// konfigurierten QuotaChecker (nil, Rückwärtskompatibilität) alle
|
||||
// Empfänger wie vor ARC-09 akzeptiert werden.
|
||||
func TestRcptTo_NoQuotaCheckerAllowsAll(t *testing.T) {
|
||||
sink := &fakeSink{}
|
||||
addr, stop := startTestServer(t, sink, defaultMaxMessageBytes)
|
||||
defer stop()
|
||||
|
||||
c := dial(t, addr)
|
||||
defer c.close()
|
||||
c.send(t, "EHLO client.example.com")
|
||||
for {
|
||||
line := c.readLine(t)
|
||||
if strings.HasPrefix(line, "250 ") {
|
||||
break
|
||||
}
|
||||
}
|
||||
c.send(t, "MAIL FROM:<a@example.com>")
|
||||
if resp := c.send(t, "RCPT TO:<beliebig@example.com>"); code(resp) != "250" {
|
||||
t.Fatalf("erwartete 250 ohne quotachecker, habe: %q", resp)
|
||||
}
|
||||
}
|
||||
@@ -95,7 +95,7 @@ func (s *Session) handleMailFrom(arg string) bool {
|
||||
// handleRcptTo ist Teil des Envelope-Aufbaus (Akzeptanzkriterium 1):
|
||||
// jede Empfängeradresse wird vor der Annahme validiert; mehrere RCPT TO
|
||||
// sind erlaubt.
|
||||
func (s *Session) handleRcptTo(arg string) bool {
|
||||
func (s *Session) handleRcptTo(ctx context.Context, arg string) bool {
|
||||
if s.state != MailFromSet && s.state != RcptToSet {
|
||||
return s.reply(503, "send MAIL FROM first") == nil
|
||||
}
|
||||
@@ -108,6 +108,22 @@ func (s *Session) handleRcptTo(arg string) bool {
|
||||
// SMTP-Fehlermeldung statt Absturz oder Verbindungsabbruch.
|
||||
return s.reply(553, "invalid recipient address") == nil
|
||||
}
|
||||
if s.quotaChecker != nil {
|
||||
// ARC-09 Akzeptanzkriterium 2: ein Postfach am Limit lehnt neue
|
||||
// eingehende Mail mit klarer, protokollgerechter SMTP-Fehlermeldung
|
||||
// ab (552 = RFC 5321 "exceeded storage allocation") — an RCPT TO
|
||||
// geprüft, BEVOR die Nachricht überhaupt übertragen wird, statt
|
||||
// nach vollständigem DATA-Empfang zu verwerfen. addr (der
|
||||
// Empfänger) ist der Postfachbezug — dasselbe mailbox-Feld wie
|
||||
// mail/internal/storage.ArchiveKey/mail/internal/mailboxconfig.
|
||||
allowed, err := s.quotaChecker.Allowed(ctx, s.tenantID, addr)
|
||||
if err != nil {
|
||||
return s.reply(451, "unable to verify mailbox quota, try again later") == nil
|
||||
}
|
||||
if !allowed {
|
||||
return s.reply(552, "mailbox quota exceeded for "+addr) == nil
|
||||
}
|
||||
}
|
||||
s.to = append(s.to, addr)
|
||||
s.state = RcptToSet
|
||||
return s.reply(250, "OK") == nil
|
||||
|
||||
@@ -38,6 +38,7 @@ type Server struct {
|
||||
|
||||
tenantID string
|
||||
acceptLimiter *ratelimit.Limiter
|
||||
quotaChecker QuotaChecker
|
||||
}
|
||||
|
||||
func NewServer(sink MessageSink) *Server {
|
||||
@@ -80,6 +81,14 @@ func NewServerWithMaxMessageBytesTLSLoggerRateLimitAndGuardConfig(sink MessageSi
|
||||
return &Server{sink: sink, maxMessageBytes: maxMessageBytes, tlsConfig: tlsConfig, logger: logger, tenantID: tenantID, acceptLimiter: acceptLimiter, guardCfg: guardCfg}
|
||||
}
|
||||
|
||||
// NewServerWithMaxMessageBytesTLSLoggerRateLimitGuardAndQuota erlaubt
|
||||
// zusätzlich Postfach-Quota-Prüfung bei RCPT TO (ARC-09).
|
||||
// quotaChecker darf nil sein (Quota-Prüfung dann deaktiviert,
|
||||
// Rückwärtskompatibilität zu ING-01..QA-04).
|
||||
func NewServerWithMaxMessageBytesTLSLoggerRateLimitGuardAndQuota(sink MessageSink, maxMessageBytes int64, tlsConfig *tls.Config, logger *slog.Logger, tenantID string, acceptLimiter *ratelimit.Limiter, guardCfg protoguard.Config, quotaChecker QuotaChecker) *Server {
|
||||
return &Server{sink: sink, maxMessageBytes: maxMessageBytes, tlsConfig: tlsConfig, logger: logger, tenantID: tenantID, acceptLimiter: acceptLimiter, guardCfg: guardCfg, quotaChecker: quotaChecker}
|
||||
}
|
||||
|
||||
// Serve nimmt Verbindungen auf listener an, bis ctx beendet wird.
|
||||
func (srv *Server) Serve(ctx context.Context, listener net.Listener) error {
|
||||
go func() {
|
||||
@@ -99,7 +108,7 @@ func (srv *Server) Serve(ctx context.Context, listener net.Listener) error {
|
||||
}
|
||||
return fmt.Errorf("smtp: verbindung annehmen: %w", err)
|
||||
}
|
||||
session := newSession(conn, srv.sink, srv.maxMessageBytes, srv.tlsConfig, srv.logger, srv.tenantID, srv.acceptLimiter, srv.guardCfg)
|
||||
session := newSession(conn, srv.sink, srv.maxMessageBytes, srv.tlsConfig, srv.logger, srv.tenantID, srv.acceptLimiter, srv.guardCfg, srv.quotaChecker)
|
||||
go session.Serve(ctx)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -15,6 +15,15 @@ import (
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/ratelimit"
|
||||
)
|
||||
|
||||
// QuotaChecker prüft, ob ein Postfach noch innerhalb seines
|
||||
// konfigurierten Speicherlimits ist (ARC-09). Erfüllt von
|
||||
// *quota.Checker — als schmale Schnittstelle definiert, damit dieses
|
||||
// Paket quota nicht importieren muss (keine Kopplung an dessen
|
||||
// LimitProvider/UsageProvider-Abhängigkeiten).
|
||||
type QuotaChecker interface {
|
||||
Allowed(ctx context.Context, tenantSlug, mailbox string) (bool, error)
|
||||
}
|
||||
|
||||
// maxCommandLineBytes begrenzt eine einzelne Kommando-/DATA-Zeile
|
||||
// (defensive Fehlerbehandlung bei nicht-konformen Gegenstellen statt
|
||||
// optimistischem Parsing, gleiche Konvention wie mail/internal/imap und
|
||||
@@ -46,6 +55,7 @@ type Session struct {
|
||||
|
||||
tenantID string
|
||||
acceptLimiter *ratelimit.Limiter // ING-09, nil = kein Rate-Limiting
|
||||
quotaChecker QuotaChecker // ARC-09, nil = keine Quota-Prüfung
|
||||
|
||||
guard *protoguard.Guard // QA-04-Nachtrag zu ING-07
|
||||
|
||||
@@ -54,7 +64,7 @@ type Session struct {
|
||||
to []string
|
||||
}
|
||||
|
||||
func newSession(conn net.Conn, sink MessageSink, maxMessageBytes int64, tlsConfig *tls.Config, logger *slog.Logger, tenantID string, acceptLimiter *ratelimit.Limiter, guardCfg protoguard.Config) *Session {
|
||||
func newSession(conn net.Conn, sink MessageSink, maxMessageBytes int64, tlsConfig *tls.Config, logger *slog.Logger, tenantID string, acceptLimiter *ratelimit.Limiter, guardCfg protoguard.Config, quotaChecker QuotaChecker) *Session {
|
||||
_, alreadyTLS := conn.(*tls.Conn)
|
||||
return &Session{
|
||||
conn: conn,
|
||||
@@ -67,6 +77,7 @@ func newSession(conn net.Conn, sink MessageSink, maxMessageBytes int64, tlsConfi
|
||||
log: protolog.NewSessionLogger(logger, "smtp"),
|
||||
tenantID: tenantID,
|
||||
acceptLimiter: acceptLimiter,
|
||||
quotaChecker: quotaChecker,
|
||||
guard: protoguard.New(guardCfg),
|
||||
state: Greeting,
|
||||
}
|
||||
@@ -153,7 +164,7 @@ func (s *Session) dispatch(ctx context.Context, verb, arg string) bool {
|
||||
case "MAIL":
|
||||
return s.handleMailFrom(arg)
|
||||
case "RCPT":
|
||||
return s.handleRcptTo(arg)
|
||||
return s.handleRcptTo(ctx, arg)
|
||||
case "DATA":
|
||||
return s.handleData(ctx)
|
||||
case "RSET":
|
||||
|
||||
@@ -0,0 +1,75 @@
|
||||
// ARC-04: Aufbewahrungsstruktur nach Mandant/Postfach/Jahr. Mandant ist
|
||||
// bereits durch den physisch getrennten Bucket (ARC-06) abgebildet —
|
||||
// ArchiveKey deckt Postfach und Jahr INNERHALB des Buckets ab, als
|
||||
// eigener, additiver Schlüssel-Konstruktor neben dem bereits
|
||||
// bestehenden, flachen ObjectKey (ARC-01, weiterhin unverändert für
|
||||
// bestehende Aufrufer wie mail/internal/mailapi — kein Umbau
|
||||
// angrenzender Bereiche).
|
||||
package storage
|
||||
|
||||
import (
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Fallback-Segmente (Akzeptanzkriterium 3): fehlende/abweichende
|
||||
// Metadaten führen zu einem DOKUMENTIERTEN Fallback-Pfad statt einem
|
||||
// Ablagefehler.
|
||||
const (
|
||||
FallbackMailboxSegment = "postfach-unbekannt"
|
||||
FallbackYearSegment = "jahr-unbekannt"
|
||||
)
|
||||
|
||||
// ArchiveKey liefert den kanonischen Objektschlüssel für einen
|
||||
// archivierten Mail-Anhang/-Teil nach dem Schema Postfach/Jahr
|
||||
// (Akzeptanzkriterium 1) — innerhalb des bereits mandantenspezifischen
|
||||
// Buckets. sentAt darf der Nullwert sein und mailbox leer
|
||||
// (Akzeptanzkriterium 3): beides führt zum jeweiligen Fallback-Segment,
|
||||
// nie zu einem Fehler.
|
||||
func ArchiveKey(mailbox string, sentAt time.Time, messageID string, partIndex int) string {
|
||||
return ArchiveYearPrefix(mailbox, yearOf(sentAt)) + ObjectKey(messageID, partIndex)
|
||||
}
|
||||
|
||||
// ArchiveYearPrefix liefert den Verzeichnispräfix EINES Postfach-Jahrs
|
||||
// (Akzeptanzkriterium 2: Grundlage für spätere Retention-Regeln OHNE
|
||||
// Migration — ein Retention-Job kann alle Objekte eines Postfachs/
|
||||
// Jahrs direkt über diesen Präfix auflisten, ohne die bereits
|
||||
// abgelegten Schlüssel umzubenennen oder neu zu strukturieren).
|
||||
func ArchiveYearPrefix(mailbox string, year int) string {
|
||||
mailboxSegment := sanitizeSegment(mailbox)
|
||||
if mailboxSegment == "" {
|
||||
mailboxSegment = FallbackMailboxSegment
|
||||
}
|
||||
yearSegment := FallbackYearSegment
|
||||
if year > 0 {
|
||||
yearSegment = strconv.Itoa(year)
|
||||
}
|
||||
return "postfach/" + mailboxSegment + "/" + yearSegment + "/"
|
||||
}
|
||||
|
||||
// ArchiveMailboxPrefix liefert den Präfix ALLER Jahre eines Postfachs
|
||||
// (ohne Jahressegment) — Grundlage für eine reale
|
||||
// Postfach-Verbrauchsmessung über alle Jahre hinweg (ARC-09).
|
||||
func ArchiveMailboxPrefix(mailbox string) string {
|
||||
mailboxSegment := sanitizeSegment(mailbox)
|
||||
if mailboxSegment == "" {
|
||||
mailboxSegment = FallbackMailboxSegment
|
||||
}
|
||||
return "postfach/" + mailboxSegment + "/"
|
||||
}
|
||||
|
||||
func yearOf(t time.Time) int {
|
||||
if t.IsZero() {
|
||||
return 0
|
||||
}
|
||||
return t.UTC().Year()
|
||||
}
|
||||
|
||||
// sanitizeSegment entfernt Pfadtrenner aus einem Postfachnamen, damit
|
||||
// er nie versehentlich zusätzliche Verzeichnisebenen erzeugt (z. B. ein
|
||||
// Postfachname, der ein "/" enthält).
|
||||
func sanitizeSegment(raw string) string {
|
||||
raw = strings.TrimSpace(raw)
|
||||
return strings.ReplaceAll(raw, "/", "_")
|
||||
}
|
||||
@@ -0,0 +1,93 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
// TestArchiveKey_MultipleYearsProduceSeparateYearFolders ist die
|
||||
// geforderte Pflichtprüfung 1 (ARC-04): Import über mehrere Jahre
|
||||
// erzeugt korrekt getrennte Jahresordner.
|
||||
func TestArchiveKey_MultipleYearsProduceSeparateYearFolders(t *testing.T) {
|
||||
sent2019 := time.Date(2019, 3, 1, 0, 0, 0, 0, time.UTC)
|
||||
sent2024 := time.Date(2024, 11, 1, 0, 0, 0, 0, time.UTC)
|
||||
|
||||
key2019 := ArchiveKey("INBOX", sent2019, "msg-a", 0)
|
||||
key2024 := ArchiveKey("INBOX", sent2024, "msg-b", 0)
|
||||
|
||||
if !strings.HasPrefix(key2019, "postfach/INBOX/2019/") {
|
||||
t.Fatalf("erwartete jahresordner 2019, habe: %q", key2019)
|
||||
}
|
||||
if !strings.HasPrefix(key2024, "postfach/INBOX/2024/") {
|
||||
t.Fatalf("erwartete jahresordner 2024, habe: %q", key2024)
|
||||
}
|
||||
if key2019 == key2024 {
|
||||
t.Fatalf("erwartete unterschiedliche schlüssel für unterschiedliche jahre")
|
||||
}
|
||||
}
|
||||
|
||||
// TestArchiveKey_MissingMailboxUsesDocumentedFallback ist die
|
||||
// geforderte Pflichtprüfung 2 (ARC-04): fehlendes Postfach-Attribut
|
||||
// nutzt den dokumentierten Fallback statt eines Ablagefehlers.
|
||||
func TestArchiveKey_MissingMailboxUsesDocumentedFallback(t *testing.T) {
|
||||
key := ArchiveKey("", time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC), "msg-a", 0)
|
||||
if !strings.Contains(key, "/"+FallbackMailboxSegment+"/") {
|
||||
t.Fatalf("erwartete fallback-postfach-segment %q, habe: %q", FallbackMailboxSegment, key)
|
||||
}
|
||||
}
|
||||
|
||||
// TestArchiveKey_MissingSentAtUsesDocumentedFallback belegt denselben
|
||||
// Fallback-Grundsatz für ein fehlendes (Null-)Sendedatum.
|
||||
func TestArchiveKey_MissingSentAtUsesDocumentedFallback(t *testing.T) {
|
||||
key := ArchiveKey("INBOX", time.Time{}, "msg-a", 0)
|
||||
if !strings.Contains(key, "/"+FallbackYearSegment+"/") {
|
||||
t.Fatalf("erwartete fallback-jahr-segment %q, habe: %q", FallbackYearSegment, key)
|
||||
}
|
||||
}
|
||||
|
||||
// TestArchiveKey_NeverErrorsOnAnyInput bestätigt, dass ArchiveKey für
|
||||
// KEINE Eingabekombination fehlschlägt (Akzeptanzkriterium 3:
|
||||
// "definierter Fallback-Pfad, nicht Ablagefehler" — ArchiveKey liefert
|
||||
// bewusst keinen error-Rückgabewert, weil es strukturell keinen
|
||||
// Fehlerfall gibt).
|
||||
func TestArchiveKey_NeverErrorsOnAnyInput(t *testing.T) {
|
||||
inputs := []struct {
|
||||
mailbox string
|
||||
sentAt time.Time
|
||||
}{
|
||||
{"", time.Time{}},
|
||||
{"Postfach/Mit/Slashes", time.Time{}},
|
||||
{" ", time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC)},
|
||||
}
|
||||
for _, in := range inputs {
|
||||
key := ArchiveKey(in.mailbox, in.sentAt, "msg", 0)
|
||||
if key == "" {
|
||||
t.Fatalf("erwartete nicht-leeren schlüssel für eingabe %+v", in)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestArchiveYearPrefix_FoundationForRetentionWithoutMigration ist die
|
||||
// geforderte Pflichtprüfung für Akzeptanzkriterium 2: die Struktur ist
|
||||
// Grundlage für spätere Retention-Regeln ohne Migration — ein
|
||||
// Retention-Job kann den Präfix EINES Postfach-Jahrs berechnen und
|
||||
// findet darunter GENAU die zuvor mit ArchiveKey abgelegten Schlüssel
|
||||
// desselben Postfachs/Jahrs, ohne dass an den bereits abgelegten
|
||||
// Schlüsseln irgendetwas umbenannt werden müsste.
|
||||
func TestArchiveYearPrefix_FoundationForRetentionWithoutMigration(t *testing.T) {
|
||||
sent2022 := time.Date(2022, 6, 15, 0, 0, 0, 0, time.UTC)
|
||||
key := ArchiveKey("Rechnungen", sent2022, "msg-x", 3)
|
||||
|
||||
prefix := ArchiveYearPrefix("Rechnungen", 2022)
|
||||
if !strings.HasPrefix(key, prefix) {
|
||||
t.Fatalf("ArchiveKey %q liegt nicht unter dem für retention berechenbaren präfix %q", key, prefix)
|
||||
}
|
||||
|
||||
// Ein anderes Jahr desselben Postfachs liegt NICHT unter demselben
|
||||
// Präfix — Retention kann Jahre gezielt einzeln adressieren.
|
||||
otherYearPrefix := ArchiveYearPrefix("Rechnungen", 2023)
|
||||
if strings.HasPrefix(key, otherYearPrefix) {
|
||||
t.Fatalf("ArchiveKey %q hätte NICHT unter dem 2023-präfix liegen dürfen", key)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
|
||||
"github.com/aws/aws-sdk-go-v2/aws"
|
||||
"github.com/aws/aws-sdk-go-v2/service/s3"
|
||||
)
|
||||
|
||||
// UsageCounter misst den TATSÄCHLICHEN Speicherverbrauch eines
|
||||
// Postfachs (ARC-09) durch reales Auflisten der zugehörigen Objekte im
|
||||
// physisch getrennten Mandanten-Bucket (ARC-06) unter dem
|
||||
// ARC-04-Postfach-Präfix — kein separat gepflegter Zählerstand, der
|
||||
// von der tatsächlichen Ablage abweichen könnte.
|
||||
type UsageCounter struct {
|
||||
admin *s3.Client
|
||||
}
|
||||
|
||||
func NewUsageCounter(admin *s3.Client) *UsageCounter {
|
||||
return &UsageCounter{admin: admin}
|
||||
}
|
||||
|
||||
// UsageBytes summiert die reale Objektgröße aller unter
|
||||
// ArchiveMailboxPrefix(mailbox) abgelegten Objekte im Bucket von
|
||||
// tenantSlug (ARC-06: BucketNameForTenant). Erfüllt strukturell
|
||||
// quota.UsageProvider (ARC-09), ohne dass dieses Paket quota
|
||||
// importieren müsste.
|
||||
func (u *UsageCounter) UsageBytes(ctx context.Context, tenantSlug, mailbox string) (int64, error) {
|
||||
bucket := BucketNameForTenant(tenantSlug)
|
||||
prefix := ArchiveMailboxPrefix(mailbox)
|
||||
|
||||
var total int64
|
||||
var continuationToken *string
|
||||
for {
|
||||
out, err := u.admin.ListObjectsV2(ctx, &s3.ListObjectsV2Input{
|
||||
Bucket: aws.String(bucket),
|
||||
Prefix: aws.String(prefix),
|
||||
ContinuationToken: continuationToken,
|
||||
})
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("storage: postfach-verbrauch auflisten: %w", err)
|
||||
}
|
||||
for _, obj := range out.Contents {
|
||||
if obj.Size != nil {
|
||||
total += *obj.Size
|
||||
}
|
||||
}
|
||||
if out.IsTruncated == nil || !*out.IsTruncated {
|
||||
break
|
||||
}
|
||||
continuationToken = out.NextContinuationToken
|
||||
}
|
||||
return total, nil
|
||||
}
|
||||
Reference in New Issue
Block a user