@aws-sdk/middleware-endpoint-discovery 3.35.0 → 3.39.0

package/src/endpointDiscoveryMiddleware.spec.ts

@@ -1,145 +0,0 @@
-import { EndpointCache } from "@aws-sdk/endpoint-cache";
-import { HttpRequest } from "@aws-sdk/protocol-http";
-import { BuildHandlerArguments, MiddlewareStack } from "@aws-sdk/types";
-
-import { endpointDiscoveryMiddleware } from "./endpointDiscoveryMiddleware";
-import { getCacheKey } from "./getCacheKey";
-import { updateDiscoveredEndpointInCache } from "./updateDiscoveredEndpointInCache";
-
-jest.mock("./updateDiscoveredEndpointInCache");
-jest.mock("./getCacheKey");
-jest.mock("@aws-sdk/protocol-http");
-
-describe(endpointDiscoveryMiddleware.name, () => {
-  const cacheKey = "cacheKey";
-  const endpoint = "endpoint";
-  const getEndpoint = jest.fn().mockReturnValue(endpoint);
-  const mockConfig = {
-    credentials: jest.fn(),
-    endpointCache: {
-      getEndpoint,
-    } as unknown as EndpointCache,
-    endpointDiscoveryEnabled: jest.fn().mockResolvedValue(undefined),
-    endpointDiscoveryEnabledProvider: jest.fn(),
-    endpointDiscoveryCommandCtor: jest.fn(),
-    isCustomEndpoint: false,
-    isClientEndpointDiscoveryEnabled: false,
-  };
-
-  const mockMiddlewareConfig = {
-    isDiscoveredEndpointRequired: false,
-    clientStack: {} as MiddlewareStack<any, any>,
-  };
-
-  const mockNext = jest.fn();
-  const mockContext = {
-    clientName: "ExampleClient",
-    commandName: "ExampleCommand",
-  };
-  const mockArgs = { request: {} };
-
-  beforeEach(() => {
-    (getCacheKey as jest.Mock).mockResolvedValue(cacheKey);
-    (updateDiscoveredEndpointInCache as jest.Mock).mockResolvedValue(undefined);
-    const { isInstance } = HttpRequest;
-    (isInstance as unknown as jest.Mock).mockReturnValue(true);
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe(`isCustomEndpoint=true`, () => {
-    it(`throw error if isClientEndpointDiscoveryEnabled`, async () => {
-      try {
-        await endpointDiscoveryMiddleware(
-          { ...mockConfig, isCustomEndpoint: true, isClientEndpointDiscoveryEnabled: true },
-          mockMiddlewareConfig
-        )(
-          mockNext,
-          mockContext
-        )(mockArgs as BuildHandlerArguments<any>);
-        fail("should throw error when isCustomEndpoint=true and isClientEndpointDiscoveryEnabled=true");
-      } catch (error) {
-        expect(error).toStrictEqual(
-          new Error(`Custom endpoint is supplied; endpointDiscoveryEnabled must not be true.`)
-        );
-      }
-      expect(mockNext).not.toHaveBeenCalled();
-      expect(updateDiscoveredEndpointInCache).not.toHaveBeenCalled();
-    });
-
-    it(`returns without endpoint discovery`, async () => {
-      await endpointDiscoveryMiddleware({ ...mockConfig, isCustomEndpoint: true }, mockMiddlewareConfig)(
-        mockNext,
-        mockContext
-      )(mockArgs as BuildHandlerArguments<any>);
-      expect(mockNext).toHaveBeenCalledWith(mockArgs);
-      expect(updateDiscoveredEndpointInCache as jest.Mock).not.toHaveBeenCalled();
-    });
-  });
-
-  describe(`isDiscoveredEndpointRequired=true`, () => {
-    it(`throws error when isEndpointDiscoveryEnabled=false`, async () => {
-      mockConfig.endpointDiscoveryEnabled.mockResolvedValueOnce(false);
-      try {
-        await endpointDiscoveryMiddleware(mockConfig, { ...mockMiddlewareConfig, isDiscoveredEndpointRequired: true })(
-          mockNext,
-          mockContext
-        )(mockArgs as BuildHandlerArguments<any>);
-        fail("should throw error when isDiscoveredEndpointRequired=true and isEndpointDiscoveryEnabled=false");
-      } catch (error) {
-        expect(error).toStrictEqual(
-          new Error(
-            `Endpoint Discovery is disabled but ${mockContext.commandName} on ${mockContext.clientName} requires it.` +
-              ` Please check your configurations.`
-          )
-        );
-      }
-      expect(mockNext).not.toHaveBeenCalled();
-      expect(updateDiscoveredEndpointInCache).not.toHaveBeenCalled();
-    });
-
-    describe(`calls updateDiscoveredEndpointInCache`, () => {
-      it(`when isEndpointDiscoveryEnabled=undefined`, async () => {
-        await endpointDiscoveryMiddleware(mockConfig, { ...mockMiddlewareConfig, isDiscoveredEndpointRequired: true })(
-          mockNext,
-          mockContext
-        )(mockArgs as BuildHandlerArguments<any>);
-        expect(mockNext).toHaveBeenCalledWith(mockArgs);
-        expect(mockNext).toHaveBeenCalledWith({ request: { hostname: endpoint } });
-        expect(updateDiscoveredEndpointInCache).toHaveBeenCalled();
-      });
-
-      it(`when isEndpointDiscoveryEnabled=true`, async () => {
-        mockConfig.endpointDiscoveryEnabled.mockResolvedValueOnce(true);
-        await endpointDiscoveryMiddleware(mockConfig, { ...mockMiddlewareConfig, isDiscoveredEndpointRequired: true })(
-          mockNext,
-          mockContext
-        )(mockArgs as BuildHandlerArguments<any>);
-        expect(mockNext).toHaveBeenCalledWith(mockArgs);
-        expect(mockNext).toHaveBeenCalledWith({ request: { hostname: endpoint } });
-        expect(updateDiscoveredEndpointInCache).toHaveBeenCalled();
-      });
-    });
-
-    describe(`isDiscoveredEndpointRequired=false`, () => {
-      it(`calls updateDiscoveredEndpointInCache when isEndpointDiscoveryEnabled=true`, async () => {
-        mockConfig.endpointDiscoveryEnabled.mockResolvedValueOnce(true);
-        await endpointDiscoveryMiddleware(mockConfig, mockMiddlewareConfig)(mockNext, mockContext)(
-          mockArgs as BuildHandlerArguments<any>
-        );
-        expect(mockNext).toHaveBeenCalledWith(mockArgs);
-        expect(updateDiscoveredEndpointInCache).toHaveBeenCalled();
-      });
-
-      it(`does not call updateDiscoveredEndpointInCache when isEndpointDiscoveryEnabled=false`, async () => {
-        await endpointDiscoveryMiddleware(mockConfig, mockMiddlewareConfig)(mockNext, mockContext)(
-          mockArgs as BuildHandlerArguments<any>
-        );
-        expect(mockNext).toHaveBeenCalledWith(mockArgs);
-        expect(updateDiscoveredEndpointInCache).not.toHaveBeenCalled();
-      });
-    });
-  });
-});

package/src/endpointDiscoveryMiddleware.ts

@@ -1,72 +0,0 @@
-import { HttpRequest } from "@aws-sdk/protocol-http";
-import {
-  BuildHandler,
-  BuildHandlerArguments,
-  BuildHandlerOutput,
-  HandlerExecutionContext,
-  MetadataBearer,
-} from "@aws-sdk/types";
-
-import { getCacheKey } from "./getCacheKey";
-import { EndpointDiscoveryMiddlewareConfig } from "./getEndpointDiscoveryPlugin";
-import { EndpointDiscoveryResolvedConfig, PreviouslyResolved } from "./resolveEndpointDiscoveryConfig";
-import { updateDiscoveredEndpointInCache } from "./updateDiscoveredEndpointInCache";
-
-export const endpointDiscoveryMiddleware =
-  (config: EndpointDiscoveryResolvedConfig & PreviouslyResolved, middlewareConfig: EndpointDiscoveryMiddlewareConfig) =>
-  <Output extends MetadataBearer = MetadataBearer>(
-    next: BuildHandler<any, Output>,
-    context: HandlerExecutionContext
-  ): BuildHandler<any, Output> =>
-  async (args: BuildHandlerArguments<any>): Promise<BuildHandlerOutput<Output>> => {
-    if (config.isCustomEndpoint) {
-      if (config.isClientEndpointDiscoveryEnabled) {
-        throw new Error(`Custom endpoint is supplied; endpointDiscoveryEnabled must not be true.`);
-      }
-      return next(args);
-    }
-
-    const { endpointDiscoveryCommandCtor } = config;
-    const { isDiscoveredEndpointRequired, identifiers } = middlewareConfig;
-    const { clientName, commandName } = context;
-    const isEndpointDiscoveryEnabled = await config.endpointDiscoveryEnabled();
-    const cacheKey = await getCacheKey(commandName, config, { identifiers });
-
-    if (isDiscoveredEndpointRequired) {
-      // throw error if endpoint discovery is required, and it's explicitly disabled.
-      if (isEndpointDiscoveryEnabled === false) {
-        throw new Error(
-          `Endpoint Discovery is disabled but ${commandName} on ${clientName} requires it.` +
-            ` Please check your configurations.`
-        );
-      }
-      // call await on Endpoint Discovery API utility so that function blocks
-      // till discovered endpoint is updated in cache
-      await updateDiscoveredEndpointInCache(config, {
-        ...middlewareConfig,
-        commandName,
-        cacheKey,
-        endpointDiscoveryCommandCtor,
-      });
-    } else if (isEndpointDiscoveryEnabled) {
-      // Discover endpoints only if endpoint discovery is explicitly enabled.
-      // Do not call await await on Endpoint Discovery API utility so that function
-      // does not block, the command will use discovered endpoint, if available.
-      updateDiscoveredEndpointInCache(config, {
-        ...middlewareConfig,
-        commandName,
-        cacheKey,
-        endpointDiscoveryCommandCtor,
-      });
-    }
-
-    const { request } = args;
-    if (cacheKey && HttpRequest.isInstance(request)) {
-      const endpoint = config.endpointCache.getEndpoint(cacheKey);
-      if (endpoint) {
-        request.hostname = endpoint;
-      }
-    }
-
-    return next(args);
-  };

package/src/getCacheKey.spec.ts

@@ -1,32 +0,0 @@
-import { getCacheKey } from "./getCacheKey";
-
-describe(getCacheKey.name, () => {
-  const commandName = "commandName";
-  const mockCredentials = {
-    accessKeyId: "accessKeyId",
-    secretAccessKey: "secretAccessKey",
-  };
-
-  const config = {
-    credentials: () => Promise.resolve(mockCredentials),
-  };
-
-  it("returns accessKeyId in cacheKey", async () => {
-    const cacheKey = await getCacheKey(commandName, config, {});
-    expect(cacheKey).toEqual(JSON.stringify({ accessKeyId: mockCredentials.accessKeyId }));
-  });
-
-  it("returns commandName and identifiers if passed", async () => {
-    const identifiers = { key: "value" };
-    const cacheKey = await getCacheKey(commandName, config, { identifiers });
-    expect(cacheKey).toEqual(JSON.stringify({ accessKeyId: mockCredentials.accessKeyId, commandName, identifiers }));
-  });
-
-  it("returns same cache key irrespective of key order in identifiers", async () => {
-    const identifiers1 = { key1: "value1", key2: "value2" };
-    const cacheKey1 = await getCacheKey(commandName, config, { identifiers: identifiers1 });
-    const identifiers2 = { key2: "value2", key1: "value1" };
-    const cacheKey2 = await getCacheKey(commandName, config, { identifiers: identifiers2 });
-    expect(cacheKey1).toStrictEqual(cacheKey2);
-  });
-});

package/src/getCacheKey.ts

@@ -1,24 +0,0 @@
-import { Credentials, Provider } from "@aws-sdk/types";
-
-/**
- * Generate key to index the endpoints in the cache
- */
-export const getCacheKey = async (
-  commandName: string,
-  config: { credentials: Provider<Credentials> },
-  options: {
-    identifiers?: { [key: string]: string };
-  }
-) => {
-  const { accessKeyId } = await config.credentials();
-  const { identifiers } = options;
-  return JSON.stringify({
-    ...(accessKeyId && { accessKeyId }),
-    ...(identifiers && {
-      commandName,
-      identifiers: Object.entries(identifiers)
-        .sort()
-        .reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {}),
-    }),
-  });
-};

package/src/getEndpointDiscoveryPlugin.spec.ts

@@ -1,32 +0,0 @@
-import { endpointDiscoveryMiddleware } from "./endpointDiscoveryMiddleware";
-import { endpointDiscoveryMiddlewareOptions, getEndpointDiscoveryPlugin } from "./getEndpointDiscoveryPlugin";
-
-jest.mock("./endpointDiscoveryMiddleware");
-
-describe(getEndpointDiscoveryPlugin.name, () => {
-  const pluginConfig = {
-    isCustomEndpoint: false,
-    endpointCache: jest.fn(),
-    endpointDiscoveryEnabled: jest.fn(),
-    isClientEndpointDiscoveryEnabled: false,
-  };
-  const middlewareConfig = {
-    isDiscoveredEndpointRequired: false,
-  };
-
-  it(`applyToStack function adds endpoint discovery middleware`, () => {
-    const middlewareReturn = {};
-    (endpointDiscoveryMiddleware as jest.Mock).mockReturnValueOnce(middlewareReturn);
-
-    // @ts-ignore
-    const plugin = getEndpointDiscoveryPlugin(pluginConfig, middlewareConfig);
-    const commandStack = { add: jest.fn() };
-
-    // @ts-ignore
-    plugin.applyToStack(commandStack);
-    expect(commandStack.add).toHaveBeenCalled();
-    expect(commandStack.add).toHaveBeenCalledWith(middlewareReturn, endpointDiscoveryMiddlewareOptions);
-    expect(endpointDiscoveryMiddleware).toHaveBeenCalled();
-    expect(endpointDiscoveryMiddleware).toHaveBeenCalledWith(pluginConfig, middlewareConfig);
-  });
-});

package/src/getEndpointDiscoveryPlugin.ts

@@ -1,57 +0,0 @@
-import { BuildHandlerOptions, HttpHandlerOptions, MiddlewareStack, Pluggable } from "@aws-sdk/types";
-
-import { endpointDiscoveryMiddleware } from "./endpointDiscoveryMiddleware";
-import { EndpointDiscoveryResolvedConfig, PreviouslyResolved } from "./resolveEndpointDiscoveryConfig";
-
-export const endpointDiscoveryMiddlewareOptions: BuildHandlerOptions = {
-  name: "endpointDiscoveryMiddleware",
-  step: "build",
-  tags: ["ENDPOINT_DISCOVERY"],
-  override: true,
-};
-
-export interface EndpointDiscoveryMiddlewareConfig {
-  isDiscoveredEndpointRequired: boolean;
-  clientStack: MiddlewareStack<any, any>;
-  options?: HttpHandlerOptions;
-  identifiers?: { [key: string]: string };
-}
-
-export const getEndpointDiscoveryPlugin = (
-  pluginConfig: EndpointDiscoveryResolvedConfig & PreviouslyResolved,
-  middlewareConfig: EndpointDiscoveryMiddlewareConfig
-): Pluggable<any, any> => ({
-  applyToStack: (commandStack) => {
-    commandStack.add(endpointDiscoveryMiddleware(pluginConfig, middlewareConfig), endpointDiscoveryMiddlewareOptions);
-  },
-});
-
-/**
- * @deprecated Use getEndpointDiscoveryPlugin
- */
-export const getEndpointDiscoveryRequiredPlugin = (
-  pluginConfig: EndpointDiscoveryResolvedConfig & PreviouslyResolved,
-  middlewareConfig: Omit<EndpointDiscoveryMiddlewareConfig, "isDiscoveredEndpointRequired">
-): Pluggable<any, any> => ({
-  applyToStack: (commandStack) => {
-    commandStack.add(
-      endpointDiscoveryMiddleware(pluginConfig, { ...middlewareConfig, isDiscoveredEndpointRequired: true }),
-      endpointDiscoveryMiddlewareOptions
-    );
-  },
-});
-
-/**
- * @deprecated Use getEndpointDiscoveryPlugin
- */
-export const getEndpointDiscoveryOptionalPlugin = (
-  pluginConfig: EndpointDiscoveryResolvedConfig & PreviouslyResolved,
-  middlewareConfig: Omit<EndpointDiscoveryMiddlewareConfig, "isDiscoveredEndpointRequired">
-): Pluggable<any, any> => ({
-  applyToStack: (commandStack) => {
-    commandStack.add(
-      endpointDiscoveryMiddleware(pluginConfig, { ...middlewareConfig, isDiscoveredEndpointRequired: false }),
-      endpointDiscoveryMiddlewareOptions
-    );
-  },
-});

package/src/index.ts

@@ -1,3 +0,0 @@
-export * from "./resolveEndpointDiscoveryConfig";
-export * from "./getEndpointDiscoveryPlugin";
-export * from "./configurations";

package/src/resolveEndpointDiscoveryConfig.spec.ts

@@ -1,63 +0,0 @@
-import { EndpointCache } from "@aws-sdk/endpoint-cache";
-
-import { resolveEndpointDiscoveryConfig } from "./resolveEndpointDiscoveryConfig";
-
-jest.mock("@aws-sdk/endpoint-cache");
-
-describe(resolveEndpointDiscoveryConfig.name, () => {
-  const endpointDiscoveryCommandCtor = jest.fn();
-  const mockInput = {
-    isCustomEndpoint: false,
-    credentials: jest.fn(),
-    endpointDiscoveryEnabledProvider: jest.fn(),
-  };
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it("assigns endpointDiscoveryCommandCtor in resolvedConfig", () => {
-    const resolvedConfig = resolveEndpointDiscoveryConfig(mockInput, { endpointDiscoveryCommandCtor });
-    expect(resolvedConfig.endpointDiscoveryCommandCtor).toStrictEqual(endpointDiscoveryCommandCtor);
-  });
-
-  describe("endpointCache", () => {
-    it("creates cache of size endpointCacheSize if passed", () => {
-      const endpointCacheSize = 100;
-      resolveEndpointDiscoveryConfig(
-        {
-          ...mockInput,
-          endpointCacheSize,
-        },
-        { endpointDiscoveryCommandCtor }
-      );
-      expect(EndpointCache).toBeCalledWith(endpointCacheSize);
-    });
-
-    it("creates cache of size 1000 if endpointCacheSize not passed", () => {
-      resolveEndpointDiscoveryConfig(mockInput, { endpointDiscoveryCommandCtor });
-      expect(EndpointCache).toBeCalledWith(1000);
-    });
-  });
-
-  describe("endpointDiscoveryEnabled", () => {
-    it.each<boolean>([false, true])(`sets to value passed in the config: %s`, (endpointDiscoveryEnabled) => {
-      const resolvedConfig = resolveEndpointDiscoveryConfig(
-        {
-          ...mockInput,
-          endpointDiscoveryEnabled,
-        },
-        { endpointDiscoveryCommandCtor }
-      );
-      expect(resolvedConfig.endpointDiscoveryEnabled()).resolves.toBe(endpointDiscoveryEnabled);
-      expect(mockInput.endpointDiscoveryEnabledProvider).not.toHaveBeenCalled();
-      expect(resolvedConfig.isClientEndpointDiscoveryEnabled).toStrictEqual(true);
-    });
-
-    it(`sets to endpointDiscoveryEnabledProvider if value is not passed`, () => {
-      const resolvedConfig = resolveEndpointDiscoveryConfig(mockInput, { endpointDiscoveryCommandCtor });
-      expect(resolvedConfig.endpointDiscoveryEnabled).toBe(mockInput.endpointDiscoveryEnabledProvider);
-      expect(resolvedConfig.isClientEndpointDiscoveryEnabled).toStrictEqual(false);
-    });
-  });
-});

package/src/resolveEndpointDiscoveryConfig.ts

@@ -1,73 +0,0 @@
-import { EndpointCache } from "@aws-sdk/endpoint-cache";
-import { Credentials, Provider } from "@aws-sdk/types";
-
-export interface EndpointDiscoveryInputConfig {}
-
-export interface PreviouslyResolved {
-  isCustomEndpoint: boolean;
-  credentials: Provider<Credentials>;
-  endpointDiscoveryEnabledProvider: Provider<boolean | undefined>;
-}
-
-export interface EndpointDiscoveryInputConfig {
-  /**
-   * The size of the client cache storing endpoints from endpoint discovery operations.
-   * Defaults to 1000.
-   */
-  endpointCacheSize?: number;
-
-  /**
-   * Whether to call operations with endpoints given by service dynamically.
-   * Setting this config to `true` will enable endpoint discovery for all applicable operations.
-   * Setting it to `false` will explicitly disable endpoint discovery even though operations that
-   * require endpoint discovery will presumably fail. Leaving it to undefined means SDK only do
-   * endpoint discovery when it's required. Defaults to `undefined`.
-   */
-  endpointDiscoveryEnabled?: boolean | undefined;
-}
-export interface EndpointDiscoveryResolvedConfig {
-  /**
-   * LRU Cache which stores endpoints from endpoint discovery operations.
-   * The size is either provided by {@link EndpointDiscoveryInputConfig.endpointCacheSize}.
-   */
-  endpointCache: EndpointCache;
-
-  /**
-   * The constructor of the Command used for discovering endpoints.
-   * @internal
-   */
-  endpointDiscoveryCommandCtor: new (comandConfig: any) => any;
-
-  /**
-   * Resolved value for input config {@link EndpointDiscoveryInputConfig.endpointDiscoveryEnabled}.
-   */
-  endpointDiscoveryEnabled: Provider<boolean | undefined>;
-
-  /**
-   * Stores whether endpoint discovery configuration is set locally by passing
-   * {@link EndpointDiscoveryInputConfig.endpointDiscoveryEnabled} during client creation.
-   * @internal
-   */
-  isClientEndpointDiscoveryEnabled: boolean;
-}
-
-export interface EndpointDiscoveryConfigOptions {
-  /**
-   * The constructor of the Command used for discovering endpoints.
-   */
-  endpointDiscoveryCommandCtor: new (comandConfig: any) => any;
-}
-
-export const resolveEndpointDiscoveryConfig = <T>(
-  input: T & PreviouslyResolved & EndpointDiscoveryInputConfig,
-  { endpointDiscoveryCommandCtor }: EndpointDiscoveryConfigOptions
-): T & EndpointDiscoveryResolvedConfig => ({
-  ...input,
-  endpointDiscoveryCommandCtor,
-  endpointCache: new EndpointCache(input.endpointCacheSize ?? 1000),
-  endpointDiscoveryEnabled:
-    input.endpointDiscoveryEnabled !== undefined
-      ? () => Promise.resolve(input.endpointDiscoveryEnabled)
-      : input.endpointDiscoveryEnabledProvider,
-  isClientEndpointDiscoveryEnabled: input.endpointDiscoveryEnabled !== undefined,
-});

package/src/updateDiscoveredEndpointInCache.spec.ts

@@ -1,172 +0,0 @@
-import { updateDiscoveredEndpointInCache } from "./updateDiscoveredEndpointInCache";
-
-describe(updateDiscoveredEndpointInCache.name, () => {
-  const cacheKey = "cacheKey";
-  const mockGet = jest.fn();
-  const mockSet = jest.fn();
-  const mockDelete = jest.fn();
-
-  const mockHandler = jest.fn();
-  const mockResolveMiddleware = jest.fn().mockReturnValue(mockHandler);
-
-  const mockEndpoints = [{ Address: "mockAddress", CachePeriodInMinutes: 2 }];
-  const placeholderEndpoints = [{ Address: "", CachePeriodInMinutes: 1 }];
-
-  const config = {
-    endpointCache: { get: mockGet, set: mockSet, delete: mockDelete },
-  };
-
-  const options = {
-    cacheKey,
-    commandName: "ExampleCommand",
-    endpointDiscoveryCommandCtor: jest.fn().mockReturnValue({ resolveMiddleware: mockResolveMiddleware }),
-    isDiscoveredEndpointRequired: false,
-    identifiers: { key: "value" },
-  };
-
-  beforeEach(() => {
-    mockGet.mockReturnValue(mockEndpoints);
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it(`returns if endpoints are present in cacheKey`, async () => {
-    // @ts-ignore
-    await updateDiscoveredEndpointInCache(config, options);
-    expect(mockGet).toHaveBeenCalledWith(cacheKey);
-    expect(mockSet).not.toHaveBeenCalled();
-    expect(mockDelete).not.toHaveBeenCalled();
-  });
-
-  describe("calls endpointDiscoveryCommandCtor", () => {
-    beforeEach(() => {
-      mockGet.mockReturnValue(undefined);
-    });
-
-    const verifyCallsOnCacheUndefined = () => {
-      expect(mockGet).toHaveBeenCalledTimes(1);
-
-      expect(options.endpointDiscoveryCommandCtor).toHaveBeenCalledWith({
-        Operation: options.commandName.substr(0, options.commandName.length - 7),
-        Identifiers: options.identifiers,
-      });
-      expect(mockHandler).toHaveBeenCalledTimes(1);
-    };
-
-    it("on successful call: updates cache", async () => {
-      mockHandler.mockResolvedValueOnce({ output: { Endpoints: mockEndpoints } });
-
-      // @ts-ignore
-      await updateDiscoveredEndpointInCache(config, options);
-
-      verifyCallsOnCacheUndefined();
-      expect(mockDelete).not.toHaveBeenCalled();
-      expect(mockSet).toHaveBeenCalledTimes(2);
-      expect(mockSet).toHaveBeenNthCalledWith(1, cacheKey, placeholderEndpoints);
-      expect(mockSet).toHaveBeenNthCalledWith(2, cacheKey, mockEndpoints);
-    });
-
-    it("calls endpointDiscoveryCommandCtor command just once in case of parallel calls", async () => {
-      mockHandler.mockResolvedValueOnce({ output: { Endpoints: mockEndpoints } });
-      // First call returns undefined, while other ones return placeholder endpoints a call is in progress
-      mockGet
-        .mockReturnValueOnce(undefined)
-        .mockReturnValueOnce(placeholderEndpoints)
-        .mockReturnValueOnce(placeholderEndpoints);
-
-      await Promise.all([
-        // @ts-ignore
-        updateDiscoveredEndpointInCache(config, options),
-        // @ts-ignore
-        updateDiscoveredEndpointInCache(config, options),
-        // @ts-ignore
-        updateDiscoveredEndpointInCache(config, options),
-      ]);
-
-      expect(mockGet).toHaveBeenCalledTimes(3);
-
-      expect(options.endpointDiscoveryCommandCtor).toHaveBeenCalledWith({
-        Operation: options.commandName.substr(0, options.commandName.length - 7),
-        Identifiers: options.identifiers,
-      });
-      expect(mockHandler).toHaveBeenCalledTimes(1);
-
-      expect(mockDelete).not.toHaveBeenCalled();
-      expect(mockSet).toHaveBeenCalledTimes(2);
-      expect(mockSet).toHaveBeenNthCalledWith(1, cacheKey, placeholderEndpoints);
-      expect(mockSet).toHaveBeenNthCalledWith(2, cacheKey, mockEndpoints);
-    });
-
-    describe("on error", () => {
-      it(`throws if isDiscoveredEndpointRequired=true`, async () => {
-        const error = new Error("rejected");
-        mockHandler.mockRejectedValueOnce(error);
-
-        try {
-          // @ts-ignore
-          await updateDiscoveredEndpointInCache(config, { ...options, isDiscoveredEndpointRequired: true });
-          fail("updateDiscoveredEndpointInCache should throw");
-        } catch (error) {
-          expect(error).toEqual(
-            Object.assign(
-              new Error(
-                `The operation to discover endpoint failed.` +
-                  ` Please retry, or provide a custom endpoint and disable endpoint discovery to proceed.`
-              ),
-              { reason: error }
-            )
-          );
-        }
-        verifyCallsOnCacheUndefined();
-        expect(mockDelete).not.toHaveBeenCalled();
-        expect(mockSet).toHaveBeenCalledTimes(1);
-        expect(mockSet).toHaveBeenCalledWith(cacheKey, placeholderEndpoints);
-      });
-
-      it(`sets placeholder enpoint if isDiscoveredEndpointRequired=false`, async () => {
-        const error = new Error("rejected");
-        mockHandler.mockRejectedValueOnce(error);
-
-        // @ts-ignore
-        await updateDiscoveredEndpointInCache(config, options);
-
-        verifyCallsOnCacheUndefined();
-        expect(mockDelete).not.toHaveBeenCalled();
-        expect(mockSet).toHaveBeenCalledTimes(2);
-        expect(mockSet).toHaveBeenNthCalledWith(1, cacheKey, placeholderEndpoints);
-        expect(mockSet).toHaveBeenNthCalledWith(2, cacheKey, placeholderEndpoints);
-      });
-
-      describe(`deletes cacheKey in case of`, () => {
-        const verifyCallsOnCacheKeyDelete = () => {
-          expect(mockDelete).toHaveBeenCalledWith(cacheKey);
-          expect(mockSet).toHaveBeenCalledTimes(2);
-          expect(mockSet).toHaveBeenNthCalledWith(1, cacheKey, placeholderEndpoints);
-          expect(mockSet).toHaveBeenNthCalledWith(2, cacheKey, placeholderEndpoints);
-        };
-
-        it(`InvalidEndpointException`, async () => {
-          const error = Object.assign(new Error("Invalid endpoint!"), { name: "InvalidEndpointException" });
-          mockHandler.mockRejectedValueOnce(error);
-
-          // @ts-ignore
-          await updateDiscoveredEndpointInCache(config, options);
-          verifyCallsOnCacheUndefined();
-          verifyCallsOnCacheKeyDelete();
-        });
-
-        it(`Status code: 421`, async () => {
-          const error = Object.assign(new Error("Invalid endpoint!"), { $metadata: { httpStatusCode: 421 } });
-          mockHandler.mockRejectedValueOnce(error);
-
-          // @ts-ignore
-          await updateDiscoveredEndpointInCache(config, options);
-          verifyCallsOnCacheUndefined();
-          verifyCallsOnCacheKeyDelete();
-        });
-      });
-    });
-  });
-});