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 { describe, expect, it } from 'vitest';
import { ALERT_RESOURCE_METRIC_OFF_VALUE } from '@/components/Alerts/alertResourceTableModel';
import type { AlertConfig } from '@/types/alerts';
import {
ALERT_DOCKER_GAP_VALIDATION_ERROR,
buildAlertsConfigurationPayload,
createDefaultAlertsConfigurationSnapshot,
FACTORY_DOCKER_DEFAULTS,
FACTORY_GUEST_DEFAULTS,
FACTORY_STORAGE_DEFAULT,
readAlertsConfigurationSnapshot,
} from '../alertsConfigurationModel';
describe('alertsConfigurationModel', () => {
it('creates the canonical default snapshot', () => {
const snapshot = createDefaultAlertsConfigurationSnapshot();
expect(snapshot.identitySchemaVersion).toBe(0);
expect(snapshot.guestDefaults.cpu).toBe(FACTORY_GUEST_DEFAULTS.cpu);
expect(snapshot.dockerDefaults.serviceWarnGapPercent).toBe(
FACTORY_DOCKER_DEFAULTS.serviceWarnGapPercent,
);
expect(snapshot.storageDefault).toBe(FACTORY_STORAGE_DEFAULT);
expect(snapshot.timeThresholds.guest).toBe(5);
expect(snapshot.timeThresholds['vmware-host']).toBe(5);
expect(snapshot.vmwareDefaults.usage).toBe(85);
expect(snapshot.scheduleCooldown.enabled).toBe(true);
expect(snapshot.initialNotify).toBe('all');
expect(snapshot.backupDefaults.ignoreVMIDs).toEqual([]);
});
it('normalizes alert config into the runtime snapshot', () => {
const config = {
identitySchemaVersion: 1,
enabled: true,
guestDefaults: {
cpu: { trigger: 91, clear: 86 },
disableConnectivity: true,
poweredOffSeverity: 'critical',
},
nodeDefaults: {},
agentDefaults: {},
storageDefault: { trigger: 88, clear: 83 },
overrides: {},
dockerDefaults: {
serviceWarnGapPercent: 40,
serviceCriticalGapPercent: 10,
statePoweredOffSeverity: 'critical',
},
backupDefaults: {
enabled: true,
warningDays: 30,
criticalDays: 10,
ignoreVMIDs: [' 101 ', '101', ''],
},
vmwareDefaults: {
cpu: { trigger: 83, clear: 78 },
usage: { trigger: 91, clear: 86 },
},
snapshotDefaults: {
enabled: true,
warningDays: 25,
criticalDays: 5,
},
schedule: {
quietHours: {
enabled: true,
start: '21:00',
end: '06:00',
days: [1, 3, 5],
},
cooldown: 45,
maxAlertsHour: 7,
initialNotify: 'apprise',
escalation: {
enabled: true,
levels: [{ after: 30, notify: 'APPRISE' }],
},
},
} as AlertConfig;
const snapshot = readAlertsConfigurationSnapshot(config);
expect(snapshot.identitySchemaVersion).toBe(1);
expect(snapshot.guestDefaults.cpu).toBe(91);
expect(snapshot.guestDisableConnectivity).toBe(true);
expect(snapshot.guestPoweredOffSeverity).toBe('critical');
expect(snapshot.dockerDefaults.serviceWarnGapPercent).toBe(40);
expect(snapshot.dockerDefaults.serviceCriticalGapPercent).toBe(40);
expect(snapshot.backupDefaults.warningDays).toBe(10);
expect(snapshot.vmwareDefaults.cpu).toBe(83);
expect(snapshot.vmwareDefaults.usage).toBe(91);
expect(snapshot.backupDefaults.criticalDays).toBe(10);
expect(snapshot.backupDefaults.ignoreVMIDs).toEqual(['101']);
expect(snapshot.snapshotDefaults.warningDays).toBe(5);
expect(snapshot.snapshotDefaults.criticalDays).toBe(5);
expect(snapshot.scheduleQuietHours.days).toEqual({
sunday: false,
monday: true,
tuesday: false,
wednesday: true,
thursday: false,
friday: true,
saturday: false,
});
expect(snapshot.scheduleCooldown.maxAlerts).toBe(7);
expect(snapshot.initialNotify).toBe('apprise');
expect(snapshot.scheduleEscalation.levels).toEqual([{ after: 30, notify: 'apprise' }]);
});
it('builds the canonical save payload from the runtime snapshot', () => {
const snapshot = createDefaultAlertsConfigurationSnapshot();
snapshot.identitySchemaVersion = 1;
snapshot.guestDefaults.cpu = 92;
snapshot.dockerIgnoredPrefixes = [' web ', ''];
snapshot.guestTagWhitelist = [' prod ', ''];
snapshot.metricTimeThresholds = {
Guest: { CPU: 17 },
} as Record<string, Record<string, number>>;
snapshot.metricEvaluationWindows = {
ALL: { CPU: 300 },
VM: { CPU: 0 },
} as Record<string, Record<string, number>>;
snapshot.scheduleCooldown = {
enabled: true,
minutes: 47,
maxAlerts: 99,
};
snapshot.scheduleGrouping = {
enabled: true,
window: 2,
byNode: true,
byGuest: false,
};
snapshot.initialNotify = 'email';
snapshot.scheduleEscalation = {
enabled: true,
repeatCritical: true,
repeatEvery: 15,
levels: [
{
after: 30,
notify: 'webhook',
destinationIds: ['webhook:pager'],
},
],
};
snapshot.backupDefaults = {
enabled: true,
warningDays: 30,
criticalDays: 10,
freshHours: 12,
staleHours: 48,
alertOrphaned: true,
ignoreVMIDs: [' 101 ', ''],
};
const result = buildAlertsConfigurationPayload({
snapshot,
rawOverridesConfig: { 'guest-1': { disabled: true } },
alertsActivationState: 'active',
alertsActivationConfig: {
enabled: true,
activationTime: '2026-03-22T10:00:00Z',
observationWindowHours: 24,
},
});
expect(result.dockerValidationError).toBeUndefined();
expect(result.alertConfig).toBeDefined();
expect(result.alertConfig?.identitySchemaVersion).toBe(1);
expect(result.alertConfig?.guestDefaults.cpu).toEqual({ trigger: 92, clear: 87 });
expect(result.alertConfig?.vmwareDefaults?.cpu).toEqual({ trigger: 80, clear: 75 });
expect(result.alertConfig?.vmwareDefaults?.usage).toEqual({ trigger: 85, clear: 80 });
expect(result.alertConfig?.dockerIgnoredContainerPrefixes).toEqual(['web']);
expect(result.alertConfig?.guestTagWhitelist).toEqual(['prod']);
expect(result.alertConfig?.metricTimeThresholds).toEqual({ guest: { cpu: 17 } });
expect(result.alertConfig?.metricEvaluationWindows).toEqual({
all: { cpu: 300 },
vm: { cpu: 0 },
});
expect(result.alertConfig?.schedule?.cooldown).toBe(47);
expect(result.alertConfig?.schedule?.initialNotify).toBe('email');
expect(result.alertConfig?.schedule?.maxAlertsHour).toBe(10);
expect(result.alertConfig?.schedule?.grouping).toEqual({
enabled: true,
window: 120,
byNode: true,
byGuest: false,
});
expect(result.alertConfig?.schedule?.escalation).toEqual({
enabled: true,
repeatCritical: true,
repeatEvery: 15,
levels: [
{
after: 30,
notify: 'webhook',
destinationIds: ['webhook:pager'],
},
],
});
expect(result.alertConfig?.backupDefaults).toMatchObject({
warningDays: 10,
criticalDays: 10,
ignoreVMIDs: ['101'],
});
expect(result.alertConfig?.overrides).toEqual({ 'guest-1': { disabled: true } });
});
it('returns the canonical docker-gap validation error before save', () => {
const snapshot = createDefaultAlertsConfigurationSnapshot();
snapshot.dockerDefaults.serviceWarnGapPercent = 60;
snapshot.dockerDefaults.serviceCriticalGapPercent = 40;
const result = buildAlertsConfigurationPayload({
snapshot,
rawOverridesConfig: {},
alertsActivationState: null,
alertsActivationConfig: null,
});
expect(result.alertConfig).toBeUndefined();
expect(result.dockerValidationError).toBe(ALERT_DOCKER_GAP_VALIDATION_ERROR);
});
// The backend reads a negative default trigger as unset and restores the
// factory threshold, so every Global Defaults Off must reach it as 0.
it('writes an Off global default as trigger 0 in every section and reads it back Off', () => {
const thresholdMetrics = {
guestDefaults: ['cpu', 'memory', 'disk', 'diskRead', 'diskWrite', 'networkIn', 'networkOut'],
nodeDefaults: ['cpu', 'memory', 'disk', 'temperature'],
agentDefaults: ['cpu', 'memory', 'disk', 'diskTemperature'],
pbsDefaults: ['cpu', 'memory'],
kubernetesDefaults: [
'cpu',
'memory',
'disk',
'diskRead',
'diskWrite',
'networkIn',
'networkOut',
],
trueNASDefaults: [
'cpu',
'memory',
'disk',
'usage',
'temperature',
'diskRead',
'diskWrite',
'networkIn',
'networkOut',
],
trueNASDiskDefaults: ['temperature'],
vmwareDefaults: [
'cpu',
'memory',
'disk',
'usage',
'diskRead',
'diskWrite',
'networkIn',
'networkOut',
],
dockerDefaults: ['cpu', 'memory', 'disk'],
} as const;
const payloadSection = {
guestDefaults: 'guestDefaults',
nodeDefaults: 'nodeDefaults',
agentDefaults: 'agentDefaults',
pbsDefaults: 'pbsDefaults',
kubernetesDefaults: 'kubernetesDefaults',
trueNASDefaults: 'truenasDefaults',
trueNASDiskDefaults: 'truenasDiskDefaults',
vmwareDefaults: 'vmwareDefaults',
dockerDefaults: 'dockerDefaults',
} as const;
type Section = keyof typeof thresholdMetrics;
const snapshot = createDefaultAlertsConfigurationSnapshot();
for (const [section, metrics] of Object.entries(thresholdMetrics)) {
const defaults: Record<string, unknown> = snapshot[section as Section];
for (const metric of metrics) {
defaults[metric] = ALERT_RESOURCE_METRIC_OFF_VALUE;
}
}
snapshot.storageDefault = ALERT_RESOURCE_METRIC_OFF_VALUE;
const { alertConfig } = buildAlertsConfigurationPayload({
snapshot,
rawOverridesConfig: {},
alertsActivationState: null,
alertsActivationConfig: null,
});
expect(alertConfig).toBeTruthy();
const payload = alertConfig as unknown as Record<string, Record<string, unknown>>;
for (const [section, metrics] of Object.entries(thresholdMetrics)) {
const written = payload[payloadSection[section as Section]];
for (const metric of metrics) {
expect(written[metric], `${section}.${metric}`).toEqual({ trigger: 0, clear: 0 });
}
}
expect(alertConfig?.storageDefault).toEqual({ trigger: 0, clear: 0 });
const reloaded = readAlertsConfigurationSnapshot(alertConfig as AlertConfig);
for (const [section, metrics] of Object.entries(thresholdMetrics)) {
const defaults: Record<string, unknown> = reloaded[section as Section];
for (const metric of metrics) {
expect(defaults[metric], `${section}.${metric}`).toBe(0);
}
}
expect(reloaded.storageDefault).toBe(0);
});
// The backend reads a critical age of 0 as Off. The editor's Off toggle
// stages -1, which used to be raised to the warning age, so backups and
// snapshots went critical at the warning age instead of never.
it('saves an Off backup or snapshot critical age as 0 and reads it back Off', () => {
const snapshot = createDefaultAlertsConfigurationSnapshot();
snapshot.backupDefaults = {
...snapshot.backupDefaults,
warningDays: 7,
criticalDays: ALERT_RESOURCE_METRIC_OFF_VALUE,
};
snapshot.snapshotDefaults = {
...snapshot.snapshotDefaults,
warningDays: 30,
criticalDays: ALERT_RESOURCE_METRIC_OFF_VALUE,
};
const { alertConfig } = buildAlertsConfigurationPayload({
snapshot,
rawOverridesConfig: {},
alertsActivationState: null,
alertsActivationConfig: null,
});
expect(alertConfig?.backupDefaults?.warningDays).toBe(7);
expect(alertConfig?.backupDefaults?.criticalDays).toBe(0);
expect(alertConfig?.snapshotDefaults?.warningDays).toBe(30);
expect(alertConfig?.snapshotDefaults?.criticalDays).toBe(0);
const reloaded = readAlertsConfigurationSnapshot(alertConfig as AlertConfig);
expect(reloaded.backupDefaults.criticalDays).toBe(0);
expect(reloaded.snapshotDefaults.criticalDays).toBe(0);
});
});