feat: simplify and add extensive tests got config-resolver (#1401)

Author: trivikr

packages/config-resolver/src/EndpointsConfig.spec.ts

@@ -0,0 +1,113 @@
+import { Endpoint } from "@aws-sdk/types";
+
+import { resolveEndpointsConfig } from "./EndpointsConfig";
+
+describe("EndpointsConfig", () => {
+  const region = jest.fn();
+  const urlParser = jest.fn();
+  const regionInfoProvider = jest.fn();
+
+  const input = { region, urlParser, regionInfoProvider };
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("tls", () => {
+    [true, false].forEach((tls) => {
+      it(`returns input.tls when it's ${tls}`, () => {
+        expect(resolveEndpointsConfig({ ...input, tls }).tls).toStrictEqual(tls);
+      });
+    });
+
+    it("returns true is input.tls is undefined", () => {
+      expect(resolveEndpointsConfig({ ...input }).tls).toStrictEqual(true);
+    });
+  });
+
+  describe("endpoint", () => {
+    describe("if defined in input.endpoint", () => {
+      const mockEndpoint: Endpoint = { protocol: "protocol", hostname: "hostname", path: "path" };
+
+      it("returns output of urlParser if endpoint is of type string", async () => {
+        const endpoint = "endpoint";
+        urlParser.mockReturnValueOnce(mockEndpoint);
+        const endpointOutput = await resolveEndpointsConfig({ ...input, endpoint }).endpoint();
+        expect(endpointOutput).toStrictEqual(mockEndpoint);
+        expect(urlParser).toHaveBeenCalledTimes(1);
+        expect(urlParser).toHaveBeenCalledWith(endpoint);
+      });
+
+      it("returns promisified endpoint if it's of type object", async () => {
+        const endpoint = mockEndpoint;
+        const endpointOutput = await resolveEndpointsConfig({ ...input, endpoint }).endpoint();
+        expect(endpointOutput).toStrictEqual(endpoint);
+        expect(urlParser).not.toHaveBeenCalled();
+      });
+
+      it("returns endpoint if it's already Provider<Endpoint>", async () => {
+        const endpoint = () => Promise.resolve(mockEndpoint);
+        const endpointOutput = await resolveEndpointsConfig({ ...input, endpoint }).endpoint();
+        expect(endpointOutput).toStrictEqual(mockEndpoint);
+        expect(urlParser).not.toHaveBeenCalled();
+      });
+    });
+
+    describe("if not defined in input.endpoint", () => {
+      const mockRegion = "mockRegion";
+      const mockHostname = "mockHostname";
+      const mockEndpoint: Endpoint = { protocol: "protocol", hostname: "hostname", path: "path" };
+
+      describe("returns endpoint", () => {
+        beforeEach(() => {
+          region.mockResolvedValueOnce(mockRegion);
+          regionInfoProvider.mockResolvedValueOnce({ hostname: mockHostname });
+          urlParser.mockReturnValueOnce(mockEndpoint);
+        });
+
+        it("passes http in urlParser if tls is false", async () => {
+          const endpoint = await resolveEndpointsConfig({ ...input, tls: false }).endpoint();
+          expect(endpoint).toStrictEqual(mockEndpoint);
+          expect(urlParser).toHaveBeenCalledTimes(1);
+          expect(urlParser).toHaveBeenCalledWith(`http://${mockHostname}`);
+        });
+
+        [true, undefined].forEach((tls) => {
+          it(`passes https in urlParser if tls is ${tls}`, async () => {
+            const endpoint = await resolveEndpointsConfig({ ...input, tls }).endpoint();
+            expect(endpoint).toStrictEqual(mockEndpoint);
+            expect(urlParser).toHaveBeenCalledTimes(1);
+            expect(urlParser).toHaveBeenCalledWith(`https://${mockHostname}`);
+          });
+        });
+      });
+
+      describe("throws error", () => {
+        const error = new Error("error");
+
+        it("if region throws error", () => {
+          region.mockRejectedValueOnce(error);
+          return expect(resolveEndpointsConfig(input).endpoint()).rejects.toStrictEqual(error);
+        });
+
+        describe("if regionInfoProvider", () => {
+          beforeEach(() => {
+            region.mockResolvedValueOnce(mockRegion);
+          });
+
+          it("throws error", () => {
+            regionInfoProvider.mockRejectedValueOnce(error);
+            return expect(resolveEndpointsConfig(input).endpoint()).rejects.toStrictEqual(error);
+          });
+
+          it("returns undefined", () => {
+            regionInfoProvider.mockResolvedValueOnce(undefined);
+            return expect(resolveEndpointsConfig(input).endpoint()).rejects.toStrictEqual(
+              new Error("Cannot resolve hostname from client config")
+            );
+          });
+        });
+      });
+    });
+  });
+});

packages/config-resolver/src/EndpointsConfig.ts

@@ -1,18 +1,4 @@
-import { Endpoint, Provider, RegionInfo, RegionInfoProvider, UrlParser } from "@aws-sdk/types";
-
-export function normalizeEndpoint(
-  endpoint?: string | Endpoint | Provider<Endpoint>,
-  urlParser?: UrlParser
-): Provider<Endpoint> {
-  if (typeof endpoint === "string") {
-    const promisified = Promise.resolve(urlParser!(endpoint));
-    return () => promisified;
-  } else if (typeof endpoint === "object") {
-    const promisified = Promise.resolve(endpoint);
-    return () => promisified;
-  }
-  return endpoint!;
-}
+import { Endpoint, Provider, RegionInfoProvider, UrlParser } from "@aws-sdk/types";
 
 export interface EndpointsInputConfig {
   /**
@@ -25,32 +11,43 @@ export interface EndpointsInputConfig {
    */
   tls?: boolean;
 }
+
 interface PreviouslyResolved {
   regionInfoProvider: RegionInfoProvider;
   urlParser: UrlParser;
   region: Provider<string>;
 }
+
 export interface EndpointsResolvedConfig extends Required<EndpointsInputConfig> {
   endpoint: Provider<Endpoint>;
 }
-export function resolveEndpointsConfig<T>(
+
+export const resolveEndpointsConfig = <T>(
   input: T & EndpointsInputConfig & PreviouslyResolved
-): T & EndpointsResolvedConfig {
-  const tls = input.tls === undefined ? true : input.tls;
-  const endpoint: Provider<Endpoint> = input.endpoint
-    ? normalizeEndpoint(input.endpoint, input.urlParser)
-    : () =>
-        input.region().then(async (region) => {
-          const hostname = ((await input.regionInfoProvider(region)) || ({} as RegionInfo)).hostname;
-          if (!hostname) {
-            throw new Error("Cannot resolve hostname from client config");
-          }
-          const endpoint = input.urlParser(`${tls ? "https:" : "http:"}//${hostname}`);
-          return endpoint;
-        });
-  return {
-    ...input,
-    endpoint,
-    tls,
-  };
-}
+): T & EndpointsResolvedConfig => ({
+  ...input,
+  tls: input.tls ?? true,
+  endpoint: input.endpoint ? normalizeEndpoint(input) : () => getEndPointFromRegion(input),
+});
+
+const normalizeEndpoint = (input: EndpointsInputConfig & PreviouslyResolved): Provider<Endpoint> => {
+  const { endpoint, urlParser } = input;
+  if (typeof endpoint === "string") {
+    const promisified = Promise.resolve(urlParser(endpoint));
+    return () => promisified;
+  } else if (typeof endpoint === "object") {
+    const promisified = Promise.resolve(endpoint);
+    return () => promisified;
+  }
+  return endpoint!;
+};
+
+const getEndPointFromRegion = async (input: EndpointsInputConfig & PreviouslyResolved) => {
+  const { tls = true } = input;
+  const region = await input.region();
+  const { hostname } = (await input.regionInfoProvider(region)) ?? {};
+  if (!hostname) {
+    throw new Error("Cannot resolve hostname from client config");
+  }
+  return input.urlParser(`${tls ? "https:" : "http:"}//${hostname}`);
+};

packages/config-resolver/src/RegionConfig.spec.ts

@@ -0,0 +1,27 @@
+import { resolveRegionConfig } from "./RegionConfig";
+
+describe("RegionConfig", () => {
+  const regionDefaultProvider = jest.fn();
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("assigns input region if present", async () => {
+    const region = "us-west-2";
+    const output = await resolveRegionConfig({ region, regionDefaultProvider }).region();
+    expect(output).toStrictEqual(region);
+    expect(regionDefaultProvider).not.toHaveBeenCalled();
+  });
+
+  it("assigns value returned by regionDefaultProvider if region not present", () => {
+    const mockRegion = jest.fn();
+    regionDefaultProvider.mockReturnValueOnce(mockRegion);
+
+    const input = { regionDefaultProvider };
+    expect(resolveRegionConfig(input).region).toStrictEqual(mockRegion);
+
+    expect(regionDefaultProvider).toHaveBeenCalledTimes(1);
+    expect(regionDefaultProvider).toHaveBeenCalledWith(input);
+  });
+});

packages/config-resolver/src/RegionConfig.ts

@@ -6,24 +6,27 @@ export interface RegionInputConfig {
    */
   region?: string | Provider<string>;
 }
+
 interface PreviouslyResolved {
   regionDefaultProvider: (input: any) => Provider<string>;
 }
+
 export interface RegionResolvedConfig {
   region: Provider<string>;
 }
-export function resolveRegionConfig<T>(input: T & RegionInputConfig & PreviouslyResolved): T & RegionResolvedConfig {
+
+export const resolveRegionConfig = <T>(input: T & RegionInputConfig & PreviouslyResolved): T & RegionResolvedConfig => {
   const region = input.region || input.regionDefaultProvider(input as any);
   return {
     ...input,
     region: normalizeRegion(region),
   };
-}
+};
 
-function normalizeRegion(region: string | Provider<string>): Provider<string> {
+const normalizeRegion = (region: string | Provider<string>): Provider<string> => {
   if (typeof region === "string") {
     const promisified = Promise.resolve(region);
     return () => promisified;
   }
   return region as Provider<string>;
-}
+};