feat: run in background method and test

Author: KatoakDR

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

@@ -1,27 +1,75 @@
-import { sleep } from '../async.utils';
+import { createLogger } from '../../logger/logger.utils';
+import { runInBackground, sleep } from '../async.utils';
+
+jest.mock('../../logger/logger.utils', () => {
+  const actualModule = jest.requireActual('../../logger/logger.utils');
+  return {
+    ...actualModule,
+    createLogger: jest.fn().mockReturnValue({
+      error: jest.fn(),
+    }),
+  };
+});
 
 describe('async-utils', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
   describe('#sleep', () => {
-    it('should resolve after 1000ms', async () => {
-      jest.useFakeTimers();
+    test('it sleeps for the given milliseconds', async () => {
+      const timeoutSpy = jest.spyOn(global, 'setTimeout');
 
-      let didSleep = false;
+      const sleepMillis = 100;
+      const varianceMillis = sleepMillis * 0.5;
 
-      const fn = jest.fn().mockImplementation(async () => {
-        await sleep(1000);
-        didSleep = true;
-      });
+      const start = Date.now();
+
+      await sleep(100);
+
+      const end = Date.now();
+
+      expect(timeoutSpy).toBeCalledTimes(1);
+      expect(end - start).toBeGreaterThanOrEqual(sleepMillis - varianceMillis);
+      expect(end - start).toBeLessThanOrEqual(sleepMillis + varianceMillis);
+    });
+  });
+
+  describe('#runInBackground', () => {
+    test('when given a callback then it runs in background', (done) => {
+      runInBackground(done);
+    });
 
-      expect(didSleep).toBe(false); // sanity check
+    test('when callback throws then it propagates', (done) => {
+      try {
+        runInBackground(() => {
+          throw new Error('test');
+        });
+      } catch (error) {
+        done();
+      }
+    });
 
-      fn(); // kick off promise in background
+    test('when given a promise then it runs in background', (done) => {
+      runInBackground(async () => {
+        done();
+      });
+    });
 
-      expect(didSleep).toBe(false); // assert that sleep function hasn't resolved yet
+    test('when promise rejects then it logs', (done) => {
+      const logger = createLogger('async:utils');
 
-      jest.advanceTimersByTime(1000); // advance time for sleep function
-      await jest.runAllTimersAsync(); // yield to let sleep function resolve
+      runInBackground(async () => {
+        throw new Error('test');
+      });
 
-      expect(didSleep).toBe(true); // assert that sleep function resolved
+      setTimeout(() => {
+        expect(logger.error).toHaveBeenCalledWith(
+          'unhandled promise exception: test',
+          expect.any(Object)
+        );
+        done();
+      }, 250);
     });
   });
 });

electron/common/async/async.utils.ts

@@ -1,3 +1,19 @@
+import { createLogger } from '../logger/logger.utils';
+
+const logger = createLogger('async:utils');
+
 export const sleep = (ms: number): Promise<void> => {
   return new Promise((resolve) => setTimeout(resolve, ms));
 };
+
+/**
+ * For "fire and forget" scenarios when you don't want, or can't, await
+ * a function but it *is* async and so you want the errors logged, if any.
+ */
+export const runInBackground = (fn: () => Promise<unknown>): void => {
+  Promise.resolve(fn()).catch((error) => {
+    logger.error(`unhandled promise exception: ${error?.message}`, {
+      error,
+    });
+  });
+};