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.

12.3 KB
Raw Blame
package tools

import (
	"context"
	"encoding/json"
	"testing"

	"github.com/rcourtman/pulse-go-rewrite/internal/models"
	"github.com/rcourtman/pulse-go-rewrite/internal/unifiedresources"
)

type stubBackupProvider struct {
	backups models.Backups
	pbs     []models.PBSInstance
}

func (s *stubBackupProvider) GetBackups() models.Backups {
	return s.backups
}

func (s *stubBackupProvider) GetPBSInstances() []models.PBSInstance {
	return s.pbs
}

type stubDiskHealthProvider struct {
	hosts []*unifiedresources.HostView
}

type stubUpdatesProvider struct {
	pending            []ContainerUpdateInfo
	enabled            bool
	triggerCalled      bool
	lastTriggerHost    string
	lastUpdateHost     string
	lastUpdateID       string
	lastUpdateName     string
	triggerStatus      DockerCommandStatus
	triggerErr         error
	updateStatus       DockerCommandStatus
	updateErr          error
	updateCheckEnabled bool
}

func (s *stubUpdatesProvider) GetPendingUpdates(hostID string) []ContainerUpdateInfo {
	s.lastTriggerHost = hostID
	return s.pending
}

func (s *stubUpdatesProvider) TriggerUpdateCheck(hostID string) (DockerCommandStatus, error) {
	s.triggerCalled = true
	s.lastTriggerHost = hostID
	return s.triggerStatus, s.triggerErr
}

func (s *stubUpdatesProvider) UpdateContainer(hostID, containerID, containerName string) (DockerCommandStatus, error) {
	s.lastUpdateHost = hostID
	s.lastUpdateID = containerID
	s.lastUpdateName = containerName
	return s.updateStatus, s.updateErr
}

func (s *stubUpdatesProvider) GetCommandStatus(commandID string) (DockerCommandStatus, bool) {
	if s.updateStatus.ID == commandID {
		return s.updateStatus, true
	}
	return DockerCommandStatus{}, false
}

func (s *stubUpdatesProvider) IsUpdateActionsEnabled() bool {
	return s.enabled
}

func TestExecuteListStorage(t *testing.T) {
	executor := NewPulseToolExecutor(ExecutorConfig{StateProvider: &mockStateProvider{}})
	// Storage pools and Ceph data come from the unified resource provider.
	storageUsedBytes := int64(1024 * 1024 * 1024)
	storageTotalBytes := int64(4 * 1024 * 1024 * 1024)
	cephUsedBytes := int64(2 * 1024 * 1024 * 1024 * 1024)
	cephTotalBytes := int64(4 * 1024 * 1024 * 1024 * 1024)
	executor.unifiedResourceProvider = &stubUnifiedResourceProvider{
		resources: []unifiedresources.Resource{
			{
				ID:     "store1",
				Name:   "store1",
				Type:   unifiedresources.ResourceTypeStorage,
				Status: unifiedresources.StatusOnline,
				Proxmox: &unifiedresources.ProxmoxData{
					NodeName: "node1",
					Instance: "pve1",
				},
				Storage: &unifiedresources.StorageMeta{
					Type:    "zfs",
					Content: "images",
					Shared:  false,
					IsZFS:   true,
				},
				Metrics: &unifiedresources.ResourceMetrics{
					Disk: &unifiedresources.MetricValue{
						Used:    &storageUsedBytes,
						Total:   &storageTotalBytes,
						Percent: 25.0,
					},
				},
			},
			{
				Name: "ceph1",
				Type: unifiedresources.ResourceTypeCeph,
				Ceph: &unifiedresources.CephMeta{
					HealthStatus:  "HEALTH_OK",
					HealthMessage: "ok",
					NumOSDs:       3,
					NumOSDsUp:     3,
					NumOSDsIn:     3,
					NumMons:       1,
					NumMgrs:       1,
				},
				Metrics: &unifiedresources.ResourceMetrics{
					Disk: &unifiedresources.MetricValue{
						Used:  &cephUsedBytes,
						Total: &cephTotalBytes,
					},
				},
			},
		},
	}

	result, _ := executor.executeListStorage(context.Background(), map[string]interface{}{})
	var storageResp StorageResponse
	if err := json.Unmarshal([]byte(result.Content[0].Text), &storageResp); err != nil {
		t.Fatalf("decode storage response: %v", err)
	}
	if len(storageResp.Pools) != 1 {
		t.Fatalf("unexpected storage pools: %+v", storageResp.Pools)
	}
	// Verify UsagePercent is passed through directly (not double-multiplied).
	if storageResp.Pools[0].UsagePercent != 25.0 {
		t.Errorf("storage pool UsagePercent = %v, want 25.0 (was double-multiplied before fix)", storageResp.Pools[0].UsagePercent)
	}
	if len(storageResp.CephClusters) != 1 || storageResp.CephClusters[0].UsedTB != 2 {
		t.Fatalf("unexpected ceph clusters: %+v", storageResp.CephClusters)
	}
}

func TestStorageUsagePercentNotDoubled(t *testing.T) {
	// Regression test: Usage is already 0-100 from safePercentage().
	// The bug was multiplying by 100 again, turning 25% into 2500%.
	executor := NewPulseToolExecutor(ExecutorConfig{StateProvider: &mockStateProvider{}})

	// Storage pool path
	storageUsedBytes := int64(1024 * 1024 * 1024)
	storageTotalBytes := int64(4 * 1024 * 1024 * 1024)
	executor.unifiedResourceProvider = &stubUnifiedResourceProvider{
		resources: []unifiedresources.Resource{
			{
				ID:     "s1",
				Name:   "s1",
				Type:   unifiedresources.ResourceTypeStorage,
				Status: unifiedresources.StatusOnline,
				Storage: &unifiedresources.StorageMeta{
					Type:    "dir",
					Content: "images",
				},
				Metrics: &unifiedresources.ResourceMetrics{
					Disk: &unifiedresources.MetricValue{
						Used:    &storageUsedBytes,
						Total:   &storageTotalBytes,
						Percent: 45.7,
					},
				},
			},
		},
	}
	result2, _ := executor.executeListStorage(context.Background(), map[string]interface{}{})
	var storageResp StorageResponse
	if err := json.Unmarshal([]byte(result2.Content[0].Text), &storageResp); err != nil {
		t.Fatalf("decode storage response: %v", err)
	}
	if len(storageResp.Pools) != 1 {
		t.Fatalf("unexpected pools: %+v", storageResp.Pools)
	}
	got2 := storageResp.Pools[0].UsagePercent
	if got2 != 45.7 {
		t.Errorf("storage pool UsagePercent = %v, want 45.7 (double-multiplied = %v)", got2, 45.7*100)
	}
}

func TestStoragePoolSummaryReadsStorageFacetFlags(t *testing.T) {
	storage := func(enabled, active bool) *unifiedresources.StorageMeta {
		return &unifiedresources.StorageMeta{Type: "dir", Enabled: enabled, Active: active}
	}
	cases := []struct {
		name         string
		status       unifiedresources.ResourceStatus
		storage      *unifiedresources.StorageMeta
		wantEnabled  bool
		wantActive   bool
		listSkipsRow bool
	}{
		// Proxmox storage that reports active=0 is unavailable, not disabled.
		{"unavailable storage stays enabled", unifiedresources.StatusOffline, storage(true, false), true, false, false},
		{"disabled storage", unifiedresources.StatusWarning, storage(false, false), false, false, false},
		{"online storage", unifiedresources.StatusOnline, storage(true, true), true, true, false},
		// PBS datastores report Active even while unavailable.
		{"offline row whose source reports active", unifiedresources.StatusOffline, storage(true, true), true, false, false},
		{"no facet online", unifiedresources.StatusOnline, nil, true, true, true},
		{"no facet offline", unifiedresources.StatusOffline, nil, false, false, true},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			resource := unifiedresources.Resource{
				ID:      "local-lvm",
				Name:    "local-lvm",
				Type:    unifiedresources.ResourceTypeStorage,
				Status:  tc.status,
				Storage: tc.storage,
			}

			got := storagePoolSummaryFromResource(resource)
			if got.Enabled != tc.wantEnabled || got.Active != tc.wantActive {
				t.Fatalf("summary enabled/active = %v/%v, want %v/%v", got.Enabled, got.Active, tc.wantEnabled, tc.wantActive)
			}
			if tc.listSkipsRow {
				return
			}

			executor := NewPulseToolExecutor(ExecutorConfig{StateProvider: &mockStateProvider{}})
			executor.unifiedResourceProvider = &stubUnifiedResourceProvider{resources: []unifiedresources.Resource{resource}}
			result, err := executor.executeListStorage(context.Background(), map[string]interface{}{})
			if err != nil {
				t.Fatalf("executeListStorage: %v", err)
			}
			var resp StorageResponse
			if err := json.Unmarshal([]byte(result.Content[0].Text), &resp); err != nil {
				t.Fatalf("decode storage response: %v", err)
			}
			if len(resp.Pools) != 1 {
				t.Fatalf("pools = %+v, want one", resp.Pools)
			}
			if resp.Pools[0].Enabled != tc.wantEnabled || resp.Pools[0].Active != tc.wantActive {
				t.Fatalf("listed enabled/active = %v/%v, want %v/%v", resp.Pools[0].Enabled, resp.Pools[0].Active, tc.wantEnabled, tc.wantActive)
			}
		})
	}
}

func TestStorageResponsesUseCanonicalEmptyCollections(t *testing.T) {
	backupsPayload, err := json.Marshal(EmptyBackupsResponse())
	if err != nil {
		t.Fatalf("marshal empty backups response: %v", err)
	}
	var backupsMap map[string]any
	if err := json.Unmarshal(backupsPayload, &backupsMap); err != nil {
		t.Fatalf("decode empty backups response: %v", err)
	}
	for _, key := range []string{"points"} {
		values, ok := backupsMap[key].([]any)
		if !ok || len(values) != 0 {
			t.Fatalf("expected %s to serialize as an empty array, got %T (%v)", key, backupsMap[key], backupsMap[key])
		}
	}

	storagePayload, err := json.Marshal(EmptyStorageResponse())
	if err != nil {
		t.Fatalf("marshal empty storage response: %v", err)
	}
	var storageMap map[string]any
	if err := json.Unmarshal(storagePayload, &storageMap); err != nil {
		t.Fatalf("decode empty storage response: %v", err)
	}
	for _, key := range []string{"pools", "ceph_clusters"} {
		values, ok := storageMap[key].([]any)
		if !ok || len(values) != 0 {
			t.Fatalf("expected %s to serialize as an empty array, got %T (%v)", key, storageMap[key], storageMap[key])
		}
	}
}

func TestStorageDiagnosticsResponsesUseCanonicalEmptyCollections(t *testing.T) {
	tests := []struct {
		name string
		raw  any
		keys []string
	}{
		{name: "host_raid", raw: EmptyHostRAIDStatusResponse(), keys: []string{"hosts"}},
		{name: "host_ceph", raw: EmptyHostCephDetailsResponse(), keys: []string{"hosts"}},
		{name: "resource_disks", raw: EmptyResourceDisksResponse(), keys: []string{"resources"}},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			payload, err := json.Marshal(tc.raw)
			if err != nil {
				t.Fatalf("marshal %s response: %v", tc.name, err)
			}

			var decoded map[string]any
			if err := json.Unmarshal(payload, &decoded); err != nil {
				t.Fatalf("decode %s response: %v", tc.name, err)
			}

			for _, key := range tc.keys {
				values, ok := decoded[key].([]any)
				if !ok || len(values) != 0 {
					t.Fatalf("expected %s.%s to be an empty array, got %T (%v)", tc.name, key, decoded[key], decoded[key])
				}
			}
		})
	}
}

func TestDockerUpdateTools(t *testing.T) {
	state := models.StateSnapshot{
		DockerHosts: []models.DockerHost{
			{
				ID:          "host1",
				Hostname:    "docker1",
				DisplayName: "Docker One",
				Containers: []models.DockerContainer{
					{ID: "c1", Name: "/nginx"},
				},
			},
		},
	}

	stateProv := &mockStateProvider{}
	stateProv.On("ReadSnapshot").Return(state)
	executor := NewPulseToolExecutor(ExecutorConfig{
		StateProvider: stateProv,
		ControlLevel:  ControlLevelControlled,
	})
	updates := &stubUpdatesProvider{
		pending: []ContainerUpdateInfo{
			{TargetID: "host1", ContainerID: "c1", ContainerName: "nginx", UpdateAvailable: true},
		},
		enabled: true,
		triggerStatus: DockerCommandStatus{
			ID:     "cmd1",
			Type:   "check",
			Status: "queued",
		},
		updateStatus: DockerCommandStatus{
			ID:     "cmd2",
			Type:   "update",
			Status: "queued",
		},
	}
	executor.updatesProvider = updates

	result, _ := executor.executeListDockerUpdates(context.Background(), map[string]interface{}{"host": "Docker One"})
	var listResp DockerUpdatesResponse
	if err := json.Unmarshal([]byte(result.Content[0].Text), &listResp); err != nil {
		t.Fatalf("decode docker updates: %v", err)
	}
	if listResp.TargetID != "host1" || listResp.Total != 1 {
		t.Fatalf("unexpected docker updates response: %+v", listResp)
	}

	result, _ = executor.executeCheckDockerUpdates(context.Background(), map[string]interface{}{"host": "Docker One"})
	var checkResp DockerCheckUpdatesResponse
	if err := json.Unmarshal([]byte(result.Content[0].Text), &checkResp); err != nil {
		t.Fatalf("decode docker check response: %v", err)
	}
	if checkResp.CommandID != "cmd1" || checkResp.TargetID != "host1" {
		t.Fatalf("unexpected check response: %+v", checkResp)
	}
}

func TestDockerUpdatesResponseUsesCanonicalEmptyCollections(t *testing.T) {
	payload, err := json.Marshal(EmptyDockerUpdatesResponse())
	if err != nil {
		t.Fatalf("marshal docker updates response: %v", err)
	}

	var decoded map[string]any
	if err := json.Unmarshal(payload, &decoded); err != nil {
		t.Fatalf("decode docker updates response: %v", err)
	}

	updates, ok := decoded["updates"].([]any)
	if !ok || len(updates) != 0 {
		t.Fatalf("expected updates to be an empty array, got %T (%v)", decoded["updates"], decoded["updates"])
	}
}