Skip to content

Commit 317926c

Browse files
trivikrtrivikr
committed
chore: populate requestAlgorithmMemberwhen conditions are met
It sets input[requestAlgorithmMember] to default checksum algorithm if it's not set and either requestChecksumCalculation is supported or requestChecksumRequired is set to true.
1 parent bcffb1b commit 317926c

File tree

2 files changed

+164
-26
lines changed

2 files changed

+164
-26
lines changed

‎packages/middleware-flexible-checksums/src/flexibleChecksumsInputMiddleware.spec.ts‎

Lines changed: 119 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -2,17 +2,20 @@ import { setFeature } from "@aws-sdk/core";
22
import { afterEach, describe, expect, test as it, vi } from "vitest";
33

44
import { PreviouslyResolved } from "./configuration";
5-
import { ResponseChecksumValidation } from "./constants";
5+
import { DEFAULT_CHECKSUM_ALGORITHM, RequestChecksumCalculation, ResponseChecksumValidation } from "./constants";
66
import { flexibleChecksumsInputMiddleware } from "./flexibleChecksumsInputMiddleware";
77

88
vi.mock("@aws-sdk/core");
99

1010
describe(flexibleChecksumsInputMiddleware.name, () => {
1111
const mockNext = vi.fn();
12-
const mockMiddlewareConfig = {
13-
requestValidationModeMember: "requestValidationModeMember",
14-
};
12+
13+
const mockRequestAlgorithmMember = "mockRequestAlgorithmMember";
14+
const mockRequestValidationModeMember = "mockRequestValidationModeMember";
15+
const mockMiddlewareConfig = { requestChecksumRequired: false };
16+
1517
const mockConfig = {
18+
requestChecksumCalculation: () => Promise.resolve(RequestChecksumCalculation.WHEN_SUPPORTED),
1619
responseChecksumValidation: () => Promise.resolve(ResponseChecksumValidation.WHEN_SUPPORTED),
1720
} as PreviouslyResolved;
1821

@@ -21,32 +24,100 @@ describe(flexibleChecksumsInputMiddleware.name, () => {
2124
vi.clearAllMocks();
2225
});
2326

27+
describe("sets input.requestAlgorithmMember", () => {
28+
describe("input[requestAlgorithmMember] is not defined and", () => {
29+
const mockMiddlewareConfigWithRequestAlgorithmMember = {
30+
...mockMiddlewareConfig,
31+
requestAlgorithmMember: mockRequestAlgorithmMember,
32+
};
33+
34+
it("requestChecksumCalculation is supported", async () => {
35+
const handler = flexibleChecksumsInputMiddleware(mockConfig, mockMiddlewareConfigWithRequestAlgorithmMember)(
36+
mockNext,
37+
{}
38+
);
39+
await handler({ input: {} });
40+
expect(mockNext).toHaveBeenCalledWith({ input: { [mockRequestAlgorithmMember]: DEFAULT_CHECKSUM_ALGORITHM } });
41+
});
42+
43+
it("requestChecksumRequired is set to true", async () => {
44+
const mockConfigWithReqChecksumCalculationWhenRequired = {
45+
...mockConfig,
46+
requestChecksumCalculation: () => Promise.resolve(RequestChecksumCalculation.WHEN_REQUIRED),
47+
};
48+
49+
const handler = flexibleChecksumsInputMiddleware(mockConfigWithReqChecksumCalculationWhenRequired, {
50+
...mockMiddlewareConfigWithRequestAlgorithmMember,
51+
requestChecksumRequired: true,
52+
})(mockNext, {});
53+
54+
await handler({ input: {} });
55+
expect(mockNext).toHaveBeenCalledWith({ input: { [mockRequestAlgorithmMember]: DEFAULT_CHECKSUM_ALGORITHM } });
56+
});
57+
});
58+
});
59+
60+
describe("leaves input.requestAlgorithmMember", () => {
61+
const mockMiddlewareConfigWithRequestAlgorithmMember = {
62+
...mockMiddlewareConfig,
63+
requestAlgorithmMember: mockRequestAlgorithmMember,
64+
};
65+
66+
it("when input[requestAlgorithmMember] is defined", async () => {
67+
const handler = flexibleChecksumsInputMiddleware(mockConfig, mockMiddlewareConfigWithRequestAlgorithmMember)(
68+
mockNext,
69+
{}
70+
);
71+
await handler({ input: { [mockRequestAlgorithmMember]: "SHA256" } });
72+
expect(mockNext).toHaveBeenCalledWith({ input: { [mockRequestAlgorithmMember]: "SHA256" } });
73+
});
74+
75+
it("if requestChecksumCalculation is required and requestChecksumRequired is false", async () => {
76+
const mockConfigReqChecksumCalculationWhenRequired = {
77+
...mockConfig,
78+
requestChecksumCalculation: () => Promise.resolve(RequestChecksumCalculation.WHEN_REQUIRED),
79+
} as PreviouslyResolved;
80+
81+
const handler = flexibleChecksumsInputMiddleware(
82+
mockConfigReqChecksumCalculationWhenRequired,
83+
mockMiddlewareConfigWithRequestAlgorithmMember
84+
)(mockNext, {});
85+
await handler({ input: {} });
86+
expect(mockNext).toHaveBeenCalledWith({ input: {} });
87+
});
88+
});
89+
2490
describe("sets input.requestValidationModeMember", () => {
2591
it("when requestValidationModeMember is defined and responseChecksumValidation is supported", async () => {
26-
const handler = flexibleChecksumsInputMiddleware(mockConfig, mockMiddlewareConfig)(mockNext, {});
92+
const mockMiddlewareConfigWithMockRequestValidationModeMember = {
93+
...mockMiddlewareConfig,
94+
requestValidationModeMember: mockRequestValidationModeMember,
95+
};
96+
const handler = flexibleChecksumsInputMiddleware(
97+
mockConfig,
98+
mockMiddlewareConfigWithMockRequestValidationModeMember
99+
)(mockNext, {});
27100
await handler({ input: {} });
28-
expect(mockNext).toHaveBeenCalledWith({ input: { requestValidationModeMember: "ENABLED" } });
101+
expect(mockNext).toHaveBeenCalledWith({ input: { [mockRequestValidationModeMember]: "ENABLED" } });
29102
});
30103
});
31104

32105
describe("leaves input.requestValidationModeMember", () => {
33106
const mockArgs = { input: {} };
34107

35108
it("when requestValidationModeMember is not defined", async () => {
36-
const mockMiddlewareConfig = {};
37-
38109
const handler = flexibleChecksumsInputMiddleware(mockConfig, mockMiddlewareConfig)(mockNext, {});
39110
await handler(mockArgs);
40-
41111
expect(mockNext).toHaveBeenCalledWith(mockArgs);
42112
});
43113

44114
it("when responseChecksumValidation is required", async () => {
45-
const mockConfig = {
115+
const mockConfigResWhenRequired = {
116+
...mockConfig,
46117
responseChecksumValidation: () => Promise.resolve(ResponseChecksumValidation.WHEN_REQUIRED),
47118
} as PreviouslyResolved;
48119

49-
const handler = flexibleChecksumsInputMiddleware(mockConfig, mockMiddlewareConfig)(mockNext, {});
120+
const handler = flexibleChecksumsInputMiddleware(mockConfigResWhenRequired, mockMiddlewareConfig)(mockNext, {});
50121
await handler(mockArgs);
51122

52123
expect(mockNext).toHaveBeenCalledWith(mockArgs);
@@ -55,15 +126,45 @@ describe(flexibleChecksumsInputMiddleware.name, () => {
55126

56127
describe("set feature", () => {
57128
it.each([
58-
["FLEXIBLE_CHECKSUMS_RES_WHEN_REQUIRED", "c", ResponseChecksumValidation.WHEN_REQUIRED],
59-
["FLEXIBLE_CHECKSUMS_RES_WHEN_SUPPORTED", "b", ResponseChecksumValidation.WHEN_SUPPORTED],
60-
])("logs %s and %s when ResponseChecksumValidation=%s", async (feature, value, responseChecksumValidation) => {
61-
const mockConfig = {
62-
responseChecksumValidation: () => Promise.resolve(responseChecksumValidation),
129+
[
130+
"FLEXIBLE_CHECKSUMS_REQ_WHEN_REQUIRED",
131+
"a",
132+
"requestChecksumCalculation",
133+
RequestChecksumCalculation.WHEN_REQUIRED,
134+
],
135+
[
136+
"FLEXIBLE_CHECKSUMS_REQ_WHEN_SUPPORTED",
137+
"Z",
138+
"requestChecksumCalculation",
139+
RequestChecksumCalculation.WHEN_SUPPORTED,
140+
],
141+
[
142+
"FLEXIBLE_CHECKSUMS_RES_WHEN_REQUIRED",
143+
"c",
144+
"responseChecksumValidation",
145+
ResponseChecksumValidation.WHEN_REQUIRED,
146+
],
147+
[
148+
"FLEXIBLE_CHECKSUMS_RES_WHEN_SUPPORTED",
149+
"b",
150+
"responseChecksumValidation",
151+
ResponseChecksumValidation.WHEN_SUPPORTED,
152+
],
153+
])("logs %s:%s when %s=%s", async (feature, value, configKey, configValue) => {
154+
const mockConfigOverride = {
155+
...mockConfig,
156+
[configKey]: () => Promise.resolve(configValue),
63157
} as PreviouslyResolved;
64-
const handler = flexibleChecksumsInputMiddleware(mockConfig, mockMiddlewareConfig)(mockNext, {});
158+
159+
const handler = flexibleChecksumsInputMiddleware(mockConfigOverride, mockMiddlewareConfig)(mockNext, {});
65160
await handler({ input: {} });
66-
expect(setFeature).toHaveBeenCalledWith(expect.anything(), feature, value);
161+
162+
expect(setFeature).toHaveBeenCalledTimes(2);
163+
if (configKey === "requestChecksumCalculation") {
164+
expect(setFeature).toHaveBeenNthCalledWith(1, expect.anything(), feature, value);
165+
} else {
166+
expect(setFeature).toHaveBeenNthCalledWith(2, expect.anything(), feature, value);
167+
}
67168
});
68169
});
69170
});

‎packages/middleware-flexible-checksums/src/flexibleChecksumsInputMiddleware.ts‎

Lines changed: 45 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -10,14 +10,24 @@ import {
1010
} from "@smithy/types";
1111

1212
import { PreviouslyResolved } from "./configuration";
13-
import { ResponseChecksumValidation } from "./constants";
13+
import { DEFAULT_CHECKSUM_ALGORITHM, RequestChecksumCalculation, ResponseChecksumValidation } from "./constants";
1414

1515
export interface FlexibleChecksumsInputMiddlewareConfig {
16+
/**
17+
* Indicates an operation requires a checksum in its HTTP request.
18+
*/
19+
requestChecksumRequired: boolean;
20+
1621
/**
1722
* Defines a top-level operation input member used to opt-in to best-effort validation
1823
* of a checksum returned in the HTTP response of the operation.
1924
*/
2025
requestValidationModeMember?: string;
26+
27+
/**
28+
* Defines a top-level operation input member that is used to configure request checksum behavior.
29+
*/
30+
requestAlgorithmMember?: string;
2131
}
2232

2333
/**
@@ -47,17 +57,44 @@ export const flexibleChecksumsInputMiddleware =
4757
): SerializeHandler<any, Output> =>
4858
async (args: SerializeHandlerArguments<any>): Promise<SerializeHandlerOutput<Output>> => {
4959
const input = args.input;
50-
const { requestValidationModeMember } = middlewareConfig;
60+
const { requestValidationModeMember, requestAlgorithmMember, requestChecksumRequired } = middlewareConfig;
61+
62+
const requestChecksumCalculation = await config.requestChecksumCalculation();
5163
const responseChecksumValidation = await config.responseChecksumValidation();
5264

53-
if (responseChecksumValidation === ResponseChecksumValidation.WHEN_REQUIRED) {
54-
setFeature(context, "FLEXIBLE_CHECKSUMS_RES_WHEN_REQUIRED", "c");
55-
} else {
56-
setFeature(context, "FLEXIBLE_CHECKSUMS_RES_WHEN_SUPPORTED", "b");
65+
switch (requestChecksumCalculation) {
66+
case RequestChecksumCalculation.WHEN_REQUIRED:
67+
setFeature(context, "FLEXIBLE_CHECKSUMS_REQ_WHEN_REQUIRED", "a");
68+
break;
69+
case RequestChecksumCalculation.WHEN_SUPPORTED:
70+
setFeature(context, "FLEXIBLE_CHECKSUMS_REQ_WHEN_SUPPORTED", "Z");
71+
break;
72+
}
73+
74+
switch (responseChecksumValidation) {
75+
case ResponseChecksumValidation.WHEN_REQUIRED:
76+
setFeature(context, "FLEXIBLE_CHECKSUMS_RES_WHEN_REQUIRED", "c");
77+
break;
78+
case ResponseChecksumValidation.WHEN_SUPPORTED:
79+
setFeature(context, "FLEXIBLE_CHECKSUMS_RES_WHEN_SUPPORTED", "b");
80+
break;
81+
}
82+
83+
// The value for input member to configure flexible checksum is not set.
84+
if (requestAlgorithmMember && !input[requestAlgorithmMember]) {
85+
// Set requestAlgorithmMember as default checksum algorithm only if request checksum calculation is supported
86+
// or request checksum is required.
87+
if (requestChecksumCalculation === RequestChecksumCalculation.WHEN_SUPPORTED || requestChecksumRequired) {
88+
input[requestAlgorithmMember] = DEFAULT_CHECKSUM_ALGORITHM;
89+
}
5790
}
5891

59-
if (requestValidationModeMember && responseChecksumValidation === ResponseChecksumValidation.WHEN_SUPPORTED) {
60-
input[requestValidationModeMember] = "ENABLED";
92+
// The value for input member to opt-in to best-effort validation of a checksum returned in the HTTP response is not set.
93+
if (requestValidationModeMember && !input[requestValidationModeMember]) {
94+
// Set requestValidationModeMember as ENABLED only if response checksum validation is supported.
95+
if (responseChecksumValidation === ResponseChecksumValidation.WHEN_SUPPORTED) {
96+
input[requestValidationModeMember] = "ENABLED";
97+
}
6198
}
6299

63100
return next(args);

0 commit comments

Comments
 (0)