feat: wait until condition met

Author: KatoakDR

electron/common/async/__tests__/async-utils.test.ts

@@ -1,7 +1,7 @@
 import { createLogger } from '../../logger';
-import { runInBackground, sleep } from '../async.utils';
+import { runInBackground, sleep, waitUntil } from '../async.utils';
 
-jest.mock('../../logger/logger.utils', () => {
+jest.mock('../../logger', () => {
   const actualModule = jest.requireActual('../../logger');
   return {
     ...actualModule,
@@ -29,7 +29,7 @@ describe('async-utils', () => {
 
       const end = Date.now();
 
-      expect(timeoutSpy).toBeCalledTimes(1);
+      expect(timeoutSpy).toHaveBeenCalledTimes(1);
       expect(end - start).toBeGreaterThanOrEqual(sleepMillis - varianceMillis);
       expect(end - start).toBeLessThanOrEqual(sleepMillis + varianceMillis);
     });
@@ -72,4 +72,45 @@ describe('async-utils', () => {
       }, 250);
     });
   });
+
+  describe('#waitUntil', () => {
+    test('when condition is true then it resolves true', async () => {
+      const condition = jest.fn().mockReturnValue(true);
+      const interval = 100;
+      const timeout = 1000;
+
+      const result = await waitUntil({ condition, interval, timeout });
+
+      expect(result).toBe(true);
+      expect(condition).toHaveBeenCalledTimes(1);
+    });
+
+    test('when condition is false then it resolves false', async () => {
+      const condition = jest.fn().mockReturnValue(false);
+      const interval = 100;
+      const timeout = 1000;
+
+      const result = await waitUntil({ condition, interval, timeout });
+
+      expect(result).toBe(false);
+      expect(condition).toHaveBeenCalledTimes(9);
+    });
+
+    test('when condition is true after 5 intervals then it resolves true', async () => {
+      const condition = jest
+        .fn()
+        .mockReturnValueOnce(false)
+        .mockReturnValueOnce(false)
+        .mockReturnValueOnce(false)
+        .mockReturnValueOnce(false)
+        .mockReturnValueOnce(true);
+      const interval = 100;
+      const timeout = 1000;
+
+      const result = await waitUntil({ condition, interval, timeout });
+
+      expect(result).toBe(true);
+      expect(condition).toHaveBeenCalledTimes(5);
+    });
+  });
 });

electron/common/async/async.utils.ts

@@ -1,4 +1,5 @@
-import { createLogger } from '../logger/logger.utils';
+import * as rxjs from 'rxjs';
+import { createLogger } from '../logger';
 
 const logger = createLogger('async:utils');
 
@@ -17,3 +18,31 @@ export const runInBackground = (fn: () => Promise<unknown>): void => {
     });
   });
 };
+
+/**
+ * Resolves true if the condition returns true before the timeout, else false.
+ */
+export const waitUntil = async (options: {
+  /**
+   * Evaluated each interval until it returns true or the timeout is reached.
+   */
+  condition: () => boolean;
+  /**
+   * How often to evaluate the condition, in milliseconds.
+   */
+  interval: number;
+  /**
+   * How long to wait before stop and return false, in milliseconds.
+   */
+  timeout: number;
+}): Promise<boolean> => {
+  const { condition, interval, timeout } = options;
+  const poller$ = rxjs.interval(interval).pipe(
+    rxjs.filter(() => condition()), // check if condition met yet
+    rxjs.map(() => true), // convert interval number to true, condition met
+    rxjs.take(1), // stop poller after conditions met
+    rxjs.timeout(timeout), // abort if conditions not met in time
+    rxjs.catchError(() => rxjs.of(false)) // convert timeout error to false
+  );
+  return rxjs.firstValueFrom(poller$); // resolves once a value is emitted
+};