[Unified Recorder] Allow passing undefined to sanitizers and other minor changes

sdk/test-utils/recorder-new/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## 1.0.0 (Unreleased)
 
+## 2021-12-27
+
+- Allows passing `undefined` as keys in the sanitizer options so that devs don't have to add additional checks if a certain env variable exists in playback.
+- Exports `delay`
+  - waits for expected time in record/live modes
+  - no-op in playback
+
+[#19561](https://github.com/Azure/azure-sdk-for-js/pull/19561)
+
 ## 2021-12-17
 
 - Refactoring the test proxy http clients for better clarity for the end users [#19446](https://github.com/Azure/azure-sdk-for-js/pull/19446)

sdk/test-utils/recorder-new/src/index.ts

@@ -11,3 +11,4 @@ export {
   isRecordMode
 } from "./utils/utils";
 export { env } from "./utils/env";
+export { delay } from "./utils/delay";

sdk/test-utils/recorder-new/src/sanitizer.ts

@@ -4,8 +4,10 @@ import { getRealAndFakePairs } from "./utils/connectionStringHelpers";
 import { paths } from "./utils/paths";
 import {
   getTestMode,
+  isRecordMode,
   ProxyToolSanitizers,
   RecorderError,
+  RegexSanitizer,
   sanitizerKeywordMapping,
   SanitizerOptions
 } from "./utils/utils";
@@ -74,12 +76,27 @@ export class Sanitizer {
         const replacers = options[prop];
         if (replacers) {
           return Promise.all(
-            replacers.map((replacer: unknown) =>
-              this.addSanitizer({
+            replacers.map((replacer: RegexSanitizer) => {
+              if (
+                // sanitizers where the "regex" is a required attribute
+                [
+                  "bodyKeySanitizers",
+                  "bodyRegexSanitizers",
+                  "generalRegexSanitizers",
+                  "uriRegexSanitizers"
+                ].includes(prop) &&
+                !replacer.regex
+              ) {
+                if (!isRecordMode()) return;
+                throw new RecorderError(
+                  `Attempted to add an invalid sanitizer - ${JSON.stringify(replacer)}`
+                );
+              }
+              return this.addSanitizer({
                 sanitizer: sanitizerKeywordMapping[prop],
                 body: JSON.stringify(replacer)
-              })
-            )
+              });
+            })
           );
         } else return;
       })
@@ -140,9 +157,18 @@ export class Sanitizer {
    * - generalRegexSanitizer is applied for each of the parts with the real and fake values that are parsed
    */
   async addConnectionStringSanitizer(
-    actualConnString: string,
+    actualConnString: string | undefined,
     fakeConnString: string
   ): Promise<void> {
+    if (!actualConnString) {
+      if (!isRecordMode()) return;
+      throw new RecorderError(
+        `Attempted to add an invalid sanitizer - ${JSON.stringify({
+          actualConnString: actualConnString,
+          fakeConnString: fakeConnString
+        })}`
+      );
+    }
     // extract connection string parts and match call
     const pairsMatched = getRealAndFakePairs(actualConnString, fakeConnString);
     await this.addSanitizers({

sdk/test-utils/recorder-new/src/utils/delay.ts

@@ -0,0 +1,18 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+import { isPlaybackMode } from "./utils";
+
+/**
+ * Usage - `await delay(<milliseconds>)`
+ * This `delay` has no effect if the `TEST_MODE` is `"playback"`.
+ * If the `TEST_MODE` is not `"playback"`, `delay` is a wrapper for setTimeout that resolves a promise after t milliseconds.
+ *
+ * @param {number} milliseconds The number of milliseconds to be delayed.
+ */
+export function delay(milliseconds: number): Promise<void> | void {
+  if (isPlaybackMode()) {
+    return;
+  }
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}

sdk/test-utils/recorder-new/src/utils/utils.ts

@@ -95,9 +95,9 @@ export interface RegexSanitizer {
    */
   value: string;
   /**
-   * A regex. Can be defined as a simple regex replace OR if groupForReplace is set, a subsitution operation.
+   * A regex. Can be defined as a simple regex replace OR if groupForReplace is set, a substitution operation.
    */
-  regex: string;
+  regex?: string;
   /**
    * The capture group that needs to be operated upon. Do not set if you're invoking a simple replacement operation.
    */
@@ -129,15 +129,11 @@ interface BodyKeySanitizer extends RegexSanitizer {
  * 2) To do a simple regex replace operation, define arguments "key", "value", and "regex"
  * 3) To do a targeted substitution of a specific group, define all arguments "key", "value", and "regex"
  */
-interface HeaderRegexSanitizer extends Omit<RegexSanitizer, "regex"> {
+interface HeaderRegexSanitizer extends RegexSanitizer {
   /**
    * The name of the header we're operating against.
    */
   key: string;
-  /**
-   * A regex. Can be defined as a simple regex replace OR if groupForReplace is set, a subsitution operation.
-   */
-  regex?: string;
 }
 /**
  * Internally,
@@ -149,7 +145,7 @@ interface ConnectionStringSanitizer {
   /**
    * Real connection string with all the secrets
    */
-  actualConnString: string;
+  actualConnString?: string;
   /**
    * Fake connection string - with all the parts of the connection string mapped to fake values
    */
@@ -181,7 +177,17 @@ export interface SanitizerOptions {
    * Regardless, there are examples present in `recorder-new/test/testProxyTests.spec.ts`.
    */
   bodyRegexSanitizers?: RegexSanitizer[];
-
+  /**
+   * This sanitizer offers regex update of a specific JTokenPath.
+   *
+   * EG: "TableName" within a json response body having its value replaced by whatever substitution is offered.
+   * This simply means that if you are attempting to replace a specific key wholesale, this sanitizer will be simpler
+   * than configuring a BodyRegexSanitizer that has to match against the full "KeyName": "Value" that is part of the json structure.
+   *
+   * Further reading is available [here](https://www.newtonsoft.com/json/help/html/SelectToken.htm#SelectTokenJSONPath).
+   *
+   * If the body is NOT a JSON object, this sanitizer will NOT be applied.
+   */
   bodyKeySanitizers?: BodyKeySanitizer[];
   /**
    * TODO