fix: let a fault refresh see the state it is answering

Three things could put an outdated fault list on screen. A refresh that
outlived its session wrote the previous gateway's faults into the next
one, so disconnect now clears the list and an answer whose client is gone
is dropped. An answer that the fault stream had already overtaken
replaced the newer stream state, so a refresh that finds the list rewritten
under it keeps out of the way. And the "nothing changed" comparison only
looked at code, status and severity, so a fault that moved to another
entity or changed its description was thrown away - it now covers every
field a row shows, the entity included, which is what the clear action
acts on.

Views also share the request itself: a refresh already on the wire is
reused instead of duplicated, and clearing a fault or pressing refresh
forces its own read so it cannot be answered by a request older than the
action.

Author: bburda

src/components/FaultsDashboard.polling.test.tsx

@@ -20,7 +20,8 @@
  */
 
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { render, act } from '@testing-library/react';
+import { render, act, type RenderResult } from '@testing-library/react';
+import type { ReactElement } from 'react';
 import { FaultsDashboard, FaultsCountBadge } from './FaultsDashboard';
 import { useAppStore } from '@/lib/store';
 
@@ -61,20 +62,28 @@ async function framesDuring(container: HTMLElement, run: () => Promise<void>): P
     return frames;
 }
 
+/** Renders and lets the refresh the mount starts finish, so nothing settles outside act. */
+async function mount(ui: ReactElement): Promise<RenderResult> {
+    let result!: RenderResult;
+    await act(async () => {
+        result = render(ui);
+        await vi.advanceTimersByTimeAsync(0);
+    });
+    return result;
+}
+
+/** Lets everything already scheduled run: timers due now, and the promises they start. */
 async function settle() {
     await act(async () => {
-        await Promise.resolve();
-        await Promise.resolve();
-        await Promise.resolve();
+        await vi.advanceTimersByTimeAsync(0);
     });
 }
 
+/** Moves time forward, letting each tick's request settle before the next one fires. */
 async function advance(ms: number) {
     await act(async () => {
-        vi.advanceTimersByTime(ms);
-        await Promise.resolve();
+        await vi.advanceTimersByTimeAsync(ms);
     });
-    await settle();
 }
 
 function connect(client: ReturnType<typeof clientReturning>, sseActive: boolean) {
@@ -93,15 +102,19 @@ beforeEach(() => {
 });
 
 afterEach(() => {
+    // Wrapped: this hook runs while the views are still mounted (Testing Library's
+    // own cleanup is registered earlier and so runs after this one), and an
+    // unwrapped store write would land on them outside act.
+    act(() => {
+        useAppStore.setState({ isConnected: false, client: null, faults: [], faultStreamCleanup: null } as never);
+    });
     vi.useRealTimers();
-    useAppStore.setState({ isConnected: false, client: null, faults: [], faultStreamCleanup: null } as never);
 });
 
 describe('FaultsDashboard refresh behaviour', () => {
     it('never falls back to the first-load skeleton once the empty list has loaded', async () => {
         connect(clientReturning([]), false);
-        const { container } = render(<FaultsDashboard />);
-        await settle();
+        const { container } = await mount(<FaultsDashboard />);
 
         const frames = await framesDuring(container, () => advance(POLL_INTERVAL_MS));
 
@@ -110,13 +123,12 @@ describe('FaultsDashboard refresh behaviour', () => {
 
     it('never falls back to the skeleton when the tab regains focus', async () => {
         connect(clientReturning([]), true);
-        const { container } = render(
+        const { container } = await mount(
             <>
                 <FaultsCountBadge />
                 <FaultsDashboard />
             </>
         );
-        await settle();
 
         const frames = await framesDuring(container, async () => {
             await act(async () => {
@@ -142,13 +154,12 @@ describe('FaultsDashboard refresh behaviour', () => {
     it('asks the gateway once per interval even with the badge and the dashboard mounted', async () => {
         const client = clientReturning([RAW_FAULT]);
         connect(client, false);
-        render(
+        await mount(
             <>
                 <FaultsCountBadge />
                 <FaultsDashboard />
             </>
         );
-        await settle();
         expect(client.GET).toHaveBeenCalledTimes(1);
 
         await advance(POLL_INTERVAL_MS);
@@ -161,13 +172,12 @@ describe('FaultsDashboard refresh behaviour', () => {
     it('does not poll while the fault stream delivers updates', async () => {
         const client = clientReturning([RAW_FAULT]);
         connect(client, true);
-        render(
+        await mount(
             <>
                 <FaultsCountBadge />
                 <FaultsDashboard />
             </>
         );
-        await settle();
         const afterMount = client.GET.mock.calls.length;
 
         await advance(POLL_INTERVAL_MS * 3);
@@ -178,11 +188,12 @@ describe('FaultsDashboard refresh behaviour', () => {
     it('stops polling when the last fault view unmounts', async () => {
         const client = clientReturning([RAW_FAULT]);
         connect(client, false);
-        const { unmount } = render(<FaultsDashboard />);
-        await settle();
+        const { unmount } = await mount(<FaultsDashboard />);
         const afterMount = client.GET.mock.calls.length;
 
-        unmount();
+        await act(async () => {
+            unmount();
+        });
         await advance(POLL_INTERVAL_MS * 2);
 
         expect(client.GET.mock.calls.length).toBe(afterMount);

src/components/FaultsDashboard.tsx

@@ -423,7 +423,8 @@ export function FaultsDashboard() {
     // Manual refresh handler
     const handleRefresh = useCallback(async () => {
         setIsRefreshing(true);
-        await fetchFaults();
+        // Forced: pressing refresh must start a read, not wait out one already running.
+        await fetchFaults({ force: true });
         setIsRefreshing(false);
     }, [fetchFaults]);
 

src/lib/store-faults.test.ts

@@ -0,0 +1,167 @@
+// Copyright 2026 bburda
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * What the shared fault list is allowed to do while it refreshes. The list has
+ * two writers - polling and the SSE stream - and a refresh can outlive the
+ * connection that started it, so a late answer must not decide what is on screen.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { useAppStore } from './store';
+import type { Fault } from './types';
+
+vi.mock('react-toastify', () => ({
+    toast: { success: vi.fn(), error: vi.fn(), warning: vi.fn(), info: vi.fn() },
+}));
+
+function raw(overrides: Record<string, unknown> = {}) {
+    return {
+        fault_code: 'LIDAR_RANGE_INVALID',
+        description: 'range invalid',
+        severity: 2,
+        severity_label: 'ERROR',
+        status: 'CONFIRMED',
+        first_occurred: 1756636800,
+        last_occurred: 1756636800,
+        occurrence_count: 1,
+        reporting_sources: ['/lidar_front'],
+        ...overrides,
+    };
+}
+
+/** A client whose answers are under the test's control, however many are in flight. */
+function deferredClient() {
+    const pending: ((items: unknown[]) => void)[] = [];
+    const GET = vi.fn(
+        () =>
+            new Promise((resolve) => {
+                pending.push((items: unknown[]) => resolve({ data: { items }, error: undefined }));
+            })
+    );
+    return {
+        client: { GET },
+        release: (items: unknown[]) => {
+            while (pending.length > 0) {
+                pending.shift()!(items);
+            }
+        },
+    };
+}
+
+function clientReturning(items: unknown[]) {
+    return { GET: vi.fn(async () => ({ data: { items }, error: undefined })) };
+}
+
+function connected(client: unknown) {
+    useAppStore.setState({
+        isConnected: true,
+        client,
+        faults: [],
+        faultsLoaded: false,
+        isLoadingFaults: false,
+        faultStreamCleanup: null,
+    } as never);
+}
+
+beforeEach(() => {
+    connected(null);
+});
+
+afterEach(() => {
+    useAppStore.setState({ isConnected: false, client: null, faults: [] } as never);
+});
+
+describe('fetchFaults change detection', () => {
+    it('takes up a fault that is now reported by a different entity', async () => {
+        connected(clientReturning([raw()]));
+        await useAppStore.getState().fetchFaults();
+
+        useAppStore.setState({ client: clientReturning([raw({ reporting_sources: ['/lidar_rear'] })]) } as never);
+        await useAppStore.getState().fetchFaults();
+
+        expect(useAppStore.getState().faults[0]?.entity_id).toBe('lidar_rear');
+    });
+
+    it('takes up a changed fault description', async () => {
+        connected(clientReturning([raw()]));
+        await useAppStore.getState().fetchFaults();
+
+        useAppStore.setState({ client: clientReturning([raw({ description: '3 sectors blind' })]) } as never);
+        await useAppStore.getState().fetchFaults();
+
+        expect(useAppStore.getState().faults[0]?.message).toBe('3 sectors blind');
+    });
+});
+
+describe('fetchFaults against a moving connection', () => {
+    it('ignores an answer that arrives after the session was disconnected', async () => {
+        const { client, release } = deferredClient();
+        connected(client);
+
+        const pending = useAppStore.getState().fetchFaults();
+        useAppStore.getState().disconnect();
+        release([raw({ fault_code: 'FROM_PREVIOUS_GATEWAY' })]);
+        await pending;
+
+        expect(useAppStore.getState().faults).toHaveLength(0);
+        expect(useAppStore.getState().faultsLoaded).toBe(false);
+    });
+
+    it('ignores an answer that the fault stream has already overtaken', async () => {
+        const { client, release } = deferredClient();
+        connected(client);
+
+        const pending = useAppStore.getState().fetchFaults();
+        const fromStream: Fault = {
+            code: 'STREAM_FAULT',
+            message: 'reported over the stream',
+            severity: 'error',
+            status: 'active',
+            timestamp: '2026-08-31T10:00:00.000Z',
+            entity_id: 'lidar_front',
+            entity_type: 'app',
+        };
+        useAppStore.setState({ faults: [fromStream] } as never);
+        release([raw({ fault_code: 'FROM_THE_POLL' })]);
+        await pending;
+
+        expect(useAppStore.getState().faults.map((f) => f.code)).toEqual(['STREAM_FAULT']);
+        expect(useAppStore.getState().faultsLoaded).toBe(true);
+    });
+
+    it('runs one request when several views ask for a refresh at the same time', async () => {
+        const { client, release } = deferredClient();
+        connected(client);
+
+        const first = useAppStore.getState().fetchFaults();
+        const second = useAppStore.getState().fetchFaults();
+        release([raw()]);
+        await Promise.all([first, second]);
+
+        expect(client.GET).toHaveBeenCalledTimes(1);
+    });
+
+    it('lets a forced refresh through so a cleared fault is not read back from an older answer', async () => {
+        const { client, release } = deferredClient();
+        connected(client);
+
+        const polling = useAppStore.getState().fetchFaults();
+        const forced = useAppStore.getState().fetchFaults({ force: true });
+        release([]);
+        await Promise.all([polling, forced]);
+
+        expect(client.GET).toHaveBeenCalledTimes(2);
+    });
+});