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 agentcapabilities
import (
"encoding/json"
"net/http"
"slices"
"strings"
"testing"
)
func TestPatrolScopedDetectionDefersOptionalDeepReadsToInvestigation(t *testing.T) {
detection, ok := PatrolDetectionToolNamesForResourceTypes([]string{"vm"})
if !ok {
t.Fatal("vm scope was not recognized")
}
if slices.Contains(detection, PulseReadToolName) {
t.Fatalf("Watch detection surface included optional agent-routed deep read: %v", detection)
}
for _, required := range []string{PulseQueryToolName, PulseMetricsToolName, PatrolReportFindingToolName, PatrolAssessFindingToolName} {
if !slices.Contains(detection, required) {
t.Fatalf("VM detection surface missing %q: %v", required, detection)
}
}
if slices.Contains(detection, PatrolResolveFindingToolName) {
t.Fatalf("Watch detection surface exposed the legacy direct resolver: %v", detection)
}
investigation, ok := PatrolInvestigationToolNamesForResourceTypes([]string{"vm"})
if !ok || !slices.Contains(investigation, PulseReadToolName) {
t.Fatalf("VM investigation surface lost optional deep-read preference: %v, ok=%v", investigation, ok)
}
}
func TestPatrolInfrastructureEvidenceToolVocabularyExcludesDerivedContext(t *testing.T) {
for _, name := range []string{
PulseQueryToolName,
PulseMetricsToolName,
PulseStorageToolName,
PulseDockerToolName,
PulseKubernetesToolName,
PulseReadToolName,
PulsePMGToolName,
} {
if !IsPatrolInfrastructureEvidenceToolName(name) {
t.Fatalf("canonical infrastructure evidence tool %q was not classified as evidence", name)
}
}
for _, name := range []string{
"",
PulseAlertsToolName,
PulseKnowledgeToolName,
PulseSummarizeToolName,
PatrolGetFindingsToolName,
PatrolActionCapabilitiesToolName,
PatrolProposeActionToolName,
} {
if IsPatrolInfrastructureEvidenceToolName(name) {
t.Fatalf("derived or planning tool %q was classified as infrastructure evidence", name)
}
}
}
func TestDefaultApprovalPolicyDescriptionUsesSharedPolicyVocabulary(t *testing.T) {
cases := []struct {
policy ApprovalPolicy
want string
}{
{ApprovalPolicyScopeOnly, "required scope is sufficient"},
{ApprovalPolicyActionPlan, "governed action-plan approval is required"},
{ApprovalPolicy("custom"), ""},
}
for _, tc := range cases {
got := DefaultApprovalPolicyDescription(tc.policy)
if tc.want == "" {
if got != "" {
t.Fatalf("DefaultApprovalPolicyDescription(%q) = %q, want empty", tc.policy, got)
}
continue
}
if got == "" || !strings.Contains(got, tc.want) {
t.Fatalf("DefaultApprovalPolicyDescription(%q) = %q, want substring %q", tc.policy, got, tc.want)
}
}
}
func TestToolGovernanceDescriptorUsesSharedVocabulary(t *testing.T) {
descriptor := ToolGovernanceDescriptor{
Name: "pulse_control",
Description: "Run governed control actions.",
RequireControl: true,
ActionMode: ActionModeWrite,
ApprovalPolicy: ApprovalPolicyActionPlan,
ApprovalSummary: "approval required in controlled mode",
Summary: "Runs shared Pulse control actions.",
}
if descriptor.ActionMode != ActionModeWrite {
t.Fatalf("descriptor action mode = %q, want %q", descriptor.ActionMode, ActionModeWrite)
}
if descriptor.ApprovalPolicy != ApprovalPolicyActionPlan {
t.Fatalf("descriptor approval policy = %q, want %q", descriptor.ApprovalPolicy, ApprovalPolicyActionPlan)
}
if !descriptor.RequireControl {
t.Fatal("descriptor must preserve Assistant control gating")
}
}
func TestNormalizeToolGovernanceAppliesSharedDefaults(t *testing.T) {
read := NormalizeToolGovernance(ToolGovernance{}, false, "Read state.")
if read.ActionMode != ActionModeRead {
t.Fatalf("read action mode = %q, want %q", read.ActionMode, ActionModeRead)
}
if read.ApprovalPolicy != ApprovalPolicyScopeOnly {
t.Fatalf("read approval policy = %q, want %q", read.ApprovalPolicy, ApprovalPolicyScopeOnly)
}
if read.ApprovalSummary != "no approval required" {
t.Fatalf("read approval summary = %q", read.ApprovalSummary)
}
if read.Summary != "Read state." {
t.Fatalf("read summary = %q", read.Summary)
}
control := NormalizeToolGovernance(ToolGovernance{}, true, "Run actions.")
if control.ActionMode != ActionModeWrite {
t.Fatalf("control action mode = %q, want %q", control.ActionMode, ActionModeWrite)
}
if control.ApprovalPolicy != ApprovalPolicyActionPlan {
t.Fatalf("control approval policy = %q, want %q", control.ApprovalPolicy, ApprovalPolicyActionPlan)
}
if control.ApprovalSummary != "hidden in read-only mode; approval required in controlled mode" {
t.Fatalf("control approval summary = %q", control.ApprovalSummary)
}
mixed := NormalizeToolGovernance(ToolGovernance{ActionMode: ActionModeMixed}, false, "Mixed actions.")
if mixed.ApprovalPolicy != ApprovalPolicyScopeOnly {
t.Fatalf("mixed approval policy = %q, want %q", mixed.ApprovalPolicy, ApprovalPolicyScopeOnly)
}
if !strings.Contains(mixed.ApprovalSummary, "required scope is sufficient") {
t.Fatalf("mixed approval summary = %q", mixed.ApprovalSummary)
}
}
func TestNormalizeCapabilityGovernanceAppliesSharedDefaults(t *testing.T) {
read := NormalizeCapabilityGovernance(Capability{
Description: "Read capability.",
Method: http.MethodGet,
})
if read.ActionMode != ActionModeRead {
t.Fatalf("read capability action mode = %q, want %q", read.ActionMode, ActionModeRead)
}
if read.ApprovalPolicy != ApprovalPolicyScopeOnly {
t.Fatalf("read capability approval policy = %q, want %q", read.ApprovalPolicy, ApprovalPolicyScopeOnly)
}
if read.ApprovalSummary != "no approval required" {
t.Fatalf("read capability approval summary = %q", read.ApprovalSummary)
}
if read.Summary != "Read capability." {
t.Fatalf("read capability summary = %q", read.Summary)
}
write := NormalizeCapabilityGovernance(Capability{
Description: "Write capability.",
Method: http.MethodPost,
})
if write.ActionMode != ActionModeWrite {
t.Fatalf("write capability action mode = %q, want %q", write.ActionMode, ActionModeWrite)
}
if write.ApprovalPolicy != ApprovalPolicyScopeOnly {
t.Fatalf("write capability approval policy = %q, want %q", write.ApprovalPolicy, ApprovalPolicyScopeOnly)
}
planned := NormalizeCapabilityGovernance(Capability{
Description: "Plan an action.",
Method: http.MethodPost,
ActionMode: ActionModeMixed,
ApprovalPolicy: ApprovalPolicyActionPlan,
})
if planned.ActionMode != ActionModeMixed {
t.Fatalf("explicit capability action mode = %q, want %q", planned.ActionMode, ActionModeMixed)
}
if planned.ApprovalPolicy != ApprovalPolicyActionPlan {
t.Fatalf("explicit capability approval policy = %q, want %q", planned.ApprovalPolicy, ApprovalPolicyActionPlan)
}
if !strings.Contains(planned.ApprovalSummary, "governed action-plan approval is required") {
t.Fatalf("explicit capability approval summary = %q", planned.ApprovalSummary)
}
}
func TestNewToolGovernanceDescriptorAppliesSharedDefaults(t *testing.T) {
descriptor := NewToolGovernanceDescriptor("pulse_control", "Run actions.", true, ToolGovernance{})
if descriptor.Name != "pulse_control" || descriptor.Description != "Run actions." {
t.Fatalf("descriptor identity = %+v", descriptor)
}
if !descriptor.RequireControl {
t.Fatal("descriptor must preserve control gating")
}
if descriptor.ActionMode != ActionModeWrite || descriptor.ApprovalPolicy != ApprovalPolicyActionPlan {
t.Fatalf("descriptor governance = %+v", descriptor)
}
if descriptor.ApprovalSummary != "hidden in read-only mode; approval required in controlled mode" {
t.Fatalf("descriptor approval summary = %q", descriptor.ApprovalSummary)
}
}
// Stored result evidence and provider request arguments are different wire
// contracts. In particular, explicit failure cannot disappear through omitempty.
func TestTranscriptToolCallPreservesResultOutsideProviderRequests(t *testing.T) {
failed := false
call := TranscriptToolCall{ID: "read-1", Name: PulseReadToolName, Output: "NO_AGENT", Success: &failed}.NormalizeCollections()
failed = true
body, err := json.Marshal(call)
if err != nil {
t.Fatal(err)
}
var stored map[string]interface{}
if err := json.Unmarshal(body, &stored); err != nil {
t.Fatal(err)
}
if stored["output"] != "NO_AGENT" || stored["success"] != false || stored["input"] == nil {
t.Fatalf("stored result lost explicit failure or normalized input: %s", body)
}
requestBody, err := json.Marshal(call.ProviderToolCall())
if err != nil {
t.Fatal(err)
}
var request map[string]interface{}
if err := json.Unmarshal(requestBody, &request); err != nil {
t.Fatal(err)
}
for _, key := range []string{"output", "success"} {
if _, exists := request[key]; exists {
t.Fatalf("provider request retained display-only %s: %s", key, requestBody)
}
}
unknownBody, err := json.Marshal(TranscriptToolCall{Name: PulseQueryToolName}.NormalizeCollections())
if err != nil {
t.Fatal(err)
}
var unknown map[string]interface{}
if err := json.Unmarshal(unknownBody, &unknown); err != nil {
t.Fatal(err)
}
if _, exists := unknown["success"]; exists {
t.Fatalf("unknown historical status became a result: %s", unknownBody)
}
}