@fluidframework/test-utils 0.54.2 → 0.56.0-49831

package/src/timeoutUtils.ts

@@ -5,47 +5,51 @@
 
 export const defaultTimeoutDurationMs = 250;
 
- export interface TimeoutWithError{
+export interface TimeoutWithError {
     durationMs?: number;
     reject?: true;
     errorMsg?: string;
- }
- export interface TimeoutWithValue<T = void>{
+}
+export interface TimeoutWithValue<T = void> {
     durationMs?: number;
     reject: false;
     value: T;
- }
+}
 
-// eslint-disable-next-line prefer-arrow/prefer-arrow-functions
 export async function timeoutAwait<T = void>(
     promise: PromiseLike<T>,
     timeoutOptions: TimeoutWithError | TimeoutWithValue<T> = {},
 ) {
-    return Promise.race([promise, timeoutPromise<T>(()=>{}, timeoutOptions)]);
+    return Promise.race([promise, timeoutPromise<T>(() => { }, timeoutOptions)]);
 }
 
- export async function timeoutPromise<T = void>(
+export async function timeoutPromise<T = void>(
     executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void,
     timeoutOptions: TimeoutWithError | TimeoutWithValue<T> = {},
 ): Promise<T> {
+    const timeout =
+        timeoutOptions.durationMs !== undefined
+        && Number.isFinite(timeoutOptions.durationMs)
+        && timeoutOptions.durationMs > 0
+            ?  timeoutOptions.durationMs : defaultTimeoutDurationMs;
     // create the timeout error outside the async task, so it's callstack includes
     // the original call site, this makes it easier to debug
     const err = timeoutOptions.reject === false
         ? undefined
-        : new Error(timeoutOptions.errorMsg ?? "Timeout");
-    return new Promise<T>((res,rej)=>{
-        const timeout = setTimeout(
-            ()=>timeoutOptions.reject === false ? res(timeoutOptions.value) : rej(err),
-            timeoutOptions.durationMs ?? defaultTimeoutDurationMs);
+        : new Error(`${timeoutOptions.errorMsg ?? "Timed out"}(${timeout}ms)`);
+    return new Promise<T>((resolve,reject)=>{
+        const timer = setTimeout(
+            ()=>timeoutOptions.reject === false ? resolve(timeoutOptions.value) : reject(err),
+            timeout);
 
         executor(
             (value) => {
-                clearTimeout(timeout);
-                res(value);
+                clearTimeout(timer);
+                resolve(value);
             },
             (reason) => {
-                clearTimeout(timeout);
-                rej(reason);
+                clearTimeout(timer);
+                reject(reason);
             });
     });
 }