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 {
buildKubernetesWorkloadMetadataId,
buildProxmoxGuestNativeId,
canonicalizeWorkloadFilterType,
getWorkloadCPUFraction,
getWorkloadCPUPercent,
normalizeWorkloadViewModeParam,
resolveWorkloadType,
resolveWorkloadTypeFromString,
getWorkloadMetricsKind,
getCanonicalWorkloadId,
getWorkloadMetadataIdForResource,
getWorkloadMetadataId,
getWorkloadMetadataIdCandidates,
isDockerManagedAppContainer,
getWebInterfaceTargetLabelForWorkload,
} from '@/utils/workloads';
import type { WorkloadGuest } from '@/types/workloads';
describe('workload CPU normalization', () => {
it('round-trips canonical percent without applying allocated core count', () => {
const canonicalPercent = 0.58;
const ratio = getWorkloadCPUFraction(canonicalPercent);
expect(ratio).toBe(0.0058);
expect(getWorkloadCPUPercent(ratio)).toBeCloseTo(canonicalPercent);
});
it('keeps ratios above one as percentages above 100 instead of reinterpreting units', () => {
expect(getWorkloadCPUPercent(2)).toBe(200);
});
it('rejects non-finite values and clamps negative observations to zero', () => {
expect(getWorkloadCPUPercent(Number.NaN)).toBeUndefined();
expect(getWorkloadCPUFraction(Number.POSITIVE_INFINITY)).toBe(0);
expect(getWorkloadCPUPercent(-0.5)).toBe(0);
expect(getWorkloadCPUFraction(-50)).toBe(0);
});
});
describe('resolveWorkloadType', () => {
it('returns workloadType when present', () => {
const guest = { workloadType: 'vm' as const, type: 'system-container' };
expect(resolveWorkloadType(guest)).toBe('vm');
});
it('returns vm for VM type (case insensitive)', () => {
const guest = { type: 'VM' };
expect(resolveWorkloadType(guest)).toBe('vm');
});
it('returns system-container for oci-container type', () => {
const guest = { type: 'oci-container' };
expect(resolveWorkloadType(guest)).toBe('system-container');
});
it('returns app-container for docker type', () => {
const guest = { type: 'docker' };
expect(resolveWorkloadType(guest)).toBe('app-container');
});
it('does not map removed docker-container type alias', () => {
const guest = { type: 'docker-container' };
expect(resolveWorkloadType(guest)).toBe('system-container');
});
it('does not map removed docker_container type alias', () => {
const guest = { type: 'docker_container' };
expect(resolveWorkloadType(guest)).toBe('system-container');
});
it('returns pod for k8s type', () => {
const guest = { type: 'k8s' };
expect(resolveWorkloadType(guest)).toBe('pod');
});
it('returns pod for pod type', () => {
const guest = { type: 'pod' };
expect(resolveWorkloadType(guest)).toBe('pod');
});
it('returns pod for kubernetes type', () => {
const guest = { type: 'kubernetes' };
expect(resolveWorkloadType(guest)).toBe('pod');
});
it('defaults to system-container for unknown type', () => {
const guest = { type: 'unknown' };
expect(resolveWorkloadType(guest)).toBe('system-container');
});
it('defaults to system-container for empty type', () => {
const guest = { type: '' };
expect(resolveWorkloadType(guest)).toBe('system-container');
});
it('defaults to system-container for undefined type', () => {
const guest = { type: undefined } as unknown as WorkloadGuest;
expect(resolveWorkloadType(guest)).toBe('system-container');
});
});
describe('resolveWorkloadTypeFromString', () => {
it('returns vm for canonical vm type', () => {
expect(resolveWorkloadTypeFromString('vm')).toBe('vm');
});
it('returns system-container for canonical system-container type', () => {
expect(resolveWorkloadTypeFromString('system-container')).toBe('system-container');
});
it('returns system-container for canonical oci-container type', () => {
expect(resolveWorkloadTypeFromString('oci-container')).toBe('system-container');
});
it('normalizes qemu to vm', () => {
expect(resolveWorkloadTypeFromString('qemu')).toBe('vm');
});
it('normalizes lxc to system-container', () => {
expect(resolveWorkloadTypeFromString('lxc')).toBe('system-container');
});
it('does not normalize removed container alias', () => {
expect(resolveWorkloadTypeFromString('container')).toBeNull();
});
it('does not normalize removed docker-container alias', () => {
expect(resolveWorkloadTypeFromString('docker-container')).toBeNull();
});
it('does not normalize removed docker_container alias', () => {
expect(resolveWorkloadTypeFromString('docker_container')).toBeNull();
});
});
describe('canonicalizeWorkloadFilterType', () => {
it('canonicalizes supported workload filter aliases to v6 keys', () => {
expect(canonicalizeWorkloadFilterType('docker')).toBe('app-container');
expect(canonicalizeWorkloadFilterType('k8s')).toBe('pod');
expect(canonicalizeWorkloadFilterType('host')).toBe('agent');
});
it('preserves unknown and removed aliases instead of inventing compatibility', () => {
expect(canonicalizeWorkloadFilterType('docker-container')).toBe('docker-container');
expect(canonicalizeWorkloadFilterType('custom-type')).toBe('custom-type');
expect(canonicalizeWorkloadFilterType('')).toBe('');
});
});
describe('getWorkloadMetricsKind', () => {
it('returns vm for vm workload', () => {
const guest = { workloadType: 'vm' as const, type: 'vm' };
expect(getWorkloadMetricsKind(guest)).toBe('vm');
});
it('returns container for system-container workload', () => {
const guest = { workloadType: 'system-container' as const, type: 'system-container' };
expect(getWorkloadMetricsKind(guest)).toBe('container');
});
it('returns dockerContainer for app-container workload', () => {
const guest = { workloadType: 'app-container' as const, type: 'docker' };
expect(getWorkloadMetricsKind(guest)).toBe('dockerContainer');
});
it('returns k8s for pod workload', () => {
const guest = { workloadType: 'pod' as const, type: 'k8s-pod' };
expect(getWorkloadMetricsKind(guest)).toBe('k8s');
});
it('defaults to container for unknown workload type', () => {
const guest = { workloadType: 'unknown' as unknown as 'vm', type: 'unknown' };
expect(getWorkloadMetricsKind(guest)).toBe('container');
});
});
describe('getCanonicalWorkloadId', () => {
it('preserves the supplied VM identity when provider coordinates exist', () => {
const guest = { id: 'orig', type: 'vm', instance: 'homelab', node: 'node1', vmid: 100 };
expect(getCanonicalWorkloadId(guest)).toBe('orig');
});
it('preserves the supplied container identity when provider coordinates exist', () => {
const guest = {
id: 'orig',
type: 'system-container',
instance: 'homelab',
node: 'node2',
vmid: 200,
};
expect(getCanonicalWorkloadId(guest)).toBe('orig');
});
it('returns id for app-container workloads (no instance/node/vmid)', () => {
const guest = {
id: 'app-container:docker-main:container-123',
type: 'docker',
workloadType: 'app-container' as const,
instance: '',
node: '',
vmid: 0,
};
expect(getCanonicalWorkloadId(guest)).toBe('app-container:docker-main:container-123');
});
it('returns id for pod workloads (no instance/node/vmid)', () => {
const guest = {
id: 'pod-456',
type: 'pod',
workloadType: 'pod' as const,
instance: '',
node: '',
vmid: 0,
};
expect(getCanonicalWorkloadId(guest)).toBe('pod-456');
});
it('returns id when vmid is 0', () => {
const guest = { id: 'test', type: 'vm', instance: 'homelab', node: 'node1', vmid: 0 };
expect(getCanonicalWorkloadId(guest)).toBe('test');
});
it('returns id when instance is missing', () => {
const guest = { id: 'test', type: 'vm', instance: '', node: 'node1', vmid: 100 };
expect(getCanonicalWorkloadId(guest)).toBe('test');
});
it('returns id when node is missing', () => {
const guest = { id: 'test', type: 'vm', instance: 'homelab', node: '', vmid: 100 };
expect(getCanonicalWorkloadId(guest)).toBe('test');
});
});
describe('buildProxmoxGuestNativeId', () => {
it('builds legacy metadata keys from instance, node, and vmid', () => {
expect(
buildProxmoxGuestNativeId({
instance: 'Core Fabric',
node: 'pve2',
vmid: 112,
}),
).toBe('Core Fabric:pve2:112');
});
it('returns null when any provider coordinate is missing', () => {
expect(buildProxmoxGuestNativeId({ instance: 'Core Fabric', node: '', vmid: 112 })).toBeNull();
expect(buildProxmoxGuestNativeId({ instance: '', node: 'pve2', vmid: 112 })).toBeNull();
expect(
buildProxmoxGuestNativeId({ instance: 'Core Fabric', node: 'pve2', vmid: 0 }),
).toBeNull();
});
});
describe('getWorkloadMetadataId', () => {
it('uses a stable host-and-name key for Docker-managed app-container URLs', () => {
const guest = {
id: 'app-container:docker-main:container-123',
name: '/grafana',
type: 'docker',
workloadType: 'app-container' as const,
dockerHostId: 'docker-main',
instance: '',
node: '',
vmid: 0,
};
expect(getWorkloadMetadataId(guest)).toBe('app-container:docker-main:name:grafana');
expect(getWorkloadMetadataIdCandidates(guest)).toEqual([
'app-container:docker-main:name:grafana',
'app-container:docker-main:container-123',
]);
});
it('falls back to the canonical workload id when a Docker host id is unavailable', () => {
const guest = {
id: 'app-container:truenas-main:nextcloud',
name: 'nextcloud',
type: 'app-container',
workloadType: 'app-container' as const,
platformType: 'truenas',
instance: '',
node: '',
vmid: 0,
};
expect(getWorkloadMetadataId(guest)).toBe('app-container:truenas-main:nextcloud');
expect(getWorkloadMetadataIdCandidates(guest)).toEqual([
'app-container:truenas-main:nextcloud',
]);
});
it('uses cluster, kind, namespace, and name for Kubernetes pod URL identity', () => {
const oldPod = {
id: 'k8s:cluster-a:pod:pod-uid-old',
name: 'checkout',
type: 'pod',
workloadType: 'pod' as const,
kubernetesClusterId: 'cluster-a',
namespace: 'payments',
instance: '',
node: '',
vmid: 0,
};
const recreatedPod = {
...oldPod,
id: 'k8s:cluster-a:pod:pod-uid-new',
};
expect(buildKubernetesWorkloadMetadataId(oldPod)).toBe(
'k8s-workload:cluster-a:pod:payments:checkout',
);
expect(getWorkloadMetadataIdCandidates(oldPod)).toEqual([
'k8s-workload:cluster-a:pod:payments:checkout',
'k8s:cluster-a:pod:pod-uid-old',
]);
expect(getWorkloadMetadataId(recreatedPod)).toBe(
'k8s-workload:cluster-a:pod:payments:checkout',
);
});
it('does not build a Kubernetes URL identity without every isolation scope', () => {
expect(
buildKubernetesWorkloadMetadataId({
kubernetesClusterId: '',
namespace: 'payments',
name: 'checkout',
}),
).toBeNull();
expect(
buildKubernetesWorkloadMetadataId({
kubernetesClusterId: 'cluster-a',
namespace: '',
name: 'checkout',
}),
).toBeNull();
expect(
buildKubernetesWorkloadMetadataId({
kubernetesClusterId: 'cluster-a',
namespace: 'payments',
name: '',
}),
).toBeNull();
});
});
describe('getWorkloadMetadataIdForResource', () => {
it('uses proxmox guest identity for vm and system-container resources', () => {
expect(
getWorkloadMetadataIdForResource({
id: 'system-container-45cf61f16a6e2c16',
type: 'system-container',
clusterId: 'Core Fabric',
proxmox: {
node: 'pve2',
vmid: 112,
},
} as any),
).toBe('Core Fabric:pve2:112');
});
it('falls back to the resource id when provider metadata coordinates are incomplete', () => {
expect(
getWorkloadMetadataIdForResource({
id: 'vm-123',
type: 'vm',
clusterId: '',
proxmox: {
node: 'pve1',
vmid: 0,
},
} as any),
).toBe('vm-123');
});
});
describe('isDockerManagedAppContainer', () => {
it('returns true for docker-platform app containers', () => {
expect(
isDockerManagedAppContainer({
workloadType: 'app-container',
type: 'app-container',
platformType: 'docker',
containerRuntime: 'docker',
}),
).toBe(true);
});
it('returns false for TrueNAS app containers even when runtime metadata is docker', () => {
expect(
isDockerManagedAppContainer({
workloadType: 'app-container',
type: 'app-container',
platformType: 'truenas',
containerRuntime: 'docker',
}),
).toBe(false);
});
});
describe('getWebInterfaceTargetLabelForWorkload', () => {
it('labels app-container workloads as container', () => {
const guest = { workloadType: 'app-container' as const, type: 'docker' };
expect(getWebInterfaceTargetLabelForWorkload(guest)).toBe('container');
});
it('labels pod workloads as workload', () => {
const guest = { workloadType: 'pod' as const, type: 'pod' };
expect(getWebInterfaceTargetLabelForWorkload(guest)).toBe('workload');
});
it('labels vm workloads as workload', () => {
const guest = { workloadType: 'vm' as const, type: 'qemu' };
expect(getWebInterfaceTargetLabelForWorkload(guest)).toBe('workload');
});
});
describe('normalizeWorkloadViewModeParam', () => {
it('normalizes supported dashboard view mode aliases', () => {
expect(normalizeWorkloadViewModeParam('all')).toBe('all');
expect(normalizeWorkloadViewModeParam('VM')).toBe('vm');
expect(normalizeWorkloadViewModeParam('container')).toBe('container');
expect(normalizeWorkloadViewModeParam('system-container')).toBe('system-container');
expect(normalizeWorkloadViewModeParam('docker')).toBe('app-container');
expect(normalizeWorkloadViewModeParam('app-container')).toBe('app-container');
expect(normalizeWorkloadViewModeParam('k8s')).toBe('pod');
expect(normalizeWorkloadViewModeParam('Kubernetes')).toBe('pod');
expect(normalizeWorkloadViewModeParam('pod')).toBe('pod');
});
it('rejects unsupported dashboard view mode aliases', () => {
expect(normalizeWorkloadViewModeParam('host')).toBeNull();
expect(normalizeWorkloadViewModeParam('')).toBeNull();
});
});
describe('canonical workload identity across placement changes', () => {
it.each(['vm', 'system-container'] as const)(
'keeps the %s resource identity across node migration',
(workloadType) => {
const guest = {
id: 'legacy-row-key',
canonicalResourceId: 'stable-resource',
workloadType,
type: workloadType,
instance: 'cluster-a',
node: 'node-1',
vmid: 101,
};
expect(getCanonicalWorkloadId(guest)).toBe('stable-resource');
expect(getCanonicalWorkloadId({ ...guest, node: 'node-2' })).toBe('stable-resource');
expect(getCanonicalWorkloadId({ ...guest, canonicalResourceId: 'independent-clone' })).toBe(
'independent-clone',
);
},
);
it('uses the supplied resource ID rather than deriving an identity from provider coordinates', () => {
const guest = {
id: 'stable-resource',
type: 'vm',
instance: 'cluster-a',
node: 'node-1',
vmid: 101,
};
expect(getCanonicalWorkloadId(guest)).toBe('stable-resource');
});
});
describe('Proxmox metadata compatibility boundary', () => {
it('retains provider metadata keys while the row uses stable resource identity', () => {
const guest = {
id: 'stable-resource',
canonicalResourceId: 'stable-resource',
name: 'guest-101',
type: 'vm',
instance: 'cluster-a',
node: 'node-1',
vmid: 101,
};
expect(getWorkloadMetadataId(guest)).toBe('cluster-a:node-1:101');
expect(getWorkloadMetadataIdCandidates(guest)).toEqual([
'cluster-a:node-1:101',
'stable-resource',
]);
expect(getWorkloadMetadataId({ ...guest, node: 'node-2' })).toBe('cluster-a:node-2:101');
expect(getCanonicalWorkloadId({ ...guest, node: 'node-2' })).toBe('stable-resource');
});
});