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 api
import (
"encoding/json"
"math"
"net/http"
"net/http/httptest"
"testing"
"time"
"github.com/rcourtman/pulse-go-rewrite/internal/config"
"github.com/rcourtman/pulse-go-rewrite/internal/mock"
"github.com/rcourtman/pulse-go-rewrite/internal/models"
"github.com/rcourtman/pulse-go-rewrite/internal/monitoring"
unifiedresources "github.com/rcourtman/pulse-go-rewrite/internal/unifiedresources"
"github.com/rcourtman/pulse-go-rewrite/pkg/metrics"
)
type metricsHistoryResponse struct {
ResourceType string `json:"resourceType"`
ResourceId string `json:"resourceId"`
Metric string `json:"metric"`
Range string `json:"range"`
Source string `json:"source"`
Points []struct {
Timestamp int64 `json:"timestamp"`
Value float64 `json:"value"`
} `json:"points"`
}
type staticPhysicalDiskResourceStore struct {
resources []unifiedresources.Resource
}
func (store staticPhysicalDiskResourceStore) ShouldSkipAPIPolling(string) bool {
return false
}
func (store staticPhysicalDiskResourceStore) GetPollingRecommendations() map[string]float64 {
return nil
}
func (store staticPhysicalDiskResourceStore) GetAll() []unifiedresources.Resource {
return append([]unifiedresources.Resource(nil), store.resources...)
}
func (staticPhysicalDiskResourceStore) PopulateFromSnapshot(models.StateSnapshot) {}
func TestMetricsHistoryPhysicalDiskIdentityAliasesFailClosedWhenAmbiguous(t *testing.T) {
resources := []unifiedresources.Resource{
{
ID: "physical-disk:node-a:sda",
Type: unifiedresources.ResourceTypePhysicalDisk,
PhysicalDisk: &unifiedresources.PhysicalDiskMeta{
Serial: "DUPLICATE-SERIAL",
Temperature: 31,
},
MetricsTarget: &unifiedresources.MetricsTarget{
ResourceType: "disk",
ResourceID: "DUPLICATE-SERIAL",
},
},
{
ID: "physical-disk:node-b:sda",
Type: unifiedresources.ResourceTypePhysicalDisk,
PhysicalDisk: &unifiedresources.PhysicalDiskMeta{
Serial: "DUPLICATE-SERIAL",
Temperature: 52,
},
MetricsTarget: &unifiedresources.MetricsTarget{
ResourceType: "disk",
ResourceID: "DUPLICATE-SERIAL",
},
},
}
monitor := &monitoring.Monitor{}
monitor.SetResourceStore(staticPhysicalDiskResourceStore{resources: resources})
setUnexportedField(t, monitor, "metricsHistory", monitoring.NewMetricsHistory(10, time.Hour))
router := &Router{monitor: monitor}
req := httptest.NewRequest(
http.MethodGet,
"/api/metrics-store/history?resourceType=disk&resourceId=DUPLICATE-SERIAL&metric=smart_temp&range=5m",
nil,
)
rec := httptest.NewRecorder()
router.handleMetricsHistory(rec, req)
if rec.Code != http.StatusServiceUnavailable {
t.Fatalf("ambiguous identity should not attach either live temperature: status=%d body=%s", rec.Code, rec.Body.String())
}
req = httptest.NewRequest(
http.MethodGet,
"/api/metrics-store/history?resourceType=disk&resourceId=physical-disk:node-b:sda&metric=smart_temp&range=5m",
nil,
)
rec = httptest.NewRecorder()
router.handleMetricsHistory(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("exact canonical identity should resolve: status=%d body=%s", rec.Code, rec.Body.String())
}
var response metricsHistoryResponse
if err := json.Unmarshal(rec.Body.Bytes(), &response); err != nil {
t.Fatalf("decode exact disk response: %v", err)
}
if len(response.Points) != 1 || response.Points[0].Value != 52 {
t.Fatalf("exact canonical identity resolved wrong disk: %+v", response.Points)
}
}
func TestMetricsHistoryFallbackUsesLivePoint(t *testing.T) {
state := models.NewState()
vm := models.VM{
ID: "pve1:node1:101",
VMID: 101,
Name: "vm-101",
Node: "node1",
Instance: "pve1",
Status: "running",
Type: "qemu",
CPU: 0.42,
Memory: models.Memory{
Usage: 55.0,
},
Disk: models.Disk{
Usage: 33.0,
},
}
state.UpdateVMsForInstance("pve1", []models.VM{vm})
monitor := &monitoring.Monitor{}
setUnexportedField(t, monitor, "state", state)
setUnexportedField(t, monitor, "metricsHistory", monitoring.NewMetricsHistory(10, time.Hour))
tempDir := t.TempDir()
mtp := config.NewMultiTenantPersistence(tempDir)
if _, err := mtp.GetPersistence("default"); err != nil {
t.Fatalf("failed to init persistence: %v", err)
}
router := &Router{
monitor: monitor,
licenseHandlers: NewLicenseHandlers(mtp, false),
}
req := httptest.NewRequest(http.MethodGet, "/api/metrics-store/history?resourceType=vm&resourceId=pve1:node1:101&metric=cpu&range=24h", nil)
rec := httptest.NewRecorder()
router.handleMetricsHistory(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d", rec.Code)
}
var resp metricsHistoryResponse
if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if resp.Source != "live" {
t.Fatalf("expected source live, got %q", resp.Source)
}
if len(resp.Points) != 1 {
t.Fatalf("expected 1 point, got %d", len(resp.Points))
}
if math.Abs(resp.Points[0].Value-42.0) > 0.001 {
t.Fatalf("expected value 42.0, got %f", resp.Points[0].Value)
}
}
func TestMetricsHistoryFallbackSynthesizesUnseededMockWorkloadHistory(t *testing.T) {
setMockModeForTest(t, true)
monitor := &monitoring.Monitor{}
setUnexportedField(t, monitor, "metricsHistory", monitoring.NewMetricsHistory(10, time.Hour))
router := &Router{monitor: monitor}
req := httptest.NewRequest(
http.MethodGet,
"/api/metrics-store/history?resourceType=vm&resourceId=mock-cluster-6-pve31-673&range=24h",
nil,
)
rec := httptest.NewRecorder()
router.handleMetricsHistory(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d: %s", rec.Code, rec.Body.String())
}
var resp struct {
Source string `json:"source"`
Metrics map[string][]json.RawMessage `json:"metrics"`
}
if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if resp.Source != "mock_synthetic" {
t.Fatalf("expected source mock_synthetic, got %q", resp.Source)
}
if len(resp.Metrics["cpu"]) < 2 {
t.Fatalf("expected drawable mock CPU history, got %d points", len(resp.Metrics["cpu"]))
}
}
func TestMetricsHistoryFallbackSynthesizesMockHostAndNodeDrawerSeries(t *testing.T) {
setMockModeForTest(t, true)
monitor := &monitoring.Monitor{}
setUnexportedField(t, monitor, "metricsHistory", monitoring.NewMetricsHistory(10, time.Hour))
router := &Router{monitor: monitor}
for _, tc := range []struct {
name string
resourceType string
resourceID string
metrics []string
}{
{
name: "docker host",
resourceType: "docker-host",
resourceID: "runtime-host-9",
metrics: []string{"cpu", "netin", "diskread", "temperature"},
},
{
name: "Proxmox node",
resourceType: "node",
resourceID: "cluster-1-node-9",
metrics: []string{"cpu", "netin", "temperature"},
},
} {
t.Run(tc.name, func(t *testing.T) {
req := httptest.NewRequest(
http.MethodGet,
"/api/metrics-store/history?resourceType="+tc.resourceType+"&resourceId="+tc.resourceID+"&range=24h",
nil,
)
rec := httptest.NewRecorder()
router.handleMetricsHistory(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d: %s", rec.Code, rec.Body.String())
}
var resp struct {
Source string `json:"source"`
Metrics map[string][]json.RawMessage `json:"metrics"`
}
if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if resp.Source != "mock_synthetic" {
t.Fatalf("expected source mock_synthetic, got %q", resp.Source)
}
for _, metric := range tc.metrics {
if len(resp.Metrics[metric]) < 2 {
t.Fatalf("expected drawable %s history, got %d points", metric, len(resp.Metrics[metric]))
}
}
})
}
}
func TestMetricsHistoryFallbackSupplementsPartialMockStoreSeries(t *testing.T) {
setMockModeForTest(t, true)
store, err := metrics.NewStore(metrics.DefaultConfig(t.TempDir()))
if err != nil {
t.Fatalf("metrics.NewStore() error = %v", err)
}
defer func() { _ = store.Close() }()
resourceID := "container-partial-1"
now := time.Now().UTC()
for _, sample := range []struct {
offset time.Duration
value float64
}{
{-50 * time.Minute, 15},
{-25 * time.Minute, 25},
{-time.Minute, 35},
} {
store.Write("dockerContainer", resourceID, "cpu", sample.value, now.Add(sample.offset))
}
store.Flush()
monitor := &monitoring.Monitor{}
setUnexportedField(t, monitor, "metricsHistory", monitoring.NewMetricsHistory(10, time.Hour))
setUnexportedField(t, monitor, "metricsStore", store)
router := &Router{monitor: monitor}
req := httptest.NewRequest(
http.MethodGet,
"/api/metrics-store/history?resourceType=app-container&resourceId="+resourceID+"&range=1h",
nil,
)
rec := httptest.NewRecorder()
router.handleMetricsHistory(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d: %s", rec.Code, rec.Body.String())
}
var resp struct {
Source string `json:"source"`
Metrics map[string][]json.RawMessage `json:"metrics"`
}
if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if resp.Source != "mock_synthetic" {
t.Fatalf("expected supplemented source mock_synthetic, got %q", resp.Source)
}
if len(resp.Metrics["cpu"]) != 3 {
t.Fatalf("expected the three stored CPU points to be preserved, got %d", len(resp.Metrics["cpu"]))
}
for _, metricType := range []string{"netin", "netout", "diskread", "diskwrite"} {
if len(resp.Metrics[metricType]) < 2 {
t.Fatalf("expected missing %s store history to be supplemented, got %d points", metricType, len(resp.Metrics[metricType]))
}
}
}
func TestMetricsHistoryFallbackMockDiskSynthesizesSeries(t *testing.T) {
setMockModeForTest(t, true)
state := mock.CurrentFixtureGraph().State
var disk models.PhysicalDisk
found := false
for _, candidate := range state.PhysicalDisks {
if candidate.Serial != "" && candidate.Temperature > 0 {
disk = candidate
found = true
break
}
}
if !found {
t.Fatalf("expected at least one mock physical disk with serial and temperature")
}
registry := unifiedresources.NewRegistry(nil)
registry.IngestSnapshot(state)
adapter := unifiedresources.NewMonitorAdapter(registry)
monitor := &monitoring.Monitor{}
monitor.SetResourceStore(adapter)
router := &Router{monitor: monitor}
req := httptest.NewRequest(
http.MethodGet,
"/api/metrics-store/history?resourceType=disk&resourceId="+disk.Serial+"&metric=smart_temp&range=1h",
nil,
)
rec := httptest.NewRecorder()
router.handleMetricsHistory(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d", rec.Code)
}
var resp metricsHistoryResponse
if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if resp.Source != "mock_synthetic" {
t.Fatalf("expected source mock_synthetic, got %q", resp.Source)
}
if len(resp.Points) < 24 {
t.Fatalf("expected dense synthetic history points, got %d", len(resp.Points))
}
if math.Abs(resp.Points[len(resp.Points)-1].Value-float64(disk.Temperature)) > 0.001 {
t.Fatalf("expected last point %d, got %f", disk.Temperature, resp.Points[len(resp.Points)-1].Value)
}
}
func TestMetricsHistoryFallbackMockUnifiedStorageSynthesizesSeries(t *testing.T) {
setMockModeForTest(t, true)
used := int64(7_140_000_000_000)
total := int64(20_000_000_000_000)
resourceID := "offsite-vault"
registry := unifiedresources.NewRegistry(nil)
registry.IngestResources([]unifiedresources.Resource{
{
ID: "storage-offsite-vault",
Type: unifiedresources.ResourceTypeStorage,
Name: "Offsite Vault",
Status: unifiedresources.StatusOnline,
LastSeen: time.Now().UTC(),
MetricsTarget: &unifiedresources.MetricsTarget{
ResourceType: "storage",
ResourceID: resourceID,
},
Metrics: &unifiedresources.ResourceMetrics{
Disk: &unifiedresources.MetricValue{
Used: &used,
Total: &total,
Percent: 35.7,
},
},
},
})
monitor := &monitoring.Monitor{}
monitor.SetResourceStore(unifiedresources.NewMonitorAdapter(registry))
router := &Router{monitor: monitor}
for _, query := range []string{
"resourceType=storage&resourceId=" + resourceID + "&metric=usage&range=24h",
"resourceType=storage&resourceId=" + resourceID + "&range=24h",
} {
req := httptest.NewRequest(http.MethodGet, "/api/metrics-store/history?"+query, nil)
rec := httptest.NewRecorder()
router.handleMetricsHistory(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d: %s", rec.Code, rec.Body.String())
}
var resp struct {
Source string `json:"source"`
Points []struct {
Value float64 `json:"value"`
} `json:"points"`
Metrics map[string][]struct {
Value float64 `json:"value"`
} `json:"metrics"`
}
if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if resp.Source != "mock_synthetic" {
t.Fatalf("expected source mock_synthetic, got %q: %s", resp.Source, rec.Body.String())
}
points := resp.Points
if len(points) == 0 {
points = resp.Metrics["usage"]
}
if len(points) < 24 {
t.Fatalf("expected dense synthetic storage history, got %d points", len(points))
}
if math.Abs(points[len(points)-1].Value-35.7) > 0.001 {
t.Fatalf("expected last point 35.7, got %f", points[len(points)-1].Value)
}
}
}
func TestMetricsHistoryFallbackMockStorageBypassesSparseStoreSeries(t *testing.T) {
setMockModeForTest(t, true)
resourceID := "pbs-main/offsite-vault"
store, err := metrics.NewStore(metrics.DefaultConfig(t.TempDir()))
if err != nil {
t.Fatalf("metrics.NewStore() error = %v", err)
}
defer func() { _ = store.Close() }()
store.Write("storage", resourceID, "usage", 35.7, time.Now().UTC().Add(-time.Minute))
store.Flush()
monitor := &monitoring.Monitor{}
setUnexportedField(t, monitor, "metricsStore", store)
router := &Router{monitor: monitor}
req := httptest.NewRequest(
http.MethodGet,
"/api/metrics-store/history?resourceType=storage&resourceId="+resourceID+"&metric=usage&range=24h",
nil,
)
rec := httptest.NewRecorder()
router.handleMetricsHistory(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d: %s", rec.Code, rec.Body.String())
}
var resp metricsHistoryResponse
if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if resp.Source != "mock_synthetic" {
t.Fatalf("expected sparse store series to be bypassed, got %q: %s", resp.Source, rec.Body.String())
}
if len(resp.Points) < 24 {
t.Fatalf("expected dense synthetic storage history, got %d points", len(resp.Points))
}
}
func TestMetricsHistoryDiskIOMetricsUseMemoryFallback(t *testing.T) {
mh := monitoring.NewMetricsHistory(1000, time.Hour)
now := time.Now().UTC().Truncate(time.Second)
resourceID := "SERIAL884006359727"
for i, value := range []float64{12.5, 14.0, 11.0, 16.2} {
mh.AddDiskMetric(resourceID, "diskread", value*1024*1024, now.Add(time.Duration(i-3)*10*time.Minute))
mh.AddDiskMetric(resourceID, "diskwrite", value*512*1024, now.Add(time.Duration(i-3)*10*time.Minute))
mh.AddDiskMetric(resourceID, "disk", 20+value, now.Add(time.Duration(i-3)*10*time.Minute))
}
monitor := &monitoring.Monitor{}
setUnexportedField(t, monitor, "metricsHistory", mh)
router := &Router{monitor: monitor}
req := httptest.NewRequest(
http.MethodGet,
"/api/metrics-store/history?resourceType=disk&resourceId="+resourceID+"&metric=diskread&range=30m",
nil,
)
rec := httptest.NewRecorder()
router.handleMetricsHistory(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d", rec.Code)
}
var resp metricsHistoryResponse
if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if resp.Source != "memory" {
t.Fatalf("expected source memory, got %q", resp.Source)
}
if resp.Metric != "diskread" {
t.Fatalf("expected metric diskread, got %q", resp.Metric)
}
if len(resp.Points) < 2 {
t.Fatalf("expected diskread history points, got %d", len(resp.Points))
}
}
func TestMetricsHistoryKubernetesPodUsesMemoryFallback(t *testing.T) {
mh := monitoring.NewMetricsHistory(1000, time.Hour)
now := time.Now().UTC().Truncate(time.Second)
resourceID := "k8s:cluster-1:pod:pod-1"
for i, value := range []float64{18.5, 22.0, 19.0, 24.2} {
mh.AddGuestMetric(resourceID, "cpu", value, now.Add(time.Duration(i-3)*10*time.Minute))
}
monitor := &monitoring.Monitor{}
setUnexportedField(t, monitor, "metricsHistory", mh)
router := &Router{monitor: monitor}
req := httptest.NewRequest(
http.MethodGet,
"/api/metrics-store/history?resourceType=k8s&resourceId=cluster-1:pod:pod-1&metric=cpu&range=30m",
nil,
)
rec := httptest.NewRecorder()
router.handleMetricsHistory(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d", rec.Code)
}
var resp metricsHistoryResponse
if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if resp.Source != "memory" {
t.Fatalf("expected source memory, got %q", resp.Source)
}
if resp.ResourceId != resourceID {
t.Fatalf("expected canonical resourceId %q, got %q", resourceID, resp.ResourceId)
}
if resp.Metric != "cpu" {
t.Fatalf("expected metric cpu, got %q", resp.Metric)
}
if len(resp.Points) < 2 {
t.Fatalf("expected kubernetes pod history points, got %d", len(resp.Points))
}
}
func TestMetricsHistoryKubernetesClusterNodeAndDeploymentUseMemoryFallback(t *testing.T) {
mh := monitoring.NewMetricsHistory(1000, time.Hour)
now := time.Now().UTC().Truncate(time.Second)
targets := []struct {
name string
resourceID string
}{
{name: "cluster", resourceID: "cluster-1"},
{name: "node", resourceID: "cluster-1:node:node-1"},
{name: "deployment", resourceID: "cluster-1:deployment:default/api"},
}
for _, target := range targets {
for i, value := range []float64{18.5, 22.0, 19.0, 24.2} {
mh.AddGuestMetric(target.resourceID, "cpu", value, now.Add(time.Duration(i-3)*10*time.Minute))
}
}
monitor := &monitoring.Monitor{}
setUnexportedField(t, monitor, "metricsHistory", mh)
router := &Router{monitor: monitor}
for _, target := range targets {
t.Run(target.name, func(t *testing.T) {
req := httptest.NewRequest(
http.MethodGet,
"/api/metrics-store/history?resourceType=k8s&resourceId="+target.resourceID+"&metric=cpu&range=30m",
nil,
)
rec := httptest.NewRecorder()
router.handleMetricsHistory(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d", rec.Code)
}
var resp metricsHistoryResponse
if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if resp.Source != "memory" {
t.Fatalf("expected source memory, got %q", resp.Source)
}
if resp.ResourceId != target.resourceID {
t.Fatalf("expected resourceId %q, got %q", target.resourceID, resp.ResourceId)
}
if resp.Metric != "cpu" {
t.Fatalf("expected metric cpu, got %q", resp.Metric)
}
if len(resp.Points) < 2 {
t.Fatalf("expected kubernetes %s history points, got %d", target.name, len(resp.Points))
}
})
}
}
func TestMetricsHistoryStorageDiskAliasUsesMemory(t *testing.T) {
state := models.NewState()
state.UpdateStorageForInstance("pve1", []models.Storage{
{
ID: "pve1:local-zfs",
Name: "local-zfs",
Node: "node1",
Instance: "pve1",
Type: "zfspool",
Status: "available",
Total: 100,
Used: 50,
Free: 50,
Usage: 50,
Content: "images",
Shared: false,
Enabled: true,
Active: true,
},
})
mh := monitoring.NewMetricsHistory(1000, time.Hour)
now := time.Now()
for i := 0; i < 5; i++ {
ts := now.Add(time.Duration(-50+i*10) * time.Minute)
mh.AddStorageMetric("pve1:local-zfs", "usage", 10.0+float64(i), ts)
}
monitor := &monitoring.Monitor{}
setUnexportedField(t, monitor, "state", state)
setUnexportedField(t, monitor, "metricsHistory", mh)
router := &Router{monitor: monitor}
req := httptest.NewRequest(
http.MethodGet,
"/api/metrics-store/history?resourceType=storage&resourceId=pve1:local-zfs&metric=disk&range=1h",
nil,
)
rec := httptest.NewRecorder()
router.handleMetricsHistory(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d", rec.Code)
}
var resp metricsHistoryResponse
if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if resp.Source != "memory" {
t.Fatalf("expected source memory, got %q", resp.Source)
}
if resp.Metric != "disk" {
t.Fatalf("expected metric disk, got %q", resp.Metric)
}
if len(resp.Points) < 2 {
t.Fatalf("expected at least 2 points, got %d", len(resp.Points))
}
}
func TestMetricsHistoryCanonicalUnraidStorageUsesSyncedUnifiedMetrics(t *testing.T) {
cfg := metrics.DefaultConfig(t.TempDir())
store, err := metrics.NewStore(cfg)
if err != nil {
t.Fatalf("metrics.NewStore() error = %v", err)
}
defer func() { _ = store.Close() }()
resourceStore := unifiedresources.NewMonitorAdapter(nil)
state := models.NewState()
state.UpsertHost(models.Host{
ID: "host-tower",
Hostname: "tower",
Status: "online",
LastSeen: time.Now().UTC(),
MachineID: "machine-tower",
Disks: []models.Disk{
{Mountpoint: "/mnt/user", Total: 1000, Used: 400, Free: 600, Usage: 40},
},
Unraid: &models.HostUnraidStorage{
ArrayStarted: true,
ArrayState: "STARTED",
NumProtected: 1,
},
})
monitor := &monitoring.Monitor{}
setUnexportedField(t, monitor, "state", state)
setUnexportedField(t, monitor, "metricsHistory", monitoring.NewMetricsHistory(1024, 24*time.Hour))
setUnexportedField(t, monitor, "metricsStore", store)
monitor.SetResourceStore(resourceStore)
router := &Router{monitor: monitor}
req := httptest.NewRequest(
http.MethodGet,
"/api/metrics-store/history?resourceType=storage&resourceId=host-tower/storage:unraid-array&metric=disk&range=7d",
nil,
)
rec := httptest.NewRecorder()
router.handleMetricsHistory(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d", rec.Code)
}
var resp metricsHistoryResponse
if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if len(resp.Points) == 0 {
t.Fatalf("expected canonical unraid storage history points, got none")
}
if math.Abs(resp.Points[len(resp.Points)-1].Value-40.0) > 0.001 {
t.Fatalf("expected last point 40.0, got %f", resp.Points[len(resp.Points)-1].Value)
}
}