Skip to content

armgit / Pulse

Public Imported from GitHub
0

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.

4.5 KB
Raw Blame
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)
	}
}