Implement milestone M2 of the minimal MCP plan: the tools that answer from the server's own state instead of opening a device channel. - Extract the audit-log scanner from web into package auditquery so the admin page and get_audit_log share one implementation. The web handler keeps its 500-row cap, the MCP tool uses the protocol's 1000-row cap. Query gains json tags for the web snake_case wire format (device_id, warn_only) and reports TotalAll before filters. - Add package buildinfo and inject Version/Commit with -X from build.ps1 and the Makefile; go-winres refreshes Windows resources from the git tag when available. An unversioned build reports "", and only initialize substitutes "dev". - list_hosts: online/offline pools, include_offline merge, every documented filter, limit/offset paging with total/totalAll/hasMore, and schema-named host fields (authStatus/tls/remark are never fabricated). - get_host_detail: single id or a batch of up to 50, online lookup then the last history record, capabilities from protocol.SupportsCap plus the Windows/registry/virtual-desktop rules; v2 is not listed. - get_server_status: version, uptime, online/offline counts, port and bind. sessions stays absent until the MCP session table lands in M3. - get_audit_log: case-insensitive event substring, keyword, paging; hasMore turns false at the MaxOffset clamp so paging cannot loop. Wire hub, history, audit path and listen address through mcp.Config from cmd/main.go. Tests cover pools/filters/paging, capability bits, batch failures, audit paging and the unversioned build. Co-Authored-By: deepseek-flash
249 lines
8.4 KiB
Go
249 lines
8.4 KiB
Go
package auditquery
|
|
|
|
import (
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
// writeAuditFixture writes JSON-lines audit records (oldest first) and returns
|
|
// the file path. Times are UTC RFC3339 so the tests are timezone-independent.
|
|
func writeAuditFixture(t *testing.T, records []map[string]any) string {
|
|
t.Helper()
|
|
path := filepath.Join(t.TempDir(), "audit.log")
|
|
var b strings.Builder
|
|
for _, rec := range records {
|
|
line, err := json.Marshal(rec)
|
|
if err != nil {
|
|
t.Fatalf("marshal fixture: %v", err)
|
|
}
|
|
b.Write(line)
|
|
b.WriteByte('\n')
|
|
}
|
|
if err := os.WriteFile(path, []byte(b.String()), 0o644); err != nil {
|
|
t.Fatalf("write fixture: %v", err)
|
|
}
|
|
return path
|
|
}
|
|
|
|
func auditFixtureRecords() []map[string]any {
|
|
at := func(hhmm string) string {
|
|
tm, err := time.Parse("2006-01-02T15:04", "2026-10-18T"+hhmm)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return tm.Format(time.RFC3339)
|
|
}
|
|
return []map[string]any{
|
|
{"level": "info", "time": at("10:00"), "audit": true, "event": "web.login.success", "actor": "admin", "ip": "203.0.113.1"},
|
|
{"level": "warn", "time": at("10:01"), "audit": true, "event": "web.login.failure", "actor": "alice", "ip": "203.0.113.2", "reason": "invalid_credentials"},
|
|
{"level": "info", "time": at("10:02"), "audit": true, "event": "remote.screen.start", "actor": "admin", "role": "admin", "ip": "203.0.113.1", "device_id": "dev1"},
|
|
{"level": "info", "time": at("10:03"), "audit": true, "event": "admin.user.delete", "actor": "admin", "ip": "203.0.113.1", "target": "bob"},
|
|
}
|
|
}
|
|
|
|
func runAuditQuery(t *testing.T, path string, q Query) Result {
|
|
t.Helper()
|
|
q.Limit = ClampLimit(q.Limit, MaxLimit)
|
|
q.Offset = ClampOffset(q.Offset)
|
|
res, err := Scan(path, q)
|
|
if err != nil {
|
|
t.Fatalf("Scan: %v", err)
|
|
}
|
|
return res
|
|
}
|
|
|
|
func eventNames(res Result) []string {
|
|
out := make([]string, 0, len(res.Events))
|
|
for _, e := range res.Events {
|
|
out = append(out, StringField(e, "event"))
|
|
}
|
|
return out
|
|
}
|
|
|
|
func TestNoFilterNewestFirst(t *testing.T) {
|
|
path := writeAuditFixture(t, auditFixtureRecords())
|
|
res := runAuditQuery(t, path, Query{Limit: 100})
|
|
if res.Total != 4 || len(res.Events) != 4 {
|
|
t.Fatalf("total=%d events=%d, want 4/4", res.Total, len(res.Events))
|
|
}
|
|
if res.TotalAll != 4 {
|
|
t.Fatalf("totalAll=%d, want 4", res.TotalAll)
|
|
}
|
|
got := eventNames(res)
|
|
want := []string{"admin.user.delete", "remote.screen.start", "web.login.failure", "web.login.success"}
|
|
if strings.Join(got, ",") != strings.Join(want, ",") {
|
|
t.Fatalf("events = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestEventFilters(t *testing.T) {
|
|
path := writeAuditFixture(t, auditFixtureRecords())
|
|
cases := []struct {
|
|
filter string
|
|
want []string
|
|
}{
|
|
{"web.", []string{"web.login.failure", "web.login.success"}},
|
|
{"web.*", []string{"web.login.failure", "web.login.success"}},
|
|
{"web.login.failure", []string{"web.login.failure"}},
|
|
{"remote.*", []string{"remote.screen.start"}},
|
|
}
|
|
for _, tc := range cases {
|
|
res := runAuditQuery(t, path, Query{Event: tc.filter, Limit: 100})
|
|
got := eventNames(res)
|
|
if strings.Join(got, ",") != strings.Join(tc.want, ",") {
|
|
t.Errorf("filter %q → %v, want %v", tc.filter, got, tc.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestEventContainsFilter(t *testing.T) {
|
|
path := writeAuditFixture(t, auditFixtureRecords())
|
|
res := runAuditQuery(t, path, Query{EventContains: "LOGIN", Limit: 100})
|
|
got := eventNames(res)
|
|
want := []string{"web.login.failure", "web.login.success"}
|
|
if strings.Join(got, ",") != strings.Join(want, ",") {
|
|
t.Fatalf("events = %v, want %v", got, want)
|
|
}
|
|
// Filters run before paging: total reflects matches, totalAll the window.
|
|
if res.Total != 2 || res.TotalAll != 4 {
|
|
t.Fatalf("total=%d totalAll=%d, want 2/4", res.Total, res.TotalAll)
|
|
}
|
|
}
|
|
|
|
func TestFieldFilters(t *testing.T) {
|
|
path := writeAuditFixture(t, auditFixtureRecords())
|
|
from, _ := time.Parse(time.RFC3339, "2026-10-18T10:01:00Z")
|
|
to, _ := time.Parse(time.RFC3339, "2026-10-18T10:02:00Z")
|
|
|
|
cases := []struct {
|
|
name string
|
|
q Query
|
|
want []string
|
|
}{
|
|
{"actor case-insensitive", Query{Actor: "ALICE", Limit: 100}, []string{"web.login.failure"}},
|
|
{"ip", Query{IP: "203.0.113.2", Limit: 100}, []string{"web.login.failure"}},
|
|
{"device", Query{DeviceID: "dev1", Limit: 100}, []string{"remote.screen.start"}},
|
|
{"warn only", Query{WarnOnly: true, Limit: 100}, []string{"web.login.failure"}},
|
|
{"keyword target", Query{Keyword: "BOB", Limit: 100}, []string{"admin.user.delete"}},
|
|
{"time range", Query{
|
|
From: from.Format(time.RFC3339), To: to.Format(time.RFC3339), Limit: 100,
|
|
}, []string{"remote.screen.start", "web.login.failure"}},
|
|
}
|
|
for _, tc := range cases {
|
|
res := runAuditQuery(t, path, tc.q)
|
|
got := eventNames(res)
|
|
if strings.Join(got, ",") != strings.Join(tc.want, ",") {
|
|
t.Errorf("%s → %v, want %v", tc.name, got, tc.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestOffsetAndLimit(t *testing.T) {
|
|
path := writeAuditFixture(t, auditFixtureRecords())
|
|
res := runAuditQuery(t, path, Query{Limit: 2, Offset: 1})
|
|
if res.Total != 4 {
|
|
t.Fatalf("total = %d, want 4", res.Total)
|
|
}
|
|
got := eventNames(res)
|
|
want := []string{"remote.screen.start", "web.login.failure"}
|
|
if strings.Join(got, ",") != strings.Join(want, ",") {
|
|
t.Fatalf("events = %v, want %v", got, want)
|
|
}
|
|
|
|
// Offsetting past the end yields no events but keeps the total.
|
|
res = runAuditQuery(t, path, Query{Limit: 2, Offset: 4})
|
|
if res.Total != 4 || len(res.Events) != 0 {
|
|
t.Fatalf("offset past end: total=%d events=%v", res.Total, eventNames(res))
|
|
}
|
|
}
|
|
|
|
func TestSkipsNonAuditAndTornLines(t *testing.T) {
|
|
path := filepath.Join(t.TempDir(), "audit.log")
|
|
content := `{"event":"device.online","actor":"x"}
|
|
not json at all
|
|
{"level":"info","time":"2026-10-18T10:00:00Z","audit":true,"event":"web.login.success","actor":"admin"}`
|
|
if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
res := runAuditQuery(t, path, Query{Limit: 100})
|
|
if res.Total != 1 || len(res.Events) != 1 {
|
|
t.Fatalf("total=%d events=%v, want the single valid record", res.Total, eventNames(res))
|
|
}
|
|
// Non-audit and torn lines do not count toward totalAll either.
|
|
if res.TotalAll != 1 {
|
|
t.Fatalf("totalAll=%d, want 1", res.TotalAll)
|
|
}
|
|
}
|
|
|
|
func TestMissingFile(t *testing.T) {
|
|
res := runAuditQuery(t, filepath.Join(t.TempDir(), "does-not-exist.log"), Query{Limit: 10})
|
|
if res.FileExists {
|
|
t.Error("FileExists = true for a missing file")
|
|
}
|
|
if res.Total != 0 || len(res.Events) != 0 {
|
|
t.Errorf("total=%d events=%v, want empty", res.Total, eventNames(res))
|
|
}
|
|
if res.Events == nil {
|
|
t.Error("Events is nil; JSON would encode null instead of []")
|
|
}
|
|
}
|
|
|
|
func TestClampsPaging(t *testing.T) {
|
|
if got := ClampLimit(0, MaxLimit); got != DefaultLimit {
|
|
t.Errorf("limit(0) = %d, want default %d", got, DefaultLimit)
|
|
}
|
|
if got := ClampLimit(-3, MaxLimit); got != DefaultLimit {
|
|
t.Errorf("limit(-3) = %d, want default %d", got, DefaultLimit)
|
|
}
|
|
if got := ClampLimit(9999, MaxLimit); got != MaxLimit {
|
|
t.Errorf("limit(9999) = %d, want max %d", got, MaxLimit)
|
|
}
|
|
if got := ClampLimit(9999, 500); got != 500 {
|
|
t.Errorf("limit(9999, max 500) = %d, want 500", got)
|
|
}
|
|
if got := ClampLimit(50, MaxLimit); got != 50 {
|
|
t.Errorf("limit(50) = %d, want 50", got)
|
|
}
|
|
if got := ClampLimit(0, 0); got != DefaultLimit {
|
|
t.Errorf("limit(0, max 0) = %d, want default %d", got, DefaultLimit)
|
|
}
|
|
if got := ClampOffset(-5); got != 0 {
|
|
t.Errorf("offset(-5) = %d, want 0", got)
|
|
}
|
|
if got := ClampOffset(1 << 30); got != MaxOffset {
|
|
t.Errorf("offset(huge) = %d, want max %d", got, MaxOffset)
|
|
}
|
|
}
|
|
|
|
// The web audit page sends snake_case keys. Query is decoded from that wire
|
|
// format in web/audit_query.go, so the tags must keep those names — otherwise
|
|
// device_id / warn_only silently stop filtering.
|
|
func TestQueryDecodesWebWireFormat(t *testing.T) {
|
|
body := `{"from":"2026-11-01T00:00:00Z","to":"2026-11-12T00:00:00Z",` +
|
|
`"event":"web.","actor":"admin","ip":"1.2.3.4","device_id":"1001",` +
|
|
`"keyword":"k","warn_only":true,"limit":5,"offset":2}`
|
|
var q Query
|
|
if err := json.Unmarshal([]byte(body), &q); err != nil {
|
|
t.Fatalf("unmarshal: %v", err)
|
|
}
|
|
if q.From != "2026-11-01T00:00:00Z" || q.To != "2026-11-12T00:00:00Z" {
|
|
t.Fatalf("time range = %q..%q", q.From, q.To)
|
|
}
|
|
if q.Event != "web." || q.Actor != "admin" || q.IP != "1.2.3.4" {
|
|
t.Fatalf("filters = %+v", q)
|
|
}
|
|
if q.DeviceID != "1001" {
|
|
t.Fatalf("device_id = %q, want 1001", q.DeviceID)
|
|
}
|
|
if q.Keyword != "k" || !q.WarnOnly {
|
|
t.Fatalf("keyword/warn_only = %q/%v", q.Keyword, q.WarnOnly)
|
|
}
|
|
if q.Limit != 5 || q.Offset != 2 {
|
|
t.Fatalf("limit/offset = %d/%d", q.Limit, q.Offset)
|
|
}
|
|
}
|