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.

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