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 chat
import (
"context"
"testing"
"github.com/rcourtman/pulse-go-rewrite/internal/agentexec"
"github.com/rcourtman/pulse-go-rewrite/internal/ai/providers"
"github.com/rcourtman/pulse-go-rewrite/internal/ai/tools"
"github.com/rcourtman/pulse-go-rewrite/internal/config"
"github.com/rcourtman/pulse-go-rewrite/internal/models"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/mock"
"github.com/stretchr/testify/require"
)
// Mock StateProvider
type mockStateProvider struct {
state models.StateSnapshot
}
func (m *mockStateProvider) ReadSnapshot() models.StateSnapshot {
return m.state
}
// Mock CommandPolicy
type mockCommandPolicy struct{}
func (m *mockCommandPolicy) Evaluate(command string) agentexec.PolicyDecision {
return agentexec.PolicyAllow
}
// Mock AgentServer
type mockAgentServer struct{}
func (m *mockAgentServer) GetConnectedAgents() []agentexec.ConnectedAgent {
return []agentexec.ConnectedAgent{}
}
func (m *mockAgentServer) ExecuteCommand(ctx context.Context, agentID string, cmd agentexec.ExecuteCommandPayload) (*agentexec.CommandResultPayload, error) {
return &agentexec.CommandResultPayload{}, nil
}
func hasTool(toolsList []tools.Tool, name string) bool {
for _, tool := range toolsList {
if tool.Name == name {
return true
}
}
return false
}
func hasProviderTool(toolsList []providers.Tool, name string) bool {
for _, tool := range toolsList {
if tool.Name == name {
return true
}
}
return false
}
func TestNewService(t *testing.T) {
cfg := Config{
AIConfig: &config.AIConfig{
Enabled: true,
OpenAIAPIKey: "sk-test",
ChatModel: "openai:gpt-4",
},
StateProvider: &mockStateProvider{},
Policy: &mockCommandPolicy{},
AgentServer: &mockAgentServer{},
}
service := NewService(cfg)
assert.NotNil(t, service)
assert.NotNil(t, service.executor)
assert.False(t, service.IsRunning())
}
func TestService_StartStop(t *testing.T) {
tmpDir := t.TempDir()
cfg := Config{
AIConfig: &config.AIConfig{
Enabled: true,
OpenAIAPIKey: "sk-test",
ChatModel: "openai:gpt-4",
},
StateProvider: &mockStateProvider{},
DataDir: tmpDir,
}
service := NewService(cfg)
ctx := context.Background()
// Start
err := service.Start(ctx)
assert.NoError(t, err)
assert.True(t, service.IsRunning())
assert.NotNil(t, service.sessions)
assert.NotNil(t, service.agenticLoop)
// Idempotent Start
err = service.Start(ctx)
assert.NoError(t, err)
// Stop
err = service.Stop(ctx)
assert.NoError(t, err)
assert.False(t, service.IsRunning())
}
func TestService_Restart(t *testing.T) {
tmpDir := t.TempDir()
cfg := Config{
AIConfig: &config.AIConfig{
Enabled: true,
OpenAIAPIKey: "sk-test",
ChatModel: "openai:gpt-4",
},
StateProvider: &mockStateProvider{},
DataDir: tmpDir,
}
service := NewService(cfg)
ctx := context.Background()
_ = service.Start(ctx)
newCfg := &config.AIConfig{
Enabled: true,
AnthropicAPIKey: "chk-test",
ChatModel: "anthropic:claude-3",
}
err := service.Restart(ctx, newCfg)
assert.NoError(t, err)
assert.True(t, service.IsRunning())
assert.Equal(t, "anthropic:claude-3", service.cfg.GetChatModel())
}
func TestService_CreateProvider(t *testing.T) {
tests := []struct {
name string
config *config.AIConfig
expectErr bool
}{
{
name: "OpenAI",
config: &config.AIConfig{
OpenAIAPIKey: "sk-test",
ChatModel: "openai:gpt-4",
},
expectErr: false,
},
{
name: "OpenRouter",
config: &config.AIConfig{
OpenRouterAPIKey: "sk-or-test",
ChatModel: "openrouter:openai/gpt-4o-mini",
},
expectErr: false,
},
{
name: "Anthropic",
config: &config.AIConfig{
AnthropicAPIKey: "chk-test",
ChatModel: "anthropic:claude-3",
},
expectErr: false,
},
{
name: "Ollama",
config: &config.AIConfig{
OllamaBaseURL: "http://localhost:11434",
ChatModel: "ollama:llama3",
},
expectErr: false,
},
{
name: "Missing Model",
config: &config.AIConfig{
ChatModel: "",
},
expectErr: true,
},
{
name: "Invalid Model Format",
config: &config.AIConfig{
ChatModel: "gpt-4",
},
expectErr: true,
},
{
name: "Unsupported Provider",
config: &config.AIConfig{
ChatModel: "unknown:model",
},
expectErr: true,
},
{
name: "Missing API Key",
config: &config.AIConfig{
OpenAIAPIKey: "",
ChatModel: "openai:gpt-4",
},
expectErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := &Service{cfg: tt.config}
p, err := s.createProvider()
if tt.expectErr {
assert.Error(t, err)
} else {
assert.NoError(t, err)
assert.NotNil(t, p)
}
})
}
}
func TestServiceCreateProviderRejectsUnusableConfiguredChatModelWithoutRewrite(t *testing.T) {
cfg := &config.AIConfig{
OpenAIAPIKey: "sk-test",
ChatModel: "openai:gpt-realtime-2",
}
service := &Service{cfg: cfg}
provider, err := service.createProvider()
assert.Error(t, err)
assert.Nil(t, provider)
assert.Contains(t, err.Error(), "selected chat model route")
assert.Equal(t, "openai:gpt-realtime-2", cfg.ChatModel)
}
func TestService_ExecuteStream_Failures(t *testing.T) {
service := &Service{}
err := service.ExecuteStream(context.Background(), ExecuteRequest{}, nil)
assert.Error(t, err)
assert.Contains(t, err.Error(), "service not started")
}
func TestService_Start_Failures(t *testing.T) {
t.Run("NilConfig", func(t *testing.T) {
s := &Service{cfg: nil}
err := s.Start(context.Background())
assert.Error(t, err)
assert.Contains(t, err.Error(), "Pulse Assistant config is nil")
})
t.Run("InvalidProvider", func(t *testing.T) {
cfg := Config{
AIConfig: &config.AIConfig{
ChatModel: "unknown:model",
},
DataDir: t.TempDir(),
}
s := NewService(cfg)
err := s.Start(context.Background())
assert.Error(t, err)
assert.Contains(t, err.Error(), "failed to create provider")
})
}
func TestService_SessionWrappers(t *testing.T) {
tmpDir := t.TempDir()
cfg := Config{
AIConfig: &config.AIConfig{
Enabled: true,
OpenAIAPIKey: "test-key",
ChatModel: "openai:gpt-4",
},
StateProvider: &mockStateProvider{},
DataDir: tmpDir,
}
service := NewService(cfg)
ctx := context.Background()
// Wrappers fail if service not started
_, err := service.CreateSession(ctx)
assert.Error(t, err)
assert.Contains(t, err.Error(), "service not started")
_, err = service.RenameSession(ctx, "missing", "Renamed session")
assert.Error(t, err)
assert.Contains(t, err.Error(), "service not started")
// Start service
err = service.Start(ctx)
require.NoError(t, err)
// Create Session
session, err := service.CreateSession(ctx)
require.NoError(t, err)
assert.NotEmpty(t, session.ID)
// Note: Service does not expose GetSession or AddMessage directly in its public API
// so we cannot test them as wrappers here. They are used internally by ExecuteStream.
// Get Messages
msgs, err := service.GetMessages(ctx, session.ID)
require.NoError(t, err)
assert.Empty(t, msgs) // Initially empty
require.NoError(t, service.sessions.AddMessage(session.ID, Message{
Role: "assistant",
Content: "I will inspect the device nodes.\npulse_read(target_host=\"current_resource\", command=\"ls /dev | wc -l\")",
ReasoningContent: "We need to inspect the user's prompt before answering.",
}))
msgs, err = service.GetMessages(ctx, session.ID)
require.NoError(t, err)
require.Len(t, msgs, 1)
assert.Equal(t, "I will inspect the device nodes.", msgs[0].Content)
assert.Empty(t, msgs[0].ReasoningContent)
assert.NotContains(t, msgs[0].Content, "pulse_read")
assert.NotContains(t, msgs[0].Content, "target_host")
// List Sessions
list, err := service.ListSessions(ctx)
require.NoError(t, err)
assert.Len(t, list, 1)
renamed, err := service.RenameSession(ctx, session.ID, "Renamed session")
require.NoError(t, err)
require.NotNil(t, renamed)
assert.Equal(t, "Renamed session", renamed.Title)
list, err = service.ListSessions(ctx)
require.NoError(t, err)
require.Len(t, list, 1)
assert.Equal(t, "Renamed session", list[0].Title)
// Delete Session
err = service.DeleteSession(ctx, session.ID)
require.NoError(t, err)
// Verify deletion via List
list, err = service.ListSessions(ctx)
require.NoError(t, err)
assert.Len(t, list, 0)
}
func TestServiceGetMessagesProjectsToolResultsIntoAssistantToolCalls(t *testing.T) {
tmpDir := t.TempDir()
cfg := Config{
AIConfig: &config.AIConfig{
Enabled: true,
OpenAIAPIKey: "test-key",
ChatModel: "openai:gpt-4",
},
StateProvider: &mockStateProvider{},
DataDir: tmpDir,
}
service := NewService(cfg)
ctx := context.Background()
require.NoError(t, service.Start(ctx))
session, err := service.CreateSession(ctx)
require.NoError(t, err)
require.NoError(t, service.sessions.AddMessage(session.ID, Message{
ID: "user-1",
Role: "user",
Content: "check storage",
}))
require.NoError(t, service.sessions.AddMessage(session.ID, Message{
ID: "assistant-1",
Role: "assistant",
Content: "I checked storage.",
Model: "openrouter:qwen/qwen3.7-plus",
ToolCalls: []ToolCall{
{
ID: "call-ok",
Name: "pulse_query",
Input: map[string]interface{}{"action": "topology"},
},
{
ID: "call-fail",
Name: "pulse_read",
Input: map[string]interface{}{"target": "vm-100"},
},
},
}))
require.NoError(t, service.sessions.AddMessage(session.ID, Message{
ID: "tool-result-ok",
Role: "user",
ToolResult: &ToolResult{
ToolUseID: "call-ok",
Content: "topology ok",
},
}))
require.NoError(t, service.sessions.AddMessage(session.ID, Message{
ID: "tool-result-fail",
Role: "user",
ToolResult: &ToolResult{
ToolUseID: "call-fail",
Content: "permission denied",
IsError: true,
},
}))
messages, err := service.GetMessages(ctx, session.ID)
require.NoError(t, err)
require.Len(t, messages, 2)
assert.Equal(t, "user", messages[0].Role)
assert.Equal(t, "assistant", messages[1].Role)
assert.Nil(t, messages[0].ToolResult)
assert.Nil(t, messages[1].ToolResult)
assert.Equal(t, "openrouter:qwen/qwen3.7-plus", messages[1].Model)
require.Len(t, messages[1].ToolCalls, 2)
assert.Equal(t, "topology ok", messages[1].ToolCalls[0].Output)
require.NotNil(t, messages[1].ToolCalls[0].Success)
assert.True(t, *messages[1].ToolCalls[0].Success)
assert.Equal(t, "permission denied", messages[1].ToolCalls[1].Output)
require.NotNil(t, messages[1].ToolCalls[1].Success)
assert.False(t, *messages[1].ToolCalls[1].Success)
}
func TestServiceStreamDirectAssistantAnswerPersistsLocalModelRoute(t *testing.T) {
tmpDir := t.TempDir()
cfg := Config{
AIConfig: &config.AIConfig{
Enabled: true,
OpenAIAPIKey: "test-key",
ChatModel: "openai:gpt-4",
},
StateProvider: &mockStateProvider{},
DataDir: tmpDir,
}
service := NewService(cfg)
ctx := context.Background()
require.NoError(t, service.Start(ctx))
session, err := service.CreateSession(ctx)
require.NoError(t, err)
var events []StreamEvent
service.streamDirectAssistantAnswer(service.sessions, session.ID, "Pulse sees 33 compute resources.", func(event StreamEvent) {
events = append(events, event)
})
messages, err := service.GetMessages(ctx, session.ID)
require.NoError(t, err)
require.Len(t, messages, 1)
assert.Equal(t, assistantLocalInventoryModelRoute, messages[0].Model)
assert.Equal(t, "Pulse sees 33 compute resources.", messages[0].Content)
require.Len(t, events, 2)
assert.Equal(t, "content", events[0].Type)
assert.Equal(t, "done", events[1].Type)
}
func TestService_Adapters(t *testing.T) {
// Test CommandPolicyAdapter
mockPolicy := &mockCommandPolicy{}
cpAdapter := &commandPolicyAdapter{p: mockPolicy}
decision := cpAdapter.Evaluate("echo hello")
assert.Equal(t, agentexec.PolicyAllow, decision)
// Test AgentServerAdapter
mockAgent := &mockAgentServer{}
asAdapter := &agentServerAdapter{s: mockAgent}
// GetConnectedAgents
agents := asAdapter.GetConnectedAgents()
assert.Empty(t, agents)
// ExecuteCommand
res, err := asAdapter.ExecuteCommand(context.Background(), "agent1", agentexec.ExecuteCommandPayload{})
assert.NoError(t, err)
assert.NotNil(t, res)
}
func TestService_ExtendedMethods(t *testing.T) {
cfg := Config{
AIConfig: &config.AIConfig{Enabled: true},
StateProvider: &mockStateProvider{},
}
service := NewService(cfg)
ctx := context.Background()
// 1. GetBaseURL
url := service.GetBaseURL()
assert.Equal(t, "", url)
// 2. AbortSession
err := service.AbortSession(ctx, "s1")
assert.Error(t, err) // Service not started
}
func TestService_AbortSession_UsesRegisteredActiveLoops(t *testing.T) {
service := &Service{
started: true,
activeExecutions: make(map[string]map[*AgenticLoop]struct{}),
}
loop := &AgenticLoop{
aborted: make(map[string]bool),
}
service.registerActiveLoop("session-live", loop)
err := service.AbortSession(context.Background(), "session-live")
require.NoError(t, err)
assert.True(t, loop.aborted["session-live"])
}
func TestService_SettersAndUpdateControlSettings(t *testing.T) {
service := NewService(Config{
AIConfig: &config.AIConfig{ControlLevel: config.ControlLevelReadOnly},
// Control policy is tested with canonical planning wired below.
AgentServer: &mockAgentServer{},
StateProvider: &mockStateProvider{},
})
service.SetTypedActionPlanner(&gateTestPlanner{})
require.NotNil(t, service.executor)
// In read-only mode, pulse_control is not available
assert.False(t, hasTool(service.executor.ListTools(), "pulse_control"))
service.SetAlertProvider(nil)
service.SetFindingsProvider(nil)
service.SetBaselineProvider(nil)
service.SetPatternProvider(nil)
service.SetMetricsHistory(nil)
service.SetBackupProvider(nil)
service.SetDiskHealthProvider(nil)
service.SetUpdatesProvider(nil)
service.SetAgentProfileManager(nil)
service.SetFindingsManager(nil)
service.SetMetadataUpdater(nil)
service.UpdateControlSettings(nil)
service.UpdateControlSettings(&config.AIConfig{
ControlLevel: config.ControlLevelControlled,
})
// After updating to controlled mode, pulse_control should be available
assert.True(t, hasTool(service.executor.ListTools(), "pulse_control"))
}
func TestService_ToolsForExecutionMode_ExposesGovernedTools(t *testing.T) {
service := NewService(Config{
AIConfig: &config.AIConfig{ControlLevel: config.ControlLevelControlled},
StateProvider: &mockStateProvider{},
AgentServer: &mockAgentServer{},
})
service.SetTypedActionPlanner(&gateTestPlanner{})
// After tool consolidation: pulse_control handles commands and guest control,
// pulse_docker handles Docker operations
require.True(t, hasTool(service.executor.ListTools(), "pulse_control"))
require.True(t, hasTool(service.executor.ListTools(), "pulse_docker"))
require.True(t, hasTool(service.executor.ListTools(), "pulse_query"))
filtered := service.toolsForExecutor(nil, true)
assert.True(t, hasProviderTool(filtered, "pulse_control"))
assert.True(t, hasProviderTool(filtered, "pulse_docker"))
assert.True(t, hasProviderTool(filtered, "pulse_query"))
}
func TestService_ToolsForExecutionMode_InteractiveOmitsQuestionTool(t *testing.T) {
service := NewService(Config{
AIConfig: &config.AIConfig{ControlLevel: config.ControlLevelControlled},
StateProvider: &mockStateProvider{},
AgentServer: &mockAgentServer{},
})
service.SetTypedActionPlanner(&gateTestPlanner{})
require.True(t, hasTool(service.executor.ListTools(), "pulse_control"))
require.True(t, hasTool(service.executor.ListTools(), "pulse_docker"))
require.True(t, hasTool(service.executor.ListTools(), "pulse_query"))
filtered := service.toolsForExecutor(nil, false)
assert.True(t, hasProviderTool(filtered, "pulse_control"))
assert.True(t, hasProviderTool(filtered, "pulse_docker"))
assert.True(t, hasProviderTool(filtered, "pulse_query"))
// No Pulse client can answer pulse_question since the web chat was retired.
assert.False(t, hasProviderTool(filtered, pulseQuestionToolName))
}
func TestService_Execute_NonStreaming(t *testing.T) {
tmpDir := t.TempDir()
store, err := NewSessionStore(tmpDir)
require.NoError(t, err)
mockProvider := &MockProvider{}
mockProvider.On("ChatStream", mock.Anything, mock.Anything, mock.Anything).
Return(nil).
Run(func(args mock.Arguments) {
callback := args.Get(2).(providers.StreamCallback)
callback(providers.StreamEvent{Type: "content", Data: providers.ContentEvent{Text: "Hello"}})
callback(providers.StreamEvent{Type: "done", Data: providers.DoneEvent{}})
}).
Once()
// First-exchange completion triggers background session-title generation.
mockProvider.On("Chat", mock.Anything, mock.Anything).
Return(&providers.ChatResponse{Content: "Greeting check"}, nil)
mockProvider.On("Name").Return("mock").Maybe()
executor := tools.NewPulseToolExecutor(tools.ExecutorConfig{})
service := &Service{
executor: executor,
sessions: store,
agenticLoop: NewAgenticLoop(mockProvider, executor, "prompt"),
provider: mockProvider,
started: true,
}
resp, err := service.Execute(context.Background(), ExecuteRequest{Prompt: "Hi"})
require.NoError(t, err)
assert.Equal(t, "Hello", resp["content"])
mockProvider.AssertExpectations(t)
}