Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

46.7 KB
Raw Blame
package api

import (
	"bytes"
	"context"
	"encoding/base64"
	"encoding/csv"
	"encoding/json"
	"fmt"
	"net"
	"net/http"
	"net/http/httptest"
	"net/url"
	"reflect"
	"strings"
	"testing"
	"time"

	"github.com/rcourtman/pulse-go-rewrite/internal/config"
	unifiedresources "github.com/rcourtman/pulse-go-rewrite/internal/unifiedresources"
	"github.com/rcourtman/pulse-go-rewrite/pkg/audit"
	"github.com/stretchr/testify/assert"
)

type verifyResponse struct {
	Available bool   `json:"available"`
	Verified  bool   `json:"verified"`
	Message   string `json:"message"`
}

type testAuditLogger struct {
	events       []audit.Event
	verifyResult bool
	queryErr     error
	updateErr    error
	countErr     error
	lastQuery    audit.QueryFilter
	lastCount    audit.QueryFilter
}

func (l *testAuditLogger) Record(event audit.Event) error {
	l.events = append(l.events, event)
	return nil
}

func (l *testAuditLogger) Query(filter audit.QueryFilter) ([]audit.Event, error) {
	l.lastQuery = filter
	if l.queryErr != nil {
		return nil, l.queryErr
	}
	if filter.ID != "" {
		for _, event := range l.events {
			if event.ID == filter.ID {
				return []audit.Event{event}, nil
			}
		}
		return []audit.Event{}, nil
	}
	return l.events, nil
}

func (l *testAuditLogger) Count(filter audit.QueryFilter) (int, error) {
	l.lastCount = filter
	if l.countErr != nil {
		return 0, l.countErr
	}
	return len(l.events), nil
}

func (l *testAuditLogger) Close() error {
	return nil
}

func (l *testAuditLogger) VerifySignature(event audit.Event) bool {
	return l.verifyResult
}

func (l *testAuditLogger) GetWebhookURLs() []string {
	return []string{}
}

func (l *testAuditLogger) UpdateWebhookURLs(urls []string) error {
	return l.updateErr
}

type testAuditLoggerNoVerify struct {
	events []audit.Event
}

func (l *testAuditLoggerNoVerify) Record(event audit.Event) error {
	l.events = append(l.events, event)
	return nil
}

func (l *testAuditLoggerNoVerify) Query(filter audit.QueryFilter) ([]audit.Event, error) {
	return l.events, nil
}

func (l *testAuditLoggerNoVerify) Count(filter audit.QueryFilter) (int, error) {
	return len(l.events), nil
}

func (l *testAuditLoggerNoVerify) Close() error {
	return nil
}

func (l *testAuditLoggerNoVerify) GetWebhookURLs() []string {
	return []string{}
}

func (l *testAuditLoggerNoVerify) UpdateWebhookURLs(urls []string) error {
	return nil
}

func setAuditLogger(t *testing.T, logger audit.Logger) {
	prev := audit.GetLogger()
	audit.SetLogger(logger)
	t.Cleanup(func() {
		audit.SetLogger(prev)
	})
}
func TestHandleVerifyAuditEvent_InvalidPath(t *testing.T) {
	handler := NewAuditHandlers()

	req := httptest.NewRequest(http.MethodGet, "/api/audit/verify", nil)
	rec := httptest.NewRecorder()

	handler.HandleVerifyAuditEvent(rec, req)

	if rec.Code != http.StatusBadRequest {
		t.Fatalf("expected status %d, got %d", http.StatusBadRequest, rec.Code)
	}
}

func TestHandleVerifyAuditEvent_NotPersistent(t *testing.T) {
	setAuditLogger(t, audit.NewConsoleLogger())
	handler := NewAuditHandlers()

	req := httptest.NewRequest(http.MethodGet, "/api/audit/abc/verify", nil)
	req.SetPathValue("id", "abc")
	rec := httptest.NewRecorder()

	handler.HandleVerifyAuditEvent(rec, req)

	if rec.Code != http.StatusOK {
		t.Fatalf("expected status %d, got %d", http.StatusOK, rec.Code)
	}

	var resp verifyResponse
	if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
		t.Fatalf("failed to unmarshal response: %v", err)
	}
	if resp.Available {
		t.Fatalf("expected available to be false")
	}
	if resp.Message == "" {
		t.Fatalf("expected message to be set")
	}
}

func TestHandleVerifyAuditEvent_NoVerifier(t *testing.T) {
	setAuditLogger(t, &testAuditLoggerNoVerify{})
	handler := NewAuditHandlers()

	req := httptest.NewRequest(http.MethodGet, "/api/audit/abc/verify", nil)
	req.SetPathValue("id", "abc")
	rec := httptest.NewRecorder()

	handler.HandleVerifyAuditEvent(rec, req)

	if rec.Code != http.StatusNotImplemented {
		t.Fatalf("expected status %d, got %d", http.StatusNotImplemented, rec.Code)
	}
}

func TestHandleVerifyAuditEvent_NotFound(t *testing.T) {
	setAuditLogger(t, &testAuditLogger{})
	handler := NewAuditHandlers()

	req := httptest.NewRequest(http.MethodGet, "/api/audit/abc/verify", nil)
	req.SetPathValue("id", "abc")
	rec := httptest.NewRecorder()

	handler.HandleVerifyAuditEvent(rec, req)

	if rec.Code != http.StatusNotFound {
		t.Fatalf("expected status %d, got %d", http.StatusNotFound, rec.Code)
	}
}

func TestHandleVerifyAuditEvent_Verified(t *testing.T) {
	setAuditLogger(t, &testAuditLogger{
		events:       []audit.Event{{ID: "abc"}},
		verifyResult: true,
	})
	handler := NewAuditHandlers()

	req := httptest.NewRequest(http.MethodGet, "/api/audit/abc/verify", nil)
	req.SetPathValue("id", "abc")
	rec := httptest.NewRecorder()

	handler.HandleVerifyAuditEvent(rec, req)

	if rec.Code != http.StatusOK {
		t.Fatalf("expected status %d, got %d", http.StatusOK, rec.Code)
	}

	var resp verifyResponse
	if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
		t.Fatalf("failed to unmarshal response: %v", err)
	}
	if !resp.Available {
		t.Fatalf("expected available to be true")
	}
	if !resp.Verified {
		t.Fatalf("expected verified to be true")
	}
}

func TestHandleVerifyAuditEvent_Failed(t *testing.T) {
	setAuditLogger(t, &testAuditLogger{
		events:       []audit.Event{{ID: "abc"}},
		verifyResult: false,
	})
	handler := NewAuditHandlers()

	req := httptest.NewRequest(http.MethodGet, "/api/audit/abc/verify", nil)
	req.SetPathValue("id", "abc")
	rec := httptest.NewRecorder()

	handler.HandleVerifyAuditEvent(rec, req)

	if rec.Code != http.StatusOK {
		t.Fatalf("expected status %d, got %d", http.StatusOK, rec.Code)
	}

	var resp verifyResponse
	if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
		t.Fatalf("failed to unmarshal response: %v", err)
	}
	if !resp.Available {
		t.Fatalf("expected available to be true")
	}
	if resp.Verified {
		t.Fatalf("expected verified to be false")
	}

	t.Run("Event not found", func(t *testing.T) {
		setAuditLogger(t, &testAuditLogger{
			events: []audit.Event{},
		})
		req := httptest.NewRequest(http.MethodGet, "/api/audit/missing/verify", nil)
		req.SetPathValue("id", "missing")
		rec := httptest.NewRecorder()
		handler.HandleVerifyAuditEvent(rec, req)

		assert.Equal(t, http.StatusNotFound, rec.Code)
		var resp APIError
		if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
			t.Fatalf("failed to unmarshal response: %v", err)
		}
		assert.Equal(t, "Audit event not found", resp.ErrorMessage)
	})

	t.Run("Not persistent logger", func(t *testing.T) {
		setAuditLogger(t, audit.NewConsoleLogger())
		req := httptest.NewRequest(http.MethodGet, "/api/audit/abc/verify", nil)
		req.SetPathValue("id", "abc")
		rec := httptest.NewRecorder()
		handler.HandleVerifyAuditEvent(rec, req)
		assert.Equal(t, http.StatusOK, rec.Code) // Console logger returns 200 with available: false
	})

	t.Run("Missing ID", func(t *testing.T) {
		req := httptest.NewRequest(http.MethodGet, "/api/audit//verify", nil)
		// Don't set path value
		rec := httptest.NewRecorder()
		handler.HandleVerifyAuditEvent(rec, req)
		assert.Equal(t, http.StatusBadRequest, rec.Code)
	})

	t.Run("Query error", func(t *testing.T) {
		setAuditLogger(t, &testAuditLogger{
			queryErr: fmt.Errorf("query error"),
		})
		req := httptest.NewRequest(http.MethodGet, "/api/audit/abc/verify", nil)
		req.SetPathValue("id", "abc")
		rec := httptest.NewRecorder()
		handler.HandleVerifyAuditEvent(rec, req)
		assert.Equal(t, http.StatusInternalServerError, rec.Code)
	})
}

func TestHandleListAuditEvents(t *testing.T) {
	setAuditLogger(t, &testAuditLogger{
		events: []audit.Event{{ID: "1", EventType: "login"}, {ID: "2", EventType: "logout"}},
	})
	handler := NewAuditHandlers()

	// Test success
	req := httptest.NewRequest(http.MethodGet, "/api/audit?event=login", nil)
	rec := httptest.NewRecorder()
	handler.HandleListAuditEvents(rec, req)

	if rec.Code != http.StatusOK {
		t.Fatalf("expected status %d, got %d", http.StatusOK, rec.Code)
	}

	var resp map[string]interface{}
	_ = json.Unmarshal(rec.Body.Bytes(), &resp)
	if resp["total"].(float64) != 2 {
		t.Errorf("expected total 2, got %v", resp["total"])
	}

	// Invalid time filters fail closed instead of silently widening the query.
	req = httptest.NewRequest(http.MethodGet, "/api/audit?startTime=invalid&endTime=invalid", nil)
	rec = httptest.NewRecorder()
	handler.HandleListAuditEvents(rec, req)
	assert.Equal(t, http.StatusBadRequest, rec.Code)

	// Test method not allowed
	req = httptest.NewRequest(http.MethodPost, "/api/audit", nil)
	rec = httptest.NewRecorder()
	handler.HandleListAuditEvents(rec, req)
	if rec.Code != http.StatusMethodNotAllowed {
		t.Errorf("expected status %d, got %d", http.StatusMethodNotAllowed, rec.Code)
	}
}

func TestHandleGetWebhooks(t *testing.T) {
	handler := NewAuditHandlers()

	// Test success
	req := httptest.NewRequest(http.MethodGet, "/api/audit/webhooks", nil)
	rec := httptest.NewRecorder()
	handler.HandleGetWebhooks(rec, req)

	if rec.Code != http.StatusOK {
		t.Fatalf("expected status %d, got %d", http.StatusOK, rec.Code)
	}

	var resp map[string]interface{}
	_ = json.Unmarshal(rec.Body.Bytes(), &resp)
	if _, ok := resp["urls"]; !ok {
		t.Error("expected urls field in response")
	}

	// Test method not allowed
	req = httptest.NewRequest(http.MethodPost, "/api/audit/webhooks", nil)
	rec = httptest.NewRecorder()
	handler.HandleGetWebhooks(rec, req)
	if rec.Code != http.StatusMethodNotAllowed {
		t.Errorf("expected status %d, got %d", http.StatusMethodNotAllowed, rec.Code)
	}
}

func TestHandleUpdateWebhooks(t *testing.T) {
	handler := NewAuditHandlers()
	// Make hostname resolution deterministic in tests.
	prevResolve := resolveWebhookIPs
	resolveWebhookIPs = func(ctx context.Context, host string) ([]net.IPAddr, error) {
		return []net.IPAddr{{IP: net.ParseIP("93.184.216.34")}}, nil // example.com
	}
	t.Cleanup(func() { resolveWebhookIPs = prevResolve })

	// Test success
	body := `{"urls": ["https://example.com/webhook"]}`
	req := httptest.NewRequest(http.MethodPost, "/api/audit/webhooks", strings.NewReader(body))
	rec := httptest.NewRecorder()
	handler.HandleUpdateWebhooks(rec, req)

	if rec.Code != http.StatusNoContent {
		t.Fatalf("expected status %d, got %d: %s", http.StatusNoContent, rec.Code, rec.Body.String())
	}

	// Test invalid URL (loopback)
	body = `{"urls": ["http://127.0.0.1/webhook"]}`
	req = httptest.NewRequest(http.MethodPost, "/api/audit/webhooks", strings.NewReader(body))
	rec = httptest.NewRecorder()
	handler.HandleUpdateWebhooks(rec, req)
	if rec.Code != http.StatusBadRequest {
		t.Errorf("expected status %d for loopback URL, got %d", http.StatusBadRequest, rec.Code)
	}

	// Test invalid JSON
	req = httptest.NewRequest(http.MethodPost, "/api/audit/webhooks", strings.NewReader("invalid"))
	rec = httptest.NewRecorder()
	handler.HandleUpdateWebhooks(rec, req)
	if rec.Code != http.StatusBadRequest {
		t.Errorf("expected status %d, got %d", http.StatusBadRequest, rec.Code)
	}

	// Test method not allowed
	req = httptest.NewRequest(http.MethodGet, "/api/audit/webhooks", nil)
	rec = httptest.NewRecorder()
	handler.HandleUpdateWebhooks(rec, req)
	if rec.Code != http.StatusMethodNotAllowed {
		t.Errorf("expected status %d, got %d", http.StatusMethodNotAllowed, rec.Code)
	}

	// Test update error
	setAuditLogger(t, &testAuditLogger{
		updateErr: fmt.Errorf("update failed"),
	})
	body = `{"urls": ["https://example.com/webhook"]}`
	req = httptest.NewRequest(http.MethodPost, "/api/audit/webhooks", strings.NewReader(body))
	rec = httptest.NewRecorder()
	handler.HandleUpdateWebhooks(rec, req)
	if rec.Code != http.StatusInternalServerError {
		t.Errorf("expected status %d, got %d", http.StatusInternalServerError, rec.Code)
	}
}

func TestHandleUpdateWebhooksRejectsNonArrayAndOversizedSelections(t *testing.T) {
	for _, body := range []string{
		`{"urls":"https://8.8.8.8/audit"}`,
		`{"urls":false}`,
		`{"urls":[{}]}`,
		strings.Repeat(" ", 64*1024) + `{"urls":[]}`,
	} {
		logger := newAuditSelectionLogger()
		logger.urls = []string{"https://8.8.8.8/audit"}
		setAuditLogger(t, logger)
		rec := httptest.NewRecorder()
		NewAuditHandlers().HandleUpdateWebhooks(rec, httptest.NewRequest(http.MethodPut,
			"/api/admin/webhooks/audit", strings.NewReader(body)))
		var payload APIError
		if err := json.Unmarshal(rec.Body.Bytes(), &payload); err != nil {
			t.Fatal(err)
		}
		if rec.Code != http.StatusBadRequest || payload.Code != "invalid_request" || logger.updates != 0 || len(logger.urls) != 1 {
			t.Fatalf("invalid selection changed destination: status/code/updates = %d/%q/%d", rec.Code, payload.Code, logger.updates)
		}
	}
}

func TestHandleUpdateWebhooksRejectsCompetingSelections(t *testing.T) {
	previousResolve := resolveWebhookIPs
	resolveWebhookIPs = func(context.Context, string) ([]net.IPAddr, error) {
		t.Error("competing selections must be rejected before DNS validation")
		return []net.IPAddr{{IP: net.ParseIP("8.8.8.8")}}, nil
	}
	t.Cleanup(func() { resolveWebhookIPs = previousResolve })
	for _, method := range []string{http.MethodPost, http.MethodPut} {
		for name, body := range map[string]string{
			"clear_overrides_selection": `{"urls":["https://receiver.example/new"],"urls":[]}`,
			"selection_overrides_clear": `{"urls":[],"urls":["https://receiver.example/new"]}`,
			"identical":                 `{"urls":[],"urls":[]}`,
			"escaped":                   `{"urls":["https://receiver.example/new"],"\u0075rls":[]}`,
			"upper_case":                `{"urls":["https://receiver.example/new"],"URLS":[]}`,
			"mixed_case":                `{"uRlS":["https://receiver.example/new"],"urls":[]}`,
			"unicode_fold":              `{"urls":["https://receiver.example/new"],"url\u017f":[]}`,
			"null_before_clear":         `{"urls":null,"urls":[]}`,
		} {
			t.Run(method+"/"+name, func(t *testing.T) {
				logger := newAuditSelectionLogger()
				before := []string{"https://8.8.8.8/original", "https://1.1.1.1/second"}
				logger.urls = append([]string{}, before...)
				setAuditLogger(t, logger)
				rec := httptest.NewRecorder()
				NewAuditHandlers().HandleUpdateWebhooks(rec, httptest.NewRequest(method,
					"/api/admin/webhooks/audit", strings.NewReader(body)))
				var payload APIError
				if err := json.Unmarshal(rec.Body.Bytes(), &payload); err != nil {
					t.Fatal(err)
				}
				if rec.Code != http.StatusBadRequest || payload.Code != "invalid_request" || payload.ErrorMessage != "Only one urls array may be supplied" {
					t.Errorf("status/body = %d/%s, want a clear competing-selection error", rec.Code, rec.Body.String())
				}
				if logger.updates != 0 || !reflect.DeepEqual(logger.urls, before) {
					t.Errorf("competing fields changed receivers: updates=%d urls=%v", logger.updates, logger.urls)
				}
			})
		}
	}
}

func TestHandleUpdateWebhooksAcceptsSingleSelectionAliases(t *testing.T) {
	for _, method := range []string{http.MethodPost, http.MethodPut} {
		for _, key := range []string{"urls", "URLS", "uRlS", `\u0075rls`, `url\u017f`} {
			t.Run(method+"/"+key, func(t *testing.T) {
				logger := newAuditSelectionLogger()
				logger.urls = []string{"https://8.8.8.8/original"}
				setAuditLogger(t, logger)
				// Unknown (even repeated) fields remain compatible. Nested urls
				// are metadata, not competing top-level selections.
				body := `{"future":{"urls":["ignored"]},"future":true,"` + key + `":["https://8.8.8.8/restored"]} ` + "\n\t"
				rec := httptest.NewRecorder()
				NewAuditHandlers().HandleUpdateWebhooks(rec, httptest.NewRequest(method,
					"/api/admin/webhooks/audit", strings.NewReader(body)))
				if rec.Code != http.StatusNoContent || logger.updates != 1 || !reflect.DeepEqual(logger.urls, []string{"https://8.8.8.8/restored"}) {
					t.Fatalf("status/updates/urls = %d/%d/%v: %s", rec.Code, logger.updates, logger.urls, rec.Body.String())
				}
			})
		}
	}
}

func TestHandleUpdateWebhooksRequiresCompleteBoundedObject(t *testing.T) {
	for _, method := range []string{http.MethodPost, http.MethodPut} {
		for name, body := range map[string]string{
			"second_object":     `{"urls":[]} {"urls":["https://8.8.8.8/unselected"]}`,
			"trailing_null":     `{"urls":[]} null`,
			"trailing_junk":     `{"urls":[]} broken`,
			"missing_close":     `{"urls":[]`,
			"trailing_comma":    `{"urls":[],}`,
			"non_object":        `[{"urls":[]}]`,
			"nested_only":       `{"future":{"urls":[]}}`,
			"oversized_field":   `{"urls":[],"future":"` + strings.Repeat("x", 64*1024) + `"}`,
			"oversized_suffix":  `{"urls":[]}` + strings.Repeat(" ", 64*1024),
			"malformed_unknown": `{"urls":[],"future":invalid}`,
		} {
			t.Run(method+"/"+name, func(t *testing.T) {
				logger := newAuditSelectionLogger()
				before := []string{"https://8.8.8.8/original"}
				logger.urls = append([]string{}, before...)
				setAuditLogger(t, logger)
				rec := httptest.NewRecorder()
				NewAuditHandlers().HandleUpdateWebhooks(rec, httptest.NewRequest(method,
					"/api/admin/webhooks/audit", strings.NewReader(body)))
				var payload APIError
				if err := json.Unmarshal(rec.Body.Bytes(), &payload); err != nil {
					t.Fatal(err)
				}
				if rec.Code != http.StatusBadRequest || payload.Code != "invalid_request" || logger.updates != 0 || !reflect.DeepEqual(logger.urls, before) {
					t.Fatalf("invalid body changed receivers: status/code/updates/urls = %d/%q/%d/%v", rec.Code, payload.Code, logger.updates, logger.urls)
				}
			})
		}
	}
}

func TestHandleExportAuditEvents_NotPersistent(t *testing.T) {
	setAuditLogger(t, audit.NewConsoleLogger())
	handler := NewAuditHandlers()

	req := httptest.NewRequest(http.MethodGet, "/api/audit/export", nil)
	rec := httptest.NewRecorder()
	handler.HandleExportAuditEvents(rec, req)

	if rec.Code != http.StatusNotImplemented {
		t.Fatalf("expected status %d, got %d", http.StatusNotImplemented, rec.Code)
	}
}

func TestHandleAuditSummary_NotPersistent(t *testing.T) {
	setAuditLogger(t, audit.NewConsoleLogger())
	handler := NewAuditHandlers()

	req := httptest.NewRequest(http.MethodGet, "/api/audit/summary", nil)
	rec := httptest.NewRecorder()
	handler.HandleAuditSummary(rec, req)

	if rec.Code != http.StatusNotImplemented {
		t.Fatalf("expected status %d, got %d", http.StatusNotImplemented, rec.Code)
	}
}

func TestIsPrivateOrReservedIP(t *testing.T) {
	testCases := []struct {
		ip       string
		reserved bool
	}{
		{"192.168.1.1", true},
		{"10.0.0.1", true},
		{"172.16.0.1", true},
		{"127.0.0.1", true},
		{"8.8.8.8", false},
		{"169.254.1.1", true},
		{"224.0.0.1", true},
		{"0.0.0.0", true},
		{"0.255.255.255", true},
		{"::1", true},
		{"fe80::1", true},
		{"ff02::1", true},
	}

	for _, tc := range testCases {
		ip := net.ParseIP(tc.ip)
		if got := isPrivateOrReservedIP(ip); got != tc.reserved {
			t.Errorf("isPrivateOrReservedIP(%s) = %v, want %v", tc.ip, got, tc.reserved)
		}
	}
}

func TestValidateWebhookURL(t *testing.T) {
	origResolver := resolveWebhookIPs
	resolveWebhookIPs = func(_ context.Context, host string) ([]net.IPAddr, error) {
		return []net.IPAddr{{IP: net.ParseIP("93.184.216.34")}}, nil
	}
	t.Cleanup(func() {
		resolveWebhookIPs = origResolver
	})

	testCases := []struct {
		url     string
		wantErr bool
	}{
		{"https://example.com", false},
		{"http://test.com/hook", false},
		{"", true},
		{"   ", true},
		{"://", true},
		{"ftp://example.com", true},
		{"https://", true},
		{"https://localhost", true},
		{"http://127.0.0.1", true},
		{"https://192.168.1.100", true},
		{"https://metadata.google", true},
		{"https://internal.site", true},
		{"http://example.local", true},
		{"https://example.com/path\x7f", true},
	}

	for _, tc := range testCases {
		err := validateWebhookURL(tc.url)
		if (err != nil) != tc.wantErr {
			t.Errorf("validateWebhookURL(%s) error = %v, wantErr %v", tc.url, err, tc.wantErr)
		}
	}
}

func TestValidateWebhookURLBlocksPrivateResolution(t *testing.T) {
	origResolver := resolveWebhookIPs
	resolveWebhookIPs = func(_ context.Context, host string) ([]net.IPAddr, error) {
		return []net.IPAddr{{IP: net.ParseIP("10.0.0.1")}}, nil
	}
	t.Cleanup(func() {
		resolveWebhookIPs = origResolver
	})

	if err := validateWebhookURL("https://example.com"); err == nil {
		t.Fatalf("expected hostname resolving to private IP to be rejected")
	}
}

func TestHandleListAuditEvents_Filters(t *testing.T) {
	setAuditLogger(t, &testAuditLogger{
		events: []audit.Event{{ID: "1", EventType: "login", Success: true}},
	})
	handler := NewAuditHandlers()

	// Test with various filters
	req := httptest.NewRequest(http.MethodGet, "/api/audit?limit=10&offset=0&startTime=2023-01-01T00:00:00Z&endTime=2024-01-01T00:00:00Z&success=true", nil)
	rec := httptest.NewRecorder()
	handler.HandleListAuditEvents(rec, req)

	if rec.Code != http.StatusOK {
		t.Fatalf("expected status %d, got %d", http.StatusOK, rec.Code)
	}
}

func TestHandleListAuditEvents_PaginationDefaults(t *testing.T) {
	logger := &testAuditLogger{
		events: []audit.Event{{ID: "1", EventType: "login", Success: true}},
	}
	setAuditLogger(t, logger)
	handler := NewAuditHandlers()

	req := httptest.NewRequest(http.MethodGet, "/api/audit", nil)
	rec := httptest.NewRecorder()
	handler.HandleListAuditEvents(rec, req)

	if rec.Code != http.StatusOK {
		t.Fatalf("expected status %d, got %d", http.StatusOK, rec.Code)
	}
	if logger.lastQuery.Limit != defaultAuditEventListLimit {
		t.Fatalf("limit = %d, want default %d", logger.lastQuery.Limit, defaultAuditEventListLimit)
	}
	if logger.lastQuery.Offset != 0 {
		t.Fatalf("offset = %d, want 0", logger.lastQuery.Offset)
	}

	for _, query := range []string{"?limit=0", "?offset=-4"} {
		req = httptest.NewRequest(http.MethodGet, "/api/audit"+query, nil)
		rec = httptest.NewRecorder()
		handler.HandleListAuditEvents(rec, req)
		if rec.Code != http.StatusBadRequest {
			t.Fatalf("query %q status = %d, want 400", query, rec.Code)
		}
	}

	req = httptest.NewRequest(http.MethodGet, "/api/audit?limit=5000&offset=10", nil)
	rec = httptest.NewRecorder()
	handler.HandleListAuditEvents(rec, req)

	if rec.Code != http.StatusOK {
		t.Fatalf("expected status %d, got %d", http.StatusOK, rec.Code)
	}
	if logger.lastQuery.Limit != maxAuditEventListLimit {
		t.Fatalf("limit = %d, want max %d", logger.lastQuery.Limit, maxAuditEventListLimit)
	}
	if logger.lastQuery.Offset != 10 {
		t.Fatalf("offset = %d, want 10", logger.lastQuery.Offset)
	}
	if logger.lastCount.Limit != 0 || logger.lastCount.Offset != 0 {
		t.Fatalf("count filter must clear pagination, got limit=%d offset=%d", logger.lastCount.Limit, logger.lastCount.Offset)
	}
}

func TestHandleListAuditEvents_RejectsMalformedFilters(t *testing.T) {
	setAuditLogger(t, &testAuditLogger{})
	handler := NewAuditHandlers()
	tests := []struct {
		query string
		code  string
	}{
		{query: "limit=abc", code: "invalid_limit"},
		{query: "limit=0", code: "invalid_limit"},
		{query: "offset=-1", code: "invalid_offset"},
		{query: "startTime=not-a-time", code: "invalid_start_time"},
		{query: "endTime=not-a-time", code: "invalid_end_time"},
		{
			query: "startTime=2026-07-05T12%3A00%3A00Z&endTime=2026-07-05T11%3A00%3A00Z",
			code:  "invalid_time_range",
		},
		{query: "success=maybe", code: "invalid_success"},
	}
	for _, tt := range tests {
		t.Run(tt.code, func(t *testing.T) {
			req := httptest.NewRequest(http.MethodGet, "/api/audit?"+tt.query, nil)
			rec := httptest.NewRecorder()
			handler.HandleListAuditEvents(rec, req)
			if rec.Code != http.StatusBadRequest {
				t.Fatalf("status = %d, want 400", rec.Code)
			}
			var payload struct {
				Code string `json:"code"`
			}
			if err := json.Unmarshal(rec.Body.Bytes(), &payload); err != nil {
				t.Fatalf("decode error: %v", err)
			}
			if payload.Code != tt.code {
				t.Fatalf("code = %q, want %q", payload.Code, tt.code)
			}
		})
	}
}

func TestHandleListAuditEvents_EmptyEventsIsArray(t *testing.T) {
	setAuditLogger(t, &testAuditLogger{events: nil})
	req := httptest.NewRequest(http.MethodGet, "/api/audit", nil)
	rec := httptest.NewRecorder()
	NewAuditHandlers().HandleListAuditEvents(rec, req)
	if rec.Code != http.StatusOK {
		t.Fatalf("status = %d, want 200", rec.Code)
	}
	var payload struct {
		Events json.RawMessage `json:"events"`
	}
	if err := json.Unmarshal(rec.Body.Bytes(), &payload); err != nil {
		t.Fatalf("decode response: %v", err)
	}
	if string(payload.Events) != "[]" {
		t.Fatalf("events = %s, want []", payload.Events)
	}
}

func TestHandleListAuditEvents_TenantDataIsolation(t *testing.T) {
	previousManager := GetTenantAuditManager()
	manager := audit.NewTenantLoggerManager(t.TempDir(), &audit.SQLiteLoggerFactory{
		RetentionDays:       0,
		RetentionConfigured: true,
	})
	SetTenantAuditManager(manager)
	t.Cleanup(func() {
		manager.Close()
		SetTenantAuditManager(previousManager)
	})

	for orgID, eventID := range map[string]string{"org-a": "event-a", "org-b": "event-b"} {
		if err := manager.Log(orgID, "login", orgID, "127.0.0.1", "/api/auth", true, eventID); err != nil {
			t.Fatalf("log %s event: %v", orgID, err)
		}
	}

	handler := NewAuditHandlers()
	for orgID, wantID := range map[string]string{"org-a": "event-a", "org-b": "event-b"} {
		req := httptest.NewRequest(http.MethodGet, "/api/audit", nil)
		req = req.WithContext(context.WithValue(req.Context(), OrgIDContextKey, orgID))
		rec := httptest.NewRecorder()
		handler.HandleListAuditEvents(rec, req)
		if rec.Code != http.StatusOK {
			t.Fatalf("%s status = %d, want 200", orgID, rec.Code)
		}
		var payload struct {
			Events []audit.Event `json:"events"`
		}
		if err := json.Unmarshal(rec.Body.Bytes(), &payload); err != nil {
			t.Fatalf("decode %s response: %v", orgID, err)
		}
		if len(payload.Events) != 1 || payload.Events[0].Details != wantID {
			t.Fatalf("%s events = %#v, want only %q", orgID, payload.Events, wantID)
		}
	}
}

func TestHandleListAuditEvents_QueryError(t *testing.T) {
	setAuditLogger(t, &testAuditLogger{
		queryErr: fmt.Errorf("db error"),
	})
	handler := NewAuditHandlers()

	req := httptest.NewRequest(http.MethodGet, "/api/audit", nil)
	rec := httptest.NewRecorder()
	handler.HandleListAuditEvents(rec, req)

	if rec.Code != http.StatusInternalServerError {
		t.Fatalf("expected status %d, got %d", http.StatusInternalServerError, rec.Code)
	}

	// Test Count error
	setAuditLogger(t, &testAuditLogger{
		countErr: fmt.Errorf("count error"),
	})
	req = httptest.NewRequest(http.MethodGet, "/api/audit", nil)
	rec = httptest.NewRecorder()
	handler.HandleListAuditEvents(rec, req)
	if rec.Code != http.StatusInternalServerError {
		t.Errorf("expected count error status %d, got %d", http.StatusInternalServerError, rec.Code)
	}
}

func TestHandleListAuditEvents_StoreBusyError(t *testing.T) {
	setAuditLogger(t, &testAuditLogger{
		queryErr: fmt.Errorf("database is locked (5) (SQLITE_BUSY)"),
	})
	handler := NewAuditHandlers()

	req := httptest.NewRequest(http.MethodGet, "/api/audit", nil)
	rec := httptest.NewRecorder()
	handler.HandleListAuditEvents(rec, req)

	if rec.Code != http.StatusServiceUnavailable {
		t.Fatalf("expected status %d, got %d", http.StatusServiceUnavailable, rec.Code)
	}
	if rec.Header().Get("Retry-After") == "" {
		t.Fatal("expected Retry-After header")
	}

	var resp APIError
	if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
		t.Fatalf("failed to unmarshal response: %v", err)
	}
	if resp.Code != "audit_store_busy" {
		t.Fatalf("code = %q, want audit_store_busy", resp.Code)
	}
}

func TestHandleListAuditEvents_StoreUnavailableError(t *testing.T) {
	setAuditLogger(t, &testAuditLogger{
		queryErr: fmt.Errorf("no such table: audit_events"),
	})
	handler := NewAuditHandlers()

	req := httptest.NewRequest(http.MethodGet, "/api/audit", nil)
	rec := httptest.NewRecorder()
	handler.HandleListAuditEvents(rec, req)

	if rec.Code != http.StatusServiceUnavailable {
		t.Fatalf("expected status %d, got %d", http.StatusServiceUnavailable, rec.Code)
	}

	var resp APIError
	if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
		t.Fatalf("failed to unmarshal response: %v", err)
	}
	if resp.Code != "audit_store_unavailable" {
		t.Fatalf("code = %q, want audit_store_unavailable", resp.Code)
	}
}

func TestHandleListAuditEvents_NonPersistentLoggerUnavailable(t *testing.T) {
	asyncLogger := audit.NewAsyncLogger(audit.NewConsoleLogger(), audit.AsyncLoggerConfig{BufferSize: 1})
	t.Cleanup(func() {
		_ = asyncLogger.Close()
	})
	setAuditLogger(t, asyncLogger)
	handler := NewAuditHandlers()

	req := httptest.NewRequest(http.MethodGet, "/api/audit", nil)
	rec := httptest.NewRecorder()
	handler.HandleListAuditEvents(rec, req)

	if rec.Code != http.StatusServiceUnavailable {
		t.Fatalf("expected status %d, got %d", http.StatusServiceUnavailable, rec.Code)
	}

	var resp APIError
	if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
		t.Fatalf("failed to unmarshal response: %v", err)
	}
	if resp.Code != "audit_store_unavailable" {
		t.Fatalf("code = %q, want audit_store_unavailable", resp.Code)
	}
}
func TestHandleExportAuditEvents(t *testing.T) {
	oldLogger := audit.GetLogger()
	defer audit.SetLogger(oldLogger)

	logger := &testAuditLogger{
		events: []audit.Event{
			{ID: "1", EventType: "test", Success: true, Timestamp: time.Now()},
		},
	}
	audit.SetLogger(logger)

	h := NewAuditHandlers()

	t.Run("JSON format", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/api/audit/export?format=json", nil)
		w := httptest.NewRecorder()
		h.HandleExportAuditEvents(w, req)

		assert.Equal(t, http.StatusOK, w.Code)
		assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
		assert.Contains(t, w.Header().Get("Content-Disposition"), "attachment; filename=audit-log-")
		assert.Equal(t, "1", w.Header().Get("X-Event-Count"))
	})

	t.Run("CSV format", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/api/audit/export?format=csv", nil)
		w := httptest.NewRecorder()
		h.HandleExportAuditEvents(w, req)

		assert.Equal(t, http.StatusOK, w.Code)
		assert.Equal(t, "text/csv; charset=utf-8", w.Header().Get("Content-Type"))
		assert.Contains(t, w.Header().Get("Content-Disposition"), "attachment; filename=audit-log-")
	})

	t.Run("With filters", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/api/audit/export?event=test&user=admin&startTime=2026-01-01T00:00:00Z&endTime=2026-12-31T23:59:59Z&success=true&verify=true", nil)
		w := httptest.NewRecorder()
		h.HandleExportAuditEvents(w, req)

		assert.Equal(t, http.StatusOK, w.Code)
		assert.Equal(t, "test", logger.lastQuery.EventType)
		assert.Equal(t, "admin", logger.lastQuery.User)
		assert.NotNil(t, logger.lastQuery.StartTime)
		assert.NotNil(t, logger.lastQuery.EndTime)
		assert.Equal(t, audit.MaxExportEvents+1, logger.lastQuery.Limit)
		assert.Equal(t, 0, logger.lastQuery.Offset)
		assert.NotNil(t, logger.lastQuery.Success)
		if logger.lastQuery.Success != nil {
			assert.True(t, *logger.lastQuery.Success)
		}
	})

	t.Run("Method not allowed", func(t *testing.T) {
		req := httptest.NewRequest("POST", "/api/audit/export", nil)
		w := httptest.NewRecorder()
		h.HandleExportAuditEvents(w, req)
		assert.Equal(t, http.StatusMethodNotAllowed, w.Code)
	})

	t.Run("Export error", func(t *testing.T) {
		setAuditLogger(t, &testAuditLogger{
			queryErr: fmt.Errorf("query error"),
		})
		req := httptest.NewRequest("GET", "/api/audit/export", nil)
		w := httptest.NewRecorder()
		h.HandleExportAuditEvents(w, req)
		assert.Equal(t, http.StatusInternalServerError, w.Code)
	})
}

func TestHandleAuditSummary(t *testing.T) {
	oldLogger := audit.GetLogger()
	defer audit.SetLogger(oldLogger)

	logger := &testAuditLogger{
		events: []audit.Event{
			{ID: "1", EventType: "login", Success: true, Timestamp: time.Now()},
			{ID: "2", EventType: "login", Success: false, Timestamp: time.Now()},
		},
	}
	audit.SetLogger(logger)

	h := NewAuditHandlers()

	t.Run("Success", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/api/audit/summary?verify=true", nil)
		w := httptest.NewRecorder()
		h.HandleAuditSummary(w, req)

		assert.Equal(t, http.StatusOK, w.Code)
		assert.Equal(t, "application/json", w.Header().Get("Content-Type"))

		var summary audit.ExportSummary
		err := json.NewDecoder(w.Body).Decode(&summary)
		assert.NoError(t, err)
		assert.Equal(t, 2, summary.TotalEvents)
		assert.Equal(t, 1, summary.SuccessCount)
		assert.Equal(t, 1, summary.FailureCount)
	})

	t.Run("With filters", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/api/audit/summary?event=login&user=admin&startTime=2026-01-01T00:00:00Z&endTime=2026-12-31T23:59:59Z", nil)
		w := httptest.NewRecorder()
		h.HandleAuditSummary(w, req)

		assert.Equal(t, http.StatusOK, w.Code)
		assert.Equal(t, "login", logger.lastQuery.EventType)
		assert.Equal(t, "admin", logger.lastQuery.User)
		assert.NotNil(t, logger.lastQuery.StartTime)
		assert.NotNil(t, logger.lastQuery.EndTime)
		assert.Equal(t, audit.MaxExportEvents+1, logger.lastQuery.Limit)
		assert.Equal(t, 0, logger.lastQuery.Offset)
	})

	t.Run("Method not allowed", func(t *testing.T) {
		req := httptest.NewRequest("POST", "/api/audit/summary", nil)
		w := httptest.NewRecorder()
		h.HandleAuditSummary(w, req)
		assert.Equal(t, http.StatusMethodNotAllowed, w.Code)
	})

	t.Run("Summary error", func(t *testing.T) {
		setAuditLogger(t, &testAuditLogger{
			queryErr: fmt.Errorf("query error"),
		})
		req := httptest.NewRequest("GET", "/api/audit/summary", nil)
		w := httptest.NewRecorder()
		h.HandleAuditSummary(w, req)
		assert.Equal(t, http.StatusInternalServerError, w.Code)
	})
}

func TestHandleListUnifiedActionAudits(t *testing.T) {
	store := unifiedresources.NewMemoryStore()
	now := time.Date(2026, 3, 18, 12, 0, 0, 0, time.UTC)
	records := []unifiedresources.ActionAuditRecord{
		{
			ID:        "action-1",
			CreatedAt: now.Add(-2 * time.Minute),
			UpdatedAt: now.Add(-2 * time.Minute),
			State:     unifiedresources.ActionStateCompleted,
			Request: unifiedresources.ActionRequest{
				RequestID:      "req-1",
				ResourceID:     "vm:100",
				CapabilityName: "restart",
				RequestedBy:    "agent:ops",
			},
		},
		{
			ID:        "action-2",
			CreatedAt: now.Add(-time.Minute),
			UpdatedAt: now.Add(-time.Minute),
			State:     unifiedresources.ActionStateFailed,
			Request: unifiedresources.ActionRequest{
				RequestID:      "req-2",
				ResourceID:     "vm:101",
				CapabilityName: "restart",
				RequestedBy:    "agent:ops",
			},
		},
	}
	for _, record := range records {
		if err := store.RecordActionAudit(record); err != nil {
			t.Fatalf("RecordActionAudit: %v", err)
		}
	}

	handler := NewAuditHandlers()
	handler.SetResourceStoreProvider(func(string) (unifiedresources.ResourceStore, error) {
		return store, nil
	})

	req := httptest.NewRequest(http.MethodGet, "/api/audit/actions?limit=10", nil)
	rec := httptest.NewRecorder()
	handler.HandleListUnifiedActionAudits(rec, req)

	if rec.Code != http.StatusOK {
		t.Fatalf("expected status %d, got %d", http.StatusOK, rec.Code)
	}

	var payload struct {
		Audits []unifiedresources.ActionAuditRecord `json:"audits"`
		Count  int                                  `json:"count"`
	}
	if err := json.Unmarshal(rec.Body.Bytes(), &payload); err != nil {
		t.Fatalf("unmarshal action audits: %v", err)
	}
	if payload.Count != 2 {
		t.Fatalf("expected count 2, got %d", payload.Count)
	}
	if len(payload.Audits) != 2 {
		t.Fatalf("expected 2 action audits, got %d", len(payload.Audits))
	}
	if payload.Audits[0].ID != "action-2" || payload.Audits[1].ID != "action-1" {
		t.Fatalf("unexpected action audit order: %#v", payload.Audits)
	}
}

func TestHandleListUnifiedActionLifecycleEvents(t *testing.T) {
	store := unifiedresources.NewMemoryStore()
	now := time.Date(2026, 3, 18, 12, 0, 0, 0, time.UTC)
	events := []unifiedresources.ActionLifecycleEvent{
		{ActionID: "action-1", Timestamp: now.Add(-2 * time.Minute), State: unifiedresources.ActionStatePlanned},
		{ActionID: "action-1", Timestamp: now.Add(-time.Minute), State: unifiedresources.ActionStateCompleted},
	}
	for _, event := range events {
		if err := store.RecordActionLifecycleEvent(event); err != nil {
			t.Fatalf("RecordActionLifecycleEvent: %v", err)
		}
	}

	handler := NewAuditHandlers()
	handler.SetResourceStoreProvider(func(string) (unifiedresources.ResourceStore, error) {
		return store, nil
	})

	req := httptest.NewRequest(http.MethodGet, "/api/audit/actions/action-1/events?limit=10", nil)
	req.SetPathValue("id", "action-1")
	rec := httptest.NewRecorder()
	handler.HandleListUnifiedActionLifecycleEvents(rec, req)

	if rec.Code != http.StatusOK {
		t.Fatalf("expected status %d, got %d", http.StatusOK, rec.Code)
	}

	var payload struct {
		ActionID string                                  `json:"actionId"`
		Events   []unifiedresources.ActionLifecycleEvent `json:"events"`
		Count    int                                     `json:"count"`
	}
	if err := json.Unmarshal(rec.Body.Bytes(), &payload); err != nil {
		t.Fatalf("unmarshal action lifecycle events: %v", err)
	}
	if payload.ActionID != "action-1" {
		t.Fatalf("expected action-1, got %q", payload.ActionID)
	}
	if payload.Count != 2 || len(payload.Events) != 2 {
		t.Fatalf("unexpected lifecycle event payload: %#v", payload)
	}
	if payload.Events[0].State != unifiedresources.ActionStateCompleted || payload.Events[1].State != unifiedresources.ActionStatePlanned {
		t.Fatalf("unexpected lifecycle order: %#v", payload.Events)
	}
}

func TestHandleListUnifiedExportAudits(t *testing.T) {
	store := unifiedresources.NewMemoryStore()
	now := time.Date(2026, 3, 18, 12, 0, 0, 0, time.UTC)
	if err := store.RecordExportAudit(unifiedresources.ExportAuditRecord{
		ID:           "export-1",
		Timestamp:    now.Add(-time.Minute),
		Actor:        "agent:ops",
		EnvelopeHash: "hash-1",
		Decision:     unifiedresources.ExportAllowed,
		Destination:  "gpt-4o",
		Redactions:   []string{"metadata.hostname"},
	}); err != nil {
		t.Fatalf("RecordExportAudit: %v", err)
	}

	handler := NewAuditHandlers()
	handler.SetResourceStoreProvider(func(string) (unifiedresources.ResourceStore, error) {
		return store, nil
	})

	req := httptest.NewRequest(http.MethodGet, "/api/audit/exports?limit=10", nil)
	rec := httptest.NewRecorder()
	handler.HandleListUnifiedExportAudits(rec, req)

	if rec.Code != http.StatusOK {
		t.Fatalf("expected status %d, got %d", http.StatusOK, rec.Code)
	}

	var payload struct {
		Audits []unifiedresources.ExportAuditRecord `json:"audits"`
		Count  int                                  `json:"count"`
	}
	if err := json.Unmarshal(rec.Body.Bytes(), &payload); err != nil {
		t.Fatalf("unmarshal export audits: %v", err)
	}
	if payload.Count != 1 || len(payload.Audits) != 1 {
		t.Fatalf("unexpected export payload: %#v", payload)
	}
	if payload.Audits[0].ID != "export-1" {
		t.Fatalf("unexpected export audit id: %q", payload.Audits[0].ID)
	}
}

func TestParseAuditLimitCapsOversizedRequests(t *testing.T) {
	cases := []struct {
		name         string
		raw          string
		defaultLimit int
		want         int
	}{
		{
			name:         "uses default when blank",
			raw:          "",
			defaultLimit: 100,
			want:         100,
		},
		{
			name:         "caps oversized requests",
			raw:          "5000",
			defaultLimit: 100,
			want:         1000,
		},
		{
			name:         "preserves valid request below cap",
			raw:          "250",
			defaultLimit: 100,
			want:         250,
		},
		{
			name:         "rejects non-positive input",
			raw:          "0",
			defaultLimit: 100,
			want:         100,
		},
	}

	for _, tt := range cases {
		t.Run(tt.name, func(t *testing.T) {
			if got := parseAuditLimit(tt.raw, tt.defaultLimit); got != tt.want {
				t.Fatalf("parseAuditLimit(%q, %d) = %d, want %d", tt.raw, tt.defaultLimit, got, tt.want)
			}
		})
	}
}

// A signed SAML LogoutResponse answering one user's logout, replayed into
// another user's browser through a cross-site GET to /slo, is refused like the
// other SLO refusals: the victim keeps their session and one failed
// saml_slo_callback audit event names the binding failure. The genuine
// completion of a logout still audits success.
func TestSAMLSLOAuditsLogoutResponseNotBoundToSession(t *testing.T) {
	previousManager := GetTenantAuditManager()
	SetTenantAuditManager(nil)
	t.Cleanup(func() {
		SetTenantAuditManager(previousManager)
	})
	logger := &testAuditLoggerNoVerify{}
	setAuditLogger(t, logger)

	router, idp := newSAMLSLOTestRouter(t)
	attackerRequestID := startSAMLTestLogout(t, router, newSAMLTestSession(t, "attacker"))
	victim := newSAMLTestSession(t, "victim")

	sloCallbackEvents := func() []audit.Event {
		var events []audit.Event
		for _, event := range logger.events {
			if event.EventType == "saml_slo_callback" {
				events = append(events, event)
			}
		}
		return events
	}

	rec := deliverSAMLTestLogoutResponse(router, idp.redirectQuery(t, attackerRequestID), victim)
	assertSAMLSLORefused(t, rec, "another session's response")
	if !ValidateSession(victim) {
		t.Fatal("another user's LogoutResponse cleared the victim's session")
	}
	refusals := sloCallbackEvents()
	if len(refusals) != 1 || refusals[0].Success ||
		refusals[0].Details != "LogoutResponse does not answer an outstanding logout request for this session" {
		t.Fatalf("expected one failed saml_slo_callback binding refusal, got %+v", refusals)
	}

	logger.events = nil
	victimRequestID := startSAMLTestLogout(t, router, victim)
	if rec := deliverSAMLTestLogoutResponse(router, idp.redirectQuery(t, victimRequestID), ""); rec.Code != http.StatusFound {
		t.Fatalf("genuine completion: expected status %d, got %d body=%q", http.StatusFound, rec.Code, rec.Body.String())
	}
	completions := sloCallbackEvents()
	if len(completions) != 1 || !completions[0].Success || completions[0].Details != "SAML SLO complete" {
		t.Fatalf("expected one successful saml_slo_callback event, got %+v", completions)
	}
}

// At the ACS, a correctly signed Response answering another browser's login is
// refused, creates no session and is audited as a binding refusal, while the
// browser that started that login completes it and is audited as a success.
func TestSAMLACSAuditsResponseNotAnsweringThisBrowsersLogin(t *testing.T) {
	previousManager := GetTenantAuditManager()
	SetTenantAuditManager(nil)
	t.Cleanup(func() {
		SetTenantAuditManager(previousManager)
	})
	logger := &testAuditLoggerNoVerify{}
	setAuditLogger(t, logger)

	idp := newSAMLManualCertTestIdP(t)
	router, service := newSAMLACSTestRouter(t, idp, false)
	attackerRequestID, attackerToken := startSAMLTestLogin(t, router, "", "/")
	_, victimToken := startSAMLTestLogin(t, router, "", "/")
	form := url.Values{"SAMLResponse": {base64.StdEncoding.EncodeToString(idp.responseXML(t, service, attackerRequestID))}}

	loginEvents := func() []audit.Event {
		var events []audit.Event
		for _, event := range logger.events {
			if event.EventType == "saml_login" {
				events = append(events, event)
			}
		}
		return events
	}

	assertSAMLLoginRefused(t, deliverSAMLTestResponse(t, router, form, victimToken), "another browser's Response")
	refusals := loginEvents()
	if len(refusals) != 1 || refusals[0].Success ||
		refusals[0].Details != "SAML response does not answer a login started in this browser" {
		t.Fatalf("expected one failed saml_login binding refusal, got %+v", refusals)
	}

	logger.events = nil
	assertSAMLLoginSucceeded(t, deliverSAMLTestResponse(t, router, form, attackerToken), "/?saml=success", "the Response's own browser")
	completions := loginEvents()
	if len(completions) != 1 || !completions[0].Success || completions[0].Details != "SAML login success via okta" {
		t.Fatalf("expected one successful saml_login event, got %+v", completions)
	}
}

// Real exporter, HMAC verification and authenticated router, without a database.
type csvAuditLogger struct {
	*auditSelectionLogger
	signer   *audit.Signer
	verified []audit.Event
}

func (l *csvAuditLogger) VerifySignature(event audit.Event) bool {
	l.verified = append(l.verified, event)
	return l.signer.Verify(event)
}
func newCSVAuditFixture(t *testing.T) *csvAuditLogger {
	t.Helper()
	signer, err := audit.NewSignerWithKey(bytes.Repeat([]byte{0x43}, 32))
	if err != nil {
		t.Fatal(err)
	}
	original := audit.Event{ID: "valid", Timestamp: time.Date(2026, 10, 27, 12, 0, 0, 0, time.UTC), EventType: "login",
		User: "=operator", IP: "192.0.2.1", Path: "+path", Details: "=1+1, \"quote\"\nline two", Success: true}
	original.Signature = signer.Sign(original)
	tampered := original
	tampered.ID = "tampered"
	tampered.Signature = signer.Sign(tampered)
	tampered.Details += " altered"
	malformed := original
	malformed.ID = "malformed"
	malformed.Signature = "@invalid"
	unsigned := original
	unsigned.ID = "unsigned"
	unsigned.Signature = ""
	unsigned.Success = false
	other := original
	other.ID = "unselected"
	other.User = "other-operator"
	logger := newAuditSelectionLogger()
	logger.events = []audit.Event{original, tampered, malformed, unsigned, other}
	return &csvAuditLogger{auditSelectionLogger: logger, signer: signer}
}

func TestHandleExportAuditCSVUsesLiteralProjection(t *testing.T) {
	t.Setenv("PULSE_DEV", "true")
	logger := newCSVAuditFixture(t)
	setAuditLogger(t, logger)
	token := "synthetic-csv-audit-token-123.12345678"
	record := newTokenRecord(t, token, []string{config.ScopeAuditRead}, nil)
	router := NewRouter(newTestConfigWithTokens(t, record), nil, nil, nil, nil, "1.0.0")
	original := append([]audit.Event(nil), logger.events...)
	for _, verify := range []bool{false, true} {
		for repeat := 0; repeat < 2; repeat++ {
			logger.verified = nil
			path := "/api/audit/export?event=login&user=%3Doperator&format=csv&verify=" + fmt.Sprint(verify) + "&limit=1&offset=999"
			req := httptest.NewRequest(http.MethodGet, path, nil)
			req.Header.Set("X-API-Token", token)
			rec := httptest.NewRecorder()
			router.Handler().ServeHTTP(rec, req)
			if rec.Code != 200 || rec.Header().Get("Content-Type") != "text/csv; charset=utf-8" || rec.Header().Get("X-Event-Count") != "4" || !strings.HasPrefix(rec.Header().Get("Content-Disposition"), "attachment; filename=audit-log-") {
				t.Fatalf("CSV status/metadata = %d/%v", rec.Code, rec.Header())
			}
			rows, err := csv.NewReader(rec.Body).ReadAll()
			if err != nil || len(rows) != 5 {
				t.Fatalf("invalid selected CSV: %v / %q", err, rows)
			}
			for i, row := range rows[1:] {
				if row[0] != original[i].ID || row[3] != "'=operator" || row[5] != "'+path" || row[7] != "'"+original[i].Details {
					t.Fatalf("row %d lost literal fields: %q", i, row)
				}
				if verify && row[9] != []string{"true", "false", "false", ""}[i] {
					t.Fatal("CSV changed original verdict")
				}
			}
			if verify && !reflect.DeepEqual(logger.verified, original[:3]) || !verify && len(logger.verified) != 0 {
				t.Fatal("verification did not receive original selected signatures")
			}
			if logger.lastQuery.User != "=operator" || logger.lastQuery.Limit != audit.MaxExportEvents+1 || logger.lastQuery.Offset != 0 || !reflect.DeepEqual(logger.events, original) {
				t.Fatal("projection changed selection/limits/source")
			}
			req = httptest.NewRequest(http.MethodGet, strings.Replace(path, "format=csv", "format=json", 1), nil)
			req.Header.Set("X-API-Token", token)
			rec = httptest.NewRecorder()
			router.Handler().ServeHTTP(rec, req)
			var body struct {
				Events []audit.ExportEvent `json:"events"`
			}
			if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
				t.Fatal(err)
			}
			if rec.Code != 200 || len(body.Events) != 4 {
				t.Fatal("JSON lost original selection")
			}
			for i, event := range body.Events {
				if event.ID != original[i].ID || event.User != original[i].User || event.Details != original[i].Details || event.Path != original[i].Path || event.Signature != original[i].Signature {
					t.Fatal("JSON changed signed evidence")
				}
			}
		}
	}
}