194 lines
6.9 KiB
Go
194 lines
6.9 KiB
Go
package contracttest
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
|
|
"gitea.perlbach24.de/scripte/nexarch/internal/apiserver"
|
|
"gitea.perlbach24.de/scripte/nexarch/internal/flag"
|
|
"gitea.perlbach24.de/scripte/nexarch/internal/moduleregistry"
|
|
"gitea.perlbach24.de/scripte/nexarch/internal/moduletrust"
|
|
"gitea.perlbach24.de/scripte/nexarch/internal/webhook"
|
|
)
|
|
|
|
// --- Vertrag 1: API-01 REST-Fehlerschema ---
|
|
// Akzeptanzkriterium 1/2 + Pruefung 1/2.
|
|
|
|
func TestContract_API01_ErrorEnvelope(t *testing.T) {
|
|
rec := httptest.NewRecorder()
|
|
apiserver.WriteError(rec, http.StatusUnauthorized, "unauthenticated", "nicht angemeldet")
|
|
|
|
if missing, err := RequireJSONFields(rec.Body.Bytes(), []string{"error"}); err != nil {
|
|
t.Fatalf("antwort nicht lesbar: %v", err)
|
|
} else if len(missing) != 0 {
|
|
t.Fatalf("erwartet top-level feld 'error', fehlt: %v", missing)
|
|
}
|
|
|
|
var decoded map[string]json.RawMessage
|
|
_ = json.Unmarshal(rec.Body.Bytes(), &decoded)
|
|
if missing, err := RequireJSONFields(decoded["error"], []string{"code", "message"}); err != nil {
|
|
t.Fatalf("error-objekt nicht lesbar: %v", err)
|
|
} else if len(missing) != 0 {
|
|
t.Fatalf("error-objekt fehlen pflichtfelder: %v", missing)
|
|
}
|
|
}
|
|
|
|
// Pruefung 2: absichtlich simulierter Breaking Change (Feld "message"
|
|
// entfernt) laesst den Vertragstest fehlschlagen.
|
|
func TestContract_API01_DetectsBreakingChange_RemovedField(t *testing.T) {
|
|
brokenResponse := []byte(`{"error":{"code":"unauthenticated"}}`) // "message" fehlt absichtlich
|
|
var decoded map[string]json.RawMessage
|
|
if err := json.Unmarshal(brokenResponse, &decoded); err != nil {
|
|
t.Fatalf("fixture nicht lesbar: %v", err)
|
|
}
|
|
missing, err := RequireJSONFields(decoded["error"], []string{"code", "message"})
|
|
if err != nil {
|
|
t.Fatalf("pruefung selbst fehlgeschlagen: %v", err)
|
|
}
|
|
if len(missing) != 1 || missing[0] != "message" {
|
|
t.Fatalf("erwartet erkanntes fehlendes feld 'message', habe: %v", missing)
|
|
}
|
|
}
|
|
|
|
// --- Vertrag 2: API-05 JWKS / Rechte-Cache-Kontrakt ---
|
|
// Akzeptanzkriterium 1/2 + Pruefung 1/2.
|
|
|
|
func TestContract_API05_JWKS(t *testing.T) {
|
|
km, err := moduletrust.NewKeyManager()
|
|
if err != nil {
|
|
t.Fatalf("keymanager: %v", err)
|
|
}
|
|
if _, err := km.Rotate(); err != nil {
|
|
t.Fatalf("rotate: %v", err)
|
|
}
|
|
|
|
rec := httptest.NewRecorder()
|
|
km.ServeJWKS(rec, httptest.NewRequest(http.MethodGet, "/jwks", nil))
|
|
|
|
missing, err := RequireJSONArrayItemFields(rec.Body.Bytes(), "keys", []string{"kid", "public_key"})
|
|
if err != nil {
|
|
t.Fatalf("jwks-antwort verletzt vertrag: %v", err)
|
|
}
|
|
if len(missing) != 0 {
|
|
t.Fatalf("jwks-eintrag fehlen pflichtfelder: %v", missing)
|
|
}
|
|
}
|
|
|
|
// Pruefung 2: simulierter Breaking Change — Feld "public_key" umbenannt
|
|
// (z.B. faelschlich zu "publicKey"), Vertragstest erkennt das fehlende
|
|
// Originalfeld zuverlaessig.
|
|
func TestContract_API05_DetectsBreakingChange_RenamedField(t *testing.T) {
|
|
brokenJWKS := []byte(`{"keys":[{"kid":"abc","publicKey":"base64..."}]}`)
|
|
missing, err := RequireJSONArrayItemFields(brokenJWKS, "keys", []string{"kid", "public_key"})
|
|
if err != nil {
|
|
t.Fatalf("pruefung selbst fehlgeschlagen: %v", err)
|
|
}
|
|
if len(missing) != 1 || missing[0] != "public_key" {
|
|
t.Fatalf("erwartet erkanntes umbenanntes feld 'public_key', habe: %v", missing)
|
|
}
|
|
}
|
|
|
|
// --- Vertrag 3: API-02 Modul-Registry ---
|
|
// Akzeptanzkriterium 1/2 + Pruefung 1/2.
|
|
|
|
func setupModuleRegistryTest(t *testing.T) (*moduleregistry.Registry, func()) {
|
|
t.Helper()
|
|
adminDSN := os.Getenv("TEST_ADMIN_DSN")
|
|
if adminDSN == "" {
|
|
t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
|
|
}
|
|
ctx := context.Background()
|
|
pool, err := pgxpool.New(ctx, adminDSN)
|
|
if err != nil {
|
|
t.Fatalf("pool: %v", err)
|
|
}
|
|
if _, err := pool.Exec(ctx, `
|
|
CREATE TABLE IF NOT EXISTS feature_flags (
|
|
key TEXT PRIMARY KEY, enabled BOOLEAN NOT NULL DEFAULT false,
|
|
rollout_percentage INT NOT NULL DEFAULT 0, target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
|
|
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
|
);
|
|
CREATE TABLE IF NOT EXISTS modules (
|
|
name TEXT PRIMARY KEY, version TEXT NOT NULL CHECK (version <> ''),
|
|
required_flags TEXT[] NOT NULL DEFAULT '{}', registered_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
|
);
|
|
`); err != nil {
|
|
t.Fatalf("schema: %v", err)
|
|
}
|
|
flagService := flag.NewService(flag.NewStore(pool), 10*time.Millisecond)
|
|
return moduleregistry.NewRegistry(pool, flagService), func() { pool.Close() }
|
|
}
|
|
|
|
func TestContract_API02_ModuleInfo(t *testing.T) {
|
|
registry, cleanup := setupModuleRegistryTest(t)
|
|
defer cleanup()
|
|
ctx := context.Background()
|
|
|
|
m, err := registry.Register(ctx, "contracttest-dms", "1.0.0", []string{"some-flag"})
|
|
if err != nil {
|
|
t.Fatalf("register: %v", err)
|
|
}
|
|
|
|
data, err := json.Marshal(m)
|
|
if err != nil {
|
|
t.Fatalf("marshal: %v", err)
|
|
}
|
|
missing, err := RequireJSONFields(data, []string{"Name", "Version", "RequiredFlags"})
|
|
if err != nil {
|
|
t.Fatalf("modul-antwort nicht lesbar: %v", err)
|
|
}
|
|
if len(missing) != 0 {
|
|
t.Fatalf("modul-info fehlen pflichtfelder: %v", missing)
|
|
}
|
|
}
|
|
|
|
// Pruefung 2: simulierter Breaking Change — Feld "RequiredFlags" entfernt.
|
|
func TestContract_API02_DetectsBreakingChange_RemovedField(t *testing.T) {
|
|
brokenModuleJSON := []byte(`{"Name":"dms","Version":"1.0.0"}`)
|
|
missing, err := RequireJSONFields(brokenModuleJSON, []string{"Name", "Version", "RequiredFlags"})
|
|
if err != nil {
|
|
t.Fatalf("pruefung selbst fehlgeschlagen: %v", err)
|
|
}
|
|
if len(missing) != 1 || missing[0] != "RequiredFlags" {
|
|
t.Fatalf("erwartet erkanntes fehlendes feld 'RequiredFlags', habe: %v", missing)
|
|
}
|
|
}
|
|
|
|
// --- Vertrag 4: API-07 Webhook-Zustellung (HMAC-Signaturheader) ---
|
|
// Akzeptanzkriterium 1/2 + Pruefung 1/2.
|
|
|
|
func TestContract_API07_WebhookSignatureHeader(t *testing.T) {
|
|
if webhook.SignatureHeader != "X-Nexarch-Signature-256" {
|
|
t.Fatalf("signaturheader-name = %q, want stabilen vertrag 'X-Nexarch-Signature-256' — konsumierende module lesen genau diesen namen", webhook.SignatureHeader)
|
|
}
|
|
|
|
secret := "vertragstest-secret"
|
|
payload := []byte(`{"event":"test"}`)
|
|
signature := webhook.Sign(secret, payload)
|
|
|
|
if !webhook.VerifySignature(secret, payload, signature) {
|
|
t.Fatal("konsumentenseitige signaturpruefung schlaegt fuer eine korrekte core-signatur fehl")
|
|
}
|
|
}
|
|
|
|
// Pruefung 2: simulierter Breaking Change — eine Zustellung, die den
|
|
// Signaturheader unter einem ANDEREN Namen sendet (wie es ein
|
|
// hypothetischer, den Vertrag brechender Core-Umbau taete). Ein
|
|
// konsumierendes Modul, das nach dem DOKUMENTIERTEN Namen sucht, findet in
|
|
// diesem Fall nichts — der Vertragstest erkennt das zuverlaessig.
|
|
func TestContract_API07_DetectsBreakingChange_RenamedHeader(t *testing.T) {
|
|
brokenHeaders := http.Header{}
|
|
brokenHeaders.Set("X-Signature", webhook.Sign("secret", []byte("payload"))) // falscher name, simuliert breaking change
|
|
|
|
if got := brokenHeaders.Get(webhook.SignatureHeader); got != "" {
|
|
t.Fatalf("erwartet leeren wert unter dem dokumentierten headernamen bei simuliertem breaking change, habe: %q", got)
|
|
}
|
|
}
|