test(middleware-flexible-checksums): flexibleChecksumsResponseMiddlew…

…are.spec.ts (#5342)

packages/middleware-flexible-checksums/src/flexibleChecksumsMiddleware.spec.ts

@@ -1,17 +1,15 @@
 import { HttpRequest } from "@smithy/protocol-http";
-import { BuildHandlerArguments, DeserializeHandlerArguments } from "@smithy/types";
+import { BuildHandlerArguments } from "@smithy/types";
 
 import { PreviouslyResolved } from "./configuration";
 import { ChecksumAlgorithm } from "./constants";
 import { flexibleChecksumsMiddleware } from "./flexibleChecksumsMiddleware";
-import { flexibleChecksumsResponseMiddleware } from "./flexibleChecksumsResponseMiddleware";
 import { getChecksumAlgorithmForRequest } from "./getChecksumAlgorithmForRequest";
 import { getChecksumLocationName } from "./getChecksumLocationName";
 import { hasHeader } from "./hasHeader";
 import { isStreaming } from "./isStreaming";
 import { selectChecksumAlgorithmFunction } from "./selectChecksumAlgorithmFunction";
 import { stringHasher } from "./stringHasher";
-import { validateChecksumFromResponse } from "./validateChecksumFromResponse";
 
 jest.mock("@smithy/protocol-http");
 jest.mock("./getChecksumAlgorithmForRequest");
@@ -20,7 +18,6 @@ jest.mock("./hasHeader");
 jest.mock("./isStreaming");
 jest.mock("./selectChecksumAlgorithmFunction");
 jest.mock("./stringHasher");
-jest.mock("./validateChecksumFromResponse");
 
 describe(flexibleChecksumsMiddleware.name, () => {
   const mockNext = jest.fn();
@@ -92,24 +89,6 @@ describe(flexibleChecksumsMiddleware.name, () => {
         expect(hasHeader).toHaveBeenCalledWith(mockChecksumLocationName, mockHeadersWithChecksumHeader);
       });
     });
-
-    describe("response validation", () => {
-      it("if requestValidationModeMember is not defined", async () => {
-        const handler = flexibleChecksumsMiddleware(mockConfig, mockMiddlewareConfig)(mockNext, {});
-        await handler(mockArgs);
-        expect(validateChecksumFromResponse).not.toHaveBeenCalled();
-      });
-
-      it("if requestValidationModeMember is not set to 'ENABLED' in input", async () => {
-        const mockRequestValidationModeMember = "mockRequestValidationModeMember";
-        const handler = flexibleChecksumsMiddleware(mockConfig, {
-          ...mockMiddlewareConfig,
-          requestValidationModeMember: mockRequestValidationModeMember,
-        })(mockNext, {});
-        await handler(mockArgs);
-        expect(validateChecksumFromResponse).not.toHaveBeenCalled();
-      });
-    });
   });
 
   describe("adds checksum in the request header", () => {
@@ -189,23 +168,4 @@ describe(flexibleChecksumsMiddleware.name, () => {
       expect(mockBase64Encoder).toHaveBeenCalledWith(mockRawChecksum);
     });
   });
-
-  it("validates checksum from the response header", async () => {
-    const mockRequestValidationModeMember = "mockRequestValidationModeMember";
-    const mockInput = { [mockRequestValidationModeMember]: "ENABLED" };
-    const mockResponseAlgorithms = ["ALGO1", "ALGO2"];
-
-    const responseHandler = flexibleChecksumsResponseMiddleware(mockConfig, {
-      ...mockMiddlewareConfig,
-      input: mockInput,
-      requestValidationModeMember: mockRequestValidationModeMember,
-      responseAlgorithms: mockResponseAlgorithms,
-    })(mockNext, {});
-
-    await responseHandler({ ...mockArgs, input: mockInput } as DeserializeHandlerArguments<any>);
-    expect(validateChecksumFromResponse).toHaveBeenCalledWith(mockResult.response, {
-      config: mockConfig,
-      responseAlgorithms: mockResponseAlgorithms,
-    });
-  });
 });

packages/middleware-flexible-checksums/src/flexibleChecksumsResponseMiddleware.spec.ts

@@ -0,0 +1,84 @@
+import { HttpRequest } from "@smithy/protocol-http";
+import { DeserializeHandlerArguments } from "@smithy/types";
+
+import { PreviouslyResolved } from "./configuration";
+import { flexibleChecksumsResponseMiddleware } from "./flexibleChecksumsResponseMiddleware";
+import { FlexibleChecksumsMiddlewareConfig } from "./getFlexibleChecksumsPlugin";
+import { isStreaming } from "./isStreaming";
+import { validateChecksumFromResponse } from "./validateChecksumFromResponse";
+
+jest.mock("@smithy/protocol-http");
+jest.mock("./isStreaming");
+jest.mock("./validateChecksumFromResponse");
+
+describe(flexibleChecksumsResponseMiddleware.name, () => {
+  const mockNext = jest.fn();
+
+  const mockInput = {};
+  const mockConfig = {} as PreviouslyResolved;
+  const mockRequestValidationModeMember = "ChecksumEnabled";
+  const mockMiddlewareConfig = {
+    input: mockInput,
+    requestChecksumRequired: false,
+    requestValidationModeMember: mockRequestValidationModeMember,
+  };
+
+  const mockRequest = {};
+  const mockArgs = { input: mockInput, request: mockRequest } as DeserializeHandlerArguments<any>;
+  const mockResult = { response: { body: "mockResponsebody" } };
+
+  beforeEach(() => {
+    mockNext.mockResolvedValueOnce(mockResult);
+    const { isInstance } = HttpRequest;
+    (isInstance as unknown as jest.Mock).mockReturnValue(true);
+    (isStreaming as jest.Mock).mockReturnValue(false);
+  });
+
+  afterEach(() => {
+    expect(mockNext).toHaveBeenCalledTimes(1);
+    jest.clearAllMocks();
+  });
+
+  describe("skips", () => {
+    it("if not an instance of HttpRequest", async () => {
+      const { isInstance } = HttpRequest;
+      (isInstance as unknown as jest.Mock).mockReturnValue(false);
+      const handler = flexibleChecksumsResponseMiddleware(mockConfig, mockMiddlewareConfig)(mockNext, {});
+      await handler(mockArgs);
+      expect(validateChecksumFromResponse).not.toHaveBeenCalled();
+    });
+
+    describe("response checksum", () => {
+      it("if requestValidationModeMember is not defined", async () => {
+        const mockMwConfig = Object.assign({}, mockMiddlewareConfig) as FlexibleChecksumsMiddlewareConfig;
+        delete mockMwConfig.requestValidationModeMember;
+        const handler = flexibleChecksumsResponseMiddleware(mockConfig, mockMwConfig)(mockNext, {});
+        await handler(mockArgs);
+        expect(validateChecksumFromResponse).not.toHaveBeenCalled();
+      });
+
+      it("if requestValidationModeMember is not enabled in input", async () => {
+        const handler = flexibleChecksumsResponseMiddleware(mockConfig, mockMiddlewareConfig)(mockNext, {});
+        await handler(mockArgs);
+        expect(validateChecksumFromResponse).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  it("validates checksum from the response header", async () => {
+    const mockInput = { [mockRequestValidationModeMember]: "ENABLED" };
+    const mockResponseAlgorithms = ["ALGO1", "ALGO2"];
+
+    const handler = flexibleChecksumsResponseMiddleware(mockConfig, {
+      ...mockMiddlewareConfig,
+      input: mockInput,
+      responseAlgorithms: mockResponseAlgorithms,
+    })(mockNext, {});
+
+    await handler({ ...mockArgs, input: mockInput });
+    expect(validateChecksumFromResponse).toHaveBeenCalledWith(mockResult.response, {
+      config: mockConfig,
+      responseAlgorithms: mockResponseAlgorithms,
+    });
+  });
+});