nexarch/internal/auth/token_test.go

package auth

import (
	"strings"
	"testing"
	"time"

	"github.com/golang-jwt/jwt/v5"
)

func TestTokenIssueAndVerify(t *testing.T) {
	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")

	token, err := issuer.Issue("user-1", "acme")
	if err != nil {
		t.Fatalf("issue: %v", err)
	}

	claims, err := issuer.Verify(token)
	if err != nil {
		t.Fatalf("verify: %v", err)
	}
	if claims.UserID != "user-1" || claims.TenantSlug != "acme" {
		t.Fatalf("claims unerwartet: %+v", claims)
	}
}

// Pruefung 2: Token-Manipulationstest.
func TestTokenVerify_RejectsManipulatedPayload(t *testing.T) {
	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
	token, err := issuer.Issue("user-1", "acme")
	if err != nil {
		t.Fatalf("issue: %v", err)
	}

	parts := strings.Split(token, ".")
	if len(parts) != 3 {
		t.Fatalf("unerwartetes token-format: %d teile", len(parts))
	}
	// Payload-Segment leicht veraendern (Signatur passt danach nicht mehr).
	tampered := parts[0] + "." + parts[1] + "x" + "." + parts[2]

	if _, err := issuer.Verify(tampered); err == nil {
		t.Fatal("erwartet fehler bei manipuliertem token, habe nil")
	}
}

func TestTokenVerify_RejectsWrongSecret(t *testing.T) {
	issuer := NewTokenIssuer("secret-a")
	other := NewTokenIssuer("secret-b")

	token, err := issuer.Issue("user-1", "acme")
	if err != nil {
		t.Fatalf("issue: %v", err)
	}
	if _, err := other.Verify(token); err == nil {
		t.Fatal("erwartet fehler bei falschem secret, habe nil")
	}
}

// Pruefung 3: abgelaufenes Token erzwingt Neuanmeldung.
func TestTokenVerify_RejectsExpiredToken(t *testing.T) {
	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")

	claims := Claims{
		UserID:     "user-1",
		TenantSlug: "acme",
		RegisteredClaims: jwt.RegisteredClaims{
			IssuedAt:  jwt.NewNumericDate(time.Now().Add(-2 * AccessTokenTTL)),
			ExpiresAt: jwt.NewNumericDate(time.Now().Add(-time.Minute)),
		},
	}
	tok := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	expired, err := tok.SignedString([]byte("test-secret-nur-fuer-tests"))
	if err != nil {
		t.Fatalf("signieren: %v", err)
	}

	if _, err := issuer.Verify(expired); err == nil {
		t.Fatal("erwartet fehler bei abgelaufenem token, habe nil")
	}
}

// INT-21 AC1: langlebiges Token fuer native Clients hat eine andere
// Gueltigkeit als das normale Sitzungstoken, bleibt sonst identisch pruefbar.
func TestTokenIssueWithTTL(t *testing.T) {
	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")

	longToken, err := issuer.IssueWithTTL("user-1", "acme", 90*24*time.Hour)
	if err != nil {
		t.Fatalf("issue: %v", err)
	}
	claims, err := issuer.Verify(longToken)
	if err != nil {
		t.Fatalf("verify: %v", err)
	}
	if claims.UserID != "user-1" || claims.TenantSlug != "acme" {
		t.Fatalf("claims unerwartet: %+v", claims)
	}
	remaining := time.Until(claims.ExpiresAt.Time)
	if remaining < 89*24*time.Hour {
		t.Fatalf("erwartete ca. 90 tage restlaufzeit, war %v", remaining)
	}
}

// INT-21 Pruefung 1: abgelaufenes langlebiges Token wird abgewiesen.
func TestTokenIssueWithTTL_RejectsExpired(t *testing.T) {
	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
	token, err := issuer.IssueWithTTL("user-1", "acme", -time.Hour)
	if err != nil {
		t.Fatalf("issue: %v", err)
	}
	if _, err := issuer.Verify(token); err == nil {
		t.Fatal("erwartete fehler fuer abgelaufenes token")
	}
}