[core-util] Abstract the abortable promise pattern

sdk/core/core-util/package.json

@@ -76,11 +76,13 @@
     "@azure/dev-tool": "^1.0.0",
     "@microsoft/api-extractor": "^7.31.1",
     "@types/chai": "^4.1.6",
+    "@types/chai-as-promised": "^7.1.4",
     "@types/mocha": "^7.0.2",
     "@types/node": "^14.0.0",
     "@types/sinon": "^9.0.4",
     "@azure/eslint-plugin-azure-sdk": "^3.0.0",
     "chai": "^4.2.0",
+    "chai-as-promised": "^7.1.1",
     "downlevel-dts": "^0.10.0",
     "cross-env": "^7.0.2",
     "eslint": "^8.0.0",

sdk/core/core-util/src/delay.ts

@@ -19,33 +19,71 @@ export interface DelayOptions {
   abortErrorMsg?: string;
 }
 
+/**
+ *
+ * @param inputs - The inputs for creating an abortable promise are the
+ *                 buildPromise function and the cleanupBeforeAbort function.
+ *                 buildPromise takes both the resolve and reject functions as
+ *                 parameters. cleanupBeforeAbort is called right before the
+ *                 promise is rejected.
+ * @returns a function that takes an optional DelayOptions parameter and returns
+ *          a promise that can be aborted.
+ * @internal
+ */
+export function createAbortablePromise<T>(inputs: {
+  buildPromise: (inputs: {
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+  }) => void;
+  cleanupBeforeAbort?: () => void;
+}): (options?: DelayOptions) => Promise<T> {
+  const { buildPromise, cleanupBeforeAbort } = inputs;
+  return ({ abortSignal, abortErrorMsg } = {}) =>
+    new Promise((resolve, reject) => {
+      function rejectOnAbort(): void {
+        reject(new AbortError(abortErrorMsg ?? "The operation was aborted."));
+      }
+      function removeListeners(): void {
+        abortSignal?.removeEventListener("abort", onAbort);
+      }
+      function onAbort(): void {
+        cleanupBeforeAbort?.();
+        removeListeners();
+        rejectOnAbort();
+      }
+      if (abortSignal?.aborted) {
+        return rejectOnAbort();
+      }
+      buildPromise({
+        resolve: (x) => {
+          removeListeners();
+          resolve(x);
+        },
+        reject: (x) => {
+          removeListeners();
+          reject(x);
+        },
+      });
+      abortSignal?.addEventListener("abort", onAbort);
+    });
+}
+
 /**
  * A wrapper for setTimeout that resolves a promise after timeInMs milliseconds.
  * @param timeInMs - The number of milliseconds to be delayed.
  * @param options - The options for delay - currently abort options
  * @returns Promise that is resolved after timeInMs
  */
 export function delay(timeInMs: number, options?: DelayOptions): Promise<void> {
-  return new Promise((resolve, reject) => {
-    function rejectOnAbort(): void {
-      reject(new AbortError(options?.abortErrorMsg ?? StandardAbortMessage));
-    }
-    function removeListeners(): void {
-      options?.abortSignal?.removeEventListener("abort", onAbort);
-    }
-    function onAbort(): void {
-      // eslint-disable-next-line @typescript-eslint/no-use-before-define
-      clearTimeout(token);
-      removeListeners();
-      rejectOnAbort();
-    }
-    if (options?.abortSignal?.aborted) {
-      return rejectOnAbort();
-    }
-    const token = setTimeout(() => {
-      removeListeners();
-      resolve();
-    }, timeInMs);
-    options?.abortSignal?.addEventListener("abort", onAbort);
+  let token: ReturnType<typeof setTimeout>;
+  const { abortSignal, abortErrorMsg } = options || {};
+  return createAbortablePromise<void>({
+    buildPromise: ({ resolve }) => {
+      token = setTimeout(resolve, timeInMs);
+    },
+    cleanupBeforeAbort: () => clearTimeout(token),
+  })({
+    abortSignal,
+    abortErrorMsg: abortErrorMsg ?? StandardAbortMessage,
   });
 }

sdk/core/core-util/test/internal/createAbortablePromise.spec.ts

@@ -0,0 +1,45 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+import * as sinon from "sinon";
+import { AbortController } from "@azure/abort-controller";
+import chai from "chai";
+import chaiAsPromised from "chai-as-promised";
+import { createAbortablePromise } from "../../src/delay";
+
+chai.use(chaiAsPromised);
+const { assert } = chai;
+
+describe("createAbortablePromise", function () {
+  let token: ReturnType<typeof setTimeout>;
+  const delayTime = 2500;
+  const createPromise = createAbortablePromise<void>({
+    buildPromise: ({ resolve }) => {
+      token = setTimeout(resolve, delayTime);
+    },
+    cleanupBeforeAbort: () => clearTimeout(token),
+  });
+  afterEach(function () {
+    sinon.restore();
+  });
+
+  it("should resolve if not aborted nor rejected", async function () {
+    const clock = sinon.useFakeTimers();
+    const promise = createPromise();
+    const time = await clock.nextAsync();
+    clock.restore();
+    assert.strictEqual(time, delayTime);
+    await assert.isFulfilled(promise);
+  });
+
+  it("should reject when aborted", async function () {
+    const aborter = new AbortController();
+    const abortErrorMsg = "The operation was aborted.";
+    const promise = createPromise({
+      abortSignal: aborter.signal,
+      abortErrorMsg,
+    });
+    aborter.abort();
+    await assert.isRejected(promise, new RegExp(abortErrorMsg));
+  });
+});