feat(helpers): add poll function

Author: nandi95

.gitignore

@@ -4,7 +4,7 @@ index.*.*js*
 array.*.*js*
 string.*.*js*
 types
-Support
+/Support
 *.tgz
 
 # in case gh-pages manually managed

src/Support/function/poll.ts

@@ -0,0 +1,28 @@
+export default async function poll<T>(
+    fn: () => Promise<T>,
+    wait: number | ((result: T, attempts: number) => number) = 0,
+    until?: Date | ((result: T, attempts: number) => boolean)
+): Promise<T> {
+    let attempts = 0;
+
+    return new Promise((resolve, reject) => {
+        const check = async () => {
+            try {
+                attempts++;
+                const result = await fn();
+
+                if (until && (until instanceof Date ? new Date() >= until : until(result, attempts))) {
+                    resolve(result);
+                    return;
+                }
+
+                setTimeout(() => void check(), typeof wait === 'function' ? wait(result, attempts) : wait);
+            } catch (err: unknown) {
+                // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+                reject(err);
+            }
+        };
+
+        void check();
+    });
+}

tests/Support/function.test.ts

@@ -331,42 +331,102 @@ describe('function helpers', () => {
 
     describe('poll()', () => {
         it('should poll indefinitely', async () => {
+            jest.useRealTimers();
             const timesToRun = Math.floor(Math.random() * 10) + 1;
             let timesRan = 0;
 
-            const asyncFunc = jest.fn(async () => new Promise(resolve => {
+            const asyncFunc = async () => new Promise(resolve => {
                 // eslint-disable-next-line jest/no-conditional-in-test
                 if (timesRan === timesToRun) {
                     throw new Error('Done');
                 }
 
                 timesRan++;
+                resolve('Not yet');
+            });
+
+            await func.poll(asyncFunc).catch(() => {});
+
+            expect(timesRan).toBe(timesToRun);
+        });
+
+        it('should reject if any attempts fail', async () => {
+            jest.useRealTimers();
+            const asyncFunc = jest.fn(async () => new Promise(() => {
+                throw new Error('Done');
+            }));
+
+            await expect(func.poll(asyncFunc)).rejects.toThrow('Done');
+        });
+
+        it('should wait the specified number of milliseconds', async () => {
+            const start = jest.useFakeTimers({ advanceTimers: true }).now();
+            let timesRan = 0;
+            const asyncFunc = jest.fn(async () => new Promise(resolve => {
+                timesRan++;
+
+                // eslint-disable-next-line jest/no-conditional-in-test
+                if (timesRan === 2) {
+                    throw new Error('Done');
+                }
+
                 resolve('Not yet');
             }));
 
-            await func.poll(asyncFunc, 10);
-
-            expect(asyncFunc).toHaveBeenCalledTimes(timesToRun);
-        });
-
-        // it('should reject if any attempts fail', () => {
-        //
-        // });
-        //
-        // it('should wait the specified number of seconds', () => {
-        //
-        // });
-        //
-        // it('should wait the specified number of seconds returned from the wait function', () => {
-        //
-        // });
-        //
-        // it('should poll until the given date', () => {
-        //
-        // });
-        //
-        // it('should poll until the until argument returns true', () => {
-        //
-        // });
+            await func.poll(asyncFunc, 100).catch(() => {});
+
+            expect(asyncFunc).toHaveBeenCalledTimes(2);
+            expect(jest.useFakeTimers().now() - start).toBeGreaterThanOrEqual(100);
+        });
+
+        it('should wait the specified number of seconds returned from the wait function', async () => {
+            const start = jest.useFakeTimers({ advanceTimers: true }).now();
+            let timesRan = 0;
+            const asyncFunc = jest.fn(async () => new Promise(resolve => {
+                timesRan++;
+
+                // eslint-disable-next-line jest/no-conditional-in-test
+                if (timesRan === 3) {
+                    throw new Error('Done');
+                }
+
+                resolve('Not yet');
+            }));
+
+            await func.poll(
+                asyncFunc,
+                // wait for 100ms on the first attempt, 200ms on second and the 3rd attempt exits
+                (_result, attempts) => attempts * 100
+            ).catch(() => {});
+
+            expect(asyncFunc).toHaveBeenCalledTimes(3);
+            expect(jest.useFakeTimers().now() - start).toBeGreaterThanOrEqual(300);
+        });
+
+        it('should poll until the given date', async () => {
+            const start = jest.useFakeTimers({ advanceTimers: true }).now();
+            const asyncFunc = jest.fn(async () => new Promise(resolve => resolve('Not yet')));
+
+            await func.poll(
+                asyncFunc,
+                0,
+                new Date(start + 100)
+            ).catch(() => {});
+
+            expect(jest.useFakeTimers().now() - start).toBeGreaterThanOrEqual(100);
+        });
+
+        it('should poll until the until argument returns true', async () => {
+            jest.useFakeTimers({ advanceTimers: true });
+            const asyncFunc = jest.fn(async () => new Promise(resolve => resolve('Not yet')));
+
+            await func.poll(
+                asyncFunc,
+                0,
+                (_result, attempts) => attempts === 3
+            ).catch(() => {});
+
+            expect(asyncFunc).toHaveBeenCalledTimes(3);
+        });
     });
 });