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 {
buildAvailabilitySettingsPath,
buildAvailabilityTargetAddPath,
getAvailabilityTargetAddKind,
getAvailabilityTargetAddressLabel,
getAvailabilityTargetKindLabel,
getAvailabilityTargetMethodLabel,
getAvailabilityTargetProbeSourceLabel,
getAvailabilityTargetHealth,
getAvailabilityTargetStatusClass,
getAvailabilityTargetStatusLabel,
getAvailabilityTargetStatusTitle,
getAvailabilityTargetsSummary,
normalizeAvailabilityTargetKind,
shouldOpenAvailabilityTargetAddDialog,
} from '../availabilitySettingsModel';
import type { AvailabilityTarget } from '@/api/availabilityTargets';
const target = (overrides: Partial<AvailabilityTarget> = {}): AvailabilityTarget => ({
id: 'mqtt-broker',
name: 'MQTT broker',
address: 'mqtt.local',
protocol: 'tcp',
port: 1883,
enabled: true,
...overrides,
});
describe('availabilitySettingsModel', () => {
it('owns the canonical monitoring availability settings path', () => {
expect(buildAvailabilitySettingsPath()).toBe('/settings/monitoring/availability');
expect(buildAvailabilityTargetAddPath()).toBe('/settings/monitoring/availability?add=target');
expect(buildAvailabilityTargetAddPath('machine')).toBe(
'/settings/monitoring/availability?add=target&targetKind=machine',
);
expect(buildAvailabilityTargetAddPath('service')).toBe(
'/settings/monitoring/availability?add=target&targetKind=service',
);
expect(
shouldOpenAvailabilityTargetAddDialog('/settings/monitoring/availability', '?add=target'),
).toBe(true);
expect(
shouldOpenAvailabilityTargetAddDialog(
'/settings/monitoring/availability',
'?add=target&targetKind=machine',
),
).toBe(true);
expect(
shouldOpenAvailabilityTargetAddDialog(
'/settings/monitoring/availability',
'?add=target&targetKind=vm',
),
).toBe(false);
expect(
getAvailabilityTargetAddKind(
'/settings/monitoring/availability',
'?add=target&targetKind=machine',
),
).toBe('machine');
expect(getAvailabilityTargetAddKind('/settings/monitoring/availability', '?add=target')).toBe(
undefined,
);
expect(
shouldOpenAvailabilityTargetAddDialog('/settings/infrastructure', '?add=availability'),
).toBe(false);
expect(normalizeAvailabilityTargetKind('Machine')).toBe('machine');
expect(normalizeAvailabilityTargetKind('vm')).toBe(undefined);
});
it('formats endpoint methods and addresses without infrastructure copy', () => {
expect(getAvailabilityTargetMethodLabel(target())).toBe('TCP 1883');
expect(getAvailabilityTargetAddressLabel(target())).toBe('mqtt.local:1883');
expect(
getAvailabilityTargetAddressLabel(
target({ protocol: 'http', address: 'http://sensor.local', path: '/health' }),
),
).toBe('http://sensor.local/health');
expect(
getAvailabilityTargetAddressLabel(
target({ protocol: 'http', address: 'http://sensor.local/', path: '/health' }),
),
).toBe('http://sensor.local/health');
expect(getAvailabilityTargetMethodLabel(target({ protocol: 'icmp', port: undefined }))).toBe(
'ICMP ping',
);
expect(getAvailabilityTargetKindLabel(target({ targetKind: 'machine' }))).toBe('Machine');
expect(getAvailabilityTargetKindLabel(target())).toBe('Service');
});
it('summarizes saved availability targets from their probe state', () => {
expect(
getAvailabilityTargetStatusLabel(
target({
status: {
...target(),
targetId: 'mqtt-broker',
available: true,
lastChecked: '2026-10-05T00:00:00Z',
latencyMillis: 12,
},
}),
),
).toBe('Online · 12 ms');
expect(
getAvailabilityTargetsSummary([
target(),
target({
id: 'http-health',
name: 'HTTP health',
protocol: 'http',
address: 'http://service.local',
status: {
...target(),
targetId: 'http-health',
available: false,
lastChecked: '2026-10-05T00:00:00Z',
},
}),
]),
).toBe('1 needs attention · 2 enabled');
expect(
getAvailabilityTargetsSummary([
target({
protocol: 'udp',
port: 27015,
status: {
...target(),
targetId: 'steam-server',
protocol: 'udp',
available: false,
lastChecked: '2026-10-05T00:00:00Z',
outcome: 'indeterminate',
},
}),
]),
).toBe('1 needs attention · 1 enabled');
expect(
getAvailabilityTargetsSummary([
target({
id: 'closed-port',
status: {
...target(),
targetId: 'closed-port',
available: false,
lastChecked: '2026-10-05T00:00:00Z',
},
}),
target({
id: 'silent-port',
protocol: 'udp',
port: 27015,
status: {
...target(),
targetId: 'silent-port',
protocol: 'udp',
available: false,
lastChecked: '2026-10-05T00:00:00Z',
outcome: 'indeterminate',
},
}),
]),
).toBe('2 need attention · 2 enabled');
expect(getAvailabilityTargetStatusClass(target({ enabled: false }))).toBe(
'bg-surface-alt text-muted',
);
expect(getAvailabilityTargetStatusClass(target())).toBe(
'bg-sky-100 text-sky-700 dark:bg-sky-900/25 dark:text-sky-300',
);
expect(
getAvailabilityTargetStatusClass(
target({
status: {
...target(),
targetId: 'mqtt-broker',
available: true,
lastChecked: '2026-10-05T00:00:00Z',
latencyMillis: 12,
},
}),
),
).toBe('bg-emerald-100 text-emerald-700 dark:bg-emerald-900/25 dark:text-emerald-300');
expect(
getAvailabilityTargetStatusClass(
target({
status: {
...target(),
targetId: 'mqtt-broker',
available: false,
lastChecked: '2026-10-05T00:00:00Z',
consecutiveFailures: 2,
},
}),
),
).toBe('bg-rose-100 text-rose-700 dark:bg-rose-900/25 dark:text-rose-300');
});
it('attributes probe-reported results to the assigned agent host', () => {
const options = [{ id: 'host-edge-01', label: 'Edge 01' }];
const probed = target({
probeAgentId: 'host-edge-01',
status: {
...target(),
targetId: 'mqtt-broker',
available: true,
lastChecked: '2026-10-05T00:00:00Z',
latencyMillis: 12,
probeAgentId: 'host-edge-01',
},
});
expect(getAvailabilityTargetProbeSourceLabel(probed, options)).toBe('via Edge 01');
// A locally executed check carries no attribution chip.
expect(
getAvailabilityTargetProbeSourceLabel(
target({ status: { ...target(), targetId: 'mqtt-broker', available: true } }),
options,
),
).toBeNull();
// Unknown hosts degrade to the raw id rather than disappearing.
expect(
getAvailabilityTargetProbeSourceLabel(
target({
status: {
...target(),
targetId: 'mqtt-broker',
available: true,
lastChecked: '2026-10-05T00:00:00Z',
probeAgentId: 'host-gone',
},
}),
options,
),
).toBe('via host-gone');
});
it('renders a stale probe assignment with the existing indeterminate treatment', () => {
const stale = target({
probeAgentId: 'host-edge-01',
status: {
...target(),
targetId: 'mqtt-broker',
available: false,
lastChecked: '2026-10-05T00:00:00Z',
outcome: 'indeterminate',
lastError: 'no recent report from probe agent',
probeAgentId: 'host-edge-01',
},
});
expect(getAvailabilityTargetStatusLabel(stale)).toBe('No recent probe report');
// No new visual language: it reuses the amber indeterminate badge.
expect(getAvailabilityTargetStatusClass(stale)).toBe(
'bg-amber-100 text-amber-700 dark:bg-amber-900/25 dark:text-amber-300',
);
// The UDP open-or-filtered case keeps its own copy.
expect(
getAvailabilityTargetStatusLabel(
target({
status: {
...target(),
targetId: 'mqtt-broker',
available: true,
lastChecked: '2026-10-05T00:00:00Z',
outcome: 'indeterminate',
},
}),
),
).toBe('Open or filtered');
});
it('counts a failing check as offline only after its failure threshold, like Machines', () => {
const failing = (consecutiveFailures: number) =>
target({
failureThreshold: 2,
status: {
...target(),
targetId: 'solar',
available: false,
lastChecked: '2026-10-05T00:00:00Z',
consecutiveFailures,
failureThreshold: 2,
lastError: 'http probe returned 503 Service Unavailable',
},
});
expect(getAvailabilityTargetHealth(failing(1))).toBe('attention');
expect(getAvailabilityTargetHealth(failing(2))).toBe('offline');
expect(getAvailabilityTargetsSummary([failing(1), failing(3), target()])).toBe(
'2 need attention · 1 offline · 3 enabled',
);
expect(getAvailabilityTargetStatusClass(failing(1))).toContain('bg-amber-100');
expect(getAvailabilityTargetStatusTitle(failing(1))).toBe(
'1 failed check in a row. It counts as offline after 2.',
);
expect(getAvailabilityTargetStatusTitle(failing(2))).toBeUndefined();
});
it('keeps the threshold for a single-location check the backend marks unavailable', () => {
const unavailable = (consecutiveFailures: number) =>
target({
status: {
...target(),
targetId: 'mqtt-broker',
available: false,
lastChecked: '2026-10-05T00:00:00Z',
aggregateState: 'unavailable',
consecutiveFailures,
},
});
// Default threshold is 2, as in internal/config/availability.go.
expect(getAvailabilityTargetHealth(unavailable(1))).toBe('attention');
expect(getAvailabilityTargetHealth(unavailable(2))).toBe('offline');
});
it('names expired loaded evidence without overriding pause or stopped-probe copy', () => {
const start = Date.parse('2026-10-10T12:00:00Z');
const check = target({
status: {
...target(),
targetId: 'mqtt-broker',
available: true,
aggregateState: 'healthy',
expectedLocations: 2,
lastChecked: new Date(start).toISOString(),
},
});
const resource = {
type: 'network-endpoint',
platformType: 'availability',
status: 'online',
availability: {
...check.status,
evidence: { validUntil: new Date(start + 10_000).toISOString() },
},
} as never;
expect(getAvailabilityTargetStatusLabel(check, resource, start)).toBe(
'Available from all 2 locations',
);
expect(getAvailabilityTargetStatusLabel(check, resource, start + 30_000)).toBe('Stale');
expect(
getAvailabilityTargetStatusLabel({ ...check, enabled: false }, resource, start + 30_000),
).toBe('Paused');
expect(
getAvailabilityTargetStatusLabel(
{
...check,
status: {
...check.status!,
outcome: 'indeterminate',
lastError: 'no recent report from probe agent',
},
},
resource,
start + 30_000,
),
).toBe('No recent probe report');
});
it('defers to the Machines status of the loaded resource', () => {
const healthyTarget = target({
status: {
...target(),
targetId: 'mqtt-broker',
available: true,
lastChecked: '2026-10-05T00:00:00Z',
},
});
const unresolvedResource = {
id: 'availability:mqtt-broker',
type: 'network-endpoint',
name: 'MQTT broker',
status: 'online',
lastSeen: Date.now(),
availability: { targetId: 'mqtt-broker', correlationState: 'unresolved' },
} as never;
expect(getAvailabilityTargetHealth(healthyTarget)).toBe('healthy');
expect(getAvailabilityTargetHealth(healthyTarget, unresolvedResource)).toBe('attention');
expect(getAvailabilityTargetsSummary([healthyTarget], () => unresolvedResource)).toBe(
'1 needs attention · 1 enabled',
);
});
});