(#241) Finally renamed timout files and made timeout cancellable

Author: s1hofmann

lib/util/poll-action.function.ts

@@ -1,4 +1,5 @@
-import {timeout} from "./poll-action.function";
+import {timeout} from "./timeout.function";
+import AbortController from "node-abort-controller";
 
 describe("poll-action", () => {
     it("should timeout after maxDuration if action rejects", async () => {
@@ -160,4 +161,26 @@ describe("poll-action", () => {
             done();
         }, 500);
     });
+
+    it("should be externally abortable", async () => {
+        // GIVEN
+        const controller = new AbortController();
+        const signal = controller.signal;
+        const updateInterval = 100;
+        const maxDuration = 3000;
+        const action = jest.fn(() => {
+            return new Promise<boolean>((_, reject) => {
+                setTimeout(() => {
+                    reject((undefined as unknown) as boolean);
+                }, 20);
+            });
+        });
+
+        // WHEN
+        const SUT = timeout(updateInterval, maxDuration, action, {signal});
+        setTimeout(() => controller.abort(), 1000);
+
+        // THEN
+        await expect(SUT).rejects.toBe(`Action aborted by signal`);
+    });
 });

lib/util/poll-action.function.spec.ts renamed to lib/util/timeout.function.spec.ts

@@ -0,0 +1,58 @@
+import {AbortSignal} from "node-abort-controller";
+
+export interface TimoutConfig {
+    signal?: AbortSignal
+}
+
+export function timeout<R>(updateIntervalMs: number, maxDurationMs: number, action: (...params: any) => Promise<R>, config?: TimoutConfig): Promise<R> {
+    return new Promise<R>((resolve, reject) => {
+        let interval: NodeJS.Timeout;
+        let timerCleaned = false
+
+        if (config?.signal) {
+            config.signal.onabort = () => {
+                cleanupTimer();
+                reject(`Action aborted by signal`);
+            }
+        }
+
+        function executeInterval() {
+            action().then(validateResult).catch(handleRejection);
+        }
+
+        function validateResult(result: R) {
+            if (!result && !timerCleaned) {
+                interval = setTimeout(executeInterval, updateIntervalMs);
+            } else {
+                cleanupTimer();
+                resolve(result);
+            }
+        }
+
+        function handleRejection() {
+            if (!timerCleaned) {
+                interval = setTimeout(executeInterval, updateIntervalMs);
+            }
+        }
+
+        function cleanupTimer() {
+            timerCleaned = true
+            if (maxTimeout) {
+                clearTimeout(maxTimeout);
+            }
+            if (interval) {
+                clearTimeout(interval);
+            }
+        }
+
+        const maxTimeout = setTimeout(
+            () => {
+                cleanupTimer();
+                reject(`Action timed out after ${maxDurationMs} ms`);
+            },
+            maxDurationMs
+        );
+
+        executeInterval()
+    });
+}