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 { render } from '@solidjs/testing-library';
import {
batch,
createComponent,
createEffect,
createRenderEffect,
createRoot,
createSignal,
Suspense,
} from 'solid-js';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import useWorkloadsSource from '../useWorkloads.ts?raw';
import { guestDiskDeferrals } from '@/components/Workloads/__fixtures__/guestDiskDeferrals';
import type { VM } from '@/types/api';
import type { Resource } from '@/types/resource';
import { getWorkloadGuestDiskRead } from '@/utils/workloadGuestPresentation';
import { getDiskUsagePercent, getWorkloadGroupKey } from '@/components/Workloads/workloadSelectors';
type UseWorkloadsModule = typeof import('@/hooks/useWorkloads');
const sampleResource = {
id: 'cluster-a-pve1-101',
type: 'vm',
name: 'vm-101',
status: 'running',
lastSeen: '2026-02-06T12:00:00Z',
vmid: 101,
node: 'pve1',
instance: 'cluster-a',
metrics: {
cpu: { percent: 25 },
memory: { used: 2 * 1024, total: 4 * 1024, percent: 50 },
disk: { used: 20 * 1024, total: 100 * 1024, percent: 20 },
},
sources: ['proxmox'],
};
const flushAsync = async () => {
await Promise.resolve();
await Promise.resolve();
};
const advanceAndFlush = async (ms: number) => {
vi.advanceTimersByTime(ms);
await flushAsync();
};
const deferred = <T>() => {
let resolve!: (value: T | PromiseLike<T>) => void;
let reject!: (reason?: unknown) => void;
const promise = new Promise<T>((res, rej) => {
resolve = res;
reject = rej;
});
return { promise, resolve, reject };
};
const waitForWorkloadCount = async (getCount: () => number, expectedMin = 1) => {
for (let i = 0; i < 20; i += 1) {
if (getCount() >= expectedMin) {
return;
}
await flushAsync();
}
throw new Error(`Timed out waiting for at least ${expectedMin} workloads`);
};
describe('useWorkloads', () => {
let apiFetchJSONMock: ReturnType<typeof vi.fn>;
let useWorkloads: UseWorkloadsModule['useWorkloads'];
let resetWorkloadsCacheForTests: UseWorkloadsModule['__resetWorkloadsCacheForTests'];
let eventBus: (typeof import('@/stores/events'))['eventBus'];
beforeEach(async () => {
vi.useFakeTimers();
vi.resetModules();
apiFetchJSONMock = vi.fn().mockResolvedValue({
data: [sampleResource],
meta: { totalPages: 1 },
});
vi.doMock('@/utils/apiClient', () => ({
apiFetchJSON: apiFetchJSONMock,
getOrgID: () => 'default',
}));
({ useWorkloads, __resetWorkloadsCacheForTests: resetWorkloadsCacheForTests } =
await import('@/hooks/useWorkloads'));
({ eventBus } = await import('@/stores/events'));
resetWorkloadsCacheForTests();
});
it.each(['api', 'snapshot'] as const)(
'preserves aggregate disk presence and percentage points through %s refreshes',
async (transport) => {
const [snapshot, setSnapshot] = createSignal<Resource[]>([]);
let dispose = () => {};
let result!: ReturnType<UseWorkloadsModule['useWorkloads']>;
createRoot((d) => {
dispose = d;
result = useWorkloads(
() => true,
transport === 'snapshot' ? { resourceSnapshot: snapshot } : {},
);
});
try {
await flushAsync();
for (const [metric, expected] of [
[{ total: 100 }, null],
[{ used: 0 }, null],
[{}, null],
[{ used: 0, total: 100 }, 0],
[{ percent: 0 }, 0],
[{ percent: 0.5 }, 0.5],
[{ percent: 1 }, 1],
[{ value: 0.5 }, 0.5],
[{ value: 0, total: 100, unit: 'bytes' }, null],
[{ value: 0, used: 0, total: 100, unit: 'bytes' }, 0],
[{ value: 0, used: 50, total: 200, unit: 'bytes' }, 25],
[{ value: 0.5, unit: 'percent' }, 0.5],
[{ used: 50, total: 200 }, 25],
[{ percent: -1, used: 0, total: 100 }, null],
[{ percent: Infinity, used: 0, total: 100 }, null],
] as const) {
if (transport === 'snapshot' && 'unit' in metric) continue;
const raw = { ...sampleResource, metrics: { ...sampleResource.metrics, disk: metric } };
if (transport === 'api') {
apiFetchJSONMock.mockResolvedValue({ data: [raw] });
await result.refetch();
} else {
const { percent, value, ...bytes } = metric as {
percent?: number;
value?: number;
total?: number;
used?: number;
};
setSnapshot([
{
...raw,
lastSeen: Date.parse(raw.lastSeen),
memory: { current: 50, used: 2048, total: 4096 },
disk: { ...bytes, current: percent ?? value } as Resource['disk'],
} as unknown as Resource,
]);
}
await flushAsync();
const row = result.workloads()[0];
expect(row.id).toBe(sampleResource.id);
expect(row.telemetryAvailability?.disk).toBe(expected !== null);
expect(getDiskUsagePercent(row)).toBe(expected);
if (expected === null && !('used' in metric)) expect(row.disk.used).toBeUndefined();
expect(row.memory.usage).toBe(50);
}
} finally {
dispose();
}
},
);
it.each(
(['api', 'snapshot'] as const).flatMap((transport) =>
(['vm', 'system-container'] as const).map((type) => ({ transport, type })),
),
)(
'preserves selected guest network interfaces through $transport for $type',
async ({ transport, type }) => {
const platformInterfaces = [
{ name: 'eth0', addresses: ['192.0.2.80'], mac: '02:00:00:00:00:80' },
{ name: 'podman0', addresses: ['10.88.0.1'] },
];
const agentInterfaces = [
{ name: 'ens18', addresses: ['192.0.2.80'], rxBytes: 1024, txBytes: 2048 },
];
const resource: Resource = {
id: `${type}-site-a-2757`,
type,
name: 'guest-2757',
displayName: 'guest-2757',
platformId: 'site-a',
platformType: 'proxmox-pve',
sourceType: 'api',
sources: ['proxmox'],
status: 'running',
lastSeen: Date.parse(sampleResource.lastSeen),
identity: { ips: ['192.0.2.80', '10.88.0.1'] },
metricsTarget: { resourceType: type, resourceId: 'site-a-node-a-2757' },
proxmox: {
vmid: 2757,
nodeName: 'node-a',
instance: 'site-a',
networkInterfaces: platformInterfaces,
},
};
const apiResource = (value: Resource) => ({
...value,
lastSeen: new Date(value.lastSeen).toISOString(),
identity: { ipAddresses: value.identity?.ips },
});
const [snapshot, setSnapshot] = createSignal([resource]);
apiFetchJSONMock.mockResolvedValue({ data: [apiResource(resource)] });
let dispose = () => {};
let result!: ReturnType<UseWorkloadsModule['useWorkloads']>;
createRoot((d) => {
dispose = d;
result = useWorkloads(
() => true,
transport === 'snapshot' ? { resourceSnapshot: snapshot } : {},
);
});
const update = async (value: Resource) => {
if (transport === 'snapshot') setSnapshot([value]);
else {
apiFetchJSONMock.mockResolvedValue({ data: [apiResource(value)] });
await result.refetch();
}
await flushAsync();
};
const check = (
interfaces: typeof platformInterfaces | typeof agentInterfaces,
fromAgent: boolean,
) => {
const guest = result.workloads()[0];
expect(guest.networkInterfaces).toEqual(interfaces);
expect(guest).toMatchObject({
id: resource.id,
canonicalResourceId: resource.id,
metricsTarget: resource.metricsTarget,
vmid: 2757,
node: 'node-a',
instance: 'site-a',
ipAddresses: ['192.0.2.80', '10.88.0.1'],
lastSeen: new Date(resource.lastSeen).toISOString(),
networkInterfacesFromAgent: fromAgent,
});
expect(Date.parse(guest.lastSeen)).toBe(resource.lastSeen);
};
try {
await waitForWorkloadCount(() => result.workloads().length);
check(platformInterfaces, false);
// An agent facet without interfaces does not erase API-provided names
// or make those API readings part of the silent agent's last report.
await update({ ...resource, agent: { agentId: 'linked-agent', stale: true } });
check(platformInterfaces, false);
expect(result.workloads()[0].agentStale).toBe(true);
await update({
...resource,
agent: { agentId: 'linked-agent', networkInterfaces: agentInterfaces },
});
check(agentInterfaces, true);
await update({
...resource,
agent: { agentId: 'linked-agent', stale: true, networkInterfaces: agentInterfaces },
});
check(agentInterfaces, true);
expect(result.workloads()[0].agentStale).toBe(true);
// A reported empty list remains authoritative; do not resurrect a
// different producer's interfaces merely because this list is empty.
await update({ ...resource, agent: { agentId: 'linked-agent', networkInterfaces: [] } });
check([], true);
await update({ ...resource, proxmox: { ...resource.proxmox, networkInterfaces: [] } });
check([], false);
await update({
...resource,
proxmox: { ...resource.proxmox, networkInterfaces: undefined },
});
expect(result.workloads()[0].networkInterfaces).toBeUndefined();
expect(result.workloads()[0].networkInterfacesFromAgent).toBeUndefined();
await update(resource);
check(platformInterfaces, false);
if (transport === 'snapshot') expect(apiFetchJSONMock).not.toHaveBeenCalled();
else expect(apiFetchJSONMock).toHaveBeenCalledTimes(8);
expect(resource.proxmox?.networkInterfaces).toEqual(platformInterfaces);
} finally {
dispose();
}
},
);
it.each([
'invalid',
'0002-01-01T00:00:00Z',
'2026-09-31T11:00:00Z',
'2026-10-04T11:00:00',
'2026-10-04',
])('does not turn a present unusable backup time %s into absence', async (lastBackup) => {
const [snapshot] = createSignal([{ ...sampleResource, proxmox: { lastBackup } }] as any);
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
result = useWorkloads(() => true, { resourceSnapshot: snapshot });
});
try {
await flushAsync();
expect(result!.workloads()[0]?.lastBackup).not.toBe(0);
if (lastBackup !== '0002-01-01T00:00:00Z') {
expect(result!.workloads()[0]?.lastBackup).toBeNaN();
}
} finally {
dispose();
}
});
it('preserves linked-agent RAID arrays and agent ID from the VM resource for guest detail', async () => {
const [snapshot] = createSignal([
{
...sampleResource,
agent: {
agentId: 'host-guest-agent',
agentVersion: '6.4.5',
raid: [
{
device: '/dev/md0',
name: 'data',
level: 'raid1',
state: 'clean',
totalDevices: 2,
activeDevices: 2,
workingDevices: 2,
failedDevices: 0,
spareDevices: 0,
},
],
},
},
] as any);
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
result = useWorkloads(() => true, { resourceSnapshot: snapshot });
});
try {
await flushAsync();
expect(result!.workloads()[0]?.canonicalResourceId).toBe(sampleResource.id);
// The guest drawer judges the agent's disks under this ID's overrides.
expect(result!.workloads()[0]?.agentId).toBe('host-guest-agent');
expect(result!.workloads()[0]?.agentRaid).toMatchObject([
{ device: '/dev/md0', level: 'raid1', state: 'clean' },
]);
expect(apiFetchJSONMock).not.toHaveBeenCalled();
} finally {
dispose();
}
});
it('marks a silent linked agent and the guest filesystems it supplied', async () => {
const disk = (mountpoint: string) => ({
mountpoint,
type: 'ext4',
total: 100,
used: 40,
free: 60,
usage: 40,
});
const [snapshot] = createSignal([
// Proxmox read no guest filesystems, so the agent's own report fills in.
{
...sampleResource,
id: 'vm-agent-disks',
vmid: 102,
sources: ['proxmox', 'agent'],
agent: { agentVersion: '6.4.5', stale: true, disks: [disk('/agent')] },
},
// Proxmox guest filesystems win over a live agent's.
{
...sampleResource,
id: 'vm-platform-disks',
vmid: 103,
sources: ['proxmox', 'agent'],
proxmox: { disks: [disk('/platform')] },
agent: { agentVersion: '6.4.5', stale: false, disks: [disk('/agent')] },
},
] as any);
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
result = useWorkloads(() => true, { resourceSnapshot: snapshot });
});
try {
await flushAsync();
const byId = (id: string) =>
result!.workloads().find((workload) => workload.canonicalResourceId === id);
expect(byId('vm-agent-disks')).toMatchObject({ agentStale: true, disksFromAgent: true });
expect(byId('vm-agent-disks')?.disks?.map((d) => d.mountpoint)).toEqual(['/agent']);
expect(byId('vm-platform-disks')?.agentStale).toBeUndefined();
expect(byId('vm-platform-disks')?.disksFromAgent).toBeUndefined();
expect(byId('vm-platform-disks')?.disks?.map((d) => d.mountpoint)).toEqual(['/platform']);
} finally {
dispose();
}
});
afterEach(() => {
vi.useRealTimers();
vi.clearAllMocks();
vi.resetModules();
});
it.each(guestDiskDeferrals)(
'preserves %s and the native lock through the resources API',
async (reason) => {
apiFetchJSONMock.mockResolvedValueOnce({
data: [
{
...sampleResource,
proxmox: {
vmid: 101,
nodeName: 'pve1',
instance: 'cluster-a',
diskStatusReason: `prev-${reason}`,
guestAgentStatus: 'deferred',
guestAgentExpected: true,
lock: 'backup',
},
},
],
meta: { totalPages: 1 },
});
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']>;
createRoot((d) => {
dispose = d;
result = useWorkloads();
});
try {
await waitForWorkloadCount(() => result.workloads().length);
expect(result!.workloads()[0]).toMatchObject({
diskStatusReason: `prev-${reason}`,
guestAgentStatus: 'deferred',
guestAgentExpected: true,
lock: 'backup',
disk: { usage: 20 },
});
expect(apiFetchJSONMock).toHaveBeenCalledTimes(1);
} finally {
dispose();
}
},
);
it.each(guestDiskDeferrals)(
'preserves %s through the owning Proxmox snapshot without another request',
async (reason) => {
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']>;
createRoot((d) => {
dispose = d;
result = useWorkloads(() => true, {
resourceSnapshot: () =>
[
{
...sampleResource,
proxmox: {
vmid: 101,
nodeName: 'pve1',
instance: 'cluster-a',
diskStatusReason: reason,
guestAgentStatus: 'deferred',
guestAgentExpected: false,
lock: 'migrate',
},
disk: { current: 20, used: 20 * 1024, total: 100 * 1024 },
},
] as any,
});
});
try {
await flushAsync();
expect(result!.workloads()[0]).toMatchObject({
diskStatusReason: reason,
guestAgentStatus: 'deferred',
guestAgentExpected: false,
lock: 'migrate',
disk: { usage: 20 },
});
expect(apiFetchJSONMock).not.toHaveBeenCalled();
} finally {
dispose();
}
},
);
it('updates read evidence even with unchanged metrics, preserving other site rows', async () => {
const buildVM = (instance: string, proxmox: Record<string, unknown> = {}, current = 20) =>
({
...sampleResource,
id: `${instance}-pve1-101`,
proxmox: { vmid: 101, nodeName: 'pve1', instance, ...proxmox },
disk: { current, used: current * 1024, total: 100 * 1024 },
}) as any;
const other = buildVM('cluster-b');
const [snapshot, setSnapshot] = createSignal([
buildVM('cluster-a', {
diskStatusReason: 'prev-vm-locked',
guestAgentStatus: 'deferred',
guestAgentExpected: true,
lock: 'backup',
}),
other,
]);
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']>;
createRoot((d) => {
dispose = d;
result = useWorkloads(() => true, { resourceSnapshot: snapshot });
});
const target = () => result!.workloads().find((row) => row.instance === 'cluster-a')! as VM;
try {
await flushAsync();
const prior = target();
const otherRow = result!.workloads().find((row) => row.instance === 'cluster-b');
expect(prior.diskStatusReason).toBe('prev-vm-locked');
setSnapshot([buildVM('cluster-a', { guestAgentStatus: 'available' }), other]);
await flushAsync();
expect(target()).not.toBe(prior);
expect(target().diskStatusReason).toBeUndefined();
expect(target().lock).toBe('');
expect(target().guestAgentStatus).toBe('available');
expect(target().guestAgentExpected).toBeUndefined();
expect(target().disk.usage).toBe(20);
expect(result!.workloads().find((row) => row.instance === 'cluster-b')).toBe(otherRow);
setSnapshot([buildVM('cluster-a', { guestAgentStatus: 'available' }, 0), other]);
await flushAsync();
expect(target().disk.usage).toBe(0);
expect(apiFetchJSONMock).not.toHaveBeenCalled();
} finally {
dispose();
}
});
it('does not treat a stopped native VM facet as current disk telemetry when health stays online', async () => {
const other = {
...sampleResource,
id: 'other-site',
instance: 'other',
disk: { current: 40, total: 100, used: 40 },
};
const snapshot = (runtimeStatus: string, diskStatusReason?: string) =>
[
{
...sampleResource,
status: 'online',
disk: { current: 20, used: 20 * 1024, total: 100 * 1024 },
proxmox: {
vmid: 101,
nodeName: 'pve1',
instance: 'cluster-a',
runtimeStatus,
diskStatusReason,
},
},
other,
] as any;
const [resources, setResources] = createSignal(snapshot('running'));
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']>;
createRoot((d) => {
dispose = d;
result = useWorkloads(() => true, { resourceSnapshot: resources });
});
const target = () =>
result!.workloads().find((row) => row.canonicalResourceId === sampleResource.id)!;
try {
await flushAsync();
const otherRow = result!.workloads().find((row) => row.canonicalResourceId === 'other-site');
expect(otherRow).toBeDefined();
expect(getDiskUsagePercent(target())).toBe(20);
setResources(snapshot('stopped'));
await flushAsync();
expect(target()).toMatchObject({
status: 'stopped',
resourceStatus: 'online',
disk: { usage: 20 },
});
expect(getWorkloadGuestDiskRead(target(), true).state).toBe('unavailable');
expect(getDiskUsagePercent(target())).toBeNull();
setResources(snapshot('running', 'prev-agent-busy'));
await flushAsync();
expect(getDiskUsagePercent(target())).toBeNull();
setResources(snapshot('running'));
await flushAsync();
expect(getDiskUsagePercent(target())).toBe(20);
expect(result!.workloads().find((row) => row.canonicalResourceId === 'other-site')).toBe(
otherRow,
);
expect(apiFetchJSONMock).not.toHaveBeenCalled();
} finally {
dispose();
}
});
it('reuses fresh cache on remount without an extra network fetch', async () => {
let disposeFirst = () => {};
createRoot((d) => {
disposeFirst = d;
const [enabled] = createSignal(true);
useWorkloads(enabled);
});
await flushAsync();
expect(apiFetchJSONMock).toHaveBeenCalledTimes(1);
disposeFirst();
let disposeSecond = () => {};
createRoot((d) => {
disposeSecond = d;
const [enabled] = createSignal(true);
useWorkloads(enabled);
});
await flushAsync();
expect(apiFetchJSONMock).toHaveBeenCalledTimes(1);
disposeSecond();
});
it('keeps loads and polls out of the app-level Suspense fallback', async () => {
const firstRead = deferred<unknown>();
apiFetchJSONMock.mockReturnValueOnce(firstRead.promise);
let result!: ReturnType<UseWorkloadsModule['useWorkloads']>;
const { container, unmount } = render(() =>
createComponent(Suspense, {
fallback: 'Loading view...',
get children() {
return createComponent(() => {
result = useWorkloads(() => true);
const node = document.createTextNode('');
createRenderEffect(() => {
node.data = `workloads:${result.workloads().length}`;
});
return node;
}, {});
},
}),
);
try {
await flushAsync();
// The first read is in flight: the surface shows its own loading state
// and the route keeps its page.
expect(result.loading()).toBe(true);
expect(container.textContent).not.toContain('Loading view...');
firstRead.resolve({ data: [sampleResource], meta: { totalPages: 1 } });
await waitForWorkloadCount(() => result.workloads().length);
expect(container.textContent).toBe('workloads:1');
const pollRead = deferred<unknown>();
apiFetchJSONMock.mockReturnValueOnce(pollRead.promise);
await advanceAndFlush(5_000);
expect(apiFetchJSONMock).toHaveBeenCalledTimes(2);
// The poll is in flight: the last table stays on screen.
expect(container.textContent).toBe('workloads:1');
pollRead.resolve({
data: [sampleResource, { ...sampleResource, id: 'cluster-a-pve1-102', vmid: 102 }],
meta: { totalPages: 1 },
});
await waitForWorkloadCount(() => result.workloads().length, 2);
expect(container.textContent).toBe('workloads:2');
} finally {
unmount();
}
});
it('projects authoritative LXC and QEMU CPU once regardless of agent sources or cores', async () => {
apiFetchJSONMock.mockResolvedValueOnce({
data: [
{
...sampleResource,
id: 'cluster-a-pve1-101',
type: 'vm',
name: 'qemu-101',
sources: ['proxmox'],
metrics: { ...sampleResource.metrics, cpu: { percent: 0.58 } },
proxmox: { vmid: 101, nodeName: 'pve1', instance: 'cluster-a', cpus: 8 },
},
{
...sampleResource,
id: 'cluster-a-pve1-102',
type: 'system-container',
name: 'lxc-102',
vmid: 102,
sources: ['proxmox', 'agent'],
metrics: { ...sampleResource.metrics, cpu: { percent: 0.58 } },
proxmox: { vmid: 102, nodeName: 'pve1', instance: 'cluster-a', cpus: 1 },
},
],
meta: { totalPages: 1 },
});
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
const [enabled] = createSignal(true);
result = useWorkloads(enabled);
});
await waitForWorkloadCount(() => result!.workloads().length, 2);
const byName = new Map(result!.workloads().map((workload) => [workload.name, workload]));
expect(byName.get('qemu-101')?.cpu).toBe(0.0058);
expect(byName.get('qemu-101')?.cpus).toBe(8);
expect(byName.get('lxc-102')?.cpu).toBe(0.0058);
expect(byName.get('lxc-102')?.cpus).toBe(1);
dispose();
});
it('projects agent-reported libvirt VM runtime metadata without Proxmox fields', async () => {
apiFetchJSONMock.mockResolvedValueOnce({
data: [
{
...sampleResource,
id: 'vm-agent-domain-a1b2c3d4',
name: 'libvirt-app',
status: 'warning',
sources: ['agent'],
parentName: 'qnap-host',
vmid: undefined,
node: undefined,
instance: undefined,
proxmox: undefined,
virtualMachine: {
runtimeState: 'running',
hypervisor: 'libvirt',
vcpus: 6,
},
},
],
meta: { totalPages: 1 },
});
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
const [enabled] = createSignal(true);
result = useWorkloads(enabled);
});
await waitForWorkloadCount(() => result!.workloads().length);
expect(result!.workloads()).toHaveLength(1);
expect(result!.workloads()[0]).toMatchObject({
id: 'vm-agent-domain-a1b2c3d4',
name: 'libvirt-app',
node: 'qnap-host',
status: 'running',
type: 'vm',
cpus: 6,
platformType: 'agent',
});
dispose();
});
it('handles empty responses without mutating into undefined state', async () => {
apiFetchJSONMock.mockResolvedValueOnce({
data: [],
meta: { totalPages: 1 },
});
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
const [enabled] = createSignal(true);
result = useWorkloads(enabled);
});
await flushAsync();
expect(apiFetchJSONMock).toHaveBeenCalledTimes(1);
expect(result!.workloads()).toEqual([]);
dispose();
});
it('uses an owning canonical resource snapshot without a second workload request', async () => {
const snapshot = [
{
id: 'cluster-a-pve1-101',
type: 'vm',
name: 'vm-101',
status: 'running',
platformType: 'proxmox-pve',
sources: ['proxmox'],
identity: { hostname: 'vm-101', ips: ['192.0.2.101'] },
metricsTarget: { resourceType: 'vm', resourceId: 'mock-cluster-a-pve1-101' },
canonicalIdentity: {
primaryId: 'vm:cluster-a-pve1-101',
aliases: ['legacy-vm-101'],
},
proxmox: {
sourceId: 'cluster-a-pve1-101',
vmid: 101,
nodeName: 'pve1',
instance: 'cluster-a',
lastBackup: '2026-02-06T06:00:00Z',
},
uptime: 86_400,
cpu: { current: 25 },
memory: { current: 50, used: 2 * 1024, total: 4 * 1024 },
disk: { current: 20, used: 20 * 1024, total: 100 * 1024 },
},
] as any;
const refetchSnapshot = vi.fn().mockResolvedValue(undefined);
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
const [enabled] = createSignal(true);
result = useWorkloads(enabled, {
resourceSnapshot: () => snapshot,
refetchSnapshot,
});
});
await flushAsync();
expect(apiFetchJSONMock).not.toHaveBeenCalled();
expect(result!.workloads()).toMatchObject([
{
name: 'vm-101',
vmid: 101,
node: 'pve1',
metricsTarget: { resourceType: 'vm', resourceId: 'mock-cluster-a-pve1-101' },
uptime: 86_400,
lastBackup: Date.parse('2026-02-06T06:00:00Z'),
alertResourceIds: expect.arrayContaining([
'cluster-a-pve1-101',
'mock-cluster-a-pve1-101',
'vm:cluster-a-pve1-101',
'legacy-vm-101',
]),
},
]);
await result!.refetch();
expect(refetchSnapshot).toHaveBeenCalledTimes(1);
expect(apiFetchJSONMock).not.toHaveBeenCalled();
dispose();
});
it.each(['api', 'snapshot'])(
'keeps selected memory provenance through %s without borrowing a raw facet',
async (transport) => {
const original = {
state: 'last-known',
source: 'guest-agent-meminfo',
observedAt: '2026-10-04T14:00:00Z',
};
const raw = { state: 'current', source: 'status-mem', observedAt: '2026-10-04T17:00:00Z' };
const resource = {
...sampleResource,
proxmox: {
vmid: 101,
nodeName: 'pve1',
instance: 'cluster-a',
memory: { observation: raw },
},
metrics: {
...sampleResource.metrics,
memory: { ...sampleResource.metrics.memory, observation: original },
},
memory: { current: 50, total: 4096, used: 2048, observation: original },
};
apiFetchJSONMock.mockResolvedValue({ data: [resource], meta: { totalPages: 1 } });
const [snapshot, setSnapshot] = createSignal([resource]);
let dispose = () => {};
let result!: ReturnType<UseWorkloadsModule['useWorkloads']>;
createRoot((d) => {
dispose = d;
result = useWorkloads(
() => true,
transport === 'snapshot' ? { resourceSnapshot: snapshot as any } : {},
);
});
try {
await waitForWorkloadCount(() => result.workloads().length);
expect(result.workloads()[0].memory).toMatchObject({ usage: 50, observation: original });
const legacy = {
...resource,
metrics: { ...resource.metrics, memory: sampleResource.metrics.memory },
memory: { current: 50, total: 4096, used: 2048 },
};
if (transport === 'snapshot') setSnapshot([legacy] as any);
else {
apiFetchJSONMock.mockResolvedValue({ data: [legacy], meta: { totalPages: 1 } });
await result.refetch();
}
await flushAsync();
expect(result.workloads()[0].memory).not.toHaveProperty('observation');
expect(result.workloads()[0].memory.usage).toBe(50);
const live = {
...resource,
metrics: {
...resource.metrics,
memory: { ...resource.metrics.memory, observation: raw },
},
memory: { ...resource.memory, observation: raw },
};
if (transport === 'snapshot') setSnapshot([live]);
else {
apiFetchJSONMock.mockResolvedValue({ data: [live], meta: { totalPages: 1 } });
await result.refetch();
}
await flushAsync();
expect(result.workloads()[0].memory).toMatchObject({ usage: 50, observation: raw });
} finally {
dispose();
}
},
);
it('tracks canonical hybrid VM memory without substituting nested agent readings', async () => {
// #1962: synthetic snapshots exercise Web reactivity, not poller recovery.
const buildVM = (instance: string, percent?: number) =>
({
id: `${instance}-pve1-101`,
type: 'vm',
name: `${instance}-vm`,
status: 'running',
platformType: 'proxmox-pve',
sourceType: 'hybrid',
sources: ['proxmox', 'agent'],
proxmox: { vmid: 101, nodeName: 'pve1', instance },
memory:
percent === undefined
? undefined
: {
current: percent,
used: percent * 1024,
total: 100 * 1024,
},
agent: { memory: { used: 35 * 1024, total: 100 * 1024, usage: 35 } },
}) as any;
const otherVM = buildVM('cluster-b', 80);
const [snapshot, setSnapshot] = createSignal([buildVM('cluster-a', 100), otherVM]);
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
result = useWorkloads(() => true, { resourceSnapshot: snapshot });
});
try {
await flushAsync();
const target = () => result!.workloads().find((vm) => vm.name === 'cluster-a-vm')!;
const other = () => result!.workloads().find((vm) => vm.name === 'cluster-b-vm')!;
expect(target().memory.usage).toBe(100);
expect(other().memory.usage).toBe(80);
setSnapshot([buildVM('cluster-a', 35), otherVM]);
await flushAsync();
expect(target().memory).toMatchObject({ usage: 35, used: 35 * 1024, total: 100 * 1024 });
expect(other().memory.usage).toBe(80);
// Missing canonical telemetry must not revive the nested agent's old value.
setSnapshot([buildVM('cluster-a'), otherVM]);
await flushAsync();
expect(target().memory.usageUnavailable).toBe(true);
expect(target().telemetryAvailability?.memory).toBe(false);
expect(other().memory.usage).toBe(80);
setSnapshot([buildVM('cluster-a', 0), otherVM]);
await flushAsync();
expect(target().memory).toMatchObject({ usage: 0, usageUnavailable: false });
expect(target().telemetryAvailability?.memory).toBe(true);
expect(apiFetchJSONMock).not.toHaveBeenCalled();
} finally {
dispose();
}
});
it('keeps row identity stable for guests whose data did not change', async () => {
const buildGuest = (id: string, vmid: number, cpu: number) =>
({
id,
type: 'vm',
name: `vm-${vmid}`,
status: 'running',
platformType: 'proxmox-pve',
sources: ['proxmox'],
proxmox: { sourceId: id, vmid, nodeName: 'pve1', instance: 'cluster-a' },
cpu: { current: cpu },
}) as any;
const [snapshot, setSnapshot] = createSignal([
buildGuest('vm-a', 101, 10),
buildGuest('vm-b', 102, 20),
]);
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
const [enabled] = createSignal(true);
result = useWorkloads(enabled, { resourceSnapshot: snapshot });
});
await flushAsync();
const firstRows = result!.workloads();
expect(firstRows).toHaveLength(2);
// One guest changes; the untouched guest's row object must be reused.
setSnapshot([buildGuest('vm-a', 101, 10), buildGuest('vm-b', 102, 85)]);
await flushAsync();
const secondRows = result!.workloads();
expect(secondRows[0]).toBe(firstRows[0]);
expect(secondRows[1]).not.toBe(firstRows[1]);
expect(secondRows[1]?.cpu).toBeCloseTo(0.85);
// A refresh that changes nothing must keep the array identity itself.
setSnapshot([buildGuest('vm-a', 101, 10), buildGuest('vm-b', 102, 85)]);
await flushAsync();
expect(result!.workloads()).toBe(secondRows);
dispose();
});
it('adapts only changed canonical guests and fully refreshes when change history is unavailable', async () => {
const buildGuest = (id: string, name: string, cpu: number) =>
({
id,
type: 'vm',
name,
status: 'running',
platformType: 'proxmox-pve',
sources: ['proxmox'],
proxmox: { sourceId: id, vmid: id === 'vm-a' ? 101 : 102, nodeName: 'pve1' },
cpu: { current: cpu },
}) as any;
let untouchedNameReads = 0;
const untouched = buildGuest('vm-a', 'vm-a', 10);
Object.defineProperty(untouched, 'name', {
get: () => {
untouchedNameReads += 1;
return 'vm-a';
},
});
const [snapshot, setSnapshot] = createSignal([untouched, buildGuest('vm-b', 'vm-b', 20)]);
const [change, setChange] = createSignal<{
version: number;
changedIds: ReadonlySet<string> | null;
}>({ version: 1, changedIds: null });
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
result = useWorkloads(() => true, {
resourceSnapshot: snapshot,
resourceSnapshotChange: change,
});
});
try {
await flushAsync();
const originalRow = result!.workloads()[0];
untouchedNameReads = 0;
batch(() => {
setSnapshot([untouched, buildGuest('vm-b', 'vm-b', 85)]);
setChange({ version: 2, changedIds: new Set(['vm-b']) });
});
await flushAsync();
expect(untouchedNameReads).toBe(0);
expect(result!.workloads()[0]).toBe(originalRow);
expect(result!.workloads()[1]?.cpu).toBeCloseTo(0.85);
batch(() => {
setSnapshot([buildGuest('vm-a', 'renamed-a', 10), buildGuest('vm-b', 'vm-b', 85)]);
setChange({ version: 3, changedIds: null });
});
await flushAsync();
expect(result!.workloads()[0]?.name).toBe('renamed-a');
batch(() => {
setSnapshot([buildGuest('vm-a', 'renamed-again', 10), buildGuest('vm-b', 'vm-b', 85)]);
setChange({ version: 5, changedIds: new Set(['vm-b']) });
});
await flushAsync();
expect(result!.workloads()[0]?.name).toBe('renamed-again');
} finally {
dispose();
}
});
it('retains the fulfilled workload snapshot when a forced refresh fails', async () => {
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
const [enabled] = createSignal(true);
result = useWorkloads(enabled);
});
await flushAsync();
await waitForWorkloadCount(() => result!.workloads().length);
const initialWorkloads = result!.workloads();
apiFetchJSONMock.mockRejectedValueOnce(new Error('temporary backend gap'));
await expect(result!.refetch()).rejects.toThrow('temporary backend gap');
expect(result!.workloads()).toBe(initialWorkloads);
expect(result!.workloads()).toHaveLength(1);
expect(result!.loading()).toBe(false);
expect(result!.error()).toBeInstanceOf(Error);
dispose();
});
it('clears a transient refresh error after a later poll succeeds', async () => {
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
const [enabled] = createSignal(true);
result = useWorkloads(enabled);
});
await flushAsync();
await waitForWorkloadCount(() => result!.workloads().length);
apiFetchJSONMock.mockRejectedValueOnce(new Error('temporary backend gap'));
await expect(result!.refetch()).rejects.toThrow('temporary backend gap');
expect(result!.error()).toBeInstanceOf(Error);
await advanceAndFlush(5_000);
expect(result!.workloads()).toHaveLength(1);
expect(result!.error()).toBeUndefined();
dispose();
});
it('keeps Proxmox power state stable while carrying aggregate health, then removes an authoritative deletion', async () => {
const guest = (vmid: number, status: string, runtimeStatus: string) => ({
...sampleResource,
id: `cluster-a-pve1-${vmid}`,
type: 'system-container',
name: `lxc-${vmid}`,
status,
vmid,
proxmox: {
vmid,
nodeName: 'pve1',
instance: 'cluster-a',
runtimeStatus,
},
});
apiFetchJSONMock.mockResolvedValueOnce({
data: [
guest(101, 'online', 'running'),
guest(102, 'online', 'running'),
guest(103, 'online', 'running'),
],
meta: { totalPages: 1 },
});
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
const [enabled] = createSignal(true);
result = useWorkloads(enabled);
});
await waitForWorkloadCount(() => result!.workloads().length, 3);
const initialIds = result!.workloads().map((workload) => workload.id);
apiFetchJSONMock.mockResolvedValueOnce({
data: [
guest(101, 'warning', 'running'),
{
...guest(102, 'online', 'running'),
availability: { targetId: 'probe-102', protocol: 'icmp', enabled: true, available: true },
},
guest(103, 'warning', 'running'),
],
meta: { totalPages: 1 },
});
await result!.refetch();
expect(result!.workloads().map((workload) => workload.id)).toEqual(initialIds);
expect(result!.workloads().map((workload) => workload.status)).toEqual([
'running',
'running',
'running',
]);
expect(result!.workloads().map((workload) => workload.resourceStatus)).toEqual([
'warning',
'online',
'warning',
]);
apiFetchJSONMock.mockResolvedValueOnce({
data: [guest(101, 'online', 'running'), guest(102, 'online', 'running')],
meta: { totalPages: 1 },
});
await result!.refetch();
expect(result!.workloads().map((workload) => workload.id)).toEqual(initialIds.slice(0, 2));
expect(result!.error()).toBeUndefined();
dispose();
});
it('rejects a partial paged refresh and retains the last coherent snapshot', async () => {
const secondResource = {
...sampleResource,
id: 'cluster-a-pve1-102',
name: 'vm-102',
vmid: 102,
};
apiFetchJSONMock.mockResolvedValueOnce({
data: [sampleResource, secondResource],
meta: { totalPages: 1 },
});
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
const [enabled] = createSignal(true);
result = useWorkloads(enabled);
});
await waitForWorkloadCount(() => result!.workloads().length, 2);
const coherentSnapshot = result!.workloads();
apiFetchJSONMock
.mockResolvedValueOnce({
data: [sampleResource],
meta: { totalPages: 2 },
})
.mockRejectedValueOnce(new Error('page 2 unavailable'));
await expect(result!.refetch()).rejects.toThrow('page 2 unavailable');
expect(result!.workloads()).toBe(coherentSnapshot);
expect(result!.workloads()).toHaveLength(2);
expect(result!.error()).toBeInstanceOf(Error);
apiFetchJSONMock
.mockResolvedValueOnce({
data: [sampleResource],
meta: { totalPages: 2 },
})
.mockResolvedValueOnce({
data: [],
meta: { totalPages: 2 },
});
await result!.refetch();
expect(result!.workloads()).toHaveLength(1);
expect(result!.error()).toBeUndefined();
dispose();
});
it('does not apply in-flight workload results after the hook is disabled', async () => {
const pendingFetch = deferred<unknown>();
apiFetchJSONMock.mockImplementationOnce(() => pendingFetch.promise as Promise<any>);
let dispose = () => {};
let setEnabled: ((enabled: boolean) => boolean) | undefined;
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
const [enabled, updateEnabled] = createSignal(true);
setEnabled = updateEnabled;
result = useWorkloads(enabled);
});
await flushAsync();
expect(result!.loading()).toBe(true);
setEnabled!(false);
await flushAsync();
expect(result!.loading()).toBe(false);
pendingFetch.resolve({
data: [sampleResource],
meta: { totalPages: 1 },
});
await flushAsync();
expect(result!.workloads()).toEqual([]);
expect(result!.error()).toBeUndefined();
dispose();
});
it('normalizes workload source aliases into canonical platform types', async () => {
apiFetchJSONMock.mockResolvedValueOnce({
data: [
{ ...sampleResource, id: 'vm-pve', sources: ['PROXMOX'] },
{ ...sampleResource, id: 'vm-pbs', sources: ['pbs'], name: 'vm-pbs' },
{ ...sampleResource, id: 'vm-pmg', sources: ['pmg'], name: 'vm-pmg' },
{
...sampleResource,
id: 'app-container:truenas-main:nextcloud',
type: 'app-container',
name: 'nextcloud',
status: 'healthy',
sources: ['agent', 'truenas'],
parentName: 'truenas-main',
docker: {
containerId: 'nextcloud-ctr',
image: 'ix-nextcloud:latest',
},
},
{
...sampleResource,
id: 'docker-container-frigate-141',
type: 'app-container',
name: 'frigate',
status: 'running',
sources: ['docker'],
platformScopes: ['proxmox-pve', 'docker'],
parentName: 'homepage-docker.lab',
docker: {
containerId: 'frigate',
hostSourceId: 'proxmox-lxc-docker:pve-a:node-a:141',
hostname: 'homepage-docker.lab',
runtime: 'docker',
image: 'ghcr.io/blakeblackshear/frigate:stable',
},
},
{
...sampleResource,
id: 'vmware-vm-crm',
name: 'crm-app-01',
status: undefined,
sources: ['vmware'],
parentName: 'esxi-01',
proxmox: undefined,
vmware: {
managedObjectId: 'vm-101',
runtimeHostName: 'esxi-01',
clusterName: 'Compute-A',
connectionName: 'Production vCenter',
powerState: 'poweredOn',
},
},
{
...sampleResource,
id: 'vmware-vm-legacy',
name: 'legacy-app-01',
status: undefined,
sources: ['vmware'],
parentName: 'esxi-02',
proxmox: undefined,
vmware: {
managedObjectId: 'vm-102',
runtimeHostName: 'esxi-02',
clusterName: 'Compute-A',
connectionName: 'Production vCenter',
powerState: 'poweredOff',
},
},
],
meta: { totalPages: 1 },
});
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
const [enabled] = createSignal(true);
result = useWorkloads(enabled);
});
await flushAsync();
await waitForWorkloadCount(() => result!.workloads().length, 7);
const byName = new Map(result!.workloads().map((workload) => [workload.name, workload]));
expect(byName.get('vm-101')?.platformType).toBe('proxmox-pve');
expect(byName.get('vm-pbs')?.platformType).toBe('proxmox-pbs');
expect(byName.get('vm-pmg')?.platformType).toBe('proxmox-pmg');
expect(byName.get('nextcloud')?.platformType).toBe('truenas');
expect(byName.get('nextcloud')?.platformScopes).toEqual(['truenas']);
expect(byName.get('nextcloud')?.id).toBe('app-container:truenas-main:nextcloud');
expect(byName.get('nextcloud')?.containerId).toBe('nextcloud-ctr');
expect(byName.get('nextcloud')?.dockerHostId).toBeUndefined();
expect(byName.get('frigate')?.platformType).toBe('docker');
expect(byName.get('frigate')?.platformScopes).toEqual(['proxmox-pve', 'docker']);
expect(byName.get('frigate')?.dockerHostId).toBe('proxmox-lxc-docker:pve-a:node-a:141');
expect(byName.get('frigate')?.dockerHostName).toBe('homepage-docker.lab');
expect(byName.get('crm-app-01')?.platformType).toBe('vmware-vsphere');
expect(byName.get('crm-app-01')?.node).toBe('esxi-01');
expect(byName.get('crm-app-01')?.instance).toBe('Compute-A');
expect(byName.get('crm-app-01')?.status).toBe('running');
expect(byName.get('legacy-app-01')?.status).toBe('stopped');
dispose();
});
it('falls back to canonical resource.uptime when no platform-specific carve-out exists (vSphere)', async () => {
// vSphere VMs surface uptime only on the canonical Resource.Uptime
// field; there is no proxmox/agent/docker/kubernetes carve-out. The
// useWorkloads mapping must land on resource.uptime so the workloads
// table renders real "N days" cells rather than the blank "0s"
// placeholder.
apiFetchJSONMock.mockResolvedValueOnce({
data: [
{
...sampleResource,
id: 'vmware-vm-uptime',
name: 'lab-app-01',
status: 'online',
uptime: 12345678,
sources: ['vmware'],
parentName: 'esxi-01',
proxmox: undefined,
vmware: {
managedObjectId: 'vm-901',
runtimeHostName: 'esxi-01',
clusterName: 'Compute-A',
connectionName: 'Production vCenter',
powerState: 'poweredOn',
},
},
],
meta: { totalPages: 1 },
});
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
const [enabled] = createSignal(true);
result = useWorkloads(enabled);
});
await flushAsync();
await waitForWorkloadCount(() => result!.workloads().length, 1);
const vm = result!.workloads().find((workload) => workload.name === 'lab-app-01');
expect(vm?.uptime).toBe(12345678);
dispose();
});
it('preserves API telemetry absence separately from reported zero values on every platform', async () => {
apiFetchJSONMock.mockResolvedValueOnce({
data: [
{
id: 'vmware-vm-unknown-telemetry',
type: 'vm',
name: 'unknown-telemetry',
status: 'online',
lastSeen: 'not-a-timestamp',
sources: ['vmware'],
metrics: {},
agent: { agentVersion: '6.2.0' },
vmware: {
managedObjectId: 'vm-903',
powerState: 'poweredOn',
cpuCount: 8,
},
},
{
id: 'docker-container-zero-telemetry',
type: 'app-container',
name: 'zero-telemetry',
status: 'running',
lastSeen: '2026-08-13T10:00:00Z',
sources: ['docker'],
uptime: 0,
metrics: {
cpu: { percent: 0 },
memory: { used: 0, total: 1024, percent: 0 },
disk: { used: 0, total: 2048, percent: 0 },
netIn: { value: 0 },
netOut: { value: 0 },
diskRead: { value: 0 },
diskWrite: { value: 0 },
},
docker: { containerId: 'zero', runtime: 'docker', uptimeSeconds: 0 },
},
],
meta: { totalPages: 1 },
});
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
const [enabled] = createSignal(true);
result = useWorkloads(enabled);
});
await waitForWorkloadCount(() => result!.workloads().length, 2);
const byName = new Map(result!.workloads().map((workload) => [workload.name, workload]));
expect(byName.get('unknown-telemetry')).toMatchObject({
cpus: 8,
agentKind: 'pulse',
lastSeen: '',
telemetryAvailability: {
cpu: false,
memory: false,
disk: false,
networkIO: false,
diskIO: false,
uptime: false,
},
});
expect(byName.get('zero-telemetry')).toMatchObject({
cpu: 0,
networkIn: 0,
networkOut: 0,
diskRead: 0,
diskWrite: 0,
uptime: 0,
telemetryAvailability: {
cpu: true,
memory: true,
disk: true,
networkIO: true,
diskIO: true,
uptime: true,
},
});
dispose();
});
it('renders vSphere row tags from the vCenter facet, never the provenance keyword set', async () => {
// `Resource.Tags` on vSphere is a mixed keyword set: adapter provenance
// strings (kept so resource search and the `?tags=` filter keep matching)
// plus the operator's real vCenter tags. A per-row Tags cell must show
// only the vCenter tags, and a vSphere VM nobody tagged must show nothing
// rather than falling back to six identical provenance dots.
apiFetchJSONMock.mockResolvedValueOnce({
data: [
{
...sampleResource,
id: 'vmware-vm-tagged',
name: 'tagged-app-01',
sources: ['vmware'],
proxmox: undefined,
tags: [
'vmware',
'vsphere',
'vm',
'source:vcenter',
'Environment:Production',
'Owner:Data',
],
vmware: {
managedObjectId: 'vm-902',
powerState: 'poweredOn',
tags: [
{ name: 'Production', category: 'Environment', label: 'Environment:Production' },
{ name: 'Data', category: 'Owner', label: 'Owner:Data' },
],
},
},
{
...sampleResource,
id: 'vmware-vm-untagged',
name: 'untagged-app-01',
sources: ['vmware'],
proxmox: undefined,
tags: ['vmware', 'vsphere', 'vm', 'source:vcenter'],
vmware: {
managedObjectId: 'vm-903',
powerState: 'poweredOn',
},
},
{
...sampleResource,
id: 'proxmox-vm-tagged',
name: 'pve-app-01',
tags: ['production', 'web'],
},
],
meta: { totalPages: 1 },
});
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
const [enabled] = createSignal(true);
result = useWorkloads(enabled);
});
await flushAsync();
await waitForWorkloadCount(() => result!.workloads().length, 3);
const byName = (name: string) => result!.workloads().find((workload) => workload.name === name);
expect(byName('tagged-app-01')?.tags).toEqual(['Environment:Production', 'Owner:Data']);
expect(byName('untagged-app-01')?.tags).toEqual([]);
// Platforms whose flat tags are already real labels are untouched.
expect(byName('pve-app-01')?.tags).toEqual(['production', 'web']);
dispose();
});
it('preserves canonical discovery targets for workloads instead of inferring them from platform type', async () => {
apiFetchJSONMock.mockResolvedValueOnce({
data: [
{
...sampleResource,
id: 'app-container:truenas-main:nextcloud',
type: 'app-container',
name: 'nextcloud',
status: 'healthy',
sources: ['agent', 'truenas'],
parentName: 'truenas-main',
discoveryTarget: {
resourceType: 'app-container',
agentId: 'truenas-helper',
resourceId: 'nextcloud',
},
docker: {
containerId: 'nextcloud-ctr',
image: 'ix-nextcloud:latest',
},
},
],
meta: { totalPages: 1 },
});
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
const [enabled] = createSignal(true);
result = useWorkloads(enabled);
});
await flushAsync();
await waitForWorkloadCount(() => result!.workloads().length, 1);
expect(result!.workloads()[0]?.discoveryTarget).toEqual({
resourceType: 'app-container',
agentId: 'truenas-helper',
resourceId: 'nextcloud',
hostname: undefined,
});
dispose();
});
it('flags a workload whose canonical health names an open alert, not backup age', async () => {
apiFetchJSONMock.mockResolvedValueOnce({
data: [
{
...sampleResource,
id: 'alerting',
name: 'alerting',
health: { verdict: 'attention', reasons: [{ code: 'warning_alert', detail: 'memory' }] },
},
{
...sampleResource,
id: 'stale-backup',
name: 'stale-backup',
vmid: 102,
health: { verdict: 'attention', reasons: [{ code: 'backup_stale' }] },
},
{ ...sampleResource, id: 'quiet', name: 'quiet', vmid: 103 },
],
meta: { totalPages: 1 },
});
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
const [enabled] = createSignal(true);
result = useWorkloads(enabled);
});
await flushAsync();
await waitForWorkloadCount(() => result!.workloads().length, 3);
const byName = new Map(result!.workloads().map((workload) => [workload.name, workload]));
expect(byName.get('alerting')?.hasOpenAlert).toBe(true);
expect(byName.get('stale-backup')?.hasOpenAlert).toBe(false);
expect(byName.get('quiet')?.hasOpenAlert).toBe(false);
dispose();
});
it('uses the canonical Kubernetes cluster name for pod context labels', async () => {
apiFetchJSONMock.mockResolvedValueOnce({
data: [
{
...sampleResource,
id: 'pod-1',
type: 'pod',
name: 'pod-1',
kubernetes: {
clusterId: 'cluster-id-a',
clusterName: 'cluster-a',
context: 'cluster-context',
namespace: 'default',
podUid: 'pod-uid-1',
},
},
],
meta: { totalPages: 1 },
});
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
const [enabled] = createSignal(true);
result = useWorkloads(enabled);
});
await flushAsync();
await waitForWorkloadCount(() => result!.workloads().length);
expect(result!.workloads()[0]?.contextLabel).toBe('cluster-a');
expect(result!.workloads()[0]?.instance).toBe('cluster-a');
expect(result!.workloads()[0]?.kubernetesClusterId).toBe('cluster-id-a');
dispose();
});
it('retains canonical vSphere parent grouping through snapshot enrichment', async () => {
const resource = {
...sampleResource,
id: 'vm-warehouse-api',
name: 'warehouse-api',
sources: ['vmware'],
parentId: 'host-vcenter-a:esxi-01',
parentName: 'esxi-01',
vmid: 0,
node: undefined,
instance: undefined,
proxmox: undefined,
};
const [snapshot, setSnapshot] = createSignal([resource] as any);
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
result = useWorkloads(() => true, { resourceSnapshot: snapshot });
});
try {
await flushAsync();
const first = result!.workloads()[0]!;
expect(first.parentResourceId).toBe(resource.parentId);
expect(first.instance).toBe('');
const group = getWorkloadGroupKey(first);
setSnapshot([
{
...resource,
vmware: {
runtimeHostName: 'esxi-01',
clusterName: 'Production Cluster',
connectionName: 'Lab vCenter',
},
},
]);
await flushAsync();
const enriched = result!.workloads()[0]!;
expect(enriched.id).toBe(first.id);
expect(enriched.instance).toBe('Production Cluster');
expect(getWorkloadGroupKey(enriched)).toBe(group);
} finally {
dispose();
}
});
it('never labels a vSphere or standalone Proxmox workload as its own cluster', async () => {
apiFetchJSONMock.mockResolvedValueOnce({
data: [
{
...sampleResource,
id: 'vmware-vm-etl',
name: 'etl-batch-01',
sources: ['vmware'],
parentName: 'esxi-01.lab.local',
proxmox: undefined,
vmware: {
managedObjectId: 'vm-206',
runtimeHostName: 'esxi-01.lab.local',
clusterName: 'Production Cluster',
connectionName: 'Lab vCenter',
powerState: 'poweredOn',
},
},
{
...sampleResource,
id: 'pve-home-pve1-102',
name: 'standalone-vm',
vmid: 102,
instance: 'pve-home',
proxmox: {},
},
],
meta: { totalPages: 1 },
});
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
const [enabled] = createSignal(true);
result = useWorkloads(enabled);
});
await flushAsync();
await waitForWorkloadCount(() => result!.workloads().length, 2);
const byName = new Map(result!.workloads().map((workload) => [workload.name, workload]));
expect(byName.get('etl-batch-01')?.clusterName).toBe('Production Cluster');
expect(byName.get('etl-batch-01')?.contextLabel).toBe('esxi-01.lab.local (Production Cluster)');
expect(byName.get('etl-batch-01')?.instance).toBe('Production Cluster');
expect(byName.get('standalone-vm')?.clusterName).toBeUndefined();
expect(byName.get('standalone-vm')?.contextLabel).toBe('pve1 (pve-home)');
expect(byName.get('standalone-vm')?.instance).toBe('pve-home');
dispose();
});
it('uses the shared cluster-name helper for proxmox workload labels', async () => {
apiFetchJSONMock.mockResolvedValueOnce({
data: [
{
...sampleResource,
id: 'vm-1',
type: 'vm',
name: 'vm-1',
instance: undefined,
proxmox: {
clusterName: 'cluster-b',
},
},
],
meta: { totalPages: 1 },
});
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
const [enabled] = createSignal(true);
result = useWorkloads(enabled);
});
await flushAsync();
await waitForWorkloadCount(() => result!.workloads().length);
expect(result!.workloads()[0]?.clusterName).toBe('cluster-b');
expect(result!.workloads()[0]?.contextLabel).toBe('pve1 (cluster-b)');
expect(result!.workloads()[0]?.instance).toBe('cluster-b');
expect(result!.workloads()[0]?.id).toBe('vm-1');
dispose();
});
it('keeps workload reference stable when polling returns identical payload', async () => {
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
let effectRuns = 0;
createRoot((d) => {
dispose = d;
const [enabled] = createSignal(true);
result = useWorkloads(enabled);
createEffect(() => {
result!.workloads();
effectRuns += 1;
});
});
await flushAsync();
expect(apiFetchJSONMock).toHaveBeenCalledTimes(1);
await waitForWorkloadCount(() => result!.workloads().length);
const initialRef = result!.workloads();
const initialEffectRuns = effectRuns;
await advanceAndFlush(5_000);
expect(apiFetchJSONMock).toHaveBeenCalledTimes(2);
expect(result!.workloads()).toBe(initialRef);
expect(effectRuns).toBe(initialEffectRuns);
dispose();
});
it('maintains polling cadence under load without overlapping fetch churn', async () => {
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
const [enabled] = createSignal(true);
result = useWorkloads(enabled);
});
await flushAsync();
expect(apiFetchJSONMock).toHaveBeenCalledTimes(1);
await waitForWorkloadCount(() => result!.workloads().length);
const slowPoll = deferred<unknown>();
apiFetchJSONMock.mockImplementationOnce(() => slowPoll.promise as Promise<any>);
await advanceAndFlush(5_000);
expect(apiFetchJSONMock).toHaveBeenCalledTimes(2);
await advanceAndFlush(10_000);
expect(apiFetchJSONMock).toHaveBeenCalledTimes(2);
slowPoll.resolve({
data: [sampleResource],
meta: { totalPages: 1 },
});
await flushAsync();
await advanceAndFlush(5_000);
expect(apiFetchJSONMock).toHaveBeenCalledTimes(3);
dispose();
});
it('scopes shared cache by org and restores cached data when switching back', async () => {
let dispose = () => {};
let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
createRoot((d) => {
dispose = d;
const [enabled] = createSignal(true);
result = useWorkloads(enabled);
});
await flushAsync();
await waitForWorkloadCount(() => result!.workloads().length);
expect(apiFetchJSONMock).toHaveBeenCalledTimes(1);
expect(result!.workloads()[0]?.id).toBe(sampleResource.id);
apiFetchJSONMock.mockResolvedValueOnce({
data: [
{
...sampleResource,
id: 'cluster-b-pve2-202',
name: 'vm-202',
vmid: 202,
node: 'pve2',
instance: 'cluster-b',
},
],
meta: { totalPages: 1 },
});
eventBus.emit('org_switched', 'tenant-b');
await flushAsync();
await waitForWorkloadCount(() => result!.workloads().length);
expect(apiFetchJSONMock).toHaveBeenCalledTimes(2);
expect(result!.workloads()[0]?.id).toBe('cluster-b-pve2-202');
eventBus.emit('org_switched', 'default');
await flushAsync();
expect(apiFetchJSONMock).toHaveBeenCalledTimes(2);
expect(result!.workloads()[0]?.id).toBe(sampleResource.id);
dispose();
});
it('normalizes org scope through the shared helper', () => {
expect(useWorkloadsSource).toContain('normalizeOrgScope(getOrgID())');
expect(useWorkloadsSource).not.toContain("const DEFAULT_ORG_SCOPE = 'default'");
expect(useWorkloadsSource).not.toContain('const normalizeOrgScope =');
});
});
describe('resource-owned workload identity', () => {
it.each(['vm', 'system-container', 'pod'] as const)(
'preserves %s row identity when placement changes',
async (type) => {
const { useWorkloads, __resetWorkloadsCacheForTests } = await import('@/hooks/useWorkloads');
__resetWorkloadsCacheForTests();
const original = {
...sampleResource,
id: 'stable-resource',
type,
proxmox: { instance: 'cluster-a', node: 'node-1', vmid: 101 },
kubernetes: { clusterId: 'cluster-a', podUid: 'native-pod-uid' },
};
const [snapshot, setSnapshot] = createSignal([original] as any);
let dispose = () => {};
let result: ReturnType<typeof useWorkloads> | undefined;
createRoot((d) => {
dispose = d;
result = useWorkloads(() => true, { resourceSnapshot: snapshot });
});
try {
await flushAsync();
expect(result!.workloads()[0]?.id).toBe(original.id);
setSnapshot([
{ ...original, node: 'node-2', proxmox: { ...original.proxmox, node: 'node-2' } },
]);
await flushAsync();
expect(result!.workloads()[0]?.id).toBe(original.id);
expect(result!.workloads()[0]?.canonicalResourceId).toBe(original.id);
} finally {
dispose();
}
},
);
});