QA-01: teststrategie-core (pflichttest-gate, testdb-isolationsnachweis, ci-workflow)

2026-08-28 22:41:06 +02:00
parent c895a67c4b
commit 5a0d07444c
7 changed files with 468 additions and 0 deletions
@@ -0,0 +1,76 @@
+// Package testdbisolation demonstriert und prüft die in docs/TESTSTRATEGIE-CORE.md Abschnitt 4
+// beschriebene Testdatenbank-Isolation: jeder Test, der eine Tenant-Datenbank braucht,
+// provisioniert seine eigene, eindeutig benannte DB und räumt sie über Cleanup wieder ab —
+// keine geteilten Fixture-Datenbanken zwischen parallelen Testläufen.
+package testdbisolation
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// ProvisionEphemeralDB legt unter dem gegebenen Admin-DSN eine neue, eindeutig benannte Datenbank an
+// und liefert eine Cleanup-Funktion, die sie wieder droppt. adminDSN muss auf eine Wartungs-DB
+// (z. B. "postgres") zeigen, name muss ein gültiger, bereits eindeutiger Bezeichner sein.
+func ProvisionEphemeralDB(ctx context.Context, adminDSN, name string) (cleanup func(context.Context) error, err error) {
+	conn, err := pgx.Connect(ctx, adminDSN)
+	if err != nil {
+		return nil, fmt.Errorf("verbindung zur wartungs-db fehlgeschlagen: %w", err)
+	}
+	defer conn.Close(ctx)
+
+	if _, err := conn.Exec(ctx, fmt.Sprintf("CREATE DATABASE %s", pgx.Identifier{name}.Sanitize())); err != nil {
+		return nil, fmt.Errorf("datenbank %q konnte nicht angelegt werden: %w", name, err)
+	}
+
+	cleanup = func(cleanupCtx context.Context) error {
+		adminConn, err := pgx.Connect(cleanupCtx, adminDSN)
+		if err != nil {
+			return fmt.Errorf("cleanup: verbindung fehlgeschlagen: %w", err)
+		}
+		defer adminConn.Close(cleanupCtx)
+		_, err = adminConn.Exec(cleanupCtx, fmt.Sprintf("DROP DATABASE IF EXISTS %s", pgx.Identifier{name}.Sanitize()))
+		return err
+	}
+	return cleanup, nil
+}
+
+// WriteMarker schreibt einen eindeutigen Beleg-Datensatz in die angegebene Datenbank (verbindet
+// per dsnForDB), um im Test nachzuweisen, dass zwei parallele Provisionierungen sich nicht sehen.
+func WriteMarker(ctx context.Context, dsn, table, value string) error {
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		return err
+	}
+	defer pool.Close()
+
+	if _, err := pool.Exec(ctx, fmt.Sprintf(
+		"CREATE TABLE IF NOT EXISTS %s (value text primary key)", pgx.Identifier{table}.Sanitize(),
+	)); err != nil {
+		return err
+	}
+	_, err = pool.Exec(ctx, fmt.Sprintf("INSERT INTO %s (value) VALUES ($1)", pgx.Identifier{table}.Sanitize()), value)
+	return err
+}
+
+// CountMarkers zählt die Belegzeilen in der angegebenen Datenbank/Tabelle.
+func CountMarkers(ctx context.Context, dsn, table string) (int, error) {
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		return 0, err
+	}
+	defer pool.Close()
+
+	if _, err := pool.Exec(ctx, fmt.Sprintf(
+		"CREATE TABLE IF NOT EXISTS %s (value text primary key)", pgx.Identifier{table}.Sanitize(),
+	)); err != nil {
+		return 0, err
+	}
+
+	var n int
+	err = pool.QueryRow(ctx, fmt.Sprintf("SELECT count(*) FROM %s", pgx.Identifier{table}.Sanitize())).Scan(&n)
+	return n, err
+}
@@ -0,0 +1,99 @@
+package testdbisolation
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+)
+
+// TestParallelProvisioning_AreIsolated ist der automatisierte Nachweis für QA-01 Prüfung 2:
+// Testdatenbank-Isolation zwischen parallelen Testläufen. Zwei Provisionierungen laufen
+// gleichzeitig, jede schreibt einen Beleg-Datensatz in ihre eigene DB — keine darf den
+// Beleg der jeweils anderen sehen.
+//
+// Braucht TEST_ADMIN_DSN (siehe Projekt-Testinfrastruktur), läuft auf dem Testhost, nicht lokal
+// auf der Entwicklungsmaschine (siehe "no installs"-Regel) — wird ohne gesetzte Variable übersprungen.
+func TestParallelProvisioning_AreIsolated(t *testing.T) {
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt — Test läuft nur auf dem Testhost, siehe docs/TESTSTRATEGIE-CORE.md")
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	const numParallel = 2
+	dbNames := make([]string, numParallel)
+	for i := range dbNames {
+		dbNames[i] = fmt.Sprintf("qa01_isolation_%d_%d", time.Now().UnixNano(), i)
+	}
+
+	var wg sync.WaitGroup
+	errs := make([]error, numParallel)
+	cleanups := make([]func(context.Context) error, numParallel)
+
+	for i, name := range dbNames {
+		wg.Add(1)
+		go func(idx int, dbName string) {
+			defer wg.Done()
+
+			cleanup, err := ProvisionEphemeralDB(ctx, adminDSN, dbName)
+			if err != nil {
+				errs[idx] = fmt.Errorf("provisionierung %d fehlgeschlagen: %w", idx, err)
+				return
+			}
+			cleanups[idx] = cleanup
+
+			dbDSN := dsnForDB(adminDSN, dbName)
+			// Jede Goroutine schreibt einen für sie eindeutigen Beleg.
+			if err := WriteMarker(ctx, dbDSN, "isolation_marker", fmt.Sprintf("marker-von-goroutine-%d", idx)); err != nil {
+				errs[idx] = fmt.Errorf("markierung %d fehlgeschlagen: %w", idx, err)
+			}
+		}(i, name)
+	}
+	wg.Wait()
+
+	t.Cleanup(func() {
+		for _, cleanup := range cleanups {
+			if cleanup != nil {
+				_ = cleanup(context.Background())
+			}
+		}
+	})
+
+	for i, err := range errs {
+		if err != nil {
+			t.Fatalf("goroutine %d: %v", i, err)
+		}
+	}
+
+	// Isolationsnachweis: jede DB enthält genau ihren eigenen Beleg (1), keinen fremden.
+	for i, name := range dbNames {
+		dbDSN := dsnForDB(adminDSN, name)
+		count, err := CountMarkers(ctx, dbDSN, "isolation_marker")
+		if err != nil {
+			t.Fatalf("zaehlung in db %d fehlgeschlagen: %v", i, err)
+		}
+		if count != 1 {
+			t.Errorf("db %d (%s): erwartet genau 1 eigenen Beleg, gefunden %d — Isolation verletzt", i, name, count)
+		}
+	}
+}
+
+// dsnForDB ersetzt den Datenbanknamen im Wartungs-DSN durch den gegebenen Namen.
+func dsnForDB(adminDSN, dbName string) string {
+	idx := strings.LastIndex(adminDSN, "/")
+	if idx == -1 {
+		return adminDSN
+	}
+	base := adminDSN[:idx+1]
+	rest := adminDSN[idx+1:]
+	if q := strings.Index(rest, "?"); q != -1 {
+		return base + dbName + rest[q:]
+	}
+	return base + dbName
+}