nexarch/workflow/internal/moduleadapter/moduleadapter_test.go

package moduleadapter

import (
	"context"
	"errors"
	"os"
	"path/filepath"
	"testing"

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

	"gitea.perlbach24.de/scripte/nexarch/workflow/internal/migrate"
	"gitea.perlbach24.de/scripte/nexarch/workflow/internal/testdb"
)

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
}

// Pflichtprüfung 1: Testadapter aus fiktivem DMS- und Mail-Modul beide
// korrekt registriert.
func TestRegister_TwoFictionalModulesRegisterIndependently(t *testing.T) {
	p := testPool(t)
	ctx := context.Background()

	dmsReg, err := Register(ctx, p, "dms-fiktiv", "invoice", []string{"document.uploaded"})
	if err != nil {
		t.Fatalf("dms registrieren: %v", err)
	}
	mailReg, err := Register(ctx, p, "mail-fiktiv", "message", []string{"mail.received"})
	if err != nil {
		t.Fatalf("mail registrieren: %v", err)
	}

	if dmsReg.ActiveVersion != 1 || mailReg.ActiveVersion != 1 {
		t.Fatalf("erwarte beide auf version 1, habe dms=%d mail=%d", dmsReg.ActiveVersion, mailReg.ActiveVersion)
	}

	regs, err := ListRegistrations(ctx, p)
	if err != nil {
		t.Fatalf("auflisten: %v", err)
	}
	if len(regs) != 2 {
		t.Fatalf("erwarte 2 registrierungen, habe %d", len(regs))
	}
}

// Pflichtprüfung 2: doppelte Registrierung wird abgewiesen.
func TestRegister_DuplicateSameTriggersRejected(t *testing.T) {
	p := testPool(t)
	ctx := context.Background()

	if _, err := Register(ctx, p, "dms-fiktiv", "invoice", []string{"document.uploaded", "document.tagged"}); err != nil {
		t.Fatalf("erste registrierung: %v", err)
	}
	_, err := Register(ctx, p, "dms-fiktiv", "invoice", []string{"document.tagged", "document.uploaded"})
	if !errors.Is(err, ErrDuplicateTriggers) {
		t.Fatalf("erwarte ErrDuplicateTriggers, habe %v", err)
	}
}

// Akzeptanzkriterium 2: Registrierung ist versionierbar und rückrollbar.
func TestRegister_ChangedTriggersCreateNewVersionAndRollbackRestoresPrevious(t *testing.T) {
	p := testPool(t)
	ctx := context.Background()

	if _, err := Register(ctx, p, "dms-fiktiv", "invoice", []string{"document.uploaded"}); err != nil {
		t.Fatalf("v1: %v", err)
	}
	v2, err := Register(ctx, p, "dms-fiktiv", "invoice", []string{"document.uploaded", "document.tagged"})
	if err != nil {
		t.Fatalf("v2: %v", err)
	}
	if v2.ActiveVersion != 2 {
		t.Fatalf("erwarte version 2, habe %d", v2.ActiveVersion)
	}

	triggers, err := TriggersFor(ctx, p, "dms-fiktiv", "invoice")
	if err != nil {
		t.Fatalf("trigger lesen: %v", err)
	}
	if len(triggers) != 2 {
		t.Fatalf("erwarte 2 trigger nach v2, habe %v", triggers)
	}

	rolled, err := Rollback(ctx, p, "dms-fiktiv", "invoice", 1)
	if err != nil {
		t.Fatalf("rollback: %v", err)
	}
	if rolled.ActiveVersion != 1 {
		t.Fatalf("erwarte version 1 nach rollback, habe %d", rolled.ActiveVersion)
	}
	triggers, err = TriggersFor(ctx, p, "dms-fiktiv", "invoice")
	if err != nil {
		t.Fatalf("trigger nach rollback lesen: %v", err)
	}
	if len(triggers) != 1 || triggers[0] != "document.uploaded" {
		t.Fatalf("erwarte nur document.uploaded nach rollback, habe %v", triggers)
	}
}

// Pflichtprüfung 3: Deregistrierung entfernt zugehörige Trigger
// vollständig.
func TestDeregister_RemovesTriggersCompletely(t *testing.T) {
	p := testPool(t)
	ctx := context.Background()

	if _, err := Register(ctx, p, "mail-fiktiv", "message", []string{"mail.received", "mail.flagged"}); err != nil {
		t.Fatalf("registrieren: %v", err)
	}
	if err := Deregister(ctx, p, "mail-fiktiv", "message"); err != nil {
		t.Fatalf("deregistrieren: %v", err)
	}

	_, err := TriggersFor(ctx, p, "mail-fiktiv", "message")
	if !errors.Is(err, ErrNotRegistered) {
		t.Fatalf("erwarte ErrNotRegistered nach deregistrierung, habe %v", err)
	}
}

// Akzeptanzkriterium 3: fehlende Registrierung führt zu klarer
// Fehlermeldung statt Absturz.
func TestTriggersFor_UnknownObjectTypeReturnsClearError(t *testing.T) {
	p := testPool(t)
	ctx := context.Background()

	_, err := TriggersFor(ctx, p, "dms-fiktiv", "nie-registriert")
	if !errors.Is(err, ErrNotRegistered) {
		t.Fatalf("erwarte ErrNotRegistered, habe %v", err)
	}
}

// Rollback auf eine nicht existierende Version liefert einen klaren
// Fehler statt eines Panics.
func TestRollback_UnknownVersionReturnsError(t *testing.T) {
	p := testPool(t)
	ctx := context.Background()

	if _, err := Register(ctx, p, "dms-fiktiv", "invoice", []string{"document.uploaded"}); err != nil {
		t.Fatalf("registrieren: %v", err)
	}
	if _, err := Rollback(ctx, p, "dms-fiktiv", "invoice", 99); err == nil {
		t.Fatal("erwarte fehler bei unbekannter zielversion")
	}
}