[App Config] Handle throttling - do not hang - should honor abort signal

sdk/appconfiguration/app-configuration/package.json

@@ -86,6 +86,7 @@
     ]
   },
   "dependencies": {
+    "@azure/abort-controller": "^1.0.0",
     "@azure/core-asynciterator-polyfill": "^1.0.0",
     "@azure/core-http": "^1.2.0",
     "@azure/core-paging": "^1.1.1",

sdk/appconfiguration/app-configuration/src/appConfigurationClient.ts

@@ -204,7 +204,6 @@ export class AppConfigurationClient {
         entity: keyValue,
         ...newOptions
       });
-
       return transformKeyValueResponse(originalResponse);
     });
   }

sdk/appconfiguration/app-configuration/src/policies/throttlingRetryPolicy.ts

@@ -12,6 +12,7 @@ import {
   delay,
   RestError
 } from "@azure/core-http";
+import { AbortError } from "@azure/abort-controller";
 
 /**
  * @internal
@@ -24,6 +25,23 @@ export function throttlingRetryPolicy(): RequestPolicyFactory {
   };
 }
 
+/**
+ * Maximum wait duration for the expected event to happen = `10000 ms`(default value is 10 seconds)(= maxWaitTimeInMilliseconds)
+ * Keep checking whether the predicate is true after every `1000 ms`(default value is 1 second) (= delayBetweenRetriesInMilliseconds)
+ */
+export async function checkWithTimeout(
+  predicate: () => boolean | Promise<boolean>,
+  delayBetweenRetriesInMilliseconds: number = 1000,
+  maxWaitTimeInMilliseconds: number = 10000
+): Promise<boolean> {
+  const maxTime = Date.now() + maxWaitTimeInMilliseconds;
+  while (Date.now() < maxTime) {
+    if (await predicate()) return true;
+    await delay(delayBetweenRetriesInMilliseconds);
+  }
+  return false;
+}
+
 /**
  * This policy is a close copy of the ThrottlingRetryPolicy class from
  * core-http with modifications to work with how AppConfig is currently
@@ -37,15 +55,19 @@ export class ThrottlingRetryPolicy extends BaseRequestPolicy {
   }
 
   public async sendRequest(httpRequest: WebResource): Promise<HttpOperationResponse> {
-    return this._nextPolicy.sendRequest(httpRequest.clone()).catch((err) => {
+    return this._nextPolicy.sendRequest(httpRequest.clone()).catch(async (err) => {
       if (isRestErrorWithHeaders(err)) {
         const delayInMs = getDelayInMs(err.response.headers);
 
         if (delayInMs == null) {
           throw err;
         }
 
-        return delay(delayInMs).then((_: any) => this.sendRequest(httpRequest.clone()));
+        await checkWithTimeout(() => httpRequest.abortSignal?.aborted === true, 1, delayInMs);
+        if (httpRequest.abortSignal?.aborted) {
+          throw new AbortError("The operation was aborted.");
+        }
+        return await this.sendRequest(httpRequest.clone());
       } else {
         throw err;
       }

sdk/appconfiguration/app-configuration/test/public/throttling.spec.ts

@@ -0,0 +1,50 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+import { createAppConfigurationClientForTests, startRecorder } from "./utils/testHelpers";
+import { AppConfigurationClient } from "../../src";
+import { Recorder } from "@azure/test-utils-recorder";
+import { Context } from "mocha";
+import { AbortController } from "@azure/abort-controller";
+
+describe("AppConfigurationClient", () => {
+  let client: AppConfigurationClient;
+  let recorder: Recorder;
+
+  beforeEach(function(this: Context) {
+    recorder = startRecorder(this);
+    client = createAppConfigurationClientForTests() || this.skip();
+  });
+
+  afterEach(async function(this: Context) {
+    await recorder.stop();
+  });
+
+  describe.only("simple usages", () => {
+    it("Add and query a setting without a label", async () => {
+      const key = recorder.getUniqueName("noLabelTests");
+      const numberOfSettings = 2000;
+      const promises = [];
+      try {
+        for (let index = 0; index < numberOfSettings; index++) {
+          promises.push(
+            client.addConfigurationSetting(
+              {
+                key: key + " " + +index,
+                value: "added"
+              },
+              {
+                abortSignal: AbortController.timeout(10000)
+              }
+            )
+          );
+        }
+        await Promise.all(promises);
+      } catch (error) {
+        console.log(error);
+      }
+
+      await client.deleteConfigurationSetting({ key });
+    });
+  });
+});