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.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
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")
}
}
}
}
}