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 ai
import (
"context"
"testing"
"time"
"github.com/rcourtman/pulse-go-rewrite/internal/ai/circuit"
"github.com/rcourtman/pulse-go-rewrite/internal/ai/knowledge"
"github.com/rcourtman/pulse-go-rewrite/internal/config"
)
type mockLearningProvider struct{}
func (m mockLearningProvider) FormatForContext() string { return "prefs" }
type mockProxmoxEventProvider struct{}
func (m mockProxmoxEventProvider) FormatForPatrol(duration time.Duration) string { return "events" }
type mockForecastProvider struct{}
func (m mockForecastProvider) FormatKeyForecasts() string { return "forecast" }
type stubInvestigationOrchestrator struct {
maxTurns int
timeout time.Duration
}
func (s *stubInvestigationOrchestrator) InvestigateFinding(ctx context.Context, finding *InvestigationFinding, autonomyLevel string) error {
return nil
}
func (s *stubInvestigationOrchestrator) GetInvestigationByFinding(findingID string) *InvestigationSession {
return nil
}
func (s *stubInvestigationOrchestrator) GetRunningCount() int { return 0 }
func (s *stubInvestigationOrchestrator) GetFixedCount() int { return 0 }
func (s *stubInvestigationOrchestrator) CanStartInvestigation() bool { return true }
func (s *stubInvestigationOrchestrator) ReinvestigateFinding(ctx context.Context, findingID, autonomyLevel string) error {
return nil
}
func (s *stubInvestigationOrchestrator) Shutdown(ctx context.Context) error { return nil }
func (s *stubInvestigationOrchestrator) SetInvestigationExecutionLimits(maxTurns int, timeout time.Duration) {
s.maxTurns = maxTurns
s.timeout = timeout
}
func TestApplyPatrolAutonomyConfigPublishesInvestigationExecutionLimits(t *testing.T) {
orchestrator := &stubInvestigationOrchestrator{}
patrol := &PatrolService{investigationOrchestrator: orchestrator}
service := &Service{
cfg: config.NewDefaultAIConfig(),
patrolService: patrol,
}
next := config.NewDefaultAIConfig()
next.PatrolAutonomyLevel = config.PatrolAutonomyApproval
next.PatrolInvestigationBudget = 27
next.PatrolInvestigationTimeoutSec = 420
if err := service.ApplyPatrolAutonomyConfig(next); err != nil {
t.Fatalf("ApplyPatrolAutonomyConfig: %v", err)
}
if orchestrator.maxTurns != 27 {
t.Fatalf("investigation max turns = %d, want 27", orchestrator.maxTurns)
}
if orchestrator.timeout != 7*time.Minute {
t.Fatalf("investigation timeout = %s, want 7m", orchestrator.timeout)
}
}
func TestPatrolService_Setters(t *testing.T) {
ps := NewPatrolService(nil, nil)
ks := &knowledge.Store{}
ps.SetKnowledgeStore(ks)
if ps.GetKnowledgeStore() != ks {
t.Fatalf("expected knowledge store to be set")
}
lp := mockLearningProvider{}
ps.SetLearningProvider(lp)
if ps.learningProvider == nil {
t.Fatalf("expected learning provider to be set")
}
pep := mockProxmoxEventProvider{}
ps.SetProxmoxEventProvider(pep)
if ps.proxmoxEventProvider == nil {
t.Fatalf("expected proxmox event provider to be set")
}
fp := mockForecastProvider{}
ps.SetForecastProvider(fp)
if ps.forecastProvider == nil {
t.Fatalf("expected forecast provider to be set")
}
tm := NewTriggerManager(TriggerManagerConfig{MaxPendingTriggers: 1})
ps.SetTriggerManager(tm)
if ps.GetTriggerManager() == nil {
t.Fatalf("expected trigger manager to be set")
}
}
func TestPatrolService_AdditionalSetters(t *testing.T) {
ps := NewPatrolService(nil, nil)
breaker := circuit.NewBreaker("test", circuit.Config{})
ps.SetCircuitBreaker(breaker)
if ps.circuitBreaker != breaker {
t.Fatalf("expected circuit breaker to be set")
}
engine := newTestRemediationEngine()
ps.SetRemediationEngine(engine)
if ps.GetRemediationEngine() != engine {
t.Fatalf("expected remediation engine to be set")
}
orchestrator := &stubInvestigationOrchestrator{}
ps.SetInvestigationOrchestrator(orchestrator)
if ps.GetInvestigationOrchestrator() != orchestrator {
t.Fatalf("expected investigation orchestrator to be set")
}
callbackCalled := false
ps.SetUnifiedFindingCallback(func(f *Finding) bool {
callbackCalled = true
return true
})
if ps.unifiedFindingCallback == nil {
t.Fatalf("expected unified finding callback to be set")
}
ps.unifiedFindingCallback(&Finding{})
if !callbackCalled {
t.Fatalf("expected unified finding callback to be invoked")
}
var resolvedID string
ps.SetUnifiedFindingResolver(func(id string) {
resolvedID = id
})
if ps.unifiedFindingResolver == nil {
t.Fatalf("expected unified finding resolver to be set")
}
ps.unifiedFindingResolver("finding-1")
if resolvedID != "finding-1" {
t.Fatalf("expected unified finding resolver to capture id, got %q", resolvedID)
}
}