Pulse/internal/ai/tools/executor_setters_test.go

package tools

import (
	"context"
	"testing"

	"github.com/rcourtman/pulse-go-rewrite/internal/models"
	"github.com/rcourtman/pulse-go-rewrite/internal/unifiedresources"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

type stubMetadataUpdater struct{}

func (s *stubMetadataUpdater) SetResourceURL(resourceType, resourceID, url string) error {
	return nil
}

type stubAgentProfileManager struct{}

func (s *stubAgentProfileManager) ApplyAgentScope(ctx context.Context, agentID, agentLabel string, settings map[string]interface{}) (string, string, bool, error) {
	return "profile-1", "default", false, nil
}

func (s *stubAgentProfileManager) AssignProfile(ctx context.Context, agentID, profileID string) (string, error) {
	return "default", nil
}

func (s *stubAgentProfileManager) GetAgentScope(ctx context.Context, agentID string) (*AgentScope, error) {
	return &AgentScope{AgentID: agentID}, nil
}

func TestPulseToolExecutor_Setters(t *testing.T) {
	exec := NewPulseToolExecutor(ExecutorConfig{})

	exec.SetContext("vm", "101", true)
	assert.Equal(t, "vm", exec.targetType)
	assert.Equal(t, "101", exec.targetID)
	assert.True(t, exec.isAutonomous)

	exec.SetControlLevel(ControlLevelControlled)
	assert.Equal(t, ControlLevelControlled, exec.controlLevel)

	exec.SetProtectedGuests([]string{"100", "101"})
	assert.Equal(t, []string{"100", "101"}, exec.protectedGuests)

	metadataUpdater := &stubMetadataUpdater{}
	exec.SetMetadataUpdater(metadataUpdater)
	assert.Equal(t, metadataUpdater, exec.metadataUpdater)

	findingsManager := &stubFindingsManager{}
	exec.SetFindingsManager(findingsManager)
	assert.Equal(t, findingsManager, exec.findingsManager)

	metricsHistory := &mockMetricsHistoryProvider{}
	exec.SetMetricsHistory(metricsHistory)
	assert.Equal(t, metricsHistory, exec.metricsHistory)

	baselineProvider := &stubBaselineProvider{}
	exec.SetBaselineProvider(baselineProvider)
	assert.Equal(t, baselineProvider, exec.baselineProvider)

	patternProvider := &stubPatternProvider{}
	exec.SetPatternProvider(patternProvider)
	assert.Equal(t, patternProvider, exec.patternProvider)

	alertProvider := &mockAlertProvider{}
	exec.SetAlertProvider(alertProvider)
	assert.Equal(t, alertProvider, exec.alertProvider)

	findingsProvider := &mockFindingsProvider{}
	exec.SetFindingsProvider(findingsProvider)
	assert.Equal(t, findingsProvider, exec.findingsProvider)

	backupProvider := &stubBackupProvider{}
	exec.SetBackupProvider(backupProvider)
	assert.Equal(t, backupProvider, exec.backupProvider)

	diskHealthProvider := &mockDiskHealthProvider{}
	exec.SetDiskHealthProvider(diskHealthProvider)
	assert.Equal(t, diskHealthProvider, exec.diskHealthProvider)

	agentProfileManager := &stubAgentProfileManager{}
	exec.SetAgentProfileManager(agentProfileManager)
	assert.Equal(t, agentProfileManager, exec.agentProfileManager)

	updatesProvider := &mockUpdatesProvider{}
	exec.SetUpdatesProvider(updatesProvider)
	assert.Equal(t, updatesProvider, exec.updatesProvider)

	actionAuditStore := unifiedresources.NewMemoryStore()
	exec.SetActionAuditStore(actionAuditStore)
	assert.Equal(t, actionAuditStore, exec.actionAuditStore)
}

func TestPulseToolExecutor_ListTools(t *testing.T) {
	exec := NewPulseToolExecutor(ExecutorConfig{})
	tools := exec.ListTools()
	// pulse_query requires state provider, so it should not be available without one
	assert.False(t, containsTool(tools, "pulse_query"))

	execWithState := NewPulseToolExecutor(ExecutorConfig{StateProvider: &mockStateProvider{}})
	stateTools := execWithState.ListTools()
	// With state provider, pulse_query should be available
	assert.True(t, containsTool(stateTools, "pulse_query"))
	assert.False(t, containsTool(stateTools, "pulse_kubernetes"))

	adapter := unifiedresources.NewMonitorAdapter(nil)
	adapter.PopulateFromSnapshot(models.StateSnapshot{
		Nodes:              []models.Node{{ID: "node-1", Name: "pve1", Status: "online"}},
		KubernetesClusters: []models.KubernetesCluster{{ID: "cluster-1", Name: "cluster-1"}},
	})
	execWithUnifiedReadState := NewPulseToolExecutor(ExecutorConfig{UnifiedResourceProvider: adapter})
	unifiedTools := execWithUnifiedReadState.ListTools()
	assert.True(t, containsTool(unifiedTools, "pulse_query"))
	assert.True(t, containsTool(unifiedTools, "pulse_pmg"))
	assert.True(t, containsTool(unifiedTools, "pulse_kubernetes"))
}

func TestPulseToolExecutor_IsToolAvailable(t *testing.T) {
	exec := NewPulseToolExecutor(ExecutorConfig{})
	// pulse_metrics requires metrics provider or state provider
	assert.False(t, exec.isToolAvailable("pulse_metrics"))
	// pulse_query requires state provider
	assert.False(t, exec.isToolAvailable("pulse_query"))

	// Create new executor with state provider and metrics history
	execWithProviders := NewPulseToolExecutor(ExecutorConfig{
		StateProvider:  &mockStateProvider{},
		MetricsHistory: &mockMetricsHistoryProvider{},
	})
	// Now pulse_metrics should be available with metrics history
	assert.True(t, execWithProviders.isToolAvailable("pulse_metrics"))
	// And pulse_query should be available with state provider
	assert.True(t, execWithProviders.isToolAvailable("pulse_query"))
	assert.True(t, execWithProviders.isToolAvailable("pulse_pmg"))
	assert.False(t, execWithProviders.isToolAvailable("pulse_kubernetes"))

	adapter := unifiedresources.NewMonitorAdapter(nil)
	adapter.PopulateFromSnapshot(models.StateSnapshot{
		PMGInstances:       []models.PMGInstance{{ID: "pmg-1", Name: "pmg-1"}},
		KubernetesClusters: []models.KubernetesCluster{{ID: "cluster-1", Name: "cluster-1"}},
	})
	execWithUnifiedReadState := NewPulseToolExecutor(ExecutorConfig{
		UnifiedResourceProvider: adapter,
	})
	assert.True(t, execWithUnifiedReadState.isToolAvailable("pulse_pmg"))
	assert.True(t, execWithUnifiedReadState.isToolAvailable("pulse_kubernetes"))
	assert.False(t, execWithUnifiedReadState.isToolAvailable("pulse_read"))

	execWithNativeRead := NewPulseToolExecutor(ExecutorConfig{
		UnifiedResourceProvider:  adapter,
		ReadState:                unifiedresources.NewRegistry(nil),
		AppContainerReadProvider: &stubAppContainerReadProvider{},
	})
	assert.True(t, execWithNativeRead.isToolAvailable("pulse_read"))
}

func TestPulseToolExecutor_GetReadStatePrefersUnifiedResourceProvider(t *testing.T) {
	adapter := unifiedresources.NewMonitorAdapter(nil)
	adapter.PopulateFromSnapshot(models.StateSnapshot{
		VMs: []models.VM{{ID: "vm-unified", Name: "vm-unified", Status: "running", Node: "pve1", Instance: "cluster-a"}},
	})

	stateProvider := &mockStateProvider{}
	stateProvider.On("ReadSnapshot").Return(models.StateSnapshot{
		VMs: []models.VM{{ID: "vm-snapshot", Name: "vm-snapshot", Status: "running", Node: "pve2", Instance: "cluster-b"}},
	})

	exec := NewPulseToolExecutor(ExecutorConfig{
		StateProvider:           stateProvider,
		UnifiedResourceProvider: adapter,
	})

	readState := exec.getReadState()
	require.NotNil(t, readState)
	require.Len(t, readState.VMs(), 1)
	assert.Equal(t, "vm-unified", readState.VMs()[0].Name())
	stateProvider.AssertNotCalled(t, "ReadSnapshot")
}

func TestToolRegistry_ListTools(t *testing.T) {
	registry := NewToolRegistry()
	registry.Register(RegisteredTool{
		Definition: Tool{Name: "read"},
	})
	registry.Register(RegisteredTool{
		Definition:     Tool{Name: "control"},
		RequireControl: true,
	})

	readOnly := registry.ListTools(ControlLevelReadOnly)
	require.Len(t, readOnly, 1)
	assert.Equal(t, "read", readOnly[0].Name)

	full := registry.ListTools(ControlLevelControlled)
	require.Len(t, full, 2)
	assert.Equal(t, "read", full[0].Name)
	assert.Equal(t, "control", full[1].Name)

	governance := registry.ListToolGovernance(ControlLevelControlled)
	require.Len(t, governance, 2)
	assert.Equal(t, ToolActionRead, governance[0].ActionMode)
	assert.Equal(t, ToolActionWrite, governance[1].ActionMode)
	assert.Equal(t, "hidden in read-only mode; approval required in controlled mode", governance[1].ApprovalPolicy)
}

func containsTool(tools []Tool, name string) bool {
	for _, tool := range tools {
		if tool.Name == name {
			return true
		}
	}
	return false
}