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.

11.0 KB
Raw Blame
package api

import (
	"context"
	"path/filepath"
	"testing"
	"time"

	"github.com/rcourtman/pulse-go-rewrite/internal/ai/chat"
	"github.com/rcourtman/pulse-go-rewrite/internal/config"
	"github.com/rcourtman/pulse-go-rewrite/internal/monitoring"
	"github.com/rcourtman/pulse-go-rewrite/internal/recovery"
	recoverymanager "github.com/rcourtman/pulse-go-rewrite/internal/recovery/manager"
)

type capturingAIService struct {
	running                    bool
	appContainerConfigProvider chat.AssistantAppContainerConfigProvider
	appContainerActionProvider chat.AssistantAppContainerActionProvider
	appContainerReadProvider   chat.AssistantAppContainerReadProvider
}

func (s *capturingAIService) Start(ctx context.Context) error { s.running = true; return nil }
func (s *capturingAIService) Stop(ctx context.Context) error  { s.running = false; return nil }
func (s *capturingAIService) Restart(ctx context.Context, newCfg *config.AIConfig) error {
	s.running = true
	return nil
}
func (s *capturingAIService) IsRunning() bool { return s.running }
func (s *capturingAIService) Execute(ctx context.Context, req chat.ExecuteRequest) (map[string]interface{}, error) {
	return nil, nil
}
func (s *capturingAIService) ExecuteStream(ctx context.Context, req chat.ExecuteRequest, callback chat.StreamCallback) error {
	return nil
}
func (s *capturingAIService) ListSessions(ctx context.Context) ([]chat.Session, error) {
	return nil, nil
}
func (s *capturingAIService) CreateSession(ctx context.Context) (*chat.Session, error) {
	return &chat.Session{ID: "test"}, nil
}
func (s *capturingAIService) DeleteSession(ctx context.Context, sessionID string) error { return nil }
func (s *capturingAIService) RenameSession(ctx context.Context, sessionID, title string) (*chat.Session, error) {
	return &chat.Session{ID: sessionID, Title: title}, nil
}
func (s *capturingAIService) GetMessages(ctx context.Context, sessionID string) ([]chat.Message, error) {
	return nil, nil
}
func (s *capturingAIService) GetModelHandoffFindingID(ctx context.Context, sessionID string) (string, error) {
	return "", nil
}
func (s *capturingAIService) GetModelHandoffMetadata(ctx context.Context, sessionID string) (chat.HandoffMetadata, error) {
	return chat.HandoffMetadata{}, nil
}
func (s *capturingAIService) ClearModelHandoffContext(ctx context.Context, sessionID string) error {
	return nil
}
func (s *capturingAIService) AbortSession(ctx context.Context, sessionID string) error          { return nil }
func (s *capturingAIService) SetAlertProvider(provider chat.AssistantAlertProvider)             {}
func (s *capturingAIService) SetFindingsProvider(provider chat.AssistantFindingsProvider)       {}
func (s *capturingAIService) SetBaselineProvider(provider chat.AssistantBaselineProvider)       {}
func (s *capturingAIService) SetPatternProvider(provider chat.AssistantPatternProvider)         {}
func (s *capturingAIService) SetMetricsHistory(provider chat.AssistantMetricsHistoryProvider)   {}
func (s *capturingAIService) SetAgentProfileManager(manager chat.AgentProfileManager)           {}
func (s *capturingAIService) SetGuestConfigProvider(provider chat.AssistantGuestConfigProvider) {}
func (s *capturingAIService) SetAppContainerConfigProvider(provider chat.AssistantAppContainerConfigProvider) {
	s.appContainerConfigProvider = provider
}
func (s *capturingAIService) SetBackupProvider(provider chat.AssistantBackupProvider)          {}
func (s *capturingAIService) SetDiskHealthProvider(provider chat.AssistantDiskHealthProvider)  {}
func (s *capturingAIService) SetUpdatesProvider(provider chat.AssistantUpdatesProvider)        {}
func (s *capturingAIService) SetFindingsManager(manager chat.FindingsManager)                  {}
func (s *capturingAIService) SetMetadataUpdater(updater chat.MetadataUpdater)                  {}
func (s *capturingAIService) SetKnowledgeStoreProvider(provider chat.KnowledgeStoreProvider)   {}
func (s *capturingAIService) SetIncidentArchiveProvider(provider chat.IncidentArchiveProvider) {}
func (s *capturingAIService) SetEventCorrelatorProvider(provider chat.EventCorrelatorProvider) {}
func (s *capturingAIService) SetUnifiedResourceProvider(provider chat.AssistantUnifiedResourceProvider) {
}
func (s *capturingAIService) SetAppContainerActionProvider(provider chat.AssistantAppContainerActionProvider) {
	s.appContainerActionProvider = provider
}
func (s *capturingAIService) SetAppContainerReadProvider(provider chat.AssistantAppContainerReadProvider) {
	s.appContainerReadProvider = provider
}
func (s *capturingAIService) UpdateControlSettings(cfg *config.AIConfig) {}
func (s *capturingAIService) GetBaseURL() string                         { return "" }

func TestWireAIChatDependenciesForService_WiresTrueNASAppActionProvider(t *testing.T) {
	router := &Router{
		trueNASPoller: monitoring.NewTrueNASPoller(nil, 0, nil),
	}
	service := &capturingAIService{}

	router.wireAIChatDependenciesForService(context.Background(), service)

	if service.appContainerActionProvider == nil {
		t.Fatal("expected TrueNAS app action provider to be wired into AI chat service")
	}
	if service.appContainerReadProvider == nil {
		t.Fatal("expected TrueNAS app read provider to be wired into AI chat service")
	}
	if service.appContainerConfigProvider == nil {
		t.Fatal("expected TrueNAS app config provider to be wired into AI chat service")
	}
}

func TestAIHandlerStart_WiresRecoveryPointsProviderForDefaultChatService(t *testing.T) {
	oldNewService := newChatService
	defer func() { newChatService = oldNewService }()

	var capturedCfg chat.Config
	newChatService = func(cfg chat.Config) AIService {
		capturedCfg = cfg
		return &capturingAIService{}
	}

	baseDir := t.TempDir()
	mtp := config.NewMultiTenantPersistence(baseDir)
	manager := recoverymanager.New(mtp)

	persistence, err := mtp.GetPersistence("default")
	if err != nil {
		t.Fatalf("GetPersistence(default): %v", err)
	}

	aiCfg := config.NewDefaultAIConfig()
	aiCfg.Enabled = true
	aiCfg.Model = "stub:model"
	aiCfg.ChatModel = "stub:model"
	aiCfg.PatrolModel = "stub:model"
	if err := persistence.SaveAIConfig(*aiCfg); err != nil {
		t.Fatalf("SaveAIConfig(default): %v", err)
	}

	dbPath := seedRecoveryPointForAIHandlerWiringTest(t, mtp, manager, "default", recovery.RecoveryPoint{
		ID:          "default-point-bad-json",
		Provider:    recovery.ProviderKubernetes,
		Kind:        recovery.KindSnapshot,
		Mode:        recovery.ModeSnapshot,
		Outcome:     recovery.OutcomeSuccess,
		StartedAt:   timePtr(time.Date(2026, 2, 20, 12, 0, 0, 0, time.UTC)),
		CompletedAt: timePtr(time.Date(2026, 2, 20, 12, 0, 0, 0, time.UTC)),
		SubjectRef: &recovery.ExternalRef{
			Type:      "k8s-pvc",
			Namespace: "default",
			Name:      "data",
		},
		Details: map[string]any{"foo": "bar"},
	})
	corruptRecoveryRowJSON(t, dbPath, "default-point-bad-json", true, false, true)

	handler := NewAIHandler(mtp, nil, nil)
	handler.SetRecoveryManager(manager)

	if err := handler.Start(context.Background(), nil); err != nil {
		t.Fatalf("Start(): %v", err)
	}

	if capturedCfg.OrgID != "default" {
		t.Fatalf("capturedCfg.OrgID = %q, want default", capturedCfg.OrgID)
	}
	if capturedCfg.RecoveryPointsProvider == nil {
		t.Fatal("expected recovery points provider to be wired into default chat service")
	}

	points, total, err := capturedCfg.RecoveryPointsProvider.ListPoints(context.Background(), recovery.ListPointsOptions{
		Limit: 10,
	})
	if err != nil {
		t.Fatalf("RecoveryPointsProvider.ListPoints(default): %v", err)
	}
	if total != 1 || len(points) != 1 {
		t.Fatalf("expected one default recovery point, got total=%d len=%d", total, len(points))
	}
	if points[0].SubjectRef != nil || points[0].Details != nil {
		t.Fatalf("expected malformed metadata to degrade gracefully, got subjectRef=%#v details=%#v", points[0].SubjectRef, points[0].Details)
	}
	if points[0].Display == nil || points[0].Display.SubjectLabel != "default/data" {
		t.Fatalf("expected canonical display fallback, got %#v", points[0].Display)
	}
}

func TestAIHandlerGetService_WiresRecoveryPointsProviderForTenantChatService(t *testing.T) {
	oldNewService := newChatService
	defer func() { newChatService = oldNewService }()

	capturedCfgs := make(map[string]chat.Config)
	newChatService = func(cfg chat.Config) AIService {
		capturedCfgs[cfg.OrgID] = cfg
		return &capturingAIService{}
	}

	baseDir := t.TempDir()
	mtp := config.NewMultiTenantPersistence(baseDir)
	manager := recoverymanager.New(mtp)

	persistence, err := mtp.GetPersistence("tenant-a")
	if err != nil {
		t.Fatalf("GetPersistence(tenant-a): %v", err)
	}

	aiCfg := config.NewDefaultAIConfig()
	aiCfg.Enabled = true
	aiCfg.Model = "stub:model"
	aiCfg.ChatModel = "stub:model"
	aiCfg.PatrolModel = "stub:model"
	if err := persistence.SaveAIConfig(*aiCfg); err != nil {
		t.Fatalf("SaveAIConfig(tenant-a): %v", err)
	}

	dbPath := seedRecoveryPointForAIHandlerWiringTest(t, mtp, manager, "tenant-a", recovery.RecoveryPoint{
		ID:          "tenant-point-bad-json",
		Provider:    recovery.ProviderTrueNAS,
		Kind:        recovery.KindSnapshot,
		Mode:        recovery.ModeSnapshot,
		Outcome:     recovery.OutcomeSuccess,
		StartedAt:   timePtr(time.Date(2026, 2, 21, 12, 0, 0, 0, time.UTC)),
		CompletedAt: timePtr(time.Date(2026, 2, 21, 12, 0, 0, 0, time.UTC)),
		SubjectRef: &recovery.ExternalRef{
			Type: "truenas-dataset",
			Name: "tank/apps",
			ID:   "tank/apps",
		},
	})
	corruptRecoveryRowJSON(t, dbPath, "tenant-point-bad-json", true, false, false)

	handler := NewAIHandler(mtp, nil, nil)
	handler.SetRecoveryManager(manager)

	ctx := context.WithValue(context.Background(), OrgIDContextKey, "tenant-a")
	svc := handler.GetService(ctx)
	if svc == nil {
		t.Fatal("expected tenant chat service to be created")
	}

	capturedCfg, ok := capturedCfgs["tenant-a"]
	if !ok {
		t.Fatal("expected tenant chat config to be captured")
	}
	if capturedCfg.RecoveryPointsProvider == nil {
		t.Fatal("expected recovery points provider to be wired into tenant chat service")
	}

	points, total, err := capturedCfg.RecoveryPointsProvider.ListPoints(context.Background(), recovery.ListPointsOptions{
		Limit: 10,
	})
	if err != nil {
		t.Fatalf("RecoveryPointsProvider.ListPoints(tenant-a): %v", err)
	}
	if total != 1 || len(points) != 1 {
		t.Fatalf("expected one tenant recovery point, got total=%d len=%d", total, len(points))
	}
	if points[0].SubjectRef != nil {
		t.Fatalf("expected malformed subject ref to degrade gracefully, got %#v", points[0].SubjectRef)
	}
	if points[0].Display == nil || points[0].Display.SubjectLabel != "tank/apps" {
		t.Fatalf("expected canonical tenant display fallback, got %#v", points[0].Display)
	}
}

func seedRecoveryPointForAIHandlerWiringTest(t *testing.T, mtp *config.MultiTenantPersistence, manager *recoverymanager.Manager, orgID string, point recovery.RecoveryPoint) string {
	t.Helper()

	store, err := manager.StoreForOrg(orgID)
	if err != nil {
		t.Fatalf("StoreForOrg(%s): %v", orgID, err)
	}
	if err := store.UpsertPoints(context.Background(), []recovery.RecoveryPoint{point}); err != nil {
		t.Fatalf("UpsertPoints(%s): %v", orgID, err)
	}

	persistence, err := mtp.GetPersistence(orgID)
	if err != nil {
		t.Fatalf("GetPersistence(%s): %v", orgID, err)
	}
	return filepath.Join(persistence.DataDir(), "recovery", "recovery.db")
}