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
import { renderHook } from '@solidjs/testing-library';
import { createSignal } from 'solid-js';
import { createStore, reconcile } from 'solid-js/store';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { AlertsAPI } from '@/api/alerts';
import { createAlertAcknowledgementRequests } from '@/stores/alertAcknowledgementRequests';
import { notificationStore } from '@/stores/notifications';
import type { Alert, AlertDeliveryDiagnosis } from '@/types/api';
import { RELATIVE_TIME_TICK_MS } from '@/utils/relativeTimeClock';
import { useAlertOverviewState } from '../useAlertOverviewState';
vi.mock('@/api/alerts', () => ({
AlertsAPI: {
getDeliveryDiagnoses: vi.fn(),
acknowledge: vi.fn(),
bulkAcknowledge: vi.fn(),
unacknowledge: vi.fn(),
},
}));
vi.mock('@/stores/notifications', () => ({
notificationStore: {
error: vi.fn(),
success: vi.fn(),
},
}));
vi.mock('@/utils/logger', () => ({
logger: {
error: vi.fn(),
},
}));
function makeAlert(id: string, startTime: string, acknowledged = false): Alert {
return {
id,
type: 'cpu',
level: 'warning',
resourceId: `vm-${id}`,
resourceName: `VM ${id}`,
node: 'node-1',
message: `CPU high on ${id}`,
startTime,
acknowledged,
} as Alert;
}
describe('useAlertOverviewState', () => {
beforeEach(() => {
vi.useFakeTimers();
vi.setSystemTime(new Date('2026-03-22T12:00:00Z'));
vi.mocked(AlertsAPI.getDeliveryDiagnoses).mockReset().mockResolvedValue([]);
vi.mocked(AlertsAPI.acknowledge).mockReset();
vi.mocked(AlertsAPI.unacknowledge).mockReset();
vi.mocked(AlertsAPI.bulkAcknowledge).mockReset();
vi.mocked(notificationStore.success).mockReset();
vi.mocked(notificationStore.error).mockReset();
});
afterEach(() => {
vi.useRealTimers();
});
it('invalidates pending diagnosis reads when the active set becomes empty', async () => {
let finish!: (value: AlertDeliveryDiagnosis[]) => void;
vi.mocked(AlertsAPI.getDeliveryDiagnoses).mockReturnValueOnce(
new Promise((resolve) => {
finish = resolve;
}),
);
const [activeAlerts, setActiveAlerts] = createSignal<Record<string, Alert>>({
a1: makeAlert('a1', new Date().toISOString()),
});
const { result } = renderHook(() =>
useAlertOverviewState({
activeAlerts,
overrides: () => [],
showAcknowledged: () => true,
updateAlert: vi.fn(),
acknowledgementRequests: createAlertAcknowledgementRequests(),
}),
);
expect(AlertsAPI.getDeliveryDiagnoses).toHaveBeenCalledOnce();
setActiveAlerts({});
finish([{ alertIdentifier: 'a1', reason: 'ready' } as AlertDeliveryDiagnosis]);
await Promise.resolve();
expect(result.deliveryDiagnoses()).toEqual({});
});
it('does not accept an older success when a newer periodic refresh fails', async () => {
let finishOlder!: (value: AlertDeliveryDiagnosis[]) => void;
const retained = {
alertIdentifier: 'a1',
reason: 'notifications_disabled',
} as AlertDeliveryDiagnosis;
vi.mocked(AlertsAPI.getDeliveryDiagnoses)
.mockResolvedValueOnce([retained])
.mockReturnValueOnce(
new Promise((resolve) => {
finishOlder = resolve;
}),
)
.mockRejectedValueOnce(new Error('refresh unavailable'));
const { result } = renderHook(() =>
useAlertOverviewState({
activeAlerts: () => ({ a1: makeAlert('a1', new Date().toISOString()) }),
overrides: () => [],
showAcknowledged: () => true,
updateAlert: vi.fn(),
acknowledgementRequests: createAlertAcknowledgementRequests(),
}),
);
await Promise.resolve();
expect(result.deliveryDiagnoses()).toEqual({ a1: retained });
await vi.advanceTimersByTimeAsync(60_000);
await vi.advanceTimersByTimeAsync(60_000);
expect(AlertsAPI.getDeliveryDiagnoses).toHaveBeenCalledTimes(3);
finishOlder([{ alertIdentifier: 'a1', reason: 'ready' } as AlertDeliveryDiagnosis]);
await Promise.resolve();
expect(result.deliveryDiagnoses()).toEqual({ a1: retained });
});
it('refreshes diagnoses once a minute, not on the 30-second age clock', async () => {
renderHook(() =>
useAlertOverviewState({
activeAlerts: () => ({ a1: makeAlert('a1', new Date().toISOString()) }),
overrides: () => [],
showAcknowledged: () => true,
updateAlert: vi.fn(),
acknowledgementRequests: createAlertAcknowledgementRequests(),
}),
);
expect(AlertsAPI.getDeliveryDiagnoses).toHaveBeenCalledOnce();
await vi.advanceTimersByTimeAsync(RELATIVE_TIME_TICK_MS);
expect(AlertsAPI.getDeliveryDiagnoses).toHaveBeenCalledOnce();
await vi.advanceTimersByTimeAsync(60_000 - RELATIVE_TIME_TICK_MS);
expect(AlertsAPI.getDeliveryDiagnoses).toHaveBeenCalledTimes(2);
});
it('ignores pending responses and stops periodic reads after disposal', async () => {
let finish!: (value: AlertDeliveryDiagnosis[]) => void;
vi.mocked(AlertsAPI.getDeliveryDiagnoses).mockReturnValueOnce(
new Promise((resolve) => {
finish = resolve;
}),
);
const { result, cleanup } = renderHook(() =>
useAlertOverviewState({
activeAlerts: () => ({ a1: makeAlert('a1', new Date().toISOString()) }),
overrides: () => [],
showAcknowledged: () => true,
updateAlert: vi.fn(),
acknowledgementRequests: createAlertAcknowledgementRequests(),
}),
);
cleanup();
finish([{ alertIdentifier: 'a1', reason: 'ready' } as AlertDeliveryDiagnosis]);
await Promise.resolve();
await vi.advanceTimersByTimeAsync(120_000);
expect(result.deliveryDiagnoses()).toEqual({});
expect(AlertsAPI.getDeliveryDiagnoses).toHaveBeenCalledOnce();
});
it('owns overview stats, filtering, and acknowledge flows outside the tab shell', async () => {
const now = Date.now();
const warning = () => makeAlert('warning', new Date(now - 60_000).toISOString(), false);
// Keyed like the websocket store: updateAlert merges into the stored
// alert and server payloads replace it in place.
const [alertsById, setAlertsById] = createStore<Record<string, Alert>>({
warning: warning(),
acknowledged: makeAlert('acknowledged', new Date(now - 2 * 60_000).toISOString(), true),
old: makeAlert('old', new Date(now - 3 * 86_400_000).toISOString(), false),
});
const activeAlerts = () => alertsById;
const [showAcknowledged, setShowAcknowledged] = createSignal(false);
const updateAlert = vi.fn((alertIdentifier: string, updates: Partial<Alert>) => {
setAlertsById(alertIdentifier, { ...alertsById[alertIdentifier], ...updates });
});
vi.mocked(AlertsAPI.acknowledge).mockResolvedValue(undefined as any);
vi.mocked(AlertsAPI.unacknowledge).mockResolvedValue(undefined as any);
vi.mocked(AlertsAPI.bulkAcknowledge).mockResolvedValue({
results: [
{ alertIdentifier: 'warning', success: true },
{ alertIdentifier: 'old', success: false },
],
} as any);
const { result } = renderHook(() =>
useAlertOverviewState({
activeAlerts,
overrides: () => [],
showAcknowledged,
updateAlert,
acknowledgementRequests: createAlertAcknowledgementRequests(),
}),
);
expect(result.alertStats()).toMatchObject({
active: 2,
acknowledged: 1,
total24h: 2,
overrides: 0,
});
expect(result.filteredAlerts().map((alert) => alert.id)).toEqual(['warning', 'old']);
await result.handleAlertAcknowledgement(activeAlerts().warning);
expect(AlertsAPI.acknowledge).toHaveBeenCalledWith('warning');
expect(updateAlert).toHaveBeenCalledWith(
'warning',
expect.objectContaining({ acknowledged: true }),
);
expect(notificationStore.success).toHaveBeenCalledWith('Alert acknowledged');
expect(result.processingAlerts().has('warning')).toBe(true);
// Hiding/counting acknowledgement is not deletion or measured recovery.
expect(result.alertStats()).toMatchObject({ active: 1, acknowledged: 2 });
expect(result.filteredAlerts().map((alert) => alert.id)).toEqual(['old']);
expect(Object.keys(activeAlerts())).toHaveLength(3);
setShowAcknowledged(true);
expect(result.filteredAlerts().map((alert) => alert.id)).toEqual([
'old',
'warning',
'acknowledged',
]);
setShowAcknowledged(false);
// The server confirms, then another session unacknowledges: the card
// returns without a reload.
setAlertsById('warning', reconcile({ ...warning(), acknowledged: true, ackUser: 'admin' }));
expect(result.filteredAlerts().map((alert) => alert.id)).toEqual(['old']);
setAlertsById('warning', reconcile(warning()));
expect(result.filteredAlerts().map((alert) => alert.id)).toEqual(['warning', 'old']);
expect(result.alertStats()).toMatchObject({ active: 2, acknowledged: 1 });
vi.advanceTimersByTime(1500);
expect(result.processingAlerts().has('warning')).toBe(false);
await result.handleAlertAcknowledgement(alertsById.warning);
vi.advanceTimersByTime(1500);
await result.handleBulkAcknowledge();
expect(AlertsAPI.bulkAcknowledge).toHaveBeenCalledWith(['old']);
expect(updateAlert).toHaveBeenCalledWith(
'warning',
expect.objectContaining({ acknowledged: true }),
);
expect(notificationStore.error).toHaveBeenCalledWith('Failed to acknowledge 1 alert.');
});
it('keeps a stable id order for alerts sharing a startTime (#1218)', () => {
const sharedStart = new Date(Date.now() - 60_000).toISOString();
const [activeAlerts] = createSignal<Record<string, Alert>>({
zeta: makeAlert('zeta', sharedStart),
alpha: makeAlert('alpha', sharedStart),
mid: makeAlert('mid', sharedStart),
});
const { result } = renderHook(() =>
useAlertOverviewState({
activeAlerts,
overrides: () => [],
showAcknowledged: () => true,
updateAlert: vi.fn(),
acknowledgementRequests: createAlertAcknowledgementRequests(),
}),
);
expect(result.filteredAlerts().map((alert) => alert.id)).toEqual(['alpha', 'mid', 'zeta']);
});
it('counts alerts with missing startTime in total24h', () => {
const now = Date.now();
const [activeAlerts] = createSignal<Record<string, Alert>>({
recent: makeAlert('recent', new Date(now - 60_000).toISOString()),
missing: { ...makeAlert('missing', ''), startTime: undefined as unknown as string },
invalid: { ...makeAlert('invalid', 'bad-date'), startTime: 'not-a-date' },
old: makeAlert('old', new Date(now - 3 * 86_400_000).toISOString()),
});
const { result } = renderHook(() =>
useAlertOverviewState({
activeAlerts,
overrides: () => [],
showAcknowledged: () => true,
updateAlert: vi.fn(),
acknowledgementRequests: createAlertAcknowledgementRequests(),
}),
);
const stats = result.alertStats();
expect(stats.active).toBe(4);
expect(stats.total24h).toBe(3);
expect(stats.acknowledged).toBe(0);
});
it('groups only explicit shared-system correlations across resources', () => {
const startTime = new Date(Date.now() - 60_000).toISOString();
const connection = {
...makeAlert('connection', startTime),
resourceId: 'pve:delly',
correlation: {
key: 'pve:delly',
kind: 'shared-system' as const,
role: 'primary' as const,
reason: 'proxmox-connection-ownership',
},
};
const node = {
...makeAlert('node', startTime),
resourceId: 'node/delly/pve-1',
level: 'critical' as const,
correlation: {
key: 'pve:delly',
kind: 'shared-system' as const,
role: 'supporting' as const,
reason: 'proxmox-node-membership',
},
};
const [activeAlerts] = createSignal<Record<string, Alert>>({ connection, node });
const { result } = renderHook(() =>
useAlertOverviewState({
activeAlerts,
overrides: () => [],
showAcknowledged: () => true,
updateAlert: vi.fn(),
acknowledgementRequests: createAlertAcknowledgementRequests(),
}),
);
expect(result.groupedAlerts()).toEqual([
expect.objectContaining({
key: 'correlation:shared-system:pve:delly',
primary: connection,
related: [node],
correlated: true,
}),
]);
});
it('groups explicit infrastructure synthesis without hiding the supporting detector', () => {
const startTime = new Date(Date.now() - 60_000).toISOString();
const root = {
...makeAlert('root', startTime),
resourceId: 'agent:edge-1',
correlation: {
key: 'infrastructure:root',
kind: 'infrastructure-incident' as const,
role: 'primary' as const,
reason: 'Supported by canonical relationships.',
failureClass: 'runtime' as const,
inference: 'supported-cause' as const,
},
};
const symptom = {
...makeAlert('symptom', startTime),
resourceId: 'availability:checkout',
correlation: {
key: 'infrastructure:root',
kind: 'infrastructure-incident' as const,
role: 'supporting' as const,
reason: 'Grouped beneath Edge host.',
failureClass: 'network-path' as const,
inference: 'supported-cause' as const,
},
};
const [activeAlerts] = createSignal<Record<string, Alert>>({ root, symptom });
const { result } = renderHook(() =>
useAlertOverviewState({
activeAlerts,
overrides: () => [],
showAcknowledged: () => true,
updateAlert: vi.fn(),
acknowledgementRequests: createAlertAcknowledgementRequests(),
}),
);
expect(result.groupedAlerts()).toEqual([
expect.objectContaining({
key: 'correlation:infrastructure-incident:infrastructure:root',
primary: root,
related: [symptom],
correlated: true,
}),
]);
});
it('does not infer correlation by truncating resource paths', () => {
const startTime = new Date(Date.now() - 60_000).toISOString();
const first = { ...makeAlert('first', startTime), resourceId: 'host/one/disk:sda' };
const second = { ...makeAlert('second', startTime), resourceId: 'host/one/disk:sdb' };
const [activeAlerts] = createSignal<Record<string, Alert>>({ first, second });
const { result } = renderHook(() =>
useAlertOverviewState({
activeAlerts,
overrides: () => [],
showAcknowledged: () => true,
updateAlert: vi.fn(),
acknowledgementRequests: createAlertAcknowledgementRequests(),
}),
);
expect(result.groupedAlerts()).toHaveLength(2);
expect(result.groupedAlerts().every((group) => !group.correlated)).toBe(true);
});
it('still groups multiple detector signals for the exact same resource', () => {
const startTime = new Date(Date.now() - 60_000).toISOString();
const first = { ...makeAlert('first', startTime), resourceId: 'vm/delly/100' };
const second = { ...makeAlert('second', startTime), resourceId: 'vm/delly/100' };
const [activeAlerts] = createSignal<Record<string, Alert>>({ first, second });
const { result } = renderHook(() =>
useAlertOverviewState({
activeAlerts,
overrides: () => [],
showAcknowledged: () => true,
updateAlert: vi.fn(),
acknowledgementRequests: createAlertAcknowledgementRequests(),
}),
);
expect(result.groupedAlerts()).toEqual([
expect.objectContaining({
key: 'resource:vm/delly/100',
related: [second],
correlated: false,
}),
]);
});
});