chore(config-resolver): remove isFipsRegion check from getResolvedSigningRegion

Author: trivikr

packages/config-resolver/src/regionInfo/getRegionInfo.spec.ts

@@ -105,9 +105,9 @@ describe(getRegionInfo.name, () => {
         partitionHostname: mockPartitionHostname,
       });
       expect(getResolvedPartition).toHaveBeenCalledWith(mockRegion, mockGetResolvedPartitionOptions);
-      expect(getResolvedSigningRegion).toHaveBeenCalledWith(mockRegion, {
-        hostname: mockHostname,
+      expect(getResolvedSigningRegion).toHaveBeenCalledWith(mockHostname, {
         regionRegex: mockRegionRegex,
+        useFipsEndpoint: false,
       });
     });
   });
@@ -169,10 +169,10 @@ describe(getRegionInfo.name, () => {
         partitionHostname: mockPartitionHostname,
       });
       expect(getResolvedPartition).toHaveBeenCalledWith(mockRegion, mockGetResolvedPartitionOptions);
-      expect(getResolvedSigningRegion).toHaveBeenCalledWith(mockRegion, {
-        hostname: mockHostname,
+      expect(getResolvedSigningRegion).toHaveBeenCalledWith(mockHostname, {
         signingRegion: mockSigningRegion,
         regionRegex: mockRegionRegex,
+        useFipsEndpoint: false,
       });
     });
   });
@@ -232,9 +232,9 @@ describe(getRegionInfo.name, () => {
         partitionHostname: mockPartitionHostname,
       });
       expect(getResolvedPartition).toHaveBeenCalledWith(mockRegion, mockGetResolvedPartitionOptions);
-      expect(getResolvedSigningRegion).toHaveBeenCalledWith(mockRegion, {
-        hostname: mockHostname,
+      expect(getResolvedSigningRegion).toHaveBeenCalledWith(mockHostname, {
         regionRegex: mockRegionRegex,
+        useFipsEndpoint: false,
       });
     });
   });

packages/config-resolver/src/regionInfo/getRegionInfo.ts

@@ -37,10 +37,10 @@ export const getRegionInfo = (
     throw new Error(`Endpoint resolution failed for: ${{ resolvedRegion, useFipsEndpoint, useDualstackEndpoint }}`);
   }
 
-  const signingRegion = getResolvedSigningRegion(region, {
-    hostname,
+  const signingRegion = getResolvedSigningRegion(hostname, {
     signingRegion: regionHash[resolvedRegion]?.signingRegion,
     regionRegex: partitionHash[partition].regionRegex,
+    useFipsEndpoint,
   });
 
   return {

packages/config-resolver/src/regionInfo/getResolvedSigningRegion.spec.ts

@@ -1,80 +1,55 @@
-import { isFipsRegion } from "../regionConfig/isFipsRegion";
 import { getResolvedSigningRegion } from "./getResolvedSigningRegion";
 
-jest.mock("../regionConfig/isFipsRegion");
-
 describe(getResolvedSigningRegion.name, () => {
-  const mockRegion = "mockRegion";
   const mockSigningRegion = "mockSigningRegion";
   const mockHostname = "mockHostname";
   const mockRegionRegex = "mockRegionRegex";
 
   const mockOptions = {
-    hostname: mockHostname,
     regionRegex: mockRegionRegex,
+    useFipsEndpoint: false,
   };
 
-  beforeEach(() => {
-    (isFipsRegion as jest.Mock).mockReturnValue(false);
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
   it("returns signingRegion if passed in options", () => {
-    expect(getResolvedSigningRegion(mockRegion, { ...mockOptions, signingRegion: mockSigningRegion })).toEqual(
+    expect(getResolvedSigningRegion(mockHostname, { ...mockOptions, signingRegion: mockSigningRegion })).toEqual(
       mockSigningRegion
     );
-    expect(isFipsRegion).not.toHaveBeenCalled();
   });
 
   describe("returns undefined if signingRegion is not present and", () => {
     it("region is not FIPS", () => {
-      expect(getResolvedSigningRegion(mockRegion, mockOptions)).not.toBeDefined();
-      expect(isFipsRegion).toHaveBeenCalledTimes(1);
-      expect(isFipsRegion).toHaveBeenCalledWith(mockRegion);
+      expect(getResolvedSigningRegion(mockHostname, mockOptions)).not.toBeDefined();
     });
 
     it("regionRegex does not return a match in hostname", () => {
-      (isFipsRegion as jest.Mock).mockReturnValueOnce(true);
       const matchSpy = jest.spyOn(String.prototype, "match").mockReturnValueOnce(null);
 
-      expect(getResolvedSigningRegion(mockRegion, mockOptions)).not.toBeDefined();
+      expect(getResolvedSigningRegion(mockHostname, { ...mockOptions, useFipsEndpoint: true })).not.toBeDefined();
       expect(matchSpy).toHaveBeenCalledTimes(1);
       expect(matchSpy).toHaveBeenCalledWith(mockRegionRegex);
-      expect(isFipsRegion).toHaveBeenCalledTimes(1);
-      expect(isFipsRegion).toHaveBeenCalledWith(mockRegion);
     });
 
     it("region is not present between dots in a hostname", () => {
       const regionInHostname = "us-east-1";
-      (isFipsRegion as jest.Mock).mockReturnValueOnce(true);
 
       expect(
-        getResolvedSigningRegion(mockRegion, {
+        getResolvedSigningRegion(`test-${regionInHostname}.amazonaws.com`, {
           ...mockOptions,
-          hostname: `test-${regionInHostname}.amazonaws.com`,
           regionRegex: "^(us|eu|ap|sa|ca|me|af)\\-\\w+\\-\\d+$",
         })
       ).not.toBeDefined();
-      expect(isFipsRegion).toHaveBeenCalledTimes(1);
-      expect(isFipsRegion).toHaveBeenCalledWith(mockRegion);
     });
   });
 
   it("returns region from hostname if signingRegion is not present", () => {
     const regionInHostname = "us-east-1";
-    (isFipsRegion as jest.Mock).mockReturnValueOnce(true);
 
     expect(
-      getResolvedSigningRegion(mockRegion, {
+      getResolvedSigningRegion(`test.${regionInHostname}.amazonaws.com`, {
         ...mockOptions,
-        hostname: `test.${regionInHostname}.amazonaws.com`,
         regionRegex: "^(us|eu|ap|sa|ca|me|af)\\-\\w+\\-\\d+$",
+        useFipsEndpoint: true,
       })
     ).toEqual(regionInHostname);
-    expect(isFipsRegion).toHaveBeenCalledTimes(1);
-    expect(isFipsRegion).toHaveBeenCalledWith(mockRegion);
   });
 });

packages/config-resolver/src/regionInfo/getResolvedSigningRegion.ts

@@ -1,18 +1,16 @@
-import { isFipsRegion } from "../regionConfig/isFipsRegion";
-
 export interface GetResolvedSigningRegionOptions {
-  hostname: string;
   regionRegex: string;
   signingRegion?: string;
+  useFipsEndpoint: boolean;
 }
 
 export const getResolvedSigningRegion = (
-  region: string,
-  { hostname, signingRegion, regionRegex }: GetResolvedSigningRegionOptions
+  hostname: string,
+  { signingRegion, regionRegex, useFipsEndpoint }: GetResolvedSigningRegionOptions
 ) => {
   if (signingRegion) {
     return signingRegion;
-  } else if (isFipsRegion(region)) {
+  } else if (useFipsEndpoint) {
     const regionRegexJs = regionRegex.replace("\\\\", "\\").replace(/^\^/g, "\\.").replace(/\$$/g, "\\.");
     const regionRegexmatchArray = hostname.match(regionRegexJs);
     if (regionRegexmatchArray) {