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 tools
import (
"context"
"encoding/json"
"fmt"
"strings"
"testing"
"github.com/rcourtman/pulse-go-rewrite/internal/agentcapabilities"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
// --- Mock PatrolFindingCreator ---
type mockPatrolFindingCreator struct {
createFindingFunc func(input PatrolFindingInput) (string, bool, error)
assessFindingFunc func(input PatrolFindingAssessmentInput) error
resolveFindingFunc func(findingID, reason string) error
getActiveFn func(resourceID, minSeverity string) []PatrolFindingInfo
// Track calls for assertions
createCalls []PatrolFindingInput
assessCalls []PatrolFindingAssessmentInput
resolveCalls []struct {
FindingID string
Reason string
}
getCalls []struct {
ResourceID string
MinSeverity string
}
checked bool
complete bool
}
type mockPatrolObserverProposer struct {
input PatrolObserverProposalInput
result PatrolObserverProposalResult
err error
}
func (m *mockPatrolObserverProposer) ProposeObserver(input PatrolObserverProposalInput) (PatrolObserverProposalResult, error) {
m.input = input
return m.result, m.err
}
func (m *mockPatrolFindingCreator) AssessFinding(input PatrolFindingAssessmentInput) error {
m.assessCalls = append(m.assessCalls, input)
if m.assessFindingFunc != nil {
return m.assessFindingFunc(input)
}
return nil
}
func (m *mockPatrolFindingCreator) CreateFinding(input PatrolFindingInput) (string, bool, error) {
m.createCalls = append(m.createCalls, input)
if m.createFindingFunc != nil {
return m.createFindingFunc(input)
}
return "finding-123", true, nil
}
func (m *mockPatrolFindingCreator) ResolveFinding(findingID, reason string) error {
m.resolveCalls = append(m.resolveCalls, struct {
FindingID string
Reason string
}{findingID, reason})
if m.resolveFindingFunc != nil {
return m.resolveFindingFunc(findingID, reason)
}
return nil
}
func (m *mockPatrolFindingCreator) GetActiveFindings(resourceID, minSeverity string) []PatrolFindingInfo {
m.getCalls = append(m.getCalls, struct {
ResourceID string
MinSeverity string
}{resourceID, minSeverity})
m.checked = true
if strings.TrimSpace(resourceID) == "" {
minimum := strings.ToLower(strings.TrimSpace(minSeverity))
m.complete = minimum == "" || minimum == "info"
}
if m.getActiveFn != nil {
return m.getActiveFn(resourceID, minSeverity)
}
return nil
}
func (m *mockPatrolFindingCreator) HasCheckedFindings() bool {
return m.checked
}
func (m *mockPatrolFindingCreator) HasCompleteFindingSnapshot() bool {
return m.complete
}
// --- Helper to create executor with patrol creator ---
func newPatrolTestExecutor(creator PatrolFindingCreator) *PulseToolExecutor {
exec := NewPulseToolExecutor(ExecutorConfig{})
exec.SetPatrolFindingCreator(creator)
return exec
}
func validReportArgs() map[string]interface{} {
return map[string]interface{}{
"key": "high-cpu",
"severity": "warning",
"category": "performance",
"resource_id": "node/pve1",
"resource_name": "pve1",
"resource_type": "node",
"title": "High CPU usage on pve1",
"description": "CPU usage is at 92% for the last 15 minutes",
"recommendation": "Inspect the busiest processes and rebalance workloads if the pressure persists.",
"evidence": "CPU usage remained at 92% for 15 minutes.",
}
}
// --- patrol_report_finding tests ---
func TestHandlePatrolReportFinding_NilCreator(t *testing.T) {
exec := NewPulseToolExecutor(ExecutorConfig{})
// Creator is nil (not in a patrol run)
result, err := handlePatrolReportFinding(context.Background(), exec, validReportArgs())
require.NoError(t, err)
text := extractText(result)
assert.Contains(t, text, "only available during a patrol run")
}
func TestHandlePatrolReportFinding_RequiresGetFindings(t *testing.T) {
creator := &mockPatrolFindingCreator{}
exec := newPatrolTestExecutor(creator)
result, err := handlePatrolReportFinding(context.Background(), exec, validReportArgs())
require.NoError(t, err)
text := extractText(result)
assert.Contains(t, text, "patrol_get_findings")
}
func TestHandlePatrolReportFinding_AcknowledgesSameRunDuplicateAsNoOp(t *testing.T) {
creator := &mockPatrolFindingCreator{
createFindingFunc: func(PatrolFindingInput) (string, bool, error) {
return "finding-new", true, &PatrolFindingAlreadyReportedError{FindingID: "finding-new"}
},
checked: true,
}
exec := newPatrolTestExecutor(creator)
result, err := handlePatrolReportFinding(context.Background(), exec, validReportArgs())
require.NoError(t, err)
var parsed map[string]interface{}
require.NoError(t, json.Unmarshal([]byte(extractText(result)), &parsed))
assert.Equal(t, true, parsed["ok"])
assert.Equal(t, false, parsed["applied"])
assert.Equal(t, true, parsed["is_new"])
assert.Equal(t, "finding_reported_this_run", parsed["reason"])
assert.Equal(t, "finding-new", parsed[agentcapabilities.FindingIDArgumentName])
require.Len(t, creator.createCalls, 1)
}
func TestHandlePatrolReportFinding_AcknowledgesAlertOwnedStateAsNoOp(t *testing.T) {
creator := &mockPatrolFindingCreator{
createFindingFunc: func(PatrolFindingInput) (string, bool, error) {
return "finding-alert-owned", false, &PatrolFindingOwnedByAlertsError{FindingID: "finding-alert-owned"}
},
checked: true,
}
exec := newPatrolTestExecutor(creator)
result, err := handlePatrolReportFinding(context.Background(), exec, validReportArgs())
require.NoError(t, err)
var parsed map[string]interface{}
require.NoError(t, json.Unmarshal([]byte(extractText(result)), &parsed))
assert.Equal(t, true, parsed["ok"])
assert.Equal(t, false, parsed["applied"])
assert.Equal(t, false, parsed["is_new"])
assert.Equal(t, "alert_owned_resource_state", parsed["reason"])
assert.Equal(t, "finding-alert-owned", parsed[agentcapabilities.FindingIDArgumentName])
}
func TestHandlePatrolReportFinding_ValidInput(t *testing.T) {
creator := &mockPatrolFindingCreator{checked: true}
exec := newPatrolTestExecutor(creator)
args := validReportArgs()
args["recommendation"] = "Consider migrating VMs to reduce load"
args["evidence"] = "CPU at 92% over 15 minutes"
result, err := handlePatrolReportFinding(context.Background(), exec, args)
require.NoError(t, err)
var parsed map[string]interface{}
text := extractText(result)
require.NoError(t, json.Unmarshal([]byte(text), &parsed))
assert.Equal(t, true, parsed["ok"])
assert.Equal(t, "finding-123", parsed[agentcapabilities.FindingIDArgumentName])
assert.Equal(t, true, parsed["is_new"])
assert.Equal(t, true, result.StructuredContent["ok"])
assert.Equal(t, "finding-123", result.StructuredContent[agentcapabilities.FindingIDArgumentName])
// Verify the creator was called with correct input
require.Len(t, creator.createCalls, 1)
input := creator.createCalls[0]
assert.Equal(t, "high-cpu", input.Key)
assert.Equal(t, "warning", input.Severity)
assert.Equal(t, "performance", input.Category)
assert.Equal(t, "node/pve1", input.ResourceID)
assert.Equal(t, "pve1", input.ResourceName)
assert.Equal(t, "node", input.ResourceType)
assert.Equal(t, "High CPU usage on pve1", input.Title)
assert.Equal(t, "CPU usage is at 92% for the last 15 minutes", input.Description)
assert.Equal(t, "Consider migrating VMs to reduce load", input.Recommendation)
assert.Equal(t, "CPU at 92% over 15 minutes", input.Evidence)
}
func TestHandlePatrolReportFinding_PassesImpactWhenAuthored(t *testing.T) {
creator := &mockPatrolFindingCreator{checked: true}
exec := newPatrolTestExecutor(creator)
args := validReportArgs()
args["impact"] = "Customer-facing latency rises and request queue depth grows; sustained CPU pressure will time out user requests."
result, err := handlePatrolReportFinding(context.Background(), exec, args)
require.NoError(t, err)
var parsed map[string]interface{}
require.NoError(t, json.Unmarshal([]byte(extractText(result)), &parsed))
assert.Equal(t, true, parsed["ok"])
require.Len(t, creator.createCalls, 1)
assert.Equal(t,
"Customer-facing latency rises and request queue depth grows; sustained CPU pressure will time out user requests.",
creator.createCalls[0].Impact,
)
}
func TestHandlePatrolReportFinding_LeavesImpactEmptyWhenOmitted(t *testing.T) {
creator := &mockPatrolFindingCreator{checked: true}
exec := newPatrolTestExecutor(creator)
// validReportArgs intentionally omits impact, mirroring the LLM choosing
// to leave it empty rather than fabricating one. The contract is that an
// omitted impact is honored verbatim — no default copy is synthesized.
result, err := handlePatrolReportFinding(context.Background(), exec, validReportArgs())
require.NoError(t, err)
var parsed map[string]interface{}
require.NoError(t, json.Unmarshal([]byte(extractText(result)), &parsed))
assert.Equal(t, true, parsed["ok"])
require.Len(t, creator.createCalls, 1)
assert.Equal(t, "", creator.createCalls[0].Impact)
}
func TestHandlePatrolReportFinding_AcceptsPhysicalDiskResourceType(t *testing.T) {
creator := &mockPatrolFindingCreator{checked: true}
exec := newPatrolTestExecutor(creator)
args := validReportArgs()
args["resource_id"] = "disk-1"
args["resource_name"] = "/dev/sda"
args["resource_type"] = "physical_disk"
args["title"] = "Disk health warning"
args["description"] = "Disk health reported FAILED"
result, err := handlePatrolReportFinding(context.Background(), exec, args)
require.NoError(t, err)
var parsed map[string]interface{}
text := extractText(result)
require.NoError(t, json.Unmarshal([]byte(text), &parsed))
assert.Equal(t, true, parsed["ok"])
require.Len(t, creator.createCalls, 1)
assert.Equal(t, "physical_disk", creator.createCalls[0].ResourceType)
}
func TestHandlePatrolReportFinding_MissingRequiredFields(t *testing.T) {
creator := &mockPatrolFindingCreator{checked: true}
exec := newPatrolTestExecutor(creator)
tests := []struct {
name string
remove string
missing string
}{
{"missing key", "key", "key"},
{"missing severity", "severity", "severity"},
{"missing category", "category", "category"},
{"missing resource_id", "resource_id", "resource_id"},
{"missing resource_name", "resource_name", "resource_name"},
{"missing resource_type", "resource_type", "resource_type"},
{"missing title", "title", "title"},
{"missing description", "description", "description"},
{"missing recommendation", "recommendation", "recommendation"},
{"missing evidence", "evidence", "evidence"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
args := validReportArgs()
delete(args, tt.remove)
result, err := handlePatrolReportFinding(context.Background(), exec, args)
require.NoError(t, err)
text := extractText(result)
assert.Contains(t, text, "missing required fields")
assert.Contains(t, text, tt.missing)
})
}
}
func TestHandlePatrolReportFinding_AllRequiredFieldsMissing(t *testing.T) {
creator := &mockPatrolFindingCreator{checked: true}
exec := newPatrolTestExecutor(creator)
result, err := handlePatrolReportFinding(context.Background(), exec, map[string]interface{}{})
require.NoError(t, err)
text := extractText(result)
assert.Contains(t, text, "missing required fields")
// Should mention all required fields.
for _, field := range []string{"key", "severity", "category", "resource_id", "resource_name", "resource_type", "title", "description", "recommendation", "evidence"} {
assert.Contains(t, text, field)
}
}
func TestHandlePatrolReportFinding_InvalidSeverity(t *testing.T) {
creator := &mockPatrolFindingCreator{checked: true}
exec := newPatrolTestExecutor(creator)
args := validReportArgs()
args["severity"] = "extreme"
result, err := handlePatrolReportFinding(context.Background(), exec, args)
require.NoError(t, err)
text := extractText(result)
assert.Contains(t, text, "invalid severity")
assert.Contains(t, text, "extreme")
}
func TestHandlePatrolReportFinding_InvalidCategory(t *testing.T) {
creator := &mockPatrolFindingCreator{checked: true}
exec := newPatrolTestExecutor(creator)
args := validReportArgs()
args["category"] = "networking"
result, err := handlePatrolReportFinding(context.Background(), exec, args)
require.NoError(t, err)
text := extractText(result)
assert.Contains(t, text, "invalid category")
assert.Contains(t, text, "networking")
}
func TestHandlePatrolReportFinding_RejectsLegacyResourceTypeAliases(t *testing.T) {
for _, resourceType := range []string{"host", "container", "docker", "docker-container", "docker_container", "app_container", "k8s_cluster", "kubernetes_cluster"} {
t.Run(resourceType, func(t *testing.T) {
creator := &mockPatrolFindingCreator{checked: true}
exec := newPatrolTestExecutor(creator)
args := validReportArgs()
args["resource_type"] = resourceType
result, err := handlePatrolReportFinding(context.Background(), exec, args)
require.NoError(t, err)
text := extractText(result)
assert.Contains(t, text, "unsupported resource_type")
assert.Contains(t, text, resourceType)
assert.Empty(t, creator.createCalls)
})
}
}
func TestHandlePatrolReportFinding_InvalidResourceType(t *testing.T) {
creator := &mockPatrolFindingCreator{checked: true}
exec := newPatrolTestExecutor(creator)
args := validReportArgs()
args["resource_type"] = "bad-type"
result, err := handlePatrolReportFinding(context.Background(), exec, args)
require.NoError(t, err)
text := extractText(result)
assert.Contains(t, text, "unsupported resource_type")
assert.Contains(t, text, "bad-type")
}
func TestHandlePatrolReportFinding_ValidSeverities(t *testing.T) {
for _, sev := range []string{"critical", "warning"} {
t.Run(sev, func(t *testing.T) {
creator := &mockPatrolFindingCreator{checked: true}
exec := newPatrolTestExecutor(creator)
args := validReportArgs()
args["severity"] = sev
result, err := handlePatrolReportFinding(context.Background(), exec, args)
require.NoError(t, err)
text := extractText(result)
assert.NotContains(t, text, "invalid severity")
var parsed map[string]interface{}
require.NoError(t, json.Unmarshal([]byte(text), &parsed))
assert.Equal(t, true, parsed["ok"])
})
}
}
func TestHandlePatrolReportFinding_RejectedSeverities(t *testing.T) {
for _, sev := range []string{"watch", "info"} {
t.Run(sev, func(t *testing.T) {
creator := &mockPatrolFindingCreator{checked: true}
exec := newPatrolTestExecutor(creator)
args := validReportArgs()
args["severity"] = sev
result, err := handlePatrolReportFinding(context.Background(), exec, args)
require.NoError(t, err)
text := extractText(result)
assert.Contains(t, text, "invalid severity")
})
}
}
func TestHandlePatrolReportFinding_ValidCategories(t *testing.T) {
for _, cat := range []string{"performance", "capacity", "reliability", "backup", "security", "general"} {
t.Run(cat, func(t *testing.T) {
creator := &mockPatrolFindingCreator{checked: true}
exec := newPatrolTestExecutor(creator)
args := validReportArgs()
args["category"] = cat
result, err := handlePatrolReportFinding(context.Background(), exec, args)
require.NoError(t, err)
text := extractText(result)
assert.NotContains(t, text, "invalid category")
var parsed map[string]interface{}
require.NoError(t, json.Unmarshal([]byte(text), &parsed))
assert.Equal(t, true, parsed["ok"])
})
}
}
func TestHandlePatrolReportFinding_DuplicateFinding(t *testing.T) {
creator := &mockPatrolFindingCreator{
createFindingFunc: func(input PatrolFindingInput) (string, bool, error) {
return "finding-existing", false, nil // isNew = false
},
checked: true,
}
exec := newPatrolTestExecutor(creator)
result, err := handlePatrolReportFinding(context.Background(), exec, validReportArgs())
require.NoError(t, err)
var parsed map[string]interface{}
text := extractText(result)
require.NoError(t, json.Unmarshal([]byte(text), &parsed))
assert.Equal(t, true, parsed["ok"])
assert.Equal(t, "finding-existing", parsed[agentcapabilities.FindingIDArgumentName])
assert.Equal(t, false, parsed["is_new"])
assert.Equal(t, "finding-existing", result.StructuredContent[agentcapabilities.FindingIDArgumentName])
}
func TestHandlePatrolReportFinding_CreatorError(t *testing.T) {
creator := &mockPatrolFindingCreator{
createFindingFunc: func(input PatrolFindingInput) (string, bool, error) {
return "", false, fmt.Errorf("validation failed: CPU is below threshold")
},
checked: true,
}
exec := newPatrolTestExecutor(creator)
result, err := handlePatrolReportFinding(context.Background(), exec, validReportArgs())
require.NoError(t, err)
text := extractText(result)
assert.Contains(t, text, "failed to create finding")
assert.Contains(t, text, "validation failed")
}
func TestHandlePatrolReportFinding_RejectsBlankGroundingFields(t *testing.T) {
for _, field := range []string{"recommendation", "evidence"} {
t.Run(field, func(t *testing.T) {
creator := &mockPatrolFindingCreator{checked: true}
exec := newPatrolTestExecutor(creator)
args := validReportArgs()
args[field] = " \n\t"
result, err := handlePatrolReportFinding(context.Background(), exec, args)
require.NoError(t, err)
assert.Contains(t, extractText(result), "missing required fields")
assert.Contains(t, extractText(result), field)
assert.Empty(t, creator.createCalls)
})
}
}
// --- patrol_assess_finding tests ---
func TestHandlePatrolAssessFinding_RequiresGetFindings(t *testing.T) {
creator := &mockPatrolFindingCreator{}
exec := newPatrolTestExecutor(creator)
result, err := handlePatrolAssessFinding(context.Background(), exec, map[string]interface{}{
agentcapabilities.FindingIDArgumentName: "finding-1",
"verdict": "present",
"evidence": "restart count is 12",
agentcapabilities.ReasonArgumentName: "the restart loop remains active",
})
require.NoError(t, err)
assert.Contains(t, extractText(result), "patrol_get_findings")
assert.Empty(t, creator.assessCalls)
}
func TestHandlePatrolAssessFinding_AcceptsExplicitVerdicts(t *testing.T) {
for _, verdict := range []string{"present", "resolved", "uncertain"} {
t.Run(verdict, func(t *testing.T) {
creator := &mockPatrolFindingCreator{checked: true}
exec := newPatrolTestExecutor(creator)
result, err := handlePatrolAssessFinding(context.Background(), exec, map[string]interface{}{
agentcapabilities.FindingIDArgumentName: "finding-1",
"verdict": verdict,
"evidence": "current evidence",
agentcapabilities.ReasonArgumentName: "evidence supports verdict",
})
require.NoError(t, err)
require.Len(t, creator.assessCalls, 1)
assert.Equal(t, verdict, creator.assessCalls[0].Verdict)
assert.Contains(t, extractText(result), verdict)
})
}
}
func TestHandlePatrolAssessFinding_AcknowledgesSameRunNewFindingAsNoOp(t *testing.T) {
creator := &mockPatrolFindingCreator{
assessFindingFunc: func(input PatrolFindingAssessmentInput) error {
return &PatrolFindingAlreadyDecidedError{FindingID: input.FindingID}
},
checked: true,
}
exec := newPatrolTestExecutor(creator)
result, err := handlePatrolAssessFinding(context.Background(), exec, map[string]interface{}{
agentcapabilities.FindingIDArgumentName: "finding-new",
"verdict": "uncertain",
"evidence": "same evidence",
agentcapabilities.ReasonArgumentName: "already reported",
})
require.NoError(t, err)
var parsed map[string]interface{}
require.NoError(t, json.Unmarshal([]byte(extractText(result)), &parsed))
assert.Equal(t, true, parsed["ok"])
assert.Equal(t, false, parsed["applied"])
assert.Equal(t, "new_finding_reported_this_run", parsed["reason"])
assert.Equal(t, "finding-new", parsed[agentcapabilities.FindingIDArgumentName])
}
func TestHandlePatrolAssessFinding_RejectsIncompleteOrInvalidVerdict(t *testing.T) {
creator := &mockPatrolFindingCreator{checked: true}
exec := newPatrolTestExecutor(creator)
result, err := handlePatrolAssessFinding(context.Background(), exec, map[string]interface{}{
agentcapabilities.FindingIDArgumentName: "finding-1",
"verdict": "fixed-ish",
"evidence": "current evidence",
agentcapabilities.ReasonArgumentName: "reason",
})
require.NoError(t, err)
assert.Contains(t, extractText(result), "invalid verdict")
result, err = handlePatrolAssessFinding(context.Background(), exec, map[string]interface{}{
agentcapabilities.FindingIDArgumentName: "finding-1",
"verdict": "present",
})
require.NoError(t, err)
assert.Contains(t, extractText(result), "evidence")
assert.Empty(t, creator.assessCalls)
}
// --- patrol_resolve_finding tests ---
func TestHandlePatrolResolveFinding_NilCreator(t *testing.T) {
exec := NewPulseToolExecutor(ExecutorConfig{})
result, err := handlePatrolResolveFinding(context.Background(), exec, map[string]interface{}{
agentcapabilities.FindingIDArgumentName: "f-123",
agentcapabilities.ReasonArgumentName: "CPU recovered",
})
require.NoError(t, err)
text := extractText(result)
assert.Contains(t, text, "only available during a patrol run")
}
func TestHandlePatrolResolveFinding_RequiresGetFindings(t *testing.T) {
creator := &mockPatrolFindingCreator{}
exec := newPatrolTestExecutor(creator)
result, err := handlePatrolResolveFinding(context.Background(), exec, map[string]interface{}{
agentcapabilities.FindingIDArgumentName: "f-123",
agentcapabilities.ReasonArgumentName: "CPU recovered",
})
require.NoError(t, err)
text := extractText(result)
assert.Contains(t, text, "patrol_get_findings")
}
func TestHandlePatrolResolveFinding_ValidInput(t *testing.T) {
creator := &mockPatrolFindingCreator{checked: true}
exec := newPatrolTestExecutor(creator)
result, err := handlePatrolResolveFinding(context.Background(), exec, map[string]interface{}{
agentcapabilities.FindingIDArgumentName: "f-123",
agentcapabilities.ReasonArgumentName: "CPU has returned to 35%",
})
require.NoError(t, err)
var parsed map[string]interface{}
text := extractText(result)
require.NoError(t, json.Unmarshal([]byte(text), &parsed))
assert.Equal(t, true, parsed["ok"])
assert.Equal(t, true, parsed["resolved"])
assert.Equal(t, true, result.StructuredContent["ok"])
assert.Equal(t, true, result.StructuredContent["resolved"])
require.Len(t, creator.assessCalls, 1)
assert.Equal(t, "f-123", creator.assessCalls[0].FindingID)
assert.Equal(t, "resolved", creator.assessCalls[0].Verdict)
assert.Equal(t, "CPU has returned to 35%", creator.assessCalls[0].Evidence)
}
func TestHandlePatrolResolveFinding_MissingFindingID(t *testing.T) {
creator := &mockPatrolFindingCreator{checked: true}
exec := newPatrolTestExecutor(creator)
result, err := handlePatrolResolveFinding(context.Background(), exec, map[string]interface{}{
agentcapabilities.ReasonArgumentName: "CPU recovered",
})
require.NoError(t, err)
text := extractText(result)
assert.Contains(t, text, "missing required field: finding_id")
}
func TestHandlePatrolResolveFinding_MissingReason(t *testing.T) {
creator := &mockPatrolFindingCreator{checked: true}
exec := newPatrolTestExecutor(creator)
result, err := handlePatrolResolveFinding(context.Background(), exec, map[string]interface{}{
agentcapabilities.FindingIDArgumentName: "f-123",
})
require.NoError(t, err)
text := extractText(result)
assert.Contains(t, text, "missing required field: reason")
}
func TestHandlePatrolResolveFinding_ResolveError(t *testing.T) {
creator := &mockPatrolFindingCreator{
assessFindingFunc: func(input PatrolFindingAssessmentInput) error {
return fmt.Errorf("finding not found: %s", input.FindingID)
},
checked: true,
}
exec := newPatrolTestExecutor(creator)
result, err := handlePatrolResolveFinding(context.Background(), exec, map[string]interface{}{
agentcapabilities.FindingIDArgumentName: "f-nonexistent",
agentcapabilities.ReasonArgumentName: "CPU recovered",
})
require.NoError(t, err)
text := extractText(result)
assert.Contains(t, text, "failed to resolve finding")
assert.Contains(t, text, "finding not found")
}
// --- patrol_get_findings tests ---
func TestHandlePatrolGetFindings_NilCreator(t *testing.T) {
exec := NewPulseToolExecutor(ExecutorConfig{})
result, err := handlePatrolGetFindings(context.Background(), exec, map[string]interface{}{})
require.NoError(t, err)
text := extractText(result)
assert.Contains(t, text, "only available during a patrol run")
}
func TestHandlePatrolGetFindings_EmptyResult(t *testing.T) {
creator := &mockPatrolFindingCreator{}
exec := newPatrolTestExecutor(creator)
result, err := handlePatrolGetFindings(context.Background(), exec, map[string]interface{}{})
require.NoError(t, err)
var parsed map[string]interface{}
text := extractText(result)
require.NoError(t, json.Unmarshal([]byte(text), &parsed))
assert.Equal(t, true, parsed["ok"])
assert.Equal(t, float64(0), parsed["count"])
assert.Equal(t, true, result.StructuredContent["ok"])
assert.Equal(t, "0", fmt.Sprint(result.StructuredContent["count"]))
}
func TestHandlePatrolGetFindings_WithFindings(t *testing.T) {
creator := &mockPatrolFindingCreator{
getActiveFn: func(resourceID, minSeverity string) []PatrolFindingInfo {
return []PatrolFindingInfo{
{
ID: "f-1",
Key: "high-cpu",
Severity: "warning",
Category: "performance",
ResourceID: "node/pve1",
ResourceName: "pve1",
ResourceType: "node",
Title: "High CPU on pve1",
DetectedAt: "2024-01-15T10:00:00Z",
},
{
ID: "f-2",
Key: "high-disk",
Severity: "critical",
Category: "capacity",
ResourceID: "node/pve2",
ResourceName: "pve2",
ResourceType: "node",
Title: "Disk almost full on pve2",
DetectedAt: "2024-01-15T09:00:00Z",
},
}
},
}
exec := newPatrolTestExecutor(creator)
result, err := handlePatrolGetFindings(context.Background(), exec, map[string]interface{}{})
require.NoError(t, err)
var parsed map[string]interface{}
text := extractText(result)
require.NoError(t, json.Unmarshal([]byte(text), &parsed))
assert.Equal(t, true, parsed["ok"])
assert.Equal(t, float64(2), parsed["count"])
assert.Equal(t, true, result.StructuredContent["ok"])
assert.Equal(t, "2", fmt.Sprint(result.StructuredContent["count"]))
findings := parsed["findings"].([]interface{})
require.Len(t, findings, 2)
f1 := findings[0].(map[string]interface{})
assert.Equal(t, "f-1", f1["id"])
assert.Equal(t, "high-cpu", f1["key"])
assert.Equal(t, "warning", f1["severity"])
f2 := findings[1].(map[string]interface{})
assert.Equal(t, "f-2", f2["id"])
assert.Equal(t, "critical", f2["severity"])
}
func TestHandlePatrolGetFindings_WithFilters(t *testing.T) {
creator := &mockPatrolFindingCreator{
getActiveFn: func(resourceID, minSeverity string) []PatrolFindingInfo {
// Verify filters are passed through
return nil
},
}
exec := newPatrolTestExecutor(creator)
_, err := handlePatrolGetFindings(context.Background(), exec, map[string]interface{}{
"resource_id": "node/pve1",
"severity": "warning",
})
require.NoError(t, err)
require.Len(t, creator.getCalls, 1)
assert.Equal(t, "node/pve1", creator.getCalls[0].ResourceID)
assert.Equal(t, "warning", creator.getCalls[0].MinSeverity)
}
func TestHandlePatrolGetFindings_NoFilters(t *testing.T) {
creator := &mockPatrolFindingCreator{}
exec := newPatrolTestExecutor(creator)
_, err := handlePatrolGetFindings(context.Background(), exec, map[string]interface{}{})
require.NoError(t, err)
require.Len(t, creator.getCalls, 1)
assert.Equal(t, "", creator.getCalls[0].ResourceID)
assert.Equal(t, "", creator.getCalls[0].MinSeverity)
}
// --- SetPatrolFindingCreator tests ---
func TestSetPatrolFindingCreator(t *testing.T) {
exec := NewPulseToolExecutor(ExecutorConfig{})
// Initially nil
assert.Nil(t, exec.GetPatrolFindingCreator())
// Set a creator
creator := &mockPatrolFindingCreator{}
exec.SetPatrolFindingCreator(creator)
assert.NotNil(t, exec.GetPatrolFindingCreator())
assert.False(t, exec.PatrolFindingSnapshotEstablished())
creator.GetActiveFindings("", "")
assert.True(t, exec.PatrolFindingSnapshotEstablished())
// Clear it
exec.SetPatrolFindingCreator(nil)
assert.Nil(t, exec.GetPatrolFindingCreator())
assert.False(t, exec.PatrolFindingSnapshotEstablished())
}
func TestPulseAlertsFindingsSatisfiesPatrolDuplicateCheck(t *testing.T) {
creator := &mockPatrolFindingCreator{}
exec := newPatrolTestExecutor(creator)
result, err := exec.executeListFindings(context.Background(), map[string]interface{}{
"resource_type": "app-container",
"limit": 100,
})
assert.NoError(t, err)
assert.False(t, result.IsError)
assert.True(t, creator.HasCheckedFindings())
report, err := handlePatrolReportFinding(context.Background(), exec, validReportArgs())
assert.NoError(t, err)
assert.False(t, report.IsError)
}
// --- Tool registration tests ---
func TestPatrolToolsRegistered(t *testing.T) {
exec := NewPulseToolExecutor(ExecutorConfig{})
// Patrol tools should be registered but availability depends on patrolFindingCreator
tools := exec.registry.ListTools(InvocationPolicy{
ControlLevel: ControlLevelReadOnly,
PulseStateAllowlist: patrolDetectionPulseStateAllowlist(),
Profile: ProfilePatrolDetection,
})
found := map[string]bool{}
var resolveTool Tool
var reportTool Tool
var getFindingsTool Tool
for _, tool := range tools {
if tool.Name == "patrol_report_finding" || tool.Name == "patrol_assess_finding" || tool.Name == "patrol_resolve_finding" || tool.Name == "patrol_get_findings" || tool.Name == "patrol_propose_observer" {
found[tool.Name] = true
}
if tool.Name == "patrol_resolve_finding" {
resolveTool = tool
}
if tool.Name == "patrol_report_finding" {
reportTool = tool
}
if tool.Name == "patrol_get_findings" {
getFindingsTool = tool
}
}
assert.True(t, found["patrol_report_finding"], "patrol_report_finding should be registered")
assert.True(t, found["patrol_assess_finding"], "patrol_assess_finding should be registered")
assert.False(t, found["patrol_resolve_finding"], "legacy direct resolve must not be projected into Patrol detection")
assert.True(t, found["patrol_get_findings"], "patrol_get_findings should be registered")
assert.True(t, found["patrol_propose_observer"], "patrol_propose_observer should be registered")
for _, tool := range exec.registry.ListTools(InvocationPolicy{
ControlLevel: ControlLevelControlled,
PulseStateAllowlist: map[string]bool{
agentcapabilities.PatrolResolveFindingToolName: true,
},
Profile: ProfileInteractiveAssistant,
}) {
if tool.Name == agentcapabilities.PatrolResolveFindingToolName {
resolveTool = tool
}
}
require.NotEmpty(t, resolveTool.Name)
assert.Contains(t, resolveTool.InputSchema.Required, agentcapabilities.FindingIDArgumentName)
assert.Contains(t, resolveTool.InputSchema.Required, agentcapabilities.ReasonArgumentName)
assert.Contains(t, resolveTool.InputSchema.Properties, agentcapabilities.FindingIDArgumentName)
assert.Contains(t, resolveTool.InputSchema.Properties, agentcapabilities.ReasonArgumentName)
require.NotEmpty(t, reportTool.Name)
assert.Contains(t, reportTool.Description, "failed health check")
assert.Contains(t, reportTool.Description, "root cause is unknown")
assert.Contains(t, reportTool.Description, "safe, actionable recommendation")
assert.Equal(t, PatrolReportFindingRequiredArguments(), reportTool.InputSchema.Required)
assert.Contains(t, reportTool.Description, strings.Join(PatrolReportFindingRequiredArguments(), ", "))
assert.Contains(t, reportTool.Description, "real-time alerts own that condition")
assert.Contains(t, reportTool.Description, "reporting several findings in parallel")
assert.Contains(t, reportTool.InputSchema.Required, "recommendation")
assert.Contains(t, reportTool.InputSchema.Required, "evidence")
assert.NotContains(t, reportTool.InputSchema.Required, "impact")
require.NotEmpty(t, getFindingsTool.Name)
assert.Contains(t, getFindingsTool.Description, "exactly once")
}
func TestPatrolReportFindingRequiredArgumentsReturnsCopy(t *testing.T) {
first := PatrolReportFindingRequiredArguments()
first[0] = "mutated"
second := PatrolReportFindingRequiredArguments()
assert.Equal(t, "key", second[0])
}
func TestPatrolToolsAvailability(t *testing.T) {
exec := NewPulseToolExecutor(ExecutorConfig{})
// Without creator, patrol tools should not be available
assert.False(t, exec.isToolAvailable("patrol_report_finding"))
assert.False(t, exec.isToolAvailable("patrol_assess_finding"))
assert.False(t, exec.isToolAvailable("patrol_resolve_finding"))
assert.False(t, exec.isToolAvailable("patrol_get_findings"))
assert.False(t, exec.isToolAvailable("patrol_propose_observer"))
// Set creator
exec.SetPatrolFindingCreator(&mockPatrolFindingCreator{})
exec.SetPatrolObserverProposer(&mockPatrolObserverProposer{})
// Now they should be available
assert.True(t, exec.isToolAvailable("patrol_report_finding"))
assert.True(t, exec.isToolAvailable("patrol_assess_finding"))
assert.True(t, exec.isToolAvailable("patrol_resolve_finding"))
assert.True(t, exec.isToolAvailable("patrol_get_findings"))
assert.True(t, exec.isToolAvailable("patrol_propose_observer"))
}
func TestPatrolProposeObserverRecordsProposalWithoutInstallation(t *testing.T) {
proposer := &mockPatrolObserverProposer{result: PatrolObserverProposalResult{
ObjectiveID: "objective-1", Revision: 2, ObserverID: "observer-1", Version: 1,
State: "proposed", ArtifactDigest: "sha256:abc", CoverageState: "uncovered", CoverageReason: "observer_proposed",
}}
exec := NewPulseToolExecutor(ExecutorConfig{})
exec.ApplyExecutionProfile(ProfilePatrolDetection)
exec.SetPatrolObserverProposer(proposer)
result, err := exec.ExecuteTool(context.Background(), agentcapabilities.PatrolProposeObserverToolName, map[string]interface{}{
"objective_id": "objective-1", "expected_revision": float64(1),
"evidence_fit": "proxy", "interpretation": "Detect buffering", "trigger_kind": "event",
"probe_json": `{"source":"playback-events"}`,
"wake_evidence": "buffering begins", "requirements_json": `{}`,
})
if err != nil {
t.Fatalf("execute proposal tool: %v", err)
}
if result.IsError {
t.Fatalf("proposal tool returned error: %s", extractText(result))
}
if proposer.input.ObjectiveID != "objective-1" || proposer.input.ExpectedRevision != 1 || proposer.input.EvidenceFit != "proxy" || proposer.input.TriggerKind != "event" {
t.Fatalf("proposal input = %+v", proposer.input)
}
if text := extractText(result); !strings.Contains(text, `"state":"proposed"`) || !strings.Contains(text, `"coverage_state":"uncovered"`) {
t.Fatalf("proposal result = %s", text)
}
}
// --- Helper ---
func extractText(result CallToolResult) string {
if len(result.Content) == 0 {
return ""
}
return result.Content[0].Text
}