nexarch/archive/internal/reconcilereportmigration/reconcilereportmigration_test.go

package reconcilereportmigration

import (
	"context"
	"encoding/json"
	"errors"
	"os"
	"reflect"
	"testing"
	"time"

	"github.com/jackc/pgx/v5/pgxpool"
)

// fakeSource ist eine rein synthetische archivmail-Quelle — keine echten
// Kunden-/Mandantendaten (DSGVO-Hartregel).
type fakeSource struct {
	reports []SourceReport
}

func (f *fakeSource) Reports(_ context.Context) ([]SourceReport, error) {
	return f.reports, nil
}

func setupPool(t *testing.T, envVar string) *pgxpool.Pool {
	t.Helper()
	dsn := os.Getenv(envVar)
	if dsn == "" {
		t.Skipf("%s nicht gesetzt, Integrationstest uebersprungen", envVar)
	}
	ctx := context.Background()
	pool, err := pgxpool.New(ctx, dsn)
	if err != nil {
		t.Fatalf("pool: %v", err)
	}
	t.Cleanup(func() { pool.Close() })

	if _, err := pool.Exec(ctx, `
		CREATE TABLE IF NOT EXISTS reconciliation_report_archive (
			id               UUID PRIMARY KEY DEFAULT gen_random_uuid(),
			source_report_id TEXT NOT NULL UNIQUE,
			generated_at     TIMESTAMPTZ NOT NULL,
			report_json      JSONB NOT NULL,
			migrated_at      TIMESTAMPTZ NOT NULL DEFAULT now()
		);
	`); err != nil {
		t.Fatalf("schema: %v", err)
	}
	t.Cleanup(func() {
		_, _ = pool.Exec(context.Background(), `DELETE FROM reconciliation_report_archive WHERE source_report_id LIKE 'mai04test_%'`)
	})
	return pool
}

func synthReports() []SourceReport {
	oldStatus := int64(1700000000)
	return []SourceReport{
		{
			SourceReportID: "mai04test_r1",
			GeneratedAt:    time.Date(2021, 3, 1, 5, 0, 0, 0, time.UTC),
			ReportJSON:     []byte(`{"missing_in_storage":[],"orphaned_in_storage":[],"existing_in_storage":[{"storage_key":"synth-key-1"}]}`),
			IndexedAt:      &oldStatus,
		},
		{
			SourceReportID: "mai04test_r2",
			GeneratedAt:    time.Date(2021, 4, 1, 5, 0, 0, 0, time.UTC),
			ReportJSON:     []byte(`{"missing_in_storage":[{"storage_key":"synth-key-2"}],"orphaned_in_storage":[],"existing_in_storage":[]}`),
		},
	}
}

// TestMigrateAll_ReportsAreFindableWithOriginalContent ist
// Akzeptanzkriterium 1 und Prüfung 1 (Stichprobenvergleich vor/nach
// Migration): jeder historische Report ist nach Migration auffindbar,
// mit unverändertem Inhalt.
func TestMigrateAll_ReportsAreFindableWithOriginalContent(t *testing.T) {
	pool := setupPool(t, "TEST_TENANT_DSN")
	ctx := context.Background()
	src := &fakeSource{reports: synthReports()}
	m := NewMigrator(src, pool)

	res, err := m.MigrateAll(ctx)
	if err != nil {
		t.Fatalf("migrateall: %v", err)
	}
	if res.ReportsMigrated != 2 || res.ReportsSkipped != 0 {
		t.Fatalf("erwartet 2 migriert/0 übersprungen, habe %+v", res)
	}

	for _, want := range synthReports() {
		got, err := FindBySourceID(ctx, pool, want.SourceReportID)
		if err != nil {
			t.Fatalf("report %q nicht auffindbar: %v", want.SourceReportID, err)
		}
		var gotDecoded, wantDecoded any
		if err := json.Unmarshal(got.ReportJSON, &gotDecoded); err != nil {
			t.Fatalf("report %q: migrierten inhalt dekodieren: %v", want.SourceReportID, err)
		}
		if err := json.Unmarshal(want.ReportJSON, &wantDecoded); err != nil {
			t.Fatalf("report %q: erwarteten inhalt dekodieren: %v", want.SourceReportID, err)
		}
		if !reflect.DeepEqual(gotDecoded, wantDecoded) {
			t.Fatalf("report %q inhalt weicht ab: habe %s, erwartet %s", want.SourceReportID, got.ReportJSON, want.ReportJSON)
		}
		if !got.GeneratedAt.Equal(want.GeneratedAt) {
			t.Fatalf("report %q generated_at weicht ab: habe %v, erwartet %v", want.SourceReportID, got.GeneratedAt, want.GeneratedAt)
		}
	}
}

// TestMigrateAll_SecondRunSkipsAlreadyMigratedReports beweist Idempotenz:
// ein erneuter Lauf gegen dieselbe Quelle überschreibt nichts.
func TestMigrateAll_SecondRunSkipsAlreadyMigratedReports(t *testing.T) {
	pool := setupPool(t, "TEST_TENANT_DSN")
	ctx := context.Background()
	src := &fakeSource{reports: synthReports()}
	m := NewMigrator(src, pool)

	if _, err := m.MigrateAll(ctx); err != nil {
		t.Fatalf("erster lauf: %v", err)
	}

	res, err := m.MigrateAll(ctx)
	if err != nil {
		t.Fatalf("zweiter lauf: %v", err)
	}
	if res.ReportsMigrated != 0 || res.ReportsSkipped != 2 {
		t.Fatalf("erwartet 0 migriert/2 übersprungen beim zweiten lauf, habe %+v", res)
	}
}

// TestFindBySourceID_UnknownIDReturnsErrNotFound.
func TestFindBySourceID_UnknownIDReturnsErrNotFound(t *testing.T) {
	pool := setupPool(t, "TEST_TENANT_DSN")
	ctx := context.Background()

	_, err := FindBySourceID(ctx, pool, "mai04test_unknown")
	if !errors.Is(err, ErrNotFound) {
		t.Fatalf("erwartet ErrNotFound, habe: %v", err)
	}
}

// TestMigrateAll_ReportIsOnlyFindableInCorrectTenantDatabase ist
// Akzeptanzkriterium 1 (korrekte Tenant-Zuordnung): ein in Tenant-A
// migrierter Report ist über die Datenbankverbindung von Tenant B NICHT
// auffindbar — die Trennung ist strukturell (Modell C, eine physisch
// isolierte Datenbank je Mandant), keine Anwendungslogik könnte sie
// versehentlich umgehen.
func TestMigrateAll_ReportIsOnlyFindableInCorrectTenantDatabase(t *testing.T) {
	poolA := setupPool(t, "TEST_TENANT_DSN")
	poolB := setupPool(t, "TEST_TENANT_DSN_B")
	ctx := context.Background()

	src := &fakeSource{reports: synthReports()}
	m := NewMigrator(src, poolA)
	if _, err := m.MigrateAll(ctx); err != nil {
		t.Fatalf("migrateall gegen tenant a: %v", err)
	}

	if _, err := FindBySourceID(ctx, poolA, "mai04test_r1"); err != nil {
		t.Fatalf("report in tenant a nicht auffindbar: %v", err)
	}
	if _, err := FindBySourceID(ctx, poolB, "mai04test_r1"); !errors.Is(err, ErrNotFound) {
		t.Fatalf("erwartet ErrNotFound in tenant b, habe: %v", err)
	}
}

// TestSourceReport_IndexedAtIsNeverPersisted beweist Produkt-DNA: kein
// Übernehmen von indexed_at-Statusfeldern — die Spalte existiert in der
// Zieltabelle bewusst nicht.
func TestSourceReport_IndexedAtIsNeverPersisted(t *testing.T) {
	pool := setupPool(t, "TEST_TENANT_DSN")
	ctx := context.Background()
	src := &fakeSource{reports: synthReports()}
	m := NewMigrator(src, pool)

	if _, err := m.MigrateAll(ctx); err != nil {
		t.Fatalf("migrateall: %v", err)
	}

	var columnExists bool
	err := pool.QueryRow(ctx, `
		SELECT EXISTS (
			SELECT 1 FROM information_schema.columns
			WHERE table_name = 'reconciliation_report_archive' AND column_name = 'indexed_at'
		)
	`).Scan(&columnExists)
	if err != nil {
		t.Fatalf("spaltenprüfung: %v", err)
	}
	if columnExists {
		t.Fatal("reconciliation_report_archive darf keine indexed_at-spalte haben")
	}
}