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 { afterEach, describe, expect, it, vi } from 'vitest';
import { createSignal } from 'solid-js';
import { ChartsAPI } from '@/api/charts';
import { eventBus } from '@/stores/events';
import { cleanup, fireEvent, render, screen, waitFor, within } from '@solidjs/testing-library';
import { HistoryChartHeader } from '@/components/shared/HistoryChartHeader';
import type { HistoryChartState } from '@/components/shared/useHistoryChartState';
import { HistoryChart, HistoryChartHoverGroup } from '@/components/shared/HistoryChart';
import {
formatHistoryChartTooltipValue,
getHistoryChartTimeTickCount,
getHistoryChartTooltipLayout,
getHistoryChartYAxisLabels,
getHistoryReadoutLabel,
getHistorySourceNotice,
hasHistoryChartSpread,
HISTORY_CHART_RANGES,
withoutRepeatedHistoryAxisLabels,
withoutRepeatedHistoryTimeTicks,
} from '@/components/shared/historyChartModel';
it('distinguishes tiny positive percentage observations from zero in History labels', () => {
expect(formatHistoryChartTooltipValue(0, '%')).toBe('0.0%');
expect(formatHistoryChartTooltipValue(Number.MIN_VALUE, '%')).toBe('<0.1%');
expect(formatHistoryChartTooltipValue(0.026, '%')).toBe('<0.1%');
expect(formatHistoryChartTooltipValue(0.09999, '%')).toBe('<0.1%');
expect(formatHistoryChartTooltipValue(0.1, '%')).toBe('0.1%');
expect(formatHistoryChartTooltipValue(9.4, '%')).toBe('9.4%');
expect(formatHistoryChartTooltipValue(0.026, 'C')).toBe('0°C');
});
function touchPointer(canvas: Element, type: string, fields: Partial<PointerEvent> = {}) {
const event = Object.assign(new Event(type, { bubbles: true, cancelable: true }), {
pointerId: 1,
pointerType: 'touch',
isPrimary: true,
clientX: 60,
clientY: 60,
...fields,
});
fireEvent(canvas, event);
// Inspection must never consume native page panning or pinch zoom.
expect(event.defaultPrevented).toBe(false);
}
function mountTouchHistory() {
const [target, setTarget] = createSignal('disk-a');
const [data, setData] = createSignal(
[10, 20, 30].map((value, index) => ({
timestamp: (index + 1) * 1000,
value,
min: value,
max: value,
})),
);
const view = render(() => (
<HistoryChart
resourceType="disk"
resourceId={target()}
metric="disk"
unit="%"
data={data()}
hideSelector
/>
));
const canvas = view.container.querySelector('canvas')!;
vi.spyOn(canvas, 'getBoundingClientRect').mockReturnValue({
x: 0,
y: 0,
left: 0,
top: 0,
right: 400,
bottom: 200,
width: 400,
height: 200,
toJSON: () => ({}),
});
return {
...view,
canvas,
setTarget,
data,
setData,
tooltip: () => view.container.querySelector('[data-history-chart-tooltip]'),
announcement: view.container.querySelector('[aria-live="polite"]')!,
};
}
if (typeof globalThis.ResizeObserver === 'undefined') {
globalThis.ResizeObserver = class ResizeObserver {
observe() {}
unobserve() {}
disconnect() {}
} as unknown as typeof ResizeObserver;
}
HTMLCanvasElement.prototype.getContext = vi.fn(() => ({
clearRect: vi.fn(),
setTransform: vi.fn(),
beginPath: vi.fn(),
moveTo: vi.fn(),
lineTo: vi.fn(),
stroke: vi.fn(),
fillText: vi.fn(),
closePath: vi.fn(),
fill: vi.fn(),
arc: vi.fn(),
save: vi.fn(),
restore: vi.fn(),
setLineDash: vi.fn(),
createLinearGradient: vi.fn(() => ({
addColorStop: vi.fn(),
})),
measureText: vi.fn(() => ({ width: 40 })),
})) as unknown as typeof HTMLCanvasElement.prototype.getContext;
vi.mock('@/stores/license', () => ({
isRangeLocked: () => false,
loadRuntimeCapabilities: vi.fn(),
maxHistoryDays: () => 30,
}));
vi.mock('@/api/charts', () => ({
ChartsAPI: {
getMetricsHistory: vi.fn().mockResolvedValue({ points: [], source: 'store' }),
},
}));
describe('History source wording', () => {
it('names the readout and badge by where the readings came from', () => {
expect(getHistoryReadoutLabel('store', false)).toBe('Latest stored');
expect(getHistoryReadoutLabel('store', true)).toBe('Stored');
expect(getHistoryReadoutLabel('mock_synthetic', false)).toBe('Latest stored');
expect(getHistoryReadoutLabel(undefined, false)).toBe('Latest stored');
expect(getHistoryReadoutLabel('memory', false)).toBe('Latest recorded');
expect(getHistoryReadoutLabel('memory', true)).toBe('Recorded');
expect(getHistoryReadoutLabel('live', false)).toBe('Current');
expect(getHistorySourceNotice('store')).toBeNull();
expect(getHistorySourceNotice('mock_synthetic')).toBeNull();
expect(getHistorySourceNotice('memory')?.badge).toBe('Recent only');
expect(getHistorySourceNotice('live')?.badge).toBe('Current only');
});
});
describe('History chart min-max band', () => {
const at = (timestamp: number, value: number, min = value, max = value) => ({
timestamp,
value,
min,
max,
});
it("spreads only when a bucket's lowest and highest readings differ", () => {
expect(hasHistoryChartSpread([at(1, 5), at(2, 6)])).toBe(false);
expect(hasHistoryChartSpread([at(1, 5), at(2, 6, 2, 30)])).toBe(true);
expect(hasHistoryChartSpread([at(1, 5, 2, 30)])).toBe(false);
});
let restoreContext = () => {};
// Records what the chart fills, with the fill colour in force at the time.
const recordFills = () => {
const fills: string[] = [];
const getContext = vi.mocked(HTMLCanvasElement.prototype.getContext);
const original = getContext.getMockImplementation()!;
restoreContext = () => getContext.mockImplementation(original);
getContext.mockImplementation(function () {
const ctx: Record<string, unknown> = {
fillStyle: '',
clearRect: vi.fn(() => fills.splice(0)),
setTransform: vi.fn(),
beginPath: vi.fn(),
moveTo: vi.fn(),
lineTo: vi.fn(),
stroke: vi.fn(),
fillText: vi.fn(),
closePath: vi.fn(),
fill: vi.fn(() => fills.push(String(ctx.fillStyle))),
arc: vi.fn(),
save: vi.fn(),
restore: vi.fn(),
setLineDash: vi.fn(),
measureText: vi.fn(() => ({ width: 40 })),
};
return ctx as never;
});
return fills;
};
it('draws a band behind the line for spiky buckets and no area fill for flat ones', async () => {
const request = vi.mocked(ChartsAPI.getMetricsHistory);
const fills = recordFills();
try {
request.mockResolvedValueOnce({
points: [at(1000, 10, 4, 60), at(2000, 12, 8, 14)],
source: 'store',
} as never);
const spiky = render(() => (
<HistoryChart resourceType="disk" resourceId="d" metric="diskread" color="#3b82f6" />
));
await waitFor(() => expect(fills).toContain('#3b82f633'));
spiky.unmount();
fills.splice(0);
request.mockResolvedValueOnce({
points: [at(1000, 10), at(2000, 12)],
source: 'store',
} as never);
render(() => (
<HistoryChart resourceType="disk" resourceId="e" metric="diskread" color="#3b82f6" />
));
await waitFor(() =>
expect(
document.getElementById(
screen.getByRole('img', { name: 'History chart' }).getAttribute('aria-describedby')!,
)!.textContent,
).toContain('2 data points'),
);
expect(fills.filter((fill) => fill.startsWith('#3b82f6'))).toEqual([]);
} finally {
restoreContext();
}
});
});
describe('History chart axis labels', () => {
it('fits as many time labels as the plot holds without touching', () => {
// "11:30 AM" is about 45px at 10px sans-serif; neighbours need 57px apart.
expect(getHistoryChartTimeTickCount(600, 45)).toBe(4);
expect(getHistoryChartTimeTickCount(171, 45)).toBe(4);
expect(getHistoryChartTimeTickCount(170, 45)).toBe(3);
expect(getHistoryChartTimeTickCount(150, 45)).toBe(3);
expect(getHistoryChartTimeTickCount(100, 45)).toBe(2);
expect(getHistoryChartTimeTickCount(30, 45)).toBe(2);
expect(getHistoryChartTimeTickCount(0, 45)).toBe(4);
});
it('states a time label once when a short window repeats it', () => {
const tick = (label: string) => ({ timestamp: 0, label });
expect(
withoutRepeatedHistoryTimeTicks([tick('Oct 2'), tick('Oct 2'), tick('Oct 2')]).map(
(t) => t.label,
),
).toEqual(['Oct 2']);
expect(
withoutRepeatedHistoryTimeTicks([
tick('11:00 AM'),
tick('11:00 AM'),
tick('11:01 AM'),
tick('11:02 AM'),
]).map((t) => t.label),
).toEqual(['11:00 AM', '11:01 AM', '11:02 AM']);
});
it('blanks a middle gridline label that repeats a neighbour', () => {
expect(withoutRepeatedHistoryAxisLabels(['<1K/s', '<1K/s', '0'])).toEqual(['<1K/s', '', '0']);
expect(withoutRepeatedHistoryAxisLabels(['1', '1', '0'])).toEqual(['1', '', '0']);
expect(withoutRepeatedHistoryAxisLabels(['0', '0', '0'])).toEqual(['0', '', '0']);
expect(withoutRepeatedHistoryAxisLabels(['0', '50', '100'])).toEqual(['0', '50', '100']);
// A rounded range of 0-1 would read 0, 1, 1 bottom to top.
expect(
getHistoryChartYAxisLabels(
{ minValue: 0, maxValue: 1, isPercentLike: false, isByteLike: false },
'sectors',
).map((tick) => tick.label),
).toEqual(['0', '', '1']);
});
});
describe('HistoryChart', () => {
it('inspects actual readings with the keyboard and clears on escape, blur and selection changes', () => {
const [target, setTarget] = createSignal('a');
const [points, setPoints] = createSignal([
{ timestamp: 1_000, value: 10, min: 10, max: 10 },
{ timestamp: 2_000, value: 20, min: 20, max: 20 },
{ timestamp: 3_000, value: 30, min: 30, max: 30 },
]);
const { container } = render(() => (
<HistoryChart
resourceType="disk"
resourceId={target()}
metric="usage"
unit="%"
hideSelector
data={points()}
/>
));
const canvas = screen.getByRole('img', { name: 'History chart' });
const announcement = container.querySelector('[aria-live="polite"]')!;
expect(canvas).toHaveAttribute('tabindex', '0');
expect(announcement.textContent).toBe('');
fireEvent.focus(canvas);
expect(announcement).toHaveTextContent('30.0%');
fireEvent.keyDown(canvas, { key: 'ArrowLeft' });
expect(announcement).toHaveTextContent('20.0%');
fireEvent.keyDown(canvas, { key: 'Home' });
fireEvent.keyDown(canvas, { key: 'ArrowLeft' });
expect(announcement).toHaveTextContent('10.0%');
fireEvent.keyDown(canvas, { key: 'ArrowRight', ctrlKey: true });
expect(announcement).toHaveTextContent('10.0%');
fireEvent.keyDown(canvas, { key: 'End' });
fireEvent.keyDown(canvas, { key: 'ArrowRight' });
expect(announcement).toHaveTextContent('30.0%');
fireEvent.keyDown(canvas, { key: 'Escape' });
expect(announcement.textContent).toBe('');
expect(container.querySelector('[data-history-chart-tooltip]')).toBeNull();
fireEvent.keyDown(canvas, { key: 'Home' });
setPoints(points().map((point) => ({ ...point, value: point.value + 1 })));
expect(announcement).toHaveTextContent('11.0%');
setTarget('b');
expect(announcement.textContent).toBe('');
fireEvent.keyDown(canvas, { key: 'Home' });
fireEvent.blur(canvas);
expect(announcement.textContent).toBe('');
setPoints([]);
fireEvent.focus(canvas);
fireEvent.keyDown(canvas, { key: 'End' });
expect(announcement.textContent).toBe('');
});
it('inspects the tapped sample without compatibility focus selecting the latest reading', () => {
const view = mountTouchHistory();
touchPointer(view.canvas, 'pointerdown');
touchPointer(view.canvas, 'pointerup');
fireEvent.focus(view.canvas);
expect(view.tooltip()).toHaveTextContent('10.0%');
expect(view.announcement.textContent).toBe('');
fireEvent.mouseMove(view.canvas, { clientX: 370 });
fireEvent.mouseLeave(view.canvas);
expect(view.tooltip()).toHaveTextContent('10.0%');
touchPointer(view.canvas, 'pointerdown', { clientX: 200 });
touchPointer(view.canvas, 'pointerup', { clientX: 200 });
expect(view.tooltip()).toHaveTextContent('20.0%');
fireEvent.keyDown(view.canvas, { key: 'ArrowRight' });
expect(view.announcement).toHaveTextContent('30.0%');
fireEvent.keyDown(view.canvas, { key: 'Escape' });
expect(view.tooltip()).toBeNull();
fireEvent.blur(view.canvas);
fireEvent.focus(view.canvas);
expect(view.announcement).toHaveTextContent('30.0%');
});
it.each(['moved', 'release-displaced', 'cancelled', 'second-finger', 'different-pointer'])(
'does not turn a %s touch into inspection',
(gesture) => {
const view = mountTouchHistory();
touchPointer(view.canvas, 'pointerdown');
if (gesture === 'moved') {
touchPointer(view.canvas, 'pointermove', { clientY: 90 });
// Returning to the origin is still a drag, not a new tap.
touchPointer(view.canvas, 'pointermove');
} else if (gesture === 'cancelled') {
touchPointer(view.canvas, 'pointercancel');
} else if (gesture === 'second-finger') {
touchPointer(view.canvas, 'pointerdown', { pointerId: 2, isPrimary: false });
}
touchPointer(view.canvas, 'pointerup', {
...(gesture === 'release-displaced' ? { clientY: 90 } : {}),
...(gesture === 'different-pointer' ? { pointerId: 2 } : {}),
});
fireEvent.focus(view.canvas);
expect(view.tooltip()).toBeNull();
expect(view.announcement.textContent).toBe('');
},
);
it.each([{ clientX: 0 }, { clientX: 400 }, { clientY: -1 }, { clientY: 201 }])(
'does not inspect a tap outside the plot: %j',
(position) => {
const view = mountTouchHistory();
touchPointer(view.canvas, 'pointerdown', position);
touchPointer(view.canvas, 'pointerup', position);
expect(view.tooltip()).toBeNull();
},
);
it('invalidates an in-flight touch when the resource changes', () => {
const view = mountTouchHistory();
touchPointer(view.canvas, 'pointerdown');
view.setTarget('disk-b');
touchPointer(view.canvas, 'pointerup');
fireEvent.focus(view.canvas);
expect(view.tooltip()).toBeNull();
expect(view.announcement.textContent).toBe('');
touchPointer(view.canvas, 'pointerdown', { clientX: 200 });
touchPointer(view.canvas, 'pointerup', { clientX: 200 });
expect(view.tooltip()).toHaveTextContent('20.0%');
});
it('keeps the tapped time on refresh and distinguishes a lone zero from empty history', () => {
const view = mountTouchHistory();
touchPointer(view.canvas, 'pointerdown');
touchPointer(view.canvas, 'pointerup');
view.setData(view.data().map((point) => ({ ...point, value: point.value + 1 })));
expect(view.tooltip()).toHaveTextContent('11.0%');
view.setData([{ timestamp: 1000, value: 0, min: 0, max: 0 }]);
touchPointer(view.canvas, 'pointerdown', { clientX: 200 });
touchPointer(view.canvas, 'pointerup', { clientX: 200 });
expect(view.tooltip()).toHaveTextContent('0.0%');
view.setData([]);
touchPointer(view.canvas, 'pointerdown');
touchPointer(view.canvas, 'pointerup');
fireEvent.focus(view.canvas);
expect(view.tooltip()).toBeNull();
expect(view.announcement.textContent).toBe('');
});
it('leaves mouse hover available after touch inspection', () => {
const view = mountTouchHistory();
touchPointer(view.canvas, 'pointerdown');
touchPointer(view.canvas, 'pointerup');
touchPointer(view.canvas, 'pointermove', { pointerType: 'mouse', clientX: 200 });
fireEvent.mouseMove(view.canvas, { clientX: 200 });
expect(view.tooltip()).toHaveTextContent('20.0%');
fireEvent.mouseLeave(view.canvas);
expect(view.tooltip()).toBeNull();
});
it('keeps a new group chart tap when the previously focused chart blurs', () => {
const points = [10, 20, 30].map((value, index) => ({
timestamp: (index + 1) * 1000,
value,
min: value,
max: value,
}));
const { container } = render(() => (
<HistoryChartHoverGroup>
<HistoryChart resourceType="disk" resourceId="a" metric="disk" unit="%" data={points} />
<HistoryChart resourceType="disk" resourceId="a" metric="usage" unit="%" data={points} />
</HistoryChartHoverGroup>
));
const [previous, next] = container.querySelectorAll('canvas');
vi.spyOn(next, 'getBoundingClientRect').mockReturnValue({
x: 0,
y: 0,
left: 0,
top: 0,
right: 400,
bottom: 200,
width: 400,
height: 200,
toJSON: () => ({}),
});
fireEvent.focus(previous);
touchPointer(next, 'pointerdown');
touchPointer(next, 'pointerup');
fireEvent.blur(previous);
fireEvent.focus(next);
const tooltips = container.querySelectorAll('[data-history-chart-tooltip]');
expect(tooltips).toHaveLength(2);
for (const tooltip of tooltips) expect(tooltip).toHaveTextContent('10.0%');
for (const live of container.querySelectorAll('[aria-live="polite"]')) {
expect(live.textContent).toBe('');
}
});
it('renders the default history label', () => {
render(() => <HistoryChart resourceType="agent" resourceId="node-1" metric="cpu" />);
expect(screen.getByText('History')).toBeInTheDocument();
expect(screen.getByRole('img', { name: 'History chart' })).toHaveAttribute('aria-describedby');
});
it('provides a text equivalent for a populated history chart', () => {
render(() => (
<HistoryChart
resourceType="agent"
resourceId="node-1"
metric="cpu"
label="CPU usage"
unit="%"
range="24h"
data={[
{ timestamp: 1_000, value: 10, min: 8, max: 12 },
{ timestamp: 2_000, value: 30, min: 25, max: 35 },
]}
/>
));
const chart = screen.getByRole('img', { name: 'CPU usage chart' });
const description = document.getElementById(chart.getAttribute('aria-describedby')!);
expect(description).toHaveClass('sr-only');
expect(description).toHaveTextContent('24-hour history contains 2 data points');
expect(description).toHaveTextContent('Values increased from 10.0% to 30.0%.');
expect(description).toHaveTextContent('Minimum 8.0%. Maximum 35.0%.');
});
it('removes previous-target values from the accessible chart while the next target loads', async () => {
const request = vi.mocked(ChartsAPI.getMetricsHistory);
request.mockResolvedValueOnce({
points: [{ timestamp: 1000, value: 10, min: 10, max: 10 }],
source: 'store',
} as never);
const [target, setTarget] = createSignal('a');
render(() => <HistoryChart resourceType="agent" resourceId={target()} metric="cpu" unit="%" />);
const chart = screen.getByRole('img', { name: 'History chart' });
const description = document.getElementById(chart.getAttribute('aria-describedby')!)!;
await waitFor(() => expect(description).toHaveTextContent('10.0%'));
request.mockImplementationOnce(() => new Promise(() => {}));
setTarget('b');
expect(description).toHaveTextContent('Loading');
expect(description).not.toHaveTextContent('10.0%');
expect(screen.queryByText('Min')).not.toBeInTheDocument();
});
it('keeps its readings without a spinner or read while paused, then resumes', async () => {
vi.useFakeTimers();
try {
const request = vi.mocked(ChartsAPI.getMetricsHistory);
request.mockReset();
request.mockResolvedValue({
points: [{ timestamp: 1000, value: 10, min: 10, max: 10 }],
source: 'store',
} as never);
const [enabled, setEnabled] = createSignal(true);
render(() => (
<HistoryChart resourceType="disk" resourceId="d" metric="smart_temp" enabled={enabled()} />
));
const chart = screen.getByRole('img', { name: 'History chart' });
const description = document.getElementById(chart.getAttribute('aria-describedby')!)!;
await vi.advanceTimersByTimeAsync(0);
expect(description).toHaveTextContent('10');
const calls = request.mock.calls.length;
// A hidden drawer tab pauses the chart: no reads, readings kept.
setEnabled(false);
await vi.advanceTimersByTimeAsync(120_000);
expect(request.mock.calls.length).toBe(calls);
expect(description).toHaveTextContent('10');
expect(screen.queryByLabelText('Loading history')).not.toBeInTheDocument();
setEnabled(true);
expect(request.mock.calls.length).toBe(calls + 1);
expect(screen.queryByLabelText('Loading history')).not.toBeInTheDocument();
} finally {
vi.useRealTimers();
vi.mocked(ChartsAPI.getMetricsHistory)
.mockReset()
.mockResolvedValue({ points: [], source: 'store' } as never);
}
});
it('keeps its readings on screen while a resize re-reads at a new point cap', async () => {
const request = vi.mocked(ChartsAPI.getMetricsHistory);
const observers: Array<() => void> = [];
const original = globalThis.ResizeObserver;
globalThis.ResizeObserver = class {
constructor(callback: () => void) {
observers.push(callback);
}
observe() {}
unobserve() {}
disconnect() {}
} as unknown as typeof ResizeObserver;
let width = 800;
const widthSpy = vi
.spyOn(HTMLElement.prototype, 'clientWidth', 'get')
.mockImplementation(() => width);
try {
// The first measured width replaces the unmeasured read, so every read
// until the resize answers with the same reading.
request.mockResolvedValue({
points: [{ timestamp: 1000, value: 10, min: 10, max: 10 }],
source: 'store',
} as never);
render(() => <HistoryChart resourceType="disk" resourceId="d" metric="smart_temp" />);
const chart = screen.getByRole('img', { name: 'History chart' });
const description = document.getElementById(chart.getAttribute('aria-describedby')!)!;
await waitFor(() => expect(description).toHaveTextContent('10'));
const calls = request.mock.calls.length;
request.mockImplementationOnce(() => new Promise(() => {}));
width = 400;
observers.forEach((resized) => resized());
expect(request.mock.calls.length).toBe(calls + 1);
expect(request.mock.calls.at(-1)![0].maxPoints).not.toBe(
request.mock.calls.at(-2)![0].maxPoints,
);
expect(description).toHaveTextContent('10');
expect(screen.queryByLabelText('Loading history')).not.toBeInTheDocument();
} finally {
widthSpy.mockRestore();
globalThis.ResizeObserver = original;
request.mockReset().mockResolvedValue({ points: [], source: 'store' } as never);
}
});
it('exposes a stored singleton to pointer inspection without treating a later empty response as zero', async () => {
const request = vi.mocked(ChartsAPI.getMetricsHistory);
request.mockResolvedValueOnce({
points: [{ timestamp: 1000, value: 42, min: 42, max: 42 }],
source: 'store',
} as never);
const [target, setTarget] = createSignal('pool-a');
const { container } = render(() => (
<HistoryChart
resourceType="storage"
resourceId={target()}
metric="usage"
unit="%"
range="1h"
/>
));
const chart = screen.getByRole('img', { name: 'History chart' });
const description = document.getElementById(chart.getAttribute('aria-describedby')!)!;
const rectSpy = vi.spyOn(chart, 'getBoundingClientRect').mockReturnValue({
x: 0,
y: 0,
left: 0,
top: 0,
right: 300,
bottom: 200,
width: 300,
height: 200,
toJSON: () => ({}),
});
await waitFor(() => expect(description).toHaveTextContent('1 data point'));
fireEvent.mouseMove(chart, { clientX: 175 });
expect(container.querySelector('[data-history-chart-tooltip]')).toHaveTextContent('42.0%');
request.mockResolvedValueOnce({ points: [], source: 'store' } as never);
setTarget('pool-b');
await waitFor(() => expect(description).toHaveTextContent('No 1-hour history'));
expect(description).not.toHaveTextContent('0.0%');
expect(container.querySelector('[data-history-chart-tooltip]')).toBeNull();
rectSpy.mockRestore();
});
it('synchronizes the hovered timestamp across charts in the same group', () => {
const rectSpy = vi.spyOn(HTMLCanvasElement.prototype, 'getBoundingClientRect').mockReturnValue({
x: 0,
y: 0,
left: 0,
top: 0,
right: 400,
bottom: 120,
width: 400,
height: 120,
toJSON: () => ({}),
});
const data = [
{ timestamp: 1_000, value: 10, min: 10, max: 10 },
{ timestamp: 2_000, value: 20, min: 20, max: 20 },
{ timestamp: 3_000, value: 30, min: 30, max: 30 },
];
const { container } = render(() => (
<HistoryChartHoverGroup>
<HistoryChart
resourceType="disk"
resourceId="disk-1"
metric="diskread"
unit="B/s"
data={data}
/>
<HistoryChart
resourceType="disk"
resourceId="disk-1"
metric="diskwrite"
unit="B/s"
data={data.map((point) => ({
...point,
value: point.value * 2,
min: point.min * 2,
max: point.max * 2,
}))}
/>
</HistoryChartHoverGroup>
));
const canvases = container.querySelectorAll('canvas');
fireEvent.mouseMove(canvases[0], { clientX: 220 });
expect(container.querySelectorAll('[data-history-chart-tooltip="true"]')).toHaveLength(2);
fireEvent.mouseLeave(canvases[0]);
expect(container.querySelectorAll('[data-history-chart-tooltip="true"]')).toHaveLength(0);
rectSpy.mockRestore();
});
it('keeps pointer inspection when matching supplied samples refresh', () => {
const rectSpy = vi.spyOn(HTMLCanvasElement.prototype, 'getBoundingClientRect').mockReturnValue({
x: 0,
y: 0,
left: 0,
top: 0,
right: 400,
bottom: 120,
width: 400,
height: 120,
toJSON: () => ({}),
});
const samples = (value: number) =>
[1000, 2000, 3000].map((timestamp) => ({ timestamp, value, min: value, max: value }));
const [data, setData] = createSignal(samples(10));
const { container } = render(() => (
<HistoryChart resourceType="agent" resourceId="a" metric="cpu" data={data()} />
));
fireEvent.mouseMove(container.querySelector('canvas')!, { clientX: 220 });
expect(container.querySelector('[data-history-chart-tooltip="true"]')).not.toBeNull();
setData(samples(20));
expect(container.querySelector('[data-history-chart-tooltip="true"]')).not.toBeNull();
expect(container.querySelector('[data-history-chart-tooltip="true"]')).toHaveTextContent('20');
rectSpy.mockRestore();
});
it('exposes the sub-day and Relay history ranges as first-class chart options', () => {
expect(HISTORY_CHART_RANGES).toEqual(['1h', '6h', '12h', '24h', '7d', '14d', '30d', '90d']);
});
it('positions the tooltip beside the hovered point when there is chart space', () => {
const layout = getHistoryChartTooltipLayout({
hoveredPoint: { x: 150, y: 70, timestamp: 0, value: 42 },
chartWidth: 420,
chartHeight: 180,
});
expect(layout.x).toBe(162);
expect(layout.x).toBeGreaterThan(150);
expect(layout.height).toBe(64);
expect(layout.y + layout.height / 2).toBe(70);
});
it('moves the tooltip to the left edge side near the right chart boundary', () => {
const layout = getHistoryChartTooltipLayout({
hoveredPoint: { x: 380, y: 70, timestamp: 0, value: 42 },
chartWidth: 420,
chartHeight: 180,
});
expect(layout.x + layout.width).toBeLessThan(380);
expect(layout.x).toBe(212);
});
});
describe('History organisation boundary rendering', () => {
afterEach(() => {
cleanup();
vi.restoreAllMocks();
vi.useRealTimers();
});
it.each(['keyboard', 'touch'])(
'clears %s inspection and accessible values on org switch until a new read succeeds',
async (input) => {
vi.useFakeTimers();
const request = vi.mocked(ChartsAPI.getMetricsHistory);
request.mockReset();
request.mockResolvedValueOnce({
points: [{ timestamp: 1000, value: 42, min: 42, max: 42 }],
source: 'memory',
} as never);
let complete!: (response: Awaited<ReturnType<typeof ChartsAPI.getMetricsHistory>>) => void;
request.mockImplementationOnce(
() =>
new Promise((resolve) => {
complete = resolve;
}),
);
const { container } = render(() => (
<HistoryChart
resourceType="disk"
resourceId="disk:nas:sda"
metric="smart_temp"
label="Temperature"
unit="C"
range="1h"
/>
));
await vi.advanceTimersByTimeAsync(0);
const canvas = screen.getByRole('img', { name: 'Temperature chart' });
vi.spyOn(canvas, 'getBoundingClientRect').mockReturnValue({
x: 0,
y: 0,
left: 0,
top: 0,
right: 400,
bottom: 200,
width: 400,
height: 200,
toJSON: () => ({}),
});
if (input === 'keyboard') fireEvent.focus(canvas);
else {
touchPointer(canvas, 'pointerdown');
touchPointer(canvas, 'pointerup');
}
expect(container.querySelector('[data-history-chart-tooltip]')).toHaveTextContent('42°C');
// Readings from memory say so in words a reader knows, not "Buffer".
expect(container).toHaveTextContent('Recent only');
eventBus.emit('org_switched', 'org-b');
expect(container.querySelector('[data-history-chart-tooltip]')).toBeNull();
expect(container.querySelector('[aria-live="polite"]')?.textContent).toBe('');
expect(container).not.toHaveTextContent('42°C');
expect(container).not.toHaveTextContent('Recent only');
expect(canvas).toHaveAccessibleDescription(/Loading 1-hour history data/);
complete({
points: [{ timestamp: 1000, value: 80, min: 80, max: 80 }],
source: 'store',
} as never);
await vi.advanceTimersByTimeAsync(0);
expect(canvas).toHaveAccessibleDescription(/80°C/);
expect(container.querySelector('[data-history-chart-tooltip]')).toBeNull();
if (input === 'touch') {
// Touch compatibility focus from the old chart must not reactivate its pinned reading.
fireEvent.focus(canvas);
expect(container.querySelector('[data-history-chart-tooltip]')).toBeNull();
touchPointer(canvas, 'pointerdown');
touchPointer(canvas, 'pointerup');
expect(container.querySelector('[data-history-chart-tooltip]')).toHaveTextContent('80°C');
}
},
);
});
describe('History access boundary rendering', () => {
afterEach(() => {
cleanup();
vi.restoreAllMocks();
vi.useRealTimers();
});
it.each([401, 403])(
'withdraws painted readings, tooltips and keyboard announcements on %s',
async (status) => {
vi.useFakeTimers();
vi.spyOn(console, 'error').mockImplementation(() => {});
const request = vi.mocked(ChartsAPI.getMetricsHistory);
request.mockReset();
request.mockResolvedValueOnce({
points: [{ timestamp: 1000, value: 42, min: 42, max: 42 }],
source: 'store',
} as never);
const { container } = render(() => (
<HistoryChart
resourceType="disk"
resourceId="disk:nas:sda"
metric="smart_temp"
label="Temperature"
unit="C"
range="1h"
/>
));
await vi.advanceTimersByTimeAsync(0);
const canvas = screen.getByRole('img', { name: 'Temperature chart' });
fireEvent.focus(canvas);
expect(container.querySelector('[data-history-chart-tooltip]')).toHaveTextContent('42°C');
request.mockRejectedValueOnce(Object.assign(new Error('private detail'), { status }));
await vi.advanceTimersByTimeAsync(10_000);
expect(container.querySelector('[data-history-chart-tooltip]')).toBeNull();
expect(container.querySelector('[aria-live="polite"]')).toHaveTextContent('');
expect(container).not.toHaveTextContent('42°C');
expect(container).not.toHaveTextContent('last successful');
expect(container).not.toHaveTextContent('private detail');
expect(screen.getByRole('alert')).toHaveTextContent(
status === 401 ? 'Sign in again' : 'Access denied',
);
expect(screen.queryByText('No history samples in this time range.')).not.toBeInTheDocument();
fireEvent.keyDown(canvas, { key: 'End' });
expect(container.querySelector('[data-history-chart-tooltip]')).toBeNull();
},
);
});
describe('History window controls', () => {
afterEach(cleanup);
const makeChart = () => {
const [range, setRange] = createSignal<
'1h' | '6h' | '12h' | '24h' | '7d' | '14d' | '30d' | '90d'
>('1h');
const updateRange = vi.fn(setRange);
const chart = {
ranges: HISTORY_CHART_RANGES,
range,
updateRange,
dataMin: () => 0,
dataMax: () => 75,
source: () => 'store',
} as unknown as HistoryChartState;
return { chart, updateRange };
};
it('names each chart window and announces only its selected period', () => {
const cpu = makeChart();
const memory = makeChart();
render(() => (
<>
<HistoryChartHeader chart={cpu.chart} label="CPU" unit="%" />
<HistoryChartHeader chart={memory.chart} label="Memory" unit="%" />
</>
));
const cpuGroup = within(screen.getByRole('group', { name: 'CPU history window' }));
const memoryGroup = within(screen.getByRole('group', { name: 'Memory history window' }));
expect(cpuGroup.getAllByRole('button', { pressed: true })).toHaveLength(1);
expect(cpuGroup.getByRole('button', { name: '1h' })).toHaveAttribute('aria-pressed', 'true');
fireEvent.click(cpuGroup.getByRole('button', { name: '24h' }));
expect(cpu.updateRange).toHaveBeenCalledExactlyOnceWith('24h');
expect(cpuGroup.getByRole('button', { name: '24h' })).toHaveAttribute('aria-pressed', 'true');
expect(cpuGroup.getByRole('button', { name: '1h' })).toHaveAttribute('aria-pressed', 'false');
expect(cpuGroup.getAllByRole('button', { pressed: true })).toHaveLength(1);
expect(memoryGroup.getByRole('button', { name: '1h' })).toHaveAttribute('aria-pressed', 'true');
expect(memory.updateRange).not.toHaveBeenCalled();
});
it('keeps range changes out of surrounding form submission', () => {
const { chart } = makeChart();
const onSubmit = vi.fn((event: SubmitEvent) => event.preventDefault());
render(() => (
<form onSubmit={onSubmit}>
<HistoryChartHeader chart={chart} />
</form>
));
const group = within(screen.getByRole('group', { name: 'History window' }));
for (const button of group.getAllByRole('button'))
expect(button).toHaveAttribute('type', 'button');
fireEvent.click(group.getByRole('button', { name: '7d' }));
expect(group.getByRole('button', { name: '7d' })).toHaveAttribute('aria-pressed', 'true');
expect(onSubmit).not.toHaveBeenCalled();
});
it('does not expose a phantom window group when the caller hides it', () => {
const { chart } = makeChart();
render(() => <HistoryChartHeader chart={chart} label="Disk I/O" hideSelector />);
expect(screen.queryByRole('group')).not.toBeInTheDocument();
expect(screen.queryByRole('button')).not.toBeInTheDocument();
expect(screen.getByText('Disk I/O')).toBeInTheDocument();
});
});