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 { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { ResourceAPI } from '@/api/resources';
import type { Resource } from '@/types/resource';
import type { WorkloadGuest } from '@/types/workloads';
import {
clearPendingAppShellRestoreTop,
readPendingAppShellRestoreTop,
} from '@/utils/appShellScrollRestoration';
import {
ROUTE_STATE_REPLACE_OPTIONS,
createRouteStateNavigateScheduler,
} from '@/utils/routeStateNavigation';
import { resolveWorkloadResourceSelection } from '../workloadSelectionModel';
import { useWorkloadSelectionState } from '../useWorkloadSelectionState';
let locationSearch = '?resource=cluster-a:node-1:101';
let readLocationSearch = () => locationSearch;
vi.mock('@/api/resources', () => ({ ResourceAPI: { getResource: vi.fn() } }));
const navigateSpy = vi.fn();
vi.mock('@solidjs/router', () => ({
useLocation: () => ({
pathname: '/proxmox/overview',
get search() {
return readLocationSearch();
},
}),
useNavigate: () => navigateSpy,
}));
describe('useWorkloadSelectionState', () => {
beforeEach(() => {
locationSearch = '?resource=cluster-a:node-1:101';
readLocationSearch = () => locationSearch;
vi.mocked(ResourceAPI.getResource)
.mockReset()
.mockImplementation(async (id) => ({ id }) as Resource);
navigateSpy.mockReset();
vi.useFakeTimers();
vi.stubGlobal('requestAnimationFrame', (cb: FrameRequestCallback) => {
cb(0);
return 1;
});
});
afterEach(() => {
vi.runOnlyPendingTimers();
vi.useRealTimers();
document.body.innerHTML = '';
vi.unstubAllGlobals();
});
it('owns workloads resource deep-link selection without mutating workload filters', () => {
const [filteredGuests] = createSignal<WorkloadGuest[]>([]);
const { result } = renderHook(() =>
useWorkloadSelectionState({
filteredGuests,
}),
);
expect(result.selectedGuestId()).toBe('cluster-a:node-1:101');
expect(resolveWorkloadResourceSelection(locationSearch)).toBe('cluster-a:node-1:101');
});
it('clears stale hovered workload ids when filtered guests change', () => {
const guest = {
id: 'cluster-a:node-1:101',
name: 'guest-1',
status: 'running',
instance: 'cluster-a',
node: 'node-1',
vmid: 101,
} as unknown as WorkloadGuest;
const [filteredGuests, setFilteredGuests] = createSignal<WorkloadGuest[]>([guest]);
const { result } = renderHook(() =>
useWorkloadSelectionState({
filteredGuests,
}),
);
result.setHoveredWorkloadId('cluster-a:node-1:101');
expect(result.hoveredWorkloadId()).toBe('cluster-a:node-1:101');
setFilteredGuests([]);
expect(result.hoveredWorkloadId()).toBeNull();
});
it('does not invent node filters for canonical app-container deep links', () => {
locationSearch = '?type=app-container&resource=app-container:truenas-main:nextcloud';
const [filteredGuests] = createSignal<WorkloadGuest[]>([]);
const { result } = renderHook(() =>
useWorkloadSelectionState({
filteredGuests,
}),
);
expect(result.selectedGuestId()).toBe('app-container:truenas-main:nextcloud');
expect(resolveWorkloadResourceSelection(locationSearch)).toBe(
'app-container:truenas-main:nextcloud',
);
});
it('opens workload row selection locally without route navigation', () => {
locationSearch = '?type=app-container&platform=truenas&agent=truenas-main';
const [filteredGuests] = createSignal<WorkloadGuest[]>([]);
const { result } = renderHook(() =>
useWorkloadSelectionState({
filteredGuests,
}),
);
result.setSelectedGuestId('app-container:truenas-main:nextcloud');
vi.runAllTimers();
expect(result.selectedGuestId()).toBe('app-container:truenas-main:nextcloud');
expect(navigateSpy).not.toHaveBeenCalled();
});
it('clears the pinned workload row locally without mutating route filters', () => {
locationSearch =
'?type=app-container&platform=truenas&agent=truenas-main&resource=app-container%3Atruenas-main%3Anextcloud';
const [filteredGuests] = createSignal<WorkloadGuest[]>([]);
const { result } = renderHook(() =>
useWorkloadSelectionState({
filteredGuests,
}),
);
expect(result.selectedGuestId()).toBe('app-container:truenas-main:nextcloud');
result.clearPinnedSummaryScope();
vi.runAllTimers();
expect(result.selectedGuestId()).toBeNull();
expect(navigateSpy).not.toHaveBeenCalled();
});
it('routes Escape through workload scope clearing and additional page reset work', () => {
locationSearch =
'?type=app-container&platform=truenas&agent=truenas-main&resource=app-container%3Atruenas-main%3Anextcloud';
const [filteredGuests] = createSignal<WorkloadGuest[]>([]);
const clearAdditionalPageStateOnEscape = vi.fn();
renderHook(() =>
useWorkloadSelectionState({
clearAdditionalPageStateOnEscape,
filteredGuests,
}),
);
document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
vi.runAllTimers();
expect(clearAdditionalPageStateOnEscape).toHaveBeenCalledTimes(1);
expect(navigateSpy).not.toHaveBeenCalled();
});
it('does not restore the old viewport when a route selects a known canonical resource', () => {
const [search, setSearch] = createSignal('?resource=vm-first');
readLocationSearch = search;
const [filteredGuests] = createSignal<WorkloadGuest[]>([
{ id: 'vm-first' } as WorkloadGuest,
{ id: 'vm-second' } as WorkloadGuest,
]);
const { result } = renderHook(() => useWorkloadSelectionState({ filteredGuests }));
const scroller = document.createElement('div');
scroller.style.overflowY = 'auto';
Object.defineProperty(scroller, 'scrollHeight', { value: 800 });
Object.defineProperty(scroller, 'clientHeight', { value: 200 });
const writes: number[] = [];
Object.defineProperty(scroller, 'scrollTop', {
get: () => 175,
set: (value) => writes.push(value),
});
const wrapper = document.createElement('div');
scroller.append(wrapper);
document.body.append(scroller);
result.setTableWrapperRef(wrapper);
setSearch('?resource=vm-second');
expect(result.selectedGuestId()).toBe('vm-second');
expect(ResourceAPI.getResource).not.toHaveBeenCalled();
expect(writes).toEqual([]);
});
it('does not restore the old viewport when a legacy route resolves to its canonical resource', async () => {
let resolve!: (resource: Resource) => void;
vi.mocked(ResourceAPI.getResource).mockReturnValue(
new Promise((done) => {
resolve = done;
}),
);
const [filteredGuests] = createSignal<WorkloadGuest[]>([{ id: 'vm-current' } as WorkloadGuest]);
const { result } = renderHook(() => useWorkloadSelectionState({ filteredGuests }));
const scroller = document.createElement('div');
scroller.style.overflowY = 'auto';
Object.defineProperty(scroller, 'scrollHeight', { value: 800 });
Object.defineProperty(scroller, 'clientHeight', { value: 200 });
const writes: number[] = [];
Object.defineProperty(scroller, 'scrollTop', {
get: () => 175,
set: (value) => writes.push(value),
});
const wrapper = document.createElement('div');
scroller.append(wrapper);
document.body.append(scroller);
result.setTableWrapperRef(wrapper);
resolve({ id: 'vm-current' } as Resource);
await Promise.resolve();
expect(result.selectedGuestId()).toBe('vm-current');
expect(writes).toEqual([]);
});
it('preserves the nearest scrollable ancestor when row focus changes locally', () => {
locationSearch = '?type=app-container&platform=truenas&agent=truenas-main';
const [filteredGuests] = createSignal<WorkloadGuest[]>([]);
const { result } = renderHook(() =>
useWorkloadSelectionState({
filteredGuests,
}),
);
const scroller = document.createElement('div');
scroller.style.overflowY = 'auto';
Object.defineProperty(scroller, 'scrollHeight', {
configurable: true,
value: 400,
});
Object.defineProperty(scroller, 'clientHeight', {
configurable: true,
value: 200,
});
scroller.scrollTop = 140;
const tableWrapper = document.createElement('div');
scroller.appendChild(tableWrapper);
document.body.appendChild(scroller);
result.setTableWrapperRef(tableWrapper as HTMLDivElement);
result.setSelectedGuestId('app-container:truenas-main:nextcloud');
expect(scroller.scrollTop).toBe(140);
vi.runAllTimers();
expect(result.selectedGuestId()).toBe('app-container:truenas-main:nextcloud');
expect(navigateSpy).not.toHaveBeenCalled();
});
it('smart-reveals mounted workload detail when the row itself triggers focus near the fold', () => {
locationSearch = '?type=app-container&platform=truenas&agent=truenas-main';
const workloadId = 'app-container:truenas-main:nextcloud';
const [filteredGuests] = createSignal<WorkloadGuest[]>([
{
id: workloadId,
name: 'nextcloud',
status: 'running',
instance: 'truenas-main',
node: 'truenas-main',
} as unknown as WorkloadGuest,
]);
const scrollToSpy = vi.fn();
Object.defineProperty(window, 'scrollY', {
configurable: true,
value: 180,
});
window.scrollTo = scrollToSpy as typeof window.scrollTo;
const { result } = renderHook(() =>
useWorkloadSelectionState({
filteredGuests,
}),
);
const tableWrapper = document.createElement('div');
const row = document.createElement('div');
row.dataset.summarySeriesId = workloadId;
row.getBoundingClientRect = vi.fn(() => ({
top: 624,
bottom: 664,
left: 0,
right: 320,
width: 320,
height: 40,
x: 0,
y: 624,
toJSON: () => ({}),
})) as unknown as typeof row.getBoundingClientRect;
const detail = document.createElement('div');
detail.dataset.inlineDetailFor = workloadId;
detail.getBoundingClientRect = vi.fn(() => ({
top: 668,
bottom: 964,
left: 0,
right: 320,
width: 320,
height: 296,
x: 0,
y: 668,
toJSON: () => ({}),
})) as unknown as typeof detail.getBoundingClientRect;
tableWrapper.appendChild(row);
tableWrapper.appendChild(detail);
document.body.appendChild(tableWrapper);
result.setTableWrapperRef(tableWrapper as HTMLDivElement);
result.setTableRootRef(tableWrapper as HTMLDivElement);
result.setSelectedGuestId(workloadId);
vi.runAllTimers();
expect(
scrollToSpy.mock.calls.some(
([firstArg]) =>
Boolean(firstArg) &&
typeof firstArg === 'object' &&
'behavior' in firstArg &&
firstArg.behavior === 'smooth',
),
).toBe(true);
});
it('ignores a summaryGroup param because grouped rows no longer pin a group scope', () => {
locationSearch = '?summaryGroup=cluster-b&resource=cluster-a:node-1:101';
const [filteredGuests] = createSignal<WorkloadGuest[]>([
{
id: 'cluster-a:node-1:101',
name: 'guest-1',
status: 'running',
instance: 'cluster-a',
node: 'node-1',
vmid: 101,
} as unknown as WorkloadGuest,
]);
const { result } = renderHook(() =>
useWorkloadSelectionState({
filteredGuests,
}),
);
vi.runAllTimers();
expect(result.selectedGuestId()).toBe('cluster-a:node-1:101');
expect(result.activeSummaryWorkloadId()).toBe('cluster-a:node-1:101');
expect(Object.keys(result).filter((key) => /group/i.test(key))).toEqual([]);
});
it('clears row focus locally without leaving behind an inferred agent filter', () => {
locationSearch = '?resource=cluster-a:node-1:101';
const [filteredGuests] = createSignal<WorkloadGuest[]>([]);
const { result } = renderHook(() =>
useWorkloadSelectionState({
filteredGuests,
}),
);
expect(result.selectedGuestId()).toBe('cluster-a:node-1:101');
result.setSelectedGuestId(null);
vi.runAllTimers();
expect(result.selectedGuestId()).toBeNull();
expect(navigateSpy).not.toHaveBeenCalled();
});
it('stages no app-shell restore for a local row toggle that a later route change could replay', () => {
locationSearch = '';
clearPendingAppShellRestoreTop();
const shell = document.createElement('div');
shell.className = 'app-scroll-shell';
shell.scrollTop = 3000;
document.body.appendChild(shell);
const [filteredGuests] = createSignal<WorkloadGuest[]>([]);
const { result } = renderHook(() =>
useWorkloadSelectionState({
filteredGuests,
}),
);
result.setSelectedGuestId('cluster-a:node-1:101');
vi.runAllTimers();
expect(result.selectedGuestId()).toBe('cluster-a:node-1:101');
expect(readPendingAppShellRestoreTop()).toBeNull();
result.setSelectedGuestId(null);
vi.runAllTimers();
expect(readPendingAppShellRestoreTop()).toBeNull();
// Back at the top, a filter change writes the URL. The scheduler stages a
// restore only from a scrolled shell, so App.tsx would replay anything the
// row toggle had staged and jump the page back to 3000.
shell.scrollTop = 0;
const navigate = vi.fn();
const scheduler = createRouteStateNavigateScheduler(navigate, () => '/proxmox/overview');
scheduler.schedule('/proxmox/overview?type=vm');
vi.runAllTimers();
expect(navigate).toHaveBeenCalledWith('/proxmox/overview?type=vm', ROUTE_STATE_REPLACE_OPTIONS);
expect(readPendingAppShellRestoreTop()).toBeNull();
expect(navigateSpy).not.toHaveBeenCalled();
});
it('resolves an old node-scoped link through backend identity ownership', async () => {
vi.mocked(ResourceAPI.getResource).mockResolvedValueOnce({ id: 'stable-resource' } as Resource);
const { result } = renderHook(() => useWorkloadSelectionState({ filteredGuests: () => [] }));
await Promise.resolve();
await Promise.resolve();
expect(result.selectedGuestId()).toBe('stable-resource');
expect(ResourceAPI.getResource).toHaveBeenCalledWith('cluster-a:node-1:101', {
signal: expect.any(AbortSignal),
});
expect(navigateSpy).not.toHaveBeenCalled();
});
it('keeps exact current identity local without an alias lookup', () => {
locationSearch = '?resource=stable-resource';
const guest = {
id: 'stable-resource',
canonicalResourceId: 'stable-resource',
} as WorkloadGuest;
const { result } = renderHook(() =>
useWorkloadSelectionState({ filteredGuests: () => [guest] }),
);
expect(result.selectedGuestId()).toBe('stable-resource');
expect(ResourceAPI.getResource).not.toHaveBeenCalled();
});
it.each(['close', 'reselect', 'escape'] as const)(
'does not replay a pending link after %s',
async (interaction) => {
let finish!: (resource: Resource) => void;
vi.mocked(ResourceAPI.getResource).mockImplementationOnce(
() =>
new Promise((resolve) => {
finish = resolve;
}),
);
const { result } = renderHook(() => useWorkloadSelectionState({ filteredGuests: () => [] }));
const signal = vi.mocked(ResourceAPI.getResource).mock.calls[0]![1]!.signal!;
if (interaction === 'close') result.clearPinnedSummaryScope();
else if (interaction === 'reselect') result.setSelectedGuestId('independent-clone');
else document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
expect(signal.aborted).toBe(true);
finish({ id: 'stable-resource' } as Resource);
await Promise.resolve();
await Promise.resolve();
expect(result.selectedGuestId()).toBe(
interaction === 'reselect' ? 'independent-clone' : null,
);
},
);
it('aborts a superseded route lookup and accepts only its current reference', async () => {
const [search, setSearch] = createSignal('?resource=old-reference');
readLocationSearch = search;
let finishOld!: (resource: Resource) => void;
vi.mocked(ResourceAPI.getResource)
.mockImplementationOnce(
() =>
new Promise((resolve) => {
finishOld = resolve;
}),
)
.mockResolvedValueOnce({ id: 'new-resource' } as Resource);
const { result } = renderHook(() => useWorkloadSelectionState({ filteredGuests: () => [] }));
const oldSignal = vi.mocked(ResourceAPI.getResource).mock.calls[0]![1]!.signal!;
setSearch('?resource=new-reference');
await Promise.resolve();
await Promise.resolve();
finishOld({ id: 'old-resource' } as Resource);
await Promise.resolve();
expect(oldSignal.aborted).toBe(true);
expect(result.selectedGuestId()).toBe('new-resource');
});
it('does not resolve references while route state is disabled', () => {
const { result } = renderHook(() =>
useWorkloadSelectionState({ filteredGuests: () => [], routeStateEnabled: () => false }),
);
expect(result.selectedGuestId()).toBeNull();
expect(ResourceAPI.getResource).not.toHaveBeenCalled();
});
it('leaves an ambiguous or refused reference unresolved', async () => {
vi.mocked(ResourceAPI.getResource).mockRejectedValueOnce(new Error('not found'));
const { result } = renderHook(() => useWorkloadSelectionState({ filteredGuests: () => [] }));
await Promise.resolve();
await Promise.resolve();
expect(result.selectedGuestId()).toBe('cluster-a:node-1:101');
expect(navigateSpy).not.toHaveBeenCalled();
});
it('keeps a pending reference lookup and local dismissal through unrelated filter changes', async () => {
const [search, setSearch] = createSignal('?resource=old-reference');
readLocationSearch = search;
let finish!: (resource: Resource) => void;
vi.mocked(ResourceAPI.getResource).mockImplementationOnce(
() =>
new Promise((resolve) => {
finish = resolve;
}),
);
const { result } = renderHook(() => useWorkloadSelectionState({ filteredGuests: () => [] }));
const signal = vi.mocked(ResourceAPI.getResource).mock.calls[0]![1]!.signal!;
setSearch('?resource=old-reference&type=vm');
expect(signal.aborted).toBe(false);
expect(ResourceAPI.getResource).toHaveBeenCalledTimes(1);
finish({ id: 'stable-resource' } as Resource);
await Promise.resolve();
await Promise.resolve();
expect(result.selectedGuestId()).toBe('stable-resource');
result.clearPinnedSummaryScope();
setSearch('?resource=old-reference&type=vm&node=node-2');
expect(result.selectedGuestId()).toBeNull();
expect(ResourceAPI.getResource).toHaveBeenCalledTimes(1);
});
it('keeps the selected resource drawer state through regrouping and resets it on another selection', () => {
locationSearch = '';
const [guests, setGuests] = createSignal([
{ id: 'stable-resource', node: 'node-1' },
] as WorkloadGuest[]);
const { result } = renderHook(() => useWorkloadSelectionState({ filteredGuests: guests }));
result.setSelectedGuestId('stable-resource');
result.selectedGuestDrawerState.setActiveTab('manage');
result.selectedGuestDrawerState.setHistoryRange('12h');
setGuests([{ id: 'stable-resource', node: 'node-2' }] as WorkloadGuest[]);
result.setSelectedGuestId('stable-resource');
expect(result.selectedGuestDrawerState.activeTab()).toBe('manage');
expect(result.selectedGuestDrawerState.historyRange()).toBe('12h');
result.setSelectedGuestId('independent-clone');
expect(result.selectedGuestDrawerState.activeTab()).toBe('overview');
expect(result.selectedGuestDrawerState.historyRange()).toBe('24h');
result.selectedGuestDrawerState.setActiveTab('manage');
result.clearPinnedSummaryScope();
expect(result.selectedGuestDrawerState.activeTab()).toBe('overview');
});
});