perf: Deduplicate concurrent Home Assistant registry list fetches (#2650)

tests/utils/concurrency/once-runner.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { OnceRunner, type Work } from '../../../src/utils/concurrency/once-runner';
+
+describe('OnceRunner', () => {
+  const createDeferredWork = (): {
+    work: Work;
+    resolveAll: () => void;
+    rejectAll: (error: Error) => void;
+    callCount: () => number;
+  } => {
+    const resolvers: (() => void)[] = [];
+    const rejecters: ((error: Error) => void)[] = [];
+    const work = vi.fn().mockImplementation(
+      () =>
+        new Promise<void>((resolve, reject) => {
+          resolvers.push(resolve);
+          rejecters.push(reject);
+        }),
+    );
+    return {
+      work,
+      resolveAll: () => resolvers.forEach((resolve) => resolve()),
+      rejectAll: (error: Error) => rejecters.forEach((reject) => reject(error)),
+      callCount: () => work.mock.calls.length,
+    };
+  };
+
+  it('should share a single run with callers that arrive while it is running', async () => {
+    const runner = new OnceRunner();
+    const { work, resolveAll, callCount } = createDeferredWork();
+
+    const first = runner.run(work);
+    const second = runner.run(work);
+
+    expect(callCount()).toBe(1);
+
+    resolveAll();
+    await Promise.all([first, second]);
+
+    expect(callCount()).toBe(1);
+  });
+
+  it('should discard the work of a caller that joins a running run', async () => {
+    const runner = new OnceRunner();
+    const { work: runningWork, resolveAll, callCount } = createDeferredWork();
+    const joiningWork = vi.fn().mockResolvedValue(undefined);
+
+    const first = runner.run(runningWork);
+    const second = runner.run(joiningWork);
+
+    resolveAll();
+    await Promise.all([first, second]);
+
+    expect(callCount()).toBe(1);
+    expect(joiningWork).not.toHaveBeenCalled();
+  });
+
+  it('should not run the work again after it has succeeded', async () => {
+    const runner = new OnceRunner();
+    const work = vi.fn().mockResolvedValue(undefined);
+
+    await runner.run(work);
+    await runner.run(work);
+
+    expect(work).toHaveBeenCalledTimes(1);
+  });
+
+  it('should reject every caller waiting on a failed run', async () => {
+    const runner = new OnceRunner();
+    const { work, rejectAll } = createDeferredWork();
+    const error = new Error('failed');
+
+    const first = runner.run(work);
+    const second = runner.run(work);
+
+    rejectAll(error);
+
+    await expect(first).rejects.toThrow(error);
+    await expect(second).rejects.toThrow(error);
+  });
+
+  it('should run the work again after it throws synchronously', async () => {
+    const runner = new OnceRunner();
+    const work = vi
+      .fn()
+      .mockImplementationOnce(() => {
+        throw new Error('failed');
+      })
+      .mockResolvedValueOnce(undefined);
+
+    await expect(runner.run(work)).rejects.toThrow('failed');
+    await runner.run(work);
+
+    expect(work).toHaveBeenCalledTimes(2);
+  });
+
+  it('should run the work again after a failure', async () => {
+    const runner = new OnceRunner();
+    const work = vi
+      .fn()
+      .mockRejectedValueOnce(new Error('failed'))
+      .mockResolvedValueOnce(undefined);
+
+    await expect(runner.run(work)).rejects.toThrow('failed');
+    await runner.run(work);
+
+    expect(work).toHaveBeenCalledTimes(2);
+  });
+});