Files
SimpleRemoter/server/go/auditquery/auditquery_test.go
T
yuanyuanxianganddeepseek-flash 774c0d2545 Feature(Go): four local MCP read tools and a shared audit query package
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
2026-11-12 20:55:18 +01:00

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)
}
}