CI / Web-Barrierefreiheitspruefung (axe, Tastatur, Reflow, Textabstaende) (push) Canceled after 0s
CI / Core-Modul (Build/Vet/Test) (push) Successful in 1m0s
CI / DMS Security-Test-Gate (AC5, Merge-Gate) (push) Successful in 4s
CI / Connect Security-Test-Gate (QA-01 AC4, Merge-Gate) (push) Successful in 4s
CI / DMS-Modul Supply-Chain-Scan (govulncheck) (push) Failing after 20s
CI / Web (dms-browser) (push) Failing after 1m25s
CI / Web (pdf-viewer) (push) Failing after 55s
CI / Web (shl) (push) Failing after 14s
Supply-Chain-Scan (Go) / govulncheck (push) Failing after 1m1s
Workflow-Schnittstellen-Vertragstests / contract-tests (push) Successful in 16m10s
CI / DMS-Modul (Lint/Build/Test/Coverage/Artefakt) (push) Failing after 3s
271 lines
9.0 KiB
Go
271 lines
9.0 KiB
Go
package contracttest
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
|
|
"gitea.perlbach24.de/scripte/nexarch/common/testdb"
|
|
"gitea.perlbach24.de/scripte/nexarch/workflow/internal/backchannel"
|
|
"gitea.perlbach24.de/scripte/nexarch/workflow/internal/backchannelapi"
|
|
"gitea.perlbach24.de/scripte/nexarch/workflow/internal/caseobj"
|
|
"gitea.perlbach24.de/scripte/nexarch/workflow/internal/migrate"
|
|
"gitea.perlbach24.de/scripte/nexarch/workflow/internal/moduleadapter"
|
|
"gitea.perlbach24.de/scripte/nexarch/workflow/internal/reminder"
|
|
"gitea.perlbach24.de/scripte/nexarch/workflow/internal/task"
|
|
)
|
|
|
|
type alwaysValidVerifier struct{}
|
|
|
|
func (alwaysValidVerifier) VerifyTenant(_ context.Context, _ string) (bool, error) { return true, nil }
|
|
|
|
func findModuleRoot(t *testing.T) string {
|
|
t.Helper()
|
|
dir, err := os.Getwd()
|
|
if err != nil {
|
|
t.Fatalf("getwd: %v", err)
|
|
}
|
|
for {
|
|
if _, err := os.Stat(filepath.Join(dir, "go.mod")); err == nil {
|
|
return dir
|
|
}
|
|
parent := filepath.Dir(dir)
|
|
if parent == dir {
|
|
t.Fatal("go.mod nicht gefunden")
|
|
}
|
|
dir = parent
|
|
}
|
|
}
|
|
|
|
func testPool(t *testing.T) *pgxpool.Pool {
|
|
t.Helper()
|
|
dsn := os.Getenv("TEST_TENANT_DSN")
|
|
if dsn == "" {
|
|
t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest uebersprungen")
|
|
}
|
|
ctx := context.Background()
|
|
pool := testdb.Pool(t, dsn)
|
|
|
|
migrations, err := migrate.Load(filepath.Join(findModuleRoot(t), "migrations", "tenant"))
|
|
if err != nil {
|
|
t.Fatalf("migrationen laden: %v", err)
|
|
}
|
|
if _, err := migrate.Up(ctx, pool, migrations); err != nil {
|
|
t.Fatalf("migrationen anwenden: %v", err)
|
|
}
|
|
return pool
|
|
}
|
|
|
|
func marshalField(t *testing.T, decoded map[string]any, key string) []byte {
|
|
t.Helper()
|
|
raw, ok := decoded[key]
|
|
if !ok {
|
|
t.Fatalf("feld %q fehlt in der antwort: %v", key, decoded)
|
|
}
|
|
data, err := json.Marshal(raw)
|
|
if err != nil {
|
|
t.Fatalf("feld %q nicht serialisierbar: %v", key, err)
|
|
}
|
|
return data
|
|
}
|
|
|
|
func marshalFirstElement(t *testing.T, decoded map[string]any, key string) []byte {
|
|
t.Helper()
|
|
raw, ok := decoded[key].([]any)
|
|
if !ok || len(raw) == 0 {
|
|
t.Fatalf("feld %q ist keine nichtleere liste: %v", key, decoded[key])
|
|
}
|
|
data, err := json.Marshal(raw[0])
|
|
if err != nil {
|
|
t.Fatalf("erstes element von %q nicht serialisierbar: %v", key, err)
|
|
}
|
|
return data
|
|
}
|
|
|
|
// --- Vertrag 1: ENG-02 Push-Registrierung (POST /register) ---
|
|
// Akzeptanzkriterium 1 + Pruefung 1.
|
|
|
|
// TestContract_ENG02_RegisterResponse prueft die TATSAECHLICHE HTTP-Antwort
|
|
// des echten moduleadapter-Handlers gegen das dokumentierte Schema (Feldnamen,
|
|
// die DMS/Mail beim Registrieren als Rueckgabewert erwarten duerfen).
|
|
func TestContract_ENG02_RegisterResponse(t *testing.T) {
|
|
pool := testPool(t)
|
|
token := "qa-06-vertragstest-token"
|
|
srv := moduleadapter.NewServer(pool, token, "mandant-vertragstest", alwaysValidVerifier{})
|
|
mux := http.NewServeMux()
|
|
srv.RegisterRoutes(mux)
|
|
server := httptest.NewServer(mux)
|
|
defer server.Close()
|
|
|
|
body, _ := json.Marshal(map[string]any{
|
|
"module_name": "contracttest-dms", "object_type": "document",
|
|
"triggers": []string{"document.uploaded"},
|
|
})
|
|
req, _ := http.NewRequest(http.MethodPost, server.URL+"/register", bytes.NewReader(body))
|
|
req.Header.Set("X-Service-Token", token)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
resp, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
t.Fatalf("registrieren: %v", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
if resp.StatusCode != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200", resp.StatusCode)
|
|
}
|
|
var raw bytes.Buffer
|
|
if _, err := raw.ReadFrom(resp.Body); err != nil {
|
|
t.Fatalf("antwort lesen: %v", err)
|
|
}
|
|
|
|
required := []string{"ModuleName", "ObjectType", "ActiveVersion", "Triggers", "Deregistered"}
|
|
missing, err := RequireJSONFields(raw.Bytes(), required)
|
|
if err != nil {
|
|
t.Fatalf("antwort nicht lesbar: %v", err)
|
|
}
|
|
if len(missing) != 0 {
|
|
t.Fatalf("registrierungs-antwort fehlen pflichtfelder: %v", missing)
|
|
}
|
|
}
|
|
|
|
// Pruefung 2: simulierter Breaking Change -- Pflichtfeld "Triggers" entfernt.
|
|
func TestContract_ENG02_DetectsBreakingChange_RemovedField(t *testing.T) {
|
|
brokenResponse := []byte(`{"ModuleName":"dms","ObjectType":"document","ActiveVersion":1,"Deregistered":false}`) // "Triggers" fehlt absichtlich
|
|
required := []string{"ModuleName", "ObjectType", "ActiveVersion", "Triggers", "Deregistered"}
|
|
|
|
missing, err := RequireJSONFields(brokenResponse, required)
|
|
if err != nil {
|
|
t.Fatalf("pruefung selbst fehlgeschlagen: %v", err)
|
|
}
|
|
if len(missing) != 1 || missing[0] != "Triggers" {
|
|
t.Fatalf("erwartet erkanntes fehlendes feld 'Triggers', habe: %v", missing)
|
|
}
|
|
}
|
|
|
|
// --- Vertrag 2: VOR-04 Pull-Rueckkanal (GET /objects/{module}/{type}/{id}/context) ---
|
|
// Akzeptanzkriterium 1 + Pruefung 1.
|
|
|
|
func setupBackchannelTest(t *testing.T) (*httptest.Server, caseobj.Reference) {
|
|
t.Helper()
|
|
pool := testPool(t)
|
|
ctx := context.Background()
|
|
|
|
engine, err := caseobj.NewEngineWithCase(pool)
|
|
if err != nil {
|
|
t.Fatalf("engine anlegen: %v", err)
|
|
}
|
|
cases := caseobj.NewService(pool, engine)
|
|
tasks := task.NewStore(pool)
|
|
reminders := reminder.NewStore(pool, tasks)
|
|
svc := backchannel.NewService(cases, reminders, "mandant-vertragstest", alwaysValidVerifier{})
|
|
|
|
ref := caseobj.Reference{ModuleName: "dms", ObjectType: "document", ObjectID: "doc-qa-06"}
|
|
c, err := cases.Create(ctx, "", "ivan", "ivan", []caseobj.Reference{ref})
|
|
if err != nil {
|
|
t.Fatalf("akte anlegen: %v", err)
|
|
}
|
|
if _, err := cases.AddNote(ctx, c.ID, "ivan", "vertragstest-vermerk"); err != nil {
|
|
t.Fatalf("vermerk anlegen: %v", err)
|
|
}
|
|
if _, err := reminders.Create(ctx, reminder.Target{CaseID: c.ID}, time.Now().Add(24*time.Hour), "vertragstest-wiedervorlage", "ivan"); err != nil {
|
|
t.Fatalf("wiedervorlage anlegen: %v", err)
|
|
}
|
|
|
|
mux := http.NewServeMux()
|
|
backchannelapi.NewServer(svc).RegisterRoutes(mux)
|
|
server := httptest.NewServer(mux)
|
|
t.Cleanup(server.Close)
|
|
return server, ref
|
|
}
|
|
|
|
// TestContract_VOR04_ContextResponse prueft die TATSAECHLICHE HTTP-Antwort
|
|
// der echten backchannelapi gegen das dokumentierte Schema (Akte, Vermerke,
|
|
// Wiedervorlagen in einem Aufruf -- Ausgangslage des Tickets).
|
|
func TestContract_VOR04_ContextResponse(t *testing.T) {
|
|
server, ref := setupBackchannelTest(t)
|
|
|
|
path := "/objects/" + ref.ModuleName + "/" + ref.ObjectType + "/" + ref.ObjectID + "/context"
|
|
req, _ := http.NewRequest(http.MethodGet, server.URL+path, nil)
|
|
req.Header.Set("X-User-Id", "ivan")
|
|
req.Header.Set("X-Tenant-Slug", "mandant-vertragstest")
|
|
resp, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
t.Fatalf("http-aufruf: %v", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
if resp.StatusCode != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200", resp.StatusCode)
|
|
}
|
|
var raw bytes.Buffer
|
|
if _, err := raw.ReadFrom(resp.Body); err != nil {
|
|
t.Fatalf("antwort lesen: %v", err)
|
|
}
|
|
|
|
missing, err := RequireJSONFields(raw.Bytes(), []string{"Case", "Notes", "Reminders"})
|
|
if err != nil {
|
|
t.Fatalf("antwort nicht lesbar: %v", err)
|
|
}
|
|
if len(missing) != 0 {
|
|
t.Fatalf("rueckkanal-antwort fehlen pflichtfelder: %v", missing)
|
|
}
|
|
|
|
var decoded map[string]any
|
|
if err := json.Unmarshal(raw.Bytes(), &decoded); err != nil {
|
|
t.Fatalf("antwort nicht dekodierbar: %v", err)
|
|
}
|
|
|
|
caseMissing, err := RequireJSONFields(marshalField(t, decoded, "Case"), []string{"ID", "CaseNumber", "Status", "Responsible"})
|
|
if err != nil {
|
|
t.Fatalf("akte nicht lesbar: %v", err)
|
|
}
|
|
if len(caseMissing) != 0 {
|
|
t.Fatalf("akte im rueckkanal fehlen pflichtfelder: %v", caseMissing)
|
|
}
|
|
|
|
noteMissing, err := RequireJSONFields(marshalFirstElement(t, decoded, "Notes"), []string{"ID", "Author", "Body", "CreatedAt"})
|
|
if err != nil {
|
|
t.Fatalf("vermerk nicht lesbar: %v", err)
|
|
}
|
|
if len(noteMissing) != 0 {
|
|
t.Fatalf("vermerk im rueckkanal fehlen pflichtfelder: %v", noteMissing)
|
|
}
|
|
|
|
reminderMissing, err := RequireJSONFields(marshalFirstElement(t, decoded, "Reminders"), []string{"ID", "DueAt", "Status", "Note"})
|
|
if err != nil {
|
|
t.Fatalf("wiedervorlage nicht lesbar: %v", err)
|
|
}
|
|
if len(reminderMissing) != 0 {
|
|
t.Fatalf("wiedervorlage im rueckkanal fehlen pflichtfelder: %v", reminderMissing)
|
|
}
|
|
}
|
|
|
|
// Pruefung 2: simulierter Breaking Change -- Pflichtfeld "Status" der
|
|
// verschachtelten Akte entfernt (z.B. durch Umbenennung bei einem kuenftigen
|
|
// Umbau von caseobj.Case).
|
|
func TestContract_VOR04_DetectsBreakingChange_RemovedField(t *testing.T) {
|
|
brokenResponse := []byte(`{"Case":{"ID":"c-1","CaseNumber":"2026-1","Responsible":"ivan"},"Notes":[],"Reminders":[]}`) // "Status" fehlt absichtlich
|
|
var decoded map[string]any
|
|
if err := json.Unmarshal(brokenResponse, &decoded); err != nil {
|
|
t.Fatalf("pruefung selbst fehlgeschlagen: %v", err)
|
|
}
|
|
caseData, err := json.Marshal(decoded["Case"])
|
|
if err != nil {
|
|
t.Fatalf("pruefung selbst fehlgeschlagen: %v", err)
|
|
}
|
|
|
|
missing, err := RequireJSONFields(caseData, []string{"ID", "CaseNumber", "Status", "Responsible"})
|
|
if err != nil {
|
|
t.Fatalf("pruefung selbst fehlgeschlagen: %v", err)
|
|
}
|
|
if len(missing) != 1 || missing[0] != "Status" {
|
|
t.Fatalf("erwartet erkanntes fehlendes feld 'Status', habe: %v", missing)
|
|
}
|
|
}
|