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.

Reject malformed audit export and summary time filters

pulse-triage[bot]582113ccd04b
diff --git a/docs/AUDIT_LOGGING.md b/docs/AUDIT_LOGGING.md
index ecd4087c15..932122e630 100644
--- a/docs/AUDIT_LOGGING.md
+++ b/docs/AUDIT_LOGGING.md
@@ -142,9 +142,15 @@ The new owner-only response file is created in the helper's private directory.
It does not reuse filters selected in the UI. Export accepts `event`, `user`,
`success`, `startTime` and `endTime`, but **not list pagination**: adding `limit`
or `offset` does not bound an export. With no filters it requests the full
-available history. Unlike the list, export ignores malformed time filters;
-check the dates and returned event times locally rather than assuming HTTP 200
-proves that the intended window was applied.
+available history. List, export and summary reject malformed or empty supplied
+`startTime`/`endTime` values and ranges whose end is not after their start with
+HTTP 400, before reading events. List and export also reject a supplied `success`
+other than exactly `true` or `false`, including an empty value. Omit a filter to
+leave it unset; HTTP 200 alone does not establish complete archival coverage.
+
+Summary accepts `event`, `user`, `startTime` and `endTime`, not `success` or list
+pagination. These unsupported parameters do not narrow a summary; omit them
+rather than relying on them to bound the read.
Keep the export outside shared repositories and issue attachments. A failed or
incomplete download is not a valid archive. Do not widen or repeat a failed
diff --git a/docs/release-control/v6/internal/subsystems/agent-lifecycle.md b/docs/release-control/v6/internal/subsystems/agent-lifecycle.md
index 64328bd8fe..d646f53507 100644
--- a/docs/release-control/v6/internal/subsystems/agent-lifecycle.md
+++ b/docs/release-control/v6/internal/subsystems/agent-lifecycle.md
@@ -3354,6 +3354,16 @@ token rotation, or removal state, and it records nothing about agents. Node
connection tests target Proxmox, PBS, and PMG endpoints directly and never
traverse an agent.
+### Audit reads during agent investigation
+
+The shared `internal/api/` audit read boundary rejects malformed or empty
+supplied RFC3339 start/end filters and non-increasing windows before reading
+agent-related events. List/export reject non-literal success booleans. It
+preserves absent filters, tenant selection, method/access/licence gates and
+existing export/summary non-pagination semantics. This changes only audit
+request validation, not agent identity, enrolment, collection or recovery.
+Fake-logger handler controls live in `internal/api/audit_filter_validation_test.go`.
+
## Forbidden Paths
1. New install or update continuity behavior hidden only inside broad monitoring ownership.
diff --git a/docs/release-control/v6/internal/subsystems/api-contracts.md b/docs/release-control/v6/internal/subsystems/api-contracts.md
index edece2e7b7..c7f1f85e10 100644
--- a/docs/release-control/v6/internal/subsystems/api-contracts.md
+++ b/docs/release-control/v6/internal/subsystems/api-contracts.md
@@ -3952,6 +3952,20 @@ deliberately not instrumented, because instrumenting both endpoints would
double-count a single operator action and corrupt the failure share the
counters exist to measure.
+### Audit investigation filter rejection
+
+The existing GET `/api/audit`, `/api/audit/export` and `/api/audit/summary`
+validate every supplied `startTime` and `endTime` as RFC3339 and reject empty,
+malformed, equal or reversed bounds with HTTP 400 before querying events.
+List and export likewise reject supplied `success` values other than literal
+`true` or `false`. Absence remains unfiltered; event/user filters, tenant,
+licence, role and method boundaries, formats and signature verification remain.
+Export/summary do not inherit list pagination, and summary has no success
+filter. No export quota or new endpoint is introduced. Actual handlers and
+exporter are pinned by `internal/api/audit_filter_validation_test.go` with
+fake persistent loggers, including query non-execution and tenant isolation;
+`internal/api/audit_handlers_test.go` pins valid export/summary filter payloads.
+
## Forbidden Paths
1. Handler-local payload shape drift without a contract test
diff --git a/docs/release-control/v6/internal/subsystems/storage-recovery.md b/docs/release-control/v6/internal/subsystems/storage-recovery.md
index 3d0df492d1..bce7932ebe 100644
--- a/docs/release-control/v6/internal/subsystems/storage-recovery.md
+++ b/docs/release-control/v6/internal/subsystems/storage-recovery.md
@@ -2580,6 +2580,17 @@ is outside backup, restore, and recovery, and a missing or corrupt tally must be
discarded and rebuilt rather than surfaced as a recovery failure. Nothing may
take a correctness dependency on its contents.
+### Bounded audit investigation scope
+
+Audit list/export/summary consumers must not mistake a malformed time bound
+for an unfiltered storage read. `internal/api/activity_audit_handlers.go`
+rejects supplied empty/invalid RFC3339 bounds and equal/reversed windows with
+HTTP 400 before querying; list/export also validate literal success booleans.
+Absent filters and existing export/summary non-pagination remain supported.
+This boundary adds no database/schema, retention, signing, quota or recovery
+change. Fake persistent-logger controls in
+`internal/api/audit_filter_validation_test.go` prove rejection without a store.
+
## Forbidden Paths
1. Reintroducing storage or recovery product logic as ad hoc dashboard-only summaries without a canonical page-surface owner
diff --git a/frontend-modern/public/docs/AUDIT_LOGGING.md b/frontend-modern/public/docs/AUDIT_LOGGING.md
index ecd4087c15..932122e630 100644
--- a/frontend-modern/public/docs/AUDIT_LOGGING.md
+++ b/frontend-modern/public/docs/AUDIT_LOGGING.md
@@ -142,9 +142,15 @@ The new owner-only response file is created in the helper's private directory.
It does not reuse filters selected in the UI. Export accepts `event`, `user`,
`success`, `startTime` and `endTime`, but **not list pagination**: adding `limit`
or `offset` does not bound an export. With no filters it requests the full
-available history. Unlike the list, export ignores malformed time filters;
-check the dates and returned event times locally rather than assuming HTTP 200
-proves that the intended window was applied.
+available history. List, export and summary reject malformed or empty supplied
+`startTime`/`endTime` values and ranges whose end is not after their start with
+HTTP 400, before reading events. List and export also reject a supplied `success`
+other than exactly `true` or `false`, including an empty value. Omit a filter to
+leave it unset; HTTP 200 alone does not establish complete archival coverage.
+
+Summary accepts `event`, `user`, `startTime` and `endTime`, not `success` or list
+pagination. These unsupported parameters do not narrow a summary; omit them
+rather than relying on them to bound the read.
Keep the export outside shared repositories and issue attachments. A failed or
incomplete download is not a valid archive. Do not widen or repeat a failed
diff --git a/internal/api/activity_audit_handlers.go b/internal/api/activity_audit_handlers.go
index eb100f7b61..fc914454b1 100644
--- a/internal/api/activity_audit_handlers.go
+++ b/internal/api/activity_audit_handlers.go
@@ -126,10 +126,23 @@ func auditEventListFilterFromRequest(r *http.Request) (audit.QueryFilter, *audit
}
filter.Offset = offset
}
+ if err := auditTimeFilterFromQuery(query, &filter); err != nil {
+ return audit.QueryFilter{}, err
+ }
+ if err := auditSuccessFilterFromQuery(query, &filter); err != nil {
+ return audit.QueryFilter{}, err
+ }
+
+ return filter, nil
+}
+
+// A supplied malformed or empty bound must not become an unfiltered read.
+// Keep list, export and summary on the same time-window validation boundary.
+func auditTimeFilterFromQuery(query url.Values, filter *audit.QueryFilter) *auditQueryValidationError {
if query.Has("startTime") {
start, err := time.Parse(time.RFC3339, query.Get("startTime"))
if err != nil {
- return audit.QueryFilter{}, &auditQueryValidationError{
+ return &auditQueryValidationError{
code: "invalid_start_time",
message: "Invalid startTime; expected an RFC3339 timestamp",
}
@@ -139,7 +152,7 @@ func auditEventListFilterFromRequest(r *http.Request) (audit.QueryFilter, *audit
if query.Has("endTime") {
end, err := time.Parse(time.RFC3339, query.Get("endTime"))
if err != nil {
- return audit.QueryFilter{}, &auditQueryValidationError{
+ return &auditQueryValidationError{
code: "invalid_end_time",
message: "Invalid endTime; expected an RFC3339 timestamp",
}
@@ -147,15 +160,19 @@ func auditEventListFilterFromRequest(r *http.Request) (audit.QueryFilter, *audit
filter.EndTime = &end
}
if filter.StartTime != nil && filter.EndTime != nil && !filter.StartTime.Before(*filter.EndTime) {
- return audit.QueryFilter{}, &auditQueryValidationError{
+ return &auditQueryValidationError{
code: "invalid_time_range",
message: "startTime must be before endTime",
}
}
+ return nil
+}
+
+func auditSuccessFilterFromQuery(query url.Values, filter *audit.QueryFilter) *auditQueryValidationError {
if query.Has("success") {
rawSuccess := query.Get("success")
if rawSuccess != "true" && rawSuccess != "false" {
- return audit.QueryFilter{}, &auditQueryValidationError{
+ return &auditQueryValidationError{
code: "invalid_success",
message: "Invalid success; expected a boolean",
}
@@ -163,8 +180,7 @@ func auditEventListFilterFromRequest(r *http.Request) (audit.QueryFilter, *audit
success := rawSuccess == "true"
filter.Success = &success
}
-
- return filter, nil
+ return nil
}
// HandleVerifyAuditEvent handles GET /api/audit/{id}/verify
@@ -441,24 +457,13 @@ func (h *AuditHandlers) HandleExportAuditEvents(w http.ResponseWriter, r *http.R
User: query.Get("user"),
}
- // Parse startTime
- if startStr := query.Get("startTime"); startStr != "" {
- if t, err := time.Parse(time.RFC3339, startStr); err == nil {
- filter.StartTime = &t
- }
- }
-
- // Parse endTime
- if endStr := query.Get("endTime"); endStr != "" {
- if t, err := time.Parse(time.RFC3339, endStr); err == nil {
- filter.EndTime = &t
- }
+ if validationErr := auditTimeFilterFromQuery(query, &filter); validationErr != nil {
+ writeErrorResponse(w, http.StatusBadRequest, validationErr.code, validationErr.message, nil)
+ return
}
-
- // Parse success
- if successStr := query.Get("success"); successStr != "" {
- success := successStr == "true"
- filter.Success = &success
+ if validationErr := auditSuccessFilterFromQuery(query, &filter); validationErr != nil {
+ writeErrorResponse(w, http.StatusBadRequest, validationErr.code, validationErr.message, nil)
+ return
}
// Parse verification flag
@@ -512,18 +517,9 @@ func (h *AuditHandlers) HandleAuditSummary(w http.ResponseWriter, r *http.Reques
User: query.Get("user"),
}
- // Parse startTime
- if startStr := query.Get("startTime"); startStr != "" {
- if t, err := time.Parse(time.RFC3339, startStr); err == nil {
- filter.StartTime = &t
- }
- }
-
- // Parse endTime
- if endStr := query.Get("endTime"); endStr != "" {
- if t, err := time.Parse(time.RFC3339, endStr); err == nil {
- filter.EndTime = &t
- }
+ if validationErr := auditTimeFilterFromQuery(query, &filter); validationErr != nil {
+ writeErrorResponse(w, http.StatusBadRequest, validationErr.code, validationErr.message, nil)
+ return
}
// Parse verification flag
diff --git a/internal/api/audit_filter_validation_test.go b/internal/api/audit_filter_validation_test.go
new file mode 100644
index 0000000000..5a4202a0f9
--- /dev/null
+++ b/internal/api/audit_filter_validation_test.go
@@ -0,0 +1,261 @@
+package api
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "net/http/httptest"
+ "net/url"
+ "path/filepath"
+ "strings"
+ "testing"
+ "time"
+
+ "github.com/rcourtman/pulse-go-rewrite/pkg/audit"
+)
+
+// Actual handlers/exporter, but no database, IdP, provider or production events.
+type auditScopeLogger struct {
+ testAuditLogger
+ queries, counts, verifications int
+}
+
+func (l *auditScopeLogger) Query(f audit.QueryFilter) ([]audit.Event, error) {
+ l.queries++
+ return l.testAuditLogger.Query(f)
+}
+func (l *auditScopeLogger) Count(f audit.QueryFilter) (int, error) {
+ l.counts++
+ return l.testAuditLogger.Count(f)
+}
+func (l *auditScopeLogger) VerifySignature(e audit.Event) bool {
+ l.verifications++
+ return l.testAuditLogger.VerifySignature(e)
+}
+
+func auditScopeEndpoints() []struct {
+ name string
+ handle http.HandlerFunc
+} {
+ h := NewAuditHandlers()
+ return []struct {
+ name string
+ handle http.HandlerFunc
+ }{
+ {"list", h.HandleListAuditEvents},
+ {"export", h.HandleExportAuditEvents},
+ {"summary", h.HandleAuditSummary},
+ }
+}
+
+func TestAuditScopeRejectsMalformedTimes(t *testing.T) {
+ cases := []struct{ name, query, code string }{
+ {"invalid_start", "startTime=not-a-time", "invalid_start_time"},
+ {"empty_start", "startTime=", "invalid_start_time"},
+ {"invalid_end", "endTime=not-a-time", "invalid_end_time"},
+ {"empty_end", "endTime=", "invalid_end_time"},
+ {"missing_timezone", "startTime=2026-01-01T00:00:00", "invalid_start_time"},
+ {"invalid_calendar", "endTime=2026-02-30T00:00:00Z", "invalid_end_time"},
+ {"equal_bounds", "startTime=2026-01-01T00:00:00Z&endTime=2026-01-01T00:00:00Z", "invalid_time_range"},
+ {"reversed_bounds", "startTime=2026-01-02T00:00:00Z&endTime=2026-01-01T00:00:00Z", "invalid_time_range"},
+ {"equal_instants", "startTime=2026-01-01T01:00:00%2B01:00&endTime=2026-01-01T00:00:00Z", "invalid_time_range"},
+ }
+ for _, endpoint := range auditScopeEndpoints() {
+ for _, tc := range cases {
+ t.Run(endpoint.name+"/"+tc.name, func(t *testing.T) {
+ logger := &auditScopeLogger{testAuditLogger: testAuditLogger{events: []audit.Event{{ID: "private-synthetic-event", Signature: "signature"}}}}
+ setAuditLogger(t, logger)
+ rec := httptest.NewRecorder()
+ endpoint.handle(rec, httptest.NewRequest(http.MethodGet, "/api/audit?"+tc.query+"&verify=true", nil))
+ var payload APIError
+ if err := json.Unmarshal(rec.Body.Bytes(), &payload); err != nil {
+ t.Fatal(err)
+ }
+ if rec.Code != http.StatusBadRequest || payload.Code != tc.code {
+ t.Errorf("status/code = %d/%q, want 400/%q", rec.Code, payload.Code, tc.code)
+ }
+ if logger.queries != 0 || logger.counts != 0 || logger.verifications != 0 {
+ t.Errorf("rejected scope read events: query/count/verify = %d/%d/%d", logger.queries, logger.counts, logger.verifications)
+ }
+ if strings.Contains(rec.Body.String(), "private-synthetic-event") || rec.Header().Get("Content-Disposition") != "" || rec.Header().Get("X-Event-Count") != "" {
+ t.Error("invalid scope produced export/event content")
+ }
+ })
+ }
+ }
+}
+
+func TestAuditScopeRejectsMalformedSuccess(t *testing.T) {
+ for _, endpoint := range auditScopeEndpoints()[:2] { // Summary has no success filter.
+ for _, value := range []string{"", "maybe", "TRUE", "0"} {
+ name := value
+ if name == "" {
+ name = "empty"
+ }
+ t.Run(endpoint.name+"/"+name, func(t *testing.T) {
+ logger := &auditScopeLogger{}
+ setAuditLogger(t, logger)
+ rec := httptest.NewRecorder()
+ endpoint.handle(rec, httptest.NewRequest(http.MethodGet, "/api/audit?success="+value, nil))
+ var payload APIError
+ if err := json.Unmarshal(rec.Body.Bytes(), &payload); err != nil {
+ t.Fatal(err)
+ }
+ if rec.Code != http.StatusBadRequest || payload.Code != "invalid_success" || logger.queries != 0 || logger.counts != 0 {
+ t.Fatalf("status/code/query/count = %d/%q/%d/%d", rec.Code, payload.Code, logger.queries, logger.counts)
+ }
+ })
+ }
+ }
+}
+
+func TestAuditScopePreservesFilters(t *testing.T) {
+ start := time.Date(2026, 1, 1, 0, 0, 0, 125000000, time.UTC)
+ end := start.Add(time.Hour)
+ for _, endpoint := range auditScopeEndpoints() {
+ for _, bounds := range []string{"none", "start_only", "end_only", "both"} {
+ t.Run(endpoint.name+"/"+bounds, func(t *testing.T) {
+ logger := &auditScopeLogger{testAuditLogger: testAuditLogger{events: []audit.Event{{ID: "event", Signature: "signed", Timestamp: start}}, verifyResult: true}}
+ setAuditLogger(t, logger)
+ q := url.Values{}
+ if bounds != "none" {
+ q.Set("event", "login")
+ q.Set("user", "[email protected]")
+ if bounds != "end_only" {
+ q.Set("startTime", start.In(time.FixedZone("test", 3600)).Format(time.RFC3339Nano))
+ }
+ if bounds != "start_only" {
+ q.Set("endTime", end.Format(time.RFC3339Nano))
+ }
+ }
+ q.Set("verify", "true")
+ q.Set("limit", "1")
+ q.Set("offset", "7")
+ rec := httptest.NewRecorder()
+ endpoint.handle(rec, httptest.NewRequest(http.MethodGet, "/api/audit?"+q.Encode(), nil))
+ if rec.Code != http.StatusOK || logger.queries != 1 {
+ t.Fatalf("status/query = %d/%d", rec.Code, logger.queries)
+ }
+ f := logger.lastQuery
+ if f.EventType != q.Get("event") || f.User != q.Get("user") || f.Success != nil {
+ t.Fatalf("scope = %+v", f)
+ }
+ if bounds == "none" || bounds == "end_only" {
+ if f.StartTime != nil {
+ t.Fatal("invented start bound")
+ }
+ } else if f.StartTime == nil || !f.StartTime.Equal(start) {
+ t.Fatalf("start = %v", f.StartTime)
+ }
+ if bounds == "none" || bounds == "start_only" {
+ if f.EndTime != nil {
+ t.Fatal("invented end bound")
+ }
+ } else if f.EndTime == nil || !f.EndTime.Equal(end) {
+ t.Fatalf("end = %v", f.EndTime)
+ }
+ if endpoint.name == "list" {
+ if f.Limit != 1 || f.Offset != 7 || logger.counts != 1 {
+ t.Fatalf("list paging = %+v, counts=%d", f, logger.counts)
+ }
+ } else if f.Limit != 0 || f.Offset != 0 || logger.verifications != 1 {
+ t.Fatalf("export/summary = %+v, verifies=%d", f, logger.verifications)
+ }
+ })
+ }
+ }
+}
+
+func TestAuditScopePreservesSuccessAndFormats(t *testing.T) {
+ for _, endpoint := range auditScopeEndpoints()[:2] {
+ for _, value := range []string{"true", "false"} {
+ for _, format := range []string{"json", "csv"} {
+ t.Run(endpoint.name+"/"+value+"/"+format, func(t *testing.T) {
+ logger := &auditScopeLogger{}
+ setAuditLogger(t, logger)
+ rec := httptest.NewRecorder()
+ endpoint.handle(rec, httptest.NewRequest(http.MethodGet, "/api/audit?success="+value+"&format="+format, nil))
+ if rec.Code != 200 || logger.lastQuery.Success == nil || *logger.lastQuery.Success != (value == "true") {
+ t.Fatalf("status/filter = %d/%+v", rec.Code, logger.lastQuery)
+ }
+ if endpoint.name == "export" {
+ want := "application/json; charset=utf-8"
+ if format == "csv" {
+ want = "text/csv; charset=utf-8"
+ }
+ if rec.Header().Get("Content-Type") != want || rec.Header().Get("X-Event-Count") != "0" {
+ t.Fatalf("export headers = %v", rec.Header())
+ }
+ }
+ })
+ }
+ }
+ }
+}
+
+// The tenant manager uses its ordinary factory boundary, never a SQLite store.
+type auditScopeFactory map[string]*auditScopeLogger
+
+func (f auditScopeFactory) CreateLogger(path string) (audit.Logger, error) {
+ org := filepath.Base(filepath.Dir(path))
+ if logger := f[org]; logger != nil {
+ return logger, nil
+ }
+ return nil, fmt.Errorf("unexpected synthetic org")
+}
+
+func TestAuditScopeTenantIsolation(t *testing.T) {
+ for _, endpoint := range auditScopeEndpoints()[1:] {
+ t.Run(endpoint.name, func(t *testing.T) {
+ previous := GetTenantAuditManager()
+ factory := auditScopeFactory{}
+ for _, org := range []string{"org-a", "org-b"} {
+ factory[org] = &auditScopeLogger{testAuditLogger: testAuditLogger{events: []audit.Event{{ID: org, User: org, Timestamp: time.Now()}}}}
+ }
+ manager := audit.NewTenantLoggerManager(t.TempDir(), factory)
+ SetTenantAuditManager(manager)
+ t.Cleanup(func() { manager.Close(); SetTenantAuditManager(previous) })
+ for _, org := range []string{"org-a", "org-b"} {
+ req := httptest.NewRequest(http.MethodGet, "/api/audit?event=login&startTime=2026-01-01T00:00:00Z", nil)
+ req = req.WithContext(context.WithValue(req.Context(), OrgIDContextKey, org))
+ rec := httptest.NewRecorder()
+ endpoint.handle(rec, req)
+ if rec.Code != 200 || factory[org].queries != 1 || factory[org].lastQuery.StartTime == nil || !strings.Contains(rec.Body.String(), org) {
+ t.Fatalf("tenant %s status/query/body = %d/%d/%s", org, rec.Code, factory[org].queries, rec.Body.String())
+ }
+ other := "org-a"
+ if org == other {
+ other = "org-b"
+ }
+ if strings.Contains(rec.Body.String(), other) {
+ t.Fatal("read another tenant's events")
+ }
+ }
+ })
+ }
+}
+
+func TestAuditScopeMethodAndAvailabilityGates(t *testing.T) {
+ for _, endpoint := range auditScopeEndpoints() {
+ t.Run(endpoint.name, func(t *testing.T) {
+ logger := &auditScopeLogger{}
+ setAuditLogger(t, logger)
+ rec := httptest.NewRecorder()
+ endpoint.handle(rec, httptest.NewRequest(http.MethodPost, "/api/audit?startTime=bad", nil))
+ if rec.Code != http.StatusMethodNotAllowed || logger.queries != 0 {
+ t.Fatalf("method gate = %d/%d", rec.Code, logger.queries)
+ }
+ setAuditLogger(t, audit.NewConsoleLogger())
+ rec = httptest.NewRecorder()
+ endpoint.handle(rec, httptest.NewRequest(http.MethodGet, "/api/audit?startTime=bad", nil))
+ want := http.StatusNotImplemented
+ if endpoint.name == "list" {
+ want = http.StatusServiceUnavailable
+ }
+ if rec.Code != want {
+ t.Fatalf("availability gate = %d, want %d", rec.Code, want)
+ }
+ })
+ }
+}
diff --git a/internal/api/audit_handlers_test.go b/internal/api/audit_handlers_test.go
index 117f882d03..fda159306f 100644
--- a/internal/api/audit_handlers_test.go
+++ b/internal/api/audit_handlers_test.go
@@ -809,6 +809,16 @@ func TestHandleExportAuditEvents(t *testing.T) {
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, 0, 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) {
@@ -865,6 +875,12 @@ func TestHandleAuditSummary(t *testing.T) {
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, 0, logger.lastQuery.Limit)
+ assert.Equal(t, 0, logger.lastQuery.Offset)
})
t.Run("Method not allowed", func(t *testing.T) {
diff --git a/scripts/tests/test_admin_docs.py b/scripts/tests/test_admin_docs.py
index aebc1cb988..530fb1780d 100644
--- a/scripts/tests/test_admin_docs.py
+++ b/scripts/tests/test_admin_docs.py
@@ -105,7 +105,7 @@ class AdminDocsTest(unittest.TestCase):
audit = (DOCS / "AUDIT_LOGGING.md").read_text()
for boundary in ("audit:read", "audit_logging", "private directory", "redacted excerpt", "does not reuse filters",
"in the same Bash session", "not an installed Pulse command", "not list pagination",
- "ignores malformed time filters", "partial file", "does not follow redirects or retry"):
+ "reject malformed or empty supplied", "before reading events", "not `success` or list", "partial file", "does not follow redirects or retry"):
self.assertIn(boundary, audit)
org = (DOCS / "MULTI_TENANT.md").read_text()
for boundary in ("session-based user authentication", "403 session_required", "CSRF", "settings:read", "organization binding", "pending invitation", "accept the share", "accessRole"):