Skip to content

armgit / Pulse

Public Imported from GitHub
0

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.

Reproduce live guest discovery offered during backup deferrals

pulse-triage[bot]2cb3f6a9043e
diff --git a/frontend-modern/src/components/Discovery/__tests__/DiscoveryRun.safety.test.tsx b/frontend-modern/src/components/Discovery/__tests__/DiscoveryRun.safety.test.tsx
new file mode 100644
index 0000000000..16ac814dfa
--- /dev/null
+++ b/frontend-modern/src/components/Discovery/__tests__/DiscoveryRun.safety.test.tsx
@@ -0,0 +1,112 @@
+import { createSignal, Suspense } from 'solid-js';
+import { cleanup, fireEvent, render, screen, waitFor } from '@solidjs/testing-library';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { ResourceDiscovery } from '@/types/discovery';
+import { DiscoveryTab } from '../DiscoveryTab';
+import { useDiscoveryTabState } from '../useDiscoveryTabState';
+import { resetAIRuntimeState, syncAIRuntimeSettings } from '@/stores/aiRuntimeState';
+import * as discoveryApi from '@/api/discovery';
+
+vi.mock('@/api/discovery', async (importOriginal) => ({
+ ...(await importOriginal<typeof import('@/api/discovery')>()),
+ getDiscovery: vi.fn(async () => null),
+ getDiscoveryInfo: vi.fn(async () => ({
+ ai_provider: { provider: 'test', model: 'test', is_local: true, label: 'Local' },
+ commands: [],
+ command_categories: [],
+ })),
+ getConnectedAgents: vi.fn(async () => ({ count: 1, agents: [{ agent_id: 'node-agent' }] })),
+ triggerDiscovery: vi.fn(async () => null),
+}));
+
+const reason = 'Discovery paused for this guest. Saved results remain available.';
+const target = { resourceType: 'vm' as const, agentId: 'node-agent', resourceId: '100', hostname: 'guest' };
+const saved = {
+ id: 'vm:node-agent:100', resource_type: 'vm', resource_id: '100', target_id: 'node-agent',
+ hostname: 'guest', service_type: 'home-assistant', service_name: 'Saved service', category: 'app',
+ facts: [], config_paths: [], data_paths: [], log_paths: [], ports: [], user_notes: '',
+ discovered_at: '2026-10-03T12:00:00Z', updated_at: '2026-10-03T12:00:00Z', confidence: 0.9,
+} as ResourceDiscovery;
+
+beforeEach(() => {
+ resetAIRuntimeState();
+ syncAIRuntimeSettings({ discovery_enabled: true } as Parameters<typeof syncAIRuntimeSettings>[0]);
+ vi.mocked(discoveryApi.getDiscovery).mockResolvedValue(null);
+ vi.mocked(discoveryApi.triggerDiscovery).mockResolvedValue(null);
+});
+afterEach(() => { cleanup(); resetAIRuntimeState(); vi.clearAllMocks(); });
+
+describe('manual discovery safety', () => {
+ it.each([
+ ['loading', () => new Promise<ResourceDiscovery | null>(() => undefined)],
+ ['absent', async () => null],
+ ['empty', async () => ({ ...saved, service_type: '', service_name: '', confidence: 0 })],
+ ['saved', async () => saved],
+ ] as const)('blocks all run affordances with %s discovery while retaining passive reads', async (_name, lookup) => {
+ vi.mocked(discoveryApi.getDiscovery).mockImplementation(lookup);
+ const props = { ...target, runBlockReason: reason };
+ render(() => <Suspense><DiscoveryTab {...props} /></Suspense>);
+ await waitFor(() => expect(discoveryApi.getDiscoveryInfo).toHaveBeenCalled());
+ await waitFor(() => {
+ const buttons = screen.getAllByRole('button', { name: /^(Run|Re-scan|Update) Discovery/ });
+ for (const button of buttons) expect(button).toBeDisabled();
+ });
+ expect(screen.getByTestId('discovery-run-block')).toHaveTextContent(reason);
+ expect(discoveryApi.getDiscovery).toHaveBeenCalledWith('vm', 'node-agent', '100');
+ expect(discoveryApi.triggerDiscovery).not.toHaveBeenCalled();
+ });
+
+ it('keeps saved evidence mounted and restores only the explicit run action, not an automatic scan', async () => {
+ vi.mocked(discoveryApi.getDiscovery).mockResolvedValue(saved);
+ const [block, setBlock] = createSignal<string | null>(reason);
+ const props = { ...target, get runBlockReason() { return block(); }, showManualRunAction: true };
+ render(() => <Suspense><DiscoveryTab {...props} /></Suspense>);
+ const button = await screen.findByRole('button', { name: 'Run Discovery' });
+ await waitFor(() => expect(button).toBeDisabled());
+ const evidence = await screen.findByText('Saved service');
+ expect(evidence).toBeVisible();
+ setBlock(null);
+ await waitFor(() => expect(button).toBeEnabled());
+ expect(screen.getByText('Saved service')).toBe(evidence);
+ expect(screen.queryByTestId('discovery-run-block')).toBeNull();
+ expect(discoveryApi.triggerDiscovery).not.toHaveBeenCalled();
+ fireEvent.click(button);
+ await waitFor(() => expect(discoveryApi.triggerDiscovery).toHaveBeenCalledTimes(1));
+ });
+
+ it('checks the current block inside the handler even when a caller retained the old enabled verdict', async () => {
+ const [block, setBlock] = createSignal<string | null>(null);
+ const props = { ...target, get runBlockReason() { return block(); } };
+ let state!: ReturnType<typeof useDiscoveryTabState>;
+ render(() => { state = useDiscoveryTabState(props); return <span>state</span>; });
+ await waitFor(() => expect(state.canTriggerDiscovery()).toBe(true));
+ setBlock(reason);
+ await state.handleTriggerDiscovery(true);
+ expect(discoveryApi.triggerDiscovery).not.toHaveBeenCalled();
+ expect(state.isScanning()).toBe(false);
+ expect(state.scanSuccess()).toBe(false);
+ });
+
+ it('does not cancel or hide an in-flight scan when a new snapshot blocks further runs', async () => {
+ let finish!: (value: ResourceDiscovery | null) => void;
+ vi.mocked(discoveryApi.triggerDiscovery).mockReturnValue(new Promise((resolve) => { finish = resolve; }));
+ const [block, setBlock] = createSignal<string | null>(null);
+ const props = { ...target, get runBlockReason() { return block(); } };
+ let state!: ReturnType<typeof useDiscoveryTabState>;
+ render(() => { state = useDiscoveryTabState(props); return <span>state</span>; });
+ await waitFor(() => expect(state.canTriggerDiscovery()).toBe(true));
+ const original = state.handleTriggerDiscovery(true);
+ expect(state.isScanning()).toBe(true);
+ setBlock(reason);
+ await state.handleTriggerDiscovery(true);
+ expect(discoveryApi.triggerDiscovery).toHaveBeenCalledTimes(1);
+ expect(state.isScanning()).toBe(true);
+ finish(saved);
+ await original;
+ expect(state.isScanning()).toBe(false);
+ expect(state.discovery()).toBe(saved);
+ expect(state.scanSuccess()).toBe(true);
+ setBlock(null);
+ expect(discoveryApi.triggerDiscovery).toHaveBeenCalledTimes(1);
+ });
+});
diff --git a/frontend-modern/src/components/Workloads/__tests__/GuestDrawer.discovery-safety.test.tsx b/frontend-modern/src/components/Workloads/__tests__/GuestDrawer.discovery-safety.test.tsx
new file mode 100644
index 0000000000..23e1b84f8e
--- /dev/null
+++ b/frontend-modern/src/components/Workloads/__tests__/GuestDrawer.discovery-safety.test.tsx
@@ -0,0 +1,91 @@
+import { createSignal, Suspense } from 'solid-js';
+import { cleanup, fireEvent, render, screen, waitFor } from '@solidjs/testing-library';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { WorkloadGuest } from '@/types/workloads';
+import { GuestDrawer } from '../GuestDrawer';
+import { guestDiskDeferrals } from '../__fixtures__/guestDiskDeferrals';
+import { resetAIRuntimeState, syncAIRuntimeSettings } from '@/stores/aiRuntimeState';
+import { resetCreateNonSuspendingQueryCacheForTest } from '@/hooks/createNonSuspendingQuery';
+import * as discoveryApi from '@/api/discovery';
+
+vi.mock('@/api/discovery', async (importOriginal) => ({
+ ...(await importOriginal<typeof import('@/api/discovery')>()),
+ getDiscovery: vi.fn(async () => null),
+ getDiscoveryInfo: vi.fn(async () => ({
+ ai_provider: { provider: 'test', model: 'test', is_local: true, label: 'Local' },
+ commands: [], command_categories: [],
+ })),
+ getConnectedAgents: vi.fn(async () => ({ count: 1, agents: [{ agent_id: 'node-agent' }] })),
+ triggerDiscovery: vi.fn(async () => null),
+}));
+vi.mock('@/api/charts', async (importOriginal) => ({
+ ...(await importOriginal<typeof import('@/api/charts')>()),
+ ChartsAPI: { getMetricsHistory: vi.fn(async () => ({ metrics: {}, start: 1, end: 2, source: 'store' })) },
+}));
+vi.mock('@/stores/license', () => ({ isRangeLocked: () => false, loadRuntimeCapabilities: vi.fn(), maxHistoryDays: () => 90 }));
+
+const guest = (patch: Partial<WorkloadGuest> = {}): WorkloadGuest => ({
+ id: 'inst:node:100', instance: 'inst', node: 'node', vmid: 100, name: 'Backup guest', type: 'qemu',
+ status: 'running', cpu: 0.25, cpus: 2, memory: { total: 1024, used: 512, free: 512, usage: 50 },
+ disk: { total: 1024, used: 512, free: 512, usage: 50 },
+ networkIn: 1, networkOut: 2, diskRead: 3, diskWrite: 4, uptime: 100, template: false,
+ lastBackup: 0, tags: [], lock: '', lastSeen: '2026-10-04T12:00:00Z', guestAgentStatus: 'available',
+ discoveryTarget: { resourceType: 'vm', agentId: 'node-agent', resourceId: '100' }, ...patch,
+} as WorkloadGuest);
+
+beforeEach(() => {
+ resetAIRuntimeState();
+ syncAIRuntimeSettings({ discovery_enabled: true } as Parameters<typeof syncAIRuntimeSettings>[0]);
+ resetCreateNonSuspendingQueryCacheForTest();
+});
+afterEach(() => { cleanup(); resetAIRuntimeState(); vi.clearAllMocks(); });
+
+describe('guest drawer and real Discovery safety wiring', () => {
+ it.each([
+ ...guestDiskDeferrals.flatMap(([reason]) => [reason, `prev-${reason}`]),
+ ])('does not offer a live scan for %s, even with an assigned node agent and available metadata', async (reason) => {
+ render(() => <Suspense><GuestDrawer guest={guest({ diskStatusReason: reason })} onClose={vi.fn()} /></Suspense>);
+ fireEvent.click(await screen.findByRole('tab', { name: 'Discovery' }));
+ const button = await screen.findByRole('button', { name: 'Run Discovery' });
+ await waitFor(() => expect(button).toBeDisabled());
+ fireEvent.click(button);
+ expect(discoveryApi.triggerDiscovery).not.toHaveBeenCalled();
+ expect(screen.getByTestId('guest-read-precaution')).toBeVisible();
+ });
+
+ it.each([{ lock: 'backup' }, { backupInProgress: true }, { guestAgentStatus: 'deferred' }])('guards the native operation signal %j without fabricating a disk read reason', async (patch) => {
+ render(() => <Suspense><GuestDrawer guest={guest(patch)} onClose={vi.fn()} /></Suspense>);
+ fireEvent.click(await screen.findByRole('tab', { name: 'Discovery' }));
+ await waitFor(() => expect(screen.getByRole('button', { name: 'Run Discovery' })).toBeDisabled());
+ expect(discoveryApi.triggerDiscovery).not.toHaveBeenCalled();
+ });
+
+ it('updates the existing same-guest button without remounting the tab or automatically scanning', async () => {
+ const [value, setValue] = createSignal(guest({ lock: 'backup' }));
+ render(() => <Suspense><GuestDrawer guest={value()} onClose={vi.fn()} /></Suspense>);
+ fireEvent.click(await screen.findByRole('tab', { name: 'Discovery' }));
+ const button = await screen.findByRole('button', { name: 'Run Discovery' });
+ await waitFor(() => expect(button).toBeDisabled());
+ setValue(guest());
+ await waitFor(() => expect(button).toBeEnabled());
+ expect(screen.getByRole('button', { name: 'Run Discovery' })).toBe(button);
+ expect(screen.getByRole('tab', { name: 'Discovery' })).toHaveAttribute('aria-selected', 'true');
+ expect(discoveryApi.triggerDiscovery).not.toHaveBeenCalled();
+ setValue(guest({ diskStatusReason: 'prev-agent-timeout' }));
+ await waitFor(() => expect(button).toBeDisabled());
+ expect(discoveryApi.triggerDiscovery).not.toHaveBeenCalled();
+ });
+
+ it.each([
+ { type: 'qemu' },
+ { type: 'lxc', lock: 'backup', diskStatusReason: 'prev-agent-timeout', discoveryTarget: { resourceType: 'system-container', agentId: 'node-agent', resourceId: '100' } },
+ { type: 'vm', platformType: 'vmware', guestAgentStatus: '', lock: '', discoveryTarget: { resourceType: 'vm', agentId: 'node-agent', resourceId: '100' } },
+ ] as const)('preserves ordinary manual scans outside the Proxmox guest safety condition %j', async (patch) => {
+ render(() => <Suspense><GuestDrawer guest={guest(patch)} onClose={vi.fn()} /></Suspense>);
+ fireEvent.click(await screen.findByRole('tab', { name: 'Discovery' }));
+ const button = await screen.findByRole('button', { name: 'Run Discovery' });
+ await waitFor(() => expect(button).toBeEnabled());
+ fireEvent.click(button);
+ await waitFor(() => expect(discoveryApi.triggerDiscovery).toHaveBeenCalledTimes(1));
+ });
+});