nexarch/internal/lockout/lockout_test.go

package lockout

import (
	"context"
	"errors"
	"fmt"
	"os"
	"testing"
	"time"

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

	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
	"gitea.perlbach24.de/scripte/nexarch/internal/user"
)

const schema = `
CREATE TABLE IF NOT EXISTS users (
	id UUID PRIMARY KEY DEFAULT gen_random_uuid(), email TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
	status TEXT NOT NULL DEFAULT 'active', password_hash TEXT NOT NULL DEFAULT '',
	created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE TABLE IF NOT EXISTS login_attempts (
	email TEXT PRIMARY KEY, failed_count INT NOT NULL DEFAULT 0,
	locked_until TIMESTAMPTZ, last_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now()
);`

func setupTest(t *testing.T) (*pgxpool.Pool, 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, schema); err != nil {
		t.Fatalf("schema: %v", err)
	}
	cleanup := func() { pool.Close() }
	return pool, cleanup
}

func uniqueEmail() string {
	return fmt.Sprintf("lockout-test-%d@example.com", time.Now().UnixNano())
}

// Akzeptanzkriterium 1 + Pruefung 2: Sperre greift nach definierten
// Fehlversuchen zuverlaessig.
func TestRecordFailure_LocksAfterThreshold(t *testing.T) {
	pool, cleanup := setupTest(t)
	defer cleanup()
	ctx := context.Background()
	store := NewStore(pool).WithPolicy(3, time.Hour)
	email := uniqueEmail()

	for i := 0; i < 2; i++ {
		locked, _, err := store.RecordFailure(ctx, email)
		if err != nil {
			t.Fatalf("record failure %d: %v", i, err)
		}
		if locked {
			t.Fatalf("sollte nach %d fehlversuchen noch nicht gesperrt sein", i+1)
		}
	}

	locked, lockedUntil, err := store.RecordFailure(ctx, email)
	if err != nil {
		t.Fatalf("record failure 3: %v", err)
	}
	if !locked {
		t.Fatal("erwartet gesperrt nach 3 fehlversuchen (schwelle=3)")
	}
	if !lockedUntil.After(time.Now()) {
		t.Fatal("lockedUntil sollte in der zukunft liegen")
	}

	isLocked, _, err := store.IsLocked(ctx, email)
	if err != nil {
		t.Fatalf("is locked: %v", err)
	}
	if !isLocked {
		t.Fatal("IsLocked sollte true liefern")
	}
}

// Akzeptanzkriterium 2 + Pruefung 1: zwei Dienstinstanzen teilen sich
// denselben Zaehler (Mehrinstanz-Test) — hier durch zwei unabhaengige
// pgxpool.Pool-Verbindungen zur selben Datenbank simuliert.
func TestRecordFailure_SharedAcrossInstances(t *testing.T) {
	_, cleanup := setupTest(t)
	defer cleanup()
	ctx := context.Background()
	email := uniqueEmail()

	adminDSN := os.Getenv("TEST_ADMIN_DSN")
	instanceA, err := pgxpool.New(ctx, adminDSN)
	if err != nil {
		t.Fatalf("instance a: %v", err)
	}
	defer instanceA.Close()
	instanceB, err := pgxpool.New(ctx, adminDSN)
	if err != nil {
		t.Fatalf("instance b: %v", err)
	}
	defer instanceB.Close()

	storeA := NewStore(instanceA).WithPolicy(4, time.Hour)
	storeB := NewStore(instanceB).WithPolicy(4, time.Hour)

	// Zwei fehlversuche ueber "instanz A", zwei ueber "instanz B" — beide
	// muessen sich denselben Zaehler teilen und gemeinsam die Schwelle erreichen.
	if _, _, err := storeA.RecordFailure(ctx, email); err != nil {
		t.Fatalf("a1: %v", err)
	}
	if _, _, err := storeB.RecordFailure(ctx, email); err != nil {
		t.Fatalf("b1: %v", err)
	}
	if _, _, err := storeA.RecordFailure(ctx, email); err != nil {
		t.Fatalf("a2: %v", err)
	}
	locked, _, err := storeB.RecordFailure(ctx, email)
	if err != nil {
		t.Fatalf("b2: %v", err)
	}
	if !locked {
		t.Fatal("erwartet gesperrt nach insgesamt 4 fehlversuchen ueber beide instanzen hinweg")
	}
}

// Akzeptanzkriterium 3 + Pruefung 3: automatische Entsperrung nach Ablauf
// der Sperrzeit, Zeitversatz automatisiert getestet.
func TestIsLocked_AutoUnlocksAfterExpiry(t *testing.T) {
	pool, cleanup := setupTest(t)
	defer cleanup()
	ctx := context.Background()
	store := NewStore(pool).WithPolicy(1, 50*time.Millisecond)
	email := uniqueEmail()

	locked, _, err := store.RecordFailure(ctx, email)
	if err != nil {
		t.Fatalf("record failure: %v", err)
	}
	if !locked {
		t.Fatal("erwartet sofort gesperrt bei schwelle=1")
	}

	isLocked, _, err := store.IsLocked(ctx, email)
	if err != nil {
		t.Fatalf("is locked (vor ablauf): %v", err)
	}
	if !isLocked {
		t.Fatal("erwartet gesperrt vor ablauf der sperrzeit")
	}

	time.Sleep(70 * time.Millisecond)

	isLocked, _, err = store.IsLocked(ctx, email)
	if err != nil {
		t.Fatalf("is locked (nach ablauf): %v", err)
	}
	if isLocked {
		t.Fatal("erwartet automatisch entsperrt nach ablauf der sperrzeit")
	}
}

// Akzeptanzkriterium 3: Entsperrung durch Administratoreingriff.
func TestUnlock_ClearsLockImmediately(t *testing.T) {
	pool, cleanup := setupTest(t)
	defer cleanup()
	ctx := context.Background()
	store := NewStore(pool).WithPolicy(1, time.Hour)
	email := uniqueEmail()

	if _, _, err := store.RecordFailure(ctx, email); err != nil {
		t.Fatalf("record failure: %v", err)
	}
	locked, _, _ := store.IsLocked(ctx, email)
	if !locked {
		t.Fatal("erwartet gesperrt vor admin-eingriff")
	}

	if err := store.Unlock(ctx, email); err != nil {
		t.Fatalf("unlock: %v", err)
	}
	locked, _, err := store.IsLocked(ctx, email)
	if err != nil {
		t.Fatalf("is locked nach unlock: %v", err)
	}
	if locked {
		t.Fatal("erwartet sofort entsperrt nach admin-eingriff, unabhaengig von der sperrzeit")
	}
}

// Integrationstest: GuardedLogin komponiert IAM-02 LoginService mit dem
// Lockout-Zustand, ohne LoginService selbst zu veraendern.
func TestGuardedLogin_LocksAfterRepeatedFailures(t *testing.T) {
	pool, cleanup := setupTest(t)
	defer cleanup()
	ctx := context.Background()

	email := uniqueEmail()
	userStore := user.NewTenantUserStore(pool)
	u, err := userStore.Create(ctx, email, "Lockout Test")
	if err != nil {
		t.Fatalf("create user: %v", err)
	}
	hash, err := auth.HashPassword("korrektes-passwort")
	if err != nil {
		t.Fatalf("hash: %v", err)
	}
	if err := userStore.SetPasswordHash(ctx, u.ID, hash); err != nil {
		t.Fatalf("set password: %v", err)
	}

	issuer := auth.NewTokenIssuer("test-secret-nur-fuer-tests")
	loginService := auth.NewLoginService(userStore, issuer, "acme")
	lockoutStore := NewStore(pool).WithPolicy(3, time.Hour)

	for i := 0; i < 3; i++ {
		if _, err := GuardedLogin(ctx, lockoutStore, loginService, email, "falsches-passwort"); !errors.Is(err, auth.ErrInvalidCredentials) {
			t.Fatalf("versuch %d: erwartet ErrInvalidCredentials, habe %v", i, err)
		}
	}

	// Selbst das RICHTIGE Passwort wird jetzt abgewiesen, weil das Konto gesperrt ist.
	if _, err := GuardedLogin(ctx, lockoutStore, loginService, email, "korrektes-passwort"); !errors.Is(err, ErrAccountLocked) {
		t.Fatalf("erwartet ErrAccountLocked trotz korrektem passwort, habe %v", err)
	}
}