nexarch/internal/rollbackrun/rollbackrun_test.go

package rollbackrun

import (
	"context"
	"os"
	"testing"
	"time"

	"gitea.perlbach24.de/scripte/nexarch/internal/cutoverorchestrator"
	"gitea.perlbach24.de/scripte/nexarch/internal/testdb"
)

const testTenantID int64 = 101

func testCluster(t *testing.T) *cutoverorchestrator.Cluster {
	t.Helper()
	adminDSN := os.Getenv("TEST_ADMIN_DSN")
	if adminDSN == "" {
		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
	}
	c, err := cutoverorchestrator.NewCluster(adminDSN)
	if err != nil {
		t.Fatalf("NewCluster: %v", err)
	}
	return c
}

func setupTestbed(t *testing.T) (*cutoverorchestrator.Cluster, *Testbed) {
	t.Helper()
	cluster := testCluster(t)
	ctx := context.Background()

	ds, err := cutoverorchestrator.GenerateDataset(11, time.Date(2026, 10, 14, 9, 0, 0, 0, time.UTC), 4)
	if err != nil {
		t.Fatalf("GenerateDataset: %v", err)
	}

	dbName := "rol02_" + testdb.Suffix()
	tb, err := Setup(ctx, cluster, dbName, testTenantID, ds.Archivmail)
	if err != nil {
		t.Fatalf("Setup: %v", err)
	}
	t.Cleanup(func() {
		tb.Pool.Close()
		if err := DropDatabase(context.Background(), cluster, dbName); err != nil {
			t.Logf("aufraeumen %s fehlgeschlagen: %v", dbName, err)
		}
	})
	return cluster, tb
}

// AK1 (Pruefung 1): Altsystem im Wartungsmodus ist read-only -- der
// simulierte Rollback muss diesen Zustand erst aufheben, bevor Schreiben
// wieder moeglich ist.
func TestSetup_PutsLegacySystemIntoReadOnlyMaintenanceMode(t *testing.T) {
	ctx := context.Background()
	_, tb := setupTestbed(t)

	_, err := tb.Pool.Exec(ctx, `INSERT INTO legacy_writeprobe (note) VALUES ('sollte scheitern')`)
	if err == nil {
		t.Fatal("schreibzugriff im wartungsmodus haette fehlschlagen muessen")
	}
}

// AK1/AK2/AK3: Rollback durchspielen, danach Altsystem wieder nutzbar,
// Dauer gemessen und sinnvoll (kein Timeout, keine Nullzeit durch Fehler).
func TestRollback_RestoresWriteAccessAndMeasuresDuration(t *testing.T) {
	cluster, tb := setupTestbed(t)
	ctx := context.Background()

	report, err := Rollback(ctx, cluster, tb)
	if err != nil {
		t.Fatalf("Rollback: %v", err)
	}
	if report.Duration <= 0 {
		t.Fatalf("erwarte gemessene dauer > 0, habe %v", report.Duration)
	}
	if report.Duration > 30*time.Second {
		t.Fatalf("rollback hat unerwartet lange gedauert: %v", report.Duration)
	}
	t.Logf("gemessene rollback-dauer: %v", report.Duration)
	if !report.WriteVerified || report.WriteProbeID == 0 {
		t.Fatalf("schreibzugriff nach rollback nicht verifiziert: %+v", report)
	}
	if report.DataLossDetected {
		t.Fatalf("datenverlust erkannt, erwartet keiner: %+v", report.MismatchedTables)
	}

	var maint, nex bool
	if err := tb.Pool.QueryRow(ctx, `SELECT maintenance_mode, nexarch_enabled FROM legacy_system_state WHERE tenant_id = $1`, testTenantID).Scan(&maint, &nex); err != nil {
		t.Fatalf("zustand nach rollback lesen: %v", err)
	}
	if maint || nex {
		t.Fatalf("wartungsmodus/freischaltung nach rollback nicht zurueckgenommen: maintenance=%v nexarch=%v", maint, nex)
	}

	if _, err := tb.Pool.Exec(ctx, `INSERT INTO legacy_writeprobe (note) VALUES ('exemplarischer schreibzugriff nach rollback')`); err != nil {
		t.Fatalf("altsystem nach rollback nicht voll nutzbar: %v", err)
	}
}

// AK1/Pruefung 2: Rollback ohne vorherigen Wartungsmodus wird abgelehnt --
// verhindert, dass ein bereits zurueckgenommener Zustand erneut "zurueck"-
// genommen wird und dabei unbemerkt Status verliert.
func TestRollback_RejectsWhenNotInMaintenanceMode(t *testing.T) {
	cluster, tb := setupTestbed(t)
	ctx := context.Background()

	if _, err := Rollback(ctx, cluster, tb); err != nil {
		t.Fatalf("erster rollback sollte gelingen: %v", err)
	}

	if _, err := Rollback(ctx, cluster, tb); err == nil {
		t.Fatal("zweiter rollback haette an der vorbedingung scheitern muessen")
	}
}

// Pruefung "kein Datenverlust": Snapshot-Vergleich erkennt eine
// zwischenzeitliche Aenderung tatsaechlich, statt immer gleich auszufallen.
func TestSnapshotTables_DetectsChange(t *testing.T) {
	ctx := context.Background()
	cluster, tb := setupTestbed(t)
	if _, err := Rollback(ctx, cluster, tb); err != nil {
		t.Fatalf("rollback zur vorbereitung (schreibzugriff fuer testaenderung): %v", err)
	}

	before, err := snapshotTables(ctx, tb.Pool, BusinessTables)
	if err != nil {
		t.Fatalf("snapshot vorher: %v", err)
	}

	if _, err := tb.Pool.Exec(ctx, `UPDATE tenants SET name = name || ' geaendert' WHERE id = $1`, testTenantID); err != nil {
		t.Fatalf("testaenderung: %v", err)
	}

	after, err := snapshotTables(ctx, tb.Pool, BusinessTables)
	if err != nil {
		t.Fatalf("snapshot nachher: %v", err)
	}

	if before["tenants"] == after["tenants"] {
		t.Fatal("aenderung an tenants haette im snapshot sichtbar sein muessen")
	}
}