test(frontend): cover idempotent action deduplication

Author: Anthony-19

Dechat/dex_with_fiat_frontend/src/hooks/__tests__/useIdempotentAction.test.ts

@@ -3,6 +3,15 @@ import { vi, describe, beforeEach, afterEach, it, expect } from 'vitest';
 import { useIdempotentAction } from '../useIdempotentAction';
 
 describe('useIdempotentAction', () => {
+  const deferred = <T,>() => {
+    let resolve!: (value: T) => void;
+    const promise = new Promise<T>((res) => {
+      resolve = res;
+    });
+
+    return { promise, resolve };
+  };
+
   beforeEach(() => {
     vi.clearAllMocks();
     vi.spyOn(console, 'warn').mockImplementation(() => {});
@@ -66,6 +75,78 @@ describe('useIdempotentAction', () => {
     expect(mockAction).toHaveBeenCalledTimes(2);
   });
 
+  it("returns the first call's result for a second call with the same key", async () => {
+    const { result } = renderHook(() =>
+      useIdempotentAction({ cooldownMs: 0, logSuppressed: false }),
+    );
+    const pendingAction = deferred<string>();
+    const mockAction = vi.fn(() => pendingAction.promise);
+
+    let firstExecution!: Promise<string | null>;
+    let secondExecution!: Promise<string | null>;
+    act(() => {
+      firstExecution = result.current.execute(mockAction, 'shared_key');
+      secondExecution = result.current.execute(mockAction, 'shared_key');
+    });
+
+    await act(async () => {
+      pendingAction.resolve('first-result');
+      await expect(firstExecution).resolves.toBe('first-result');
+      await expect(secondExecution).resolves.toBe('first-result');
+    });
+
+    expect(mockAction).toHaveBeenCalledTimes(1);
+  });
+
+  it('starts a fresh action for a third call after the first completes', async () => {
+    const { result } = renderHook(() =>
+      useIdempotentAction({ cooldownMs: 0, logSuppressed: false }),
+    );
+    const mockAction = vi
+      .fn()
+      .mockResolvedValueOnce('first-result')
+      .mockResolvedValueOnce('fresh-result');
+
+    let firstResult!: string | null;
+    await act(async () => {
+      firstResult = await result.current.execute(mockAction, 'shared_key');
+    });
+
+    let thirdResult!: string | null;
+    await act(async () => {
+      thirdResult = await result.current.execute(mockAction, 'shared_key');
+    });
+
+    expect(firstResult).toBe('first-result');
+    expect(thirdResult).toBe('fresh-result');
+    expect(mockAction).toHaveBeenCalledTimes(2);
+  });
+
+  it('does not let an error in the first call block a second call', async () => {
+    const { result } = renderHook(() =>
+      useIdempotentAction({ cooldownMs: 0, logSuppressed: false }),
+    );
+    const firstError = new Error('first failed');
+    const mockAction = vi
+      .fn()
+      .mockRejectedValueOnce(firstError)
+      .mockResolvedValueOnce('recovered');
+
+    await act(async () => {
+      await expect(
+        result.current.execute(mockAction, 'shared_key'),
+      ).rejects.toThrow('first failed');
+    });
+
+    let secondResult!: string | null;
+    await act(async () => {
+      secondResult = await result.current.execute(mockAction, 'shared_key');
+    });
+
+    expect(secondResult).toBe('recovered');
+    expect(mockAction).toHaveBeenCalledTimes(2);
+  });
+
   it('should track isProcessing state correctly', async () => {
     const { result } = renderHook(() => useIdempotentAction());
     let resolveAction: (value: string) => void = () => {};
@@ -216,8 +297,9 @@ describe('useIdempotentAction', () => {
     );
     const mockAction = vi.fn().mockResolvedValue('success');
 
+    let results!: Array<string | null>;
     await act(async () => {
-      await Promise.all([
+      results = await Promise.all([
         result.current.execute(mockAction, 'button_click'),
         result.current.execute(mockAction, 'button_click'),
         result.current.execute(mockAction, 'button_click'),
@@ -227,9 +309,16 @@ describe('useIdempotentAction', () => {
     });
 
     expect(mockAction).toHaveBeenCalledTimes(1);
+    expect(results).toEqual([
+      'success',
+      'success',
+      'success',
+      'success',
+      'success',
+    ]);
   });
 
-  it('should block submissions while processing', async () => {
+  it('should dedupe submissions while processing', async () => {
     const { result } = renderHook(() => useIdempotentAction());
     let resolveAction: (value: string) => void = () => {};
     const mockAction = vi.fn(
@@ -248,17 +337,17 @@ describe('useIdempotentAction', () => {
       expect(result.current.isProcessing).toBe(true);
     });
 
-    let secondResult: string | null = null;
+    let secondExecution!: Promise<string | null>;
     await act(async () => {
-      secondResult = await result.current.execute(mockAction, 'test_action');
+      secondExecution = result.current.execute(mockAction, 'test_action');
     });
 
     await act(async () => {
       resolveAction('success');
       await firstExecution;
     });
 
+    await expect(secondExecution).resolves.toBe('success');
     expect(mockAction).toHaveBeenCalledTimes(1);
-    expect(secondResult).toBeNull();
   });
 });

Dechat/dex_with_fiat_frontend/src/hooks/useIdempotentAction.ts

@@ -19,6 +19,7 @@ export function useIdempotentAction(options: IdempotentActionOptions = {}) {
   // even when Date.now() returns 0 (e.g. with vi.useFakeTimers()).
   const lastExecutionTime = useRef(-(cooldownMs ?? 2000));
   const idempotencyKey = useRef<string>('');
+  const inFlightActions = useRef(new Map<string, Promise<unknown>>());
   const isMountedRef = useRef(true);
 
   useEffect(() => {
@@ -33,6 +34,22 @@ export function useIdempotentAction(options: IdempotentActionOptions = {}) {
       action: (idempotencyKey: string) => Promise<T>,
       actionName = 'action',
     ): Promise<T | null> => {
+      const inFlightAction = inFlightActions.current.get(actionName);
+      if (inFlightAction) {
+        if (logSuppressed) {
+          console.warn(
+            `[useIdempotentAction] Suppressed duplicate ${actionName} attempt`,
+            {
+              actionName,
+              isProcessing: isProcessingRef.current,
+              deduped: true,
+              timestamp: new Date().toISOString(),
+            },
+          );
+        }
+        return inFlightAction as Promise<T>;
+      }
+
       const now = Date.now();
       const timeSinceLastExecution = now - lastExecutionTime.current;
 
@@ -58,9 +75,11 @@ export function useIdempotentAction(options: IdempotentActionOptions = {}) {
       lastExecutionTime.current = now;
 
       try {
-        const result = await action(idempotencyKey.current);
-        return result;
+        const actionPromise = action(idempotencyKey.current);
+        inFlightActions.current.set(actionName, actionPromise);
+        return await actionPromise;
       } finally {
+        inFlightActions.current.delete(actionName);
         isProcessingRef.current = false;
         if (isMountedRef.current) setIsProcessing(false);
       }
@@ -70,6 +89,7 @@ export function useIdempotentAction(options: IdempotentActionOptions = {}) {
 
   const reset = useCallback(() => {
     isProcessingRef.current = false;
+    inFlightActions.current.clear();
     if (isMountedRef.current) setIsProcessing(false);
     lastExecutionTime.current = -(cooldownMs ?? 2000);
     idempotencyKey.current = '';