release(required): Amplify JS release (#14317)

Author: AllanZhengYP

packages/api-rest/__tests__/apis/common/baseHandlers/authenticatedHandler.test.ts

@@ -0,0 +1,29 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { composeTransferHandler } from '@aws-amplify/core/internals/aws-client-utils/composers';
+import {
+	fetchTransferHandler,
+	retryMiddlewareFactory,
+	signingMiddlewareFactory,
+	userAgentMiddlewareFactory,
+} from '@aws-amplify/core/internals/aws-client-utils';
+
+import { authenticatedHandler } from '../../../../src/apis/common/baseHandlers/authenticatedHandler';
+
+jest.mock('@aws-amplify/core/internals/aws-client-utils/composers', () => ({
+	composeTransferHandler: jest
+		.fn()
+		.mockReturnValue('composed_transfer_handler'),
+}));
+
+describe('authenticated handler', () => {
+	it('should be configured correctly', () => {
+		expect(authenticatedHandler).toEqual('composed_transfer_handler');
+		expect(composeTransferHandler).toHaveBeenCalledTimes(1);
+		expect(composeTransferHandler).toHaveBeenCalledWith(fetchTransferHandler, [
+			userAgentMiddlewareFactory,
+			retryMiddlewareFactory,
+			signingMiddlewareFactory,
+		]);
+	});
+});

packages/api-rest/__tests__/apis/common/baseHandlers/unauthenticatedHandler.test.ts

@@ -0,0 +1,27 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { composeTransferHandler } from '@aws-amplify/core/internals/aws-client-utils/composers';
+import {
+	fetchTransferHandler,
+	retryMiddlewareFactory,
+	userAgentMiddlewareFactory,
+} from '@aws-amplify/core/internals/aws-client-utils';
+
+import { unauthenticatedHandler } from '../../../../src/apis/common/baseHandlers/unauthenticatedHandler';
+
+jest.mock('@aws-amplify/core/internals/aws-client-utils/composers', () => ({
+	composeTransferHandler: jest
+		.fn()
+		.mockReturnValue('composed_transfer_handler'),
+}));
+
+describe('unauthenticated handler', () => {
+	it('should be configured correctly', () => {
+		expect(unauthenticatedHandler).toEqual('composed_transfer_handler');
+		expect(composeTransferHandler).toHaveBeenCalledTimes(1);
+		expect(composeTransferHandler).toHaveBeenCalledWith(fetchTransferHandler, [
+			userAgentMiddlewareFactory,
+			retryMiddlewareFactory,
+		]);
+	});
+});

packages/api-rest/__tests__/apis/common/internalPost.test.ts

@@ -4,23 +4,27 @@
 import { AmplifyClassV6 } from '@aws-amplify/core';
 import { ApiError } from '@aws-amplify/core/internals/utils';
 import {
-	authenticatedHandler,
+	getRetryDecider,
 	parseJsonError,
-	unauthenticatedHandler,
 } from '@aws-amplify/core/internals/aws-client-utils';
 
 import {
 	cancel,
 	post,
 	updateRequestToBeCancellable,
 } from '../../../src/apis/common/internalPost';
+import { authenticatedHandler } from '../../../src/apis/common/baseHandlers/authenticatedHandler';
+import { unauthenticatedHandler } from '../../../src/apis/common/baseHandlers/unauthenticatedHandler';
 import { RestApiError, isCancelError } from '../../../src/errors';
 
 jest.mock('@aws-amplify/core/internals/aws-client-utils');
+jest.mock('../../../src/apis/common/baseHandlers/authenticatedHandler');
+jest.mock('../../../src/apis/common/baseHandlers/unauthenticatedHandler');
 
-const mockAuthenticatedHandler = authenticatedHandler as jest.Mock;
-const mockUnauthenticatedHandler = unauthenticatedHandler as jest.Mock;
-const mockParseJsonError = parseJsonError as jest.Mock;
+const mockAuthenticatedHandler = jest.mocked(authenticatedHandler);
+const mockUnauthenticatedHandler = jest.mocked(unauthenticatedHandler);
+const mockParseJsonError = jest.mocked(parseJsonError);
+const mockGetRetryDecider = jest.mocked(getRetryDecider);
 const mockFetchAuthSession = jest.fn();
 const mockAmplifyInstance = {
 	Auth: {
@@ -45,13 +49,17 @@ const credentials = {
 	sessionToken: 'sessionToken',
 	secretAccessKey: 'secretAccessKey',
 };
+const retryExpectedResponse = { retryable: true };
+const mockGetRetryDeciderResponse = () =>
+	Promise.resolve(retryExpectedResponse);
 
 describe('internal post', () => {
 	beforeEach(() => {
 		jest.resetAllMocks();
 		mockFetchAuthSession.mockResolvedValue({ credentials });
 		mockAuthenticatedHandler.mockResolvedValue(successResponse);
 		mockUnauthenticatedHandler.mockResolvedValue(successResponse);
+		mockGetRetryDecider.mockReturnValue(mockGetRetryDeciderResponse);
 	});
 
 	it('should call authenticatedHandler with specified region from signingServiceInfo', async () => {
@@ -320,11 +328,12 @@ describe('internal post', () => {
 			},
 		};
 		mockParseJsonError.mockImplementationOnce(async response => {
-			const errorResponsePayload = await response.body?.json();
+			const errorResponsePayload = await response?.body?.json();
 			const error = new Error(errorResponsePayload.message);
 
 			return Object.assign(error, {
 				name: errorResponsePayload.name,
+				$metadata: {},
 			});
 		});
 		mockUnauthenticatedHandler.mockResolvedValueOnce(errorResponse);
@@ -365,11 +374,12 @@ describe('internal post', () => {
 			},
 		};
 		mockParseJsonError.mockImplementationOnce(async response => {
-			const errorResponsePayload = await response.body?.json();
+			const errorResponsePayload = await response?.body?.json();
 			const error = new Error(errorResponsePayload.message);
 
 			return Object.assign(error, {
 				name: errorResponsePayload.name,
+				$metadata: {},
 			});
 		});
 		mockUnauthenticatedHandler.mockResolvedValueOnce(errorResponse);
@@ -396,4 +406,52 @@ describe('internal post', () => {
 			});
 		}
 	});
+
+	it('should use jittered-exponential-backoff retry strategy', async () => {
+		expect.assertions(2);
+		await post(mockAmplifyInstance, {
+			url: apiGatewayUrl,
+			options: {
+				signingServiceInfo: {},
+			},
+		});
+		expect(mockAuthenticatedHandler).toHaveBeenCalledWith(
+			expect.anything(),
+			expect.objectContaining({ retryDecider: expect.any(Function) }),
+		);
+		const callArgs = mockAuthenticatedHandler.mock.calls[0];
+		const { retryDecider } = callArgs[1];
+		const retryDeciderResult = await retryDecider();
+		expect(retryDeciderResult).toEqual(retryExpectedResponse);
+	});
+
+	it('should use jittered-exponential-backoff retry strategy, even when configuring using library options', async () => {
+		expect.assertions(2);
+		const mockAmplifyInstanceWithNoRetry = {
+			...mockAmplifyInstance,
+			libraryOptions: {
+				API: {
+					REST: {
+						retryStrategy: {
+							strategy: 'no-retry',
+						},
+					},
+				},
+			},
+		} as any as AmplifyClassV6;
+		await post(mockAmplifyInstanceWithNoRetry, {
+			url: apiGatewayUrl,
+			options: {
+				signingServiceInfo: {},
+			},
+		});
+		expect(mockAuthenticatedHandler).toHaveBeenCalledWith(
+			expect.anything(),
+			expect.objectContaining({ retryDecider: expect.any(Function) }),
+		);
+		const callArgs = mockAuthenticatedHandler.mock.calls[0];
+		const { retryDecider } = callArgs[1];
+		const retryDeciderResult = await retryDecider();
+		expect(retryDeciderResult).toEqual(retryExpectedResponse);
+	});
 });

packages/api-rest/__tests__/apis/common/publicApis.test.ts

@@ -3,12 +3,13 @@
 
 import { AmplifyClassV6 } from '@aws-amplify/core';
 import {
-	authenticatedHandler,
+	getRetryDecider,
 	parseJsonError,
-	unauthenticatedHandler,
 } from '@aws-amplify/core/internals/aws-client-utils';
 import { ApiError } from '@aws-amplify/core/internals/utils';
 
+import { authenticatedHandler } from '../../../src/apis/common/baseHandlers/authenticatedHandler';
+import { unauthenticatedHandler } from '../../../src/apis/common/baseHandlers/unauthenticatedHandler';
 import {
 	del,
 	get,
@@ -26,6 +27,8 @@ import {
 import { RestApiResponse } from '../../../src/types';
 
 jest.mock('@aws-amplify/core/internals/aws-client-utils');
+jest.mock('../../../src/apis/common/baseHandlers/authenticatedHandler');
+jest.mock('../../../src/apis/common/baseHandlers/unauthenticatedHandler');
 
 const mockAuthenticatedHandler = authenticatedHandler as jest.Mock;
 const mockUnauthenticatedHandler = unauthenticatedHandler as jest.Mock;
@@ -75,6 +78,10 @@ const mockSuccessResponse = {
 		text: jest.fn(),
 	},
 };
+const mockGetRetryDecider = getRetryDecider as jest.Mock;
+const mockRetryResponse = { retryable: true };
+const mockNoRetryResponse = { retryable: false };
+const mockRetryDeciderResponse = () => Promise.resolve(mockRetryResponse);
 
 describe('public APIs', () => {
 	beforeEach(() => {
@@ -86,6 +93,7 @@ describe('public APIs', () => {
 		mockAuthenticatedHandler.mockResolvedValue(mockSuccessResponse);
 		mockUnauthenticatedHandler.mockResolvedValue(mockSuccessResponse);
 		mockGetConfig.mockReturnValue(mockConfig);
+		mockGetRetryDecider.mockReturnValue(mockRetryDeciderResponse);
 	});
 	const APIs = [
 		{ name: 'get', fn: get, method: 'GET' },
@@ -415,6 +423,160 @@ describe('public APIs', () => {
 					expect(error.message).toBe(cancelMessage);
 				}
 			});
+
+			describe('retry strategy', () => {
+				beforeEach(() => {
+					mockAuthenticatedHandler.mockReset();
+					mockAuthenticatedHandler.mockResolvedValue(mockSuccessResponse);
+				});
+
+				it('should not retry when retry is set to "no-retry"', async () => {
+					expect.assertions(2);
+					await fn(mockAmplifyInstance, {
+						apiName: 'restApi1',
+						path: '/items',
+						retryStrategy: {
+							strategy: 'no-retry',
+						},
+					}).response;
+					expect(mockAuthenticatedHandler).toHaveBeenCalledWith(
+						expect.any(Object),
+						expect.objectContaining({ retryDecider: expect.any(Function) }),
+					);
+					const callArgs = mockAuthenticatedHandler.mock.calls[0];
+					const { retryDecider } = callArgs[1];
+					const result = await retryDecider();
+					expect(result).toEqual(mockNoRetryResponse);
+				});
+
+				it('should retry when retry is set to "jittered-exponential-backoff"', async () => {
+					expect.assertions(2);
+					await fn(mockAmplifyInstance, {
+						apiName: 'restApi1',
+						path: '/items',
+						retryStrategy: {
+							strategy: 'jittered-exponential-backoff',
+						},
+					}).response;
+					expect(mockAuthenticatedHandler).toHaveBeenCalledWith(
+						expect.any(Object),
+						expect.objectContaining({ retryDecider: expect.any(Function) }),
+					);
+					const callArgs = mockAuthenticatedHandler.mock.calls[0];
+					const { retryDecider } = callArgs[1];
+					const result = await retryDecider();
+					expect(result).toEqual(mockRetryResponse);
+				});
+
+				it('should retry when retry strategy is not provided', async () => {
+					expect.assertions(2);
+					await fn(mockAmplifyInstance, {
+						apiName: 'restApi1',
+						path: '/items',
+					}).response;
+					expect(mockAuthenticatedHandler).toHaveBeenCalledWith(
+						expect.any(Object),
+						expect.objectContaining({ retryDecider: expect.any(Function) }),
+					);
+					const callArgs = mockAuthenticatedHandler.mock.calls[0];
+					const { retryDecider } = callArgs[1];
+					const result = await retryDecider();
+					expect(result).toEqual(mockRetryResponse);
+				});
+
+				it('should retry and prefer the individual retry strategy over the library options', async () => {
+					expect.assertions(2);
+					const mockAmplifyInstanceWithNoRetry = {
+						...mockAmplifyInstance,
+						libraryOptions: {
+							API: {
+								REST: {
+									retryStrategy: {
+										strategy: 'no-retry',
+									},
+								},
+							},
+						},
+					} as any as AmplifyClassV6;
+					await fn(mockAmplifyInstanceWithNoRetry, {
+						apiName: 'restApi1',
+						path: 'items',
+						retryStrategy: {
+							strategy: 'jittered-exponential-backoff',
+						},
+					}).response;
+
+					expect(mockAuthenticatedHandler).toHaveBeenCalledWith(
+						expect.any(Object),
+						expect.objectContaining({ retryDecider: expect.any(Function) }),
+					);
+					const callArgs = mockAuthenticatedHandler.mock.calls[0];
+					const { retryDecider } = callArgs[1];
+					const result = await retryDecider();
+					expect(result).toEqual(mockRetryResponse);
+				});
+
+				it('should not retry and prefer the individual retry strategy over the library options', async () => {
+					expect.assertions(2);
+					const mockAmplifyInstanceWithRetry = {
+						...mockAmplifyInstance,
+						libraryOptions: {
+							API: {
+								REST: {
+									retryStrategy: {
+										strategy: 'jittered-exponential-backoff',
+									},
+								},
+							},
+						},
+					} as any as AmplifyClassV6;
+					await fn(mockAmplifyInstanceWithRetry, {
+						apiName: 'restApi1',
+						path: 'items',
+						retryStrategy: {
+							strategy: 'no-retry',
+						},
+					}).response;
+
+					expect(mockAuthenticatedHandler).toHaveBeenCalledWith(
+						expect.any(Object),
+						expect.objectContaining({ retryDecider: expect.any(Function) }),
+					);
+					const callArgs = mockAuthenticatedHandler.mock.calls[0];
+					const { retryDecider } = callArgs[1];
+					const result = await retryDecider();
+					expect(result).toEqual(mockNoRetryResponse);
+				});
+
+				it('should not retry when configured through library options', async () => {
+					expect.assertions(2);
+					const mockAmplifyInstanceWithRetry = {
+						...mockAmplifyInstance,
+						libraryOptions: {
+							API: {
+								REST: {
+									retryStrategy: {
+										strategy: 'no-retry',
+									},
+								},
+							},
+						},
+					} as any as AmplifyClassV6;
+					await fn(mockAmplifyInstanceWithRetry, {
+						apiName: 'restApi1',
+						path: 'items',
+					}).response;
+
+					expect(mockAuthenticatedHandler).toHaveBeenCalledWith(
+						expect.any(Object),
+						expect.objectContaining({ retryDecider: expect.any(Function) }),
+					);
+					const callArgs = mockAuthenticatedHandler.mock.calls[0];
+					const { retryDecider } = callArgs[1];
+					const result = await retryDecider();
+					expect(result).toEqual(mockNoRetryResponse);
+				});
+			});
 		});
 	});
 });