fix: fixed some tests

Author: aws-amplify-bot

packages/amplify-provider-awscloudformation/src/__tests__/aws-utils/S3Service.test.ts

@@ -1,44 +1,57 @@
 import { $TSContext } from '@aws-amplify/amplify-cli-core';
 import { createS3Service } from '../../aws-utils/S3Service';
+import { HeadBucketCommand } from '@aws-sdk/client-s3';
 
-jest.mock('aws-sdk', () => {
-  const mockHeadBucketForUsEast1 = jest.fn().mockImplementation((params: { Bucket: string }) => {
-    return {
-      promise: jest.fn().mockImplementation(() => {
-        if (params.Bucket.includes('us-east-1')) {
-          return Promise.resolve({});
-        }
-        return Promise.reject({ code: 'BadRequest', region: 'eu-south-1' });
-      }),
-    };
+// Mock the AWS SDK v3 S3Client
+jest.mock('@aws-sdk/client-s3', () => {
+  const mockSendForUsEast1 = jest.fn().mockImplementation(async (command) => {
+    if (command instanceof HeadBucketCommand) {
+      const params = command.input;
+      if (params.Bucket!.includes('us-east-1')) {
+        return {};
+      }
+      const error = new Error('BadRequest');
+      error.name = 'BadRequest';
+      throw error;
+    }
+    return {};
+  });
+
+  const mockSendForEuSouth1 = jest.fn().mockImplementation(async (command) => {
+    if (command instanceof HeadBucketCommand) {
+      const params = command.input;
+      if (params.Bucket!.includes('eu-south-1')) {
+        return {};
+      }
+      const error = new Error('BadRequest');
+      error.name = 'BadRequest';
+      throw error;
+    }
+    return {};
   });
 
-  const mockHeadBucketForEuSouth1 = jest.fn().mockImplementation((params) => {
+  // Mock S3Client constructor
+  const mockS3Client = jest.fn().mockImplementation((options) => {
+    const region = options.region || 'us-east-1';
+
     return {
-      promise: jest.fn().mockImplementation(() => {
-        if (params.Bucket.includes('eu-south-1')) {
-          return Promise.resolve({});
-        }
-        return Promise.reject({ code: 'BadRequest', region: 'us-east-1' });
-      }),
+      send: region === 'eu-south-1' ? mockSendForEuSouth1 : mockSendForUsEast1,
+      config: {
+        region,
+        credentials: options.credentials,
+      },
     };
   });
 
   return {
-    S3: jest.fn((options) => {
-      const region = options.region || 'us-east-1';
-      if (region === 'eu-south-1') {
-        return {
-          headBucket: mockHeadBucketForEuSouth1,
-        };
-      }
+    S3Client: mockS3Client,
+    HeadBucketCommand: jest.fn().mockImplementation((params) => {
       return {
-        config: {
-          region,
-        },
-        headBucket: mockHeadBucketForUsEast1,
+        input: params,
       };
     }),
+    ListBucketsCommand: jest.fn(),
+    GetBucketLocationCommand: jest.fn(),
   };
 });
 

packages/amplify-provider-awscloudformation/src/__tests__/system-config-manager.test.ts

@@ -1,6 +1,6 @@
 import { $TSContext } from '@aws-amplify/amplify-cli-core';
 import fs from 'fs-extra';
-import { CredentialProviderChain, ProcessCredentials } from 'aws-sdk';
+import { fromProcess } from '@aws-sdk/credential-providers';
 import { getProfileCredentials, getProfiledAwsConfig } from '../system-config-manager';
 
 jest.setTimeout(15000);
@@ -11,9 +11,8 @@ jest.mock('../utils/aws-logger', () => ({
 jest.mock('fs-extra');
 const fs_mock = fs as jest.Mocked<typeof fs>;
 
-jest.mock('aws-sdk');
-const ProcessCredentialsMock = ProcessCredentials as jest.MockedClass<typeof ProcessCredentials>;
-const CredentialProviderChainMock = CredentialProviderChain as jest.MockedClass<typeof CredentialProviderChain>;
+jest.mock('@aws-sdk/credential-providers');
+const fromProcessMock = fromProcess as jest.MockedFunction<typeof fromProcess>;
 
 const context_stub = {
   print: {
@@ -29,14 +28,14 @@ describe('profile tests', () => {
   fs_mock.existsSync.mockReturnValue(true);
 
   describe('credential process loading', () => {
-    const mockResolvePromise = jest.fn().mockReturnValue(
-      Promise.resolve({
-        accessKeyId: 'chainTestAccessKey',
-        secretAccessKey: 'chainTestSecret',
-        sessionToken: 'chainTestSessionToken',
-        expireTime: new Date(1234),
-      }),
-    );
+    const mockCredentials = {
+      accessKeyId: 'chainTestAccessKey',
+      secretAccessKey: 'chainTestSecret',
+      sessionToken: 'chainTestSessionToken',
+      expiration: new Date(1234),
+    };
+
+    const mockCredentialProvider = jest.fn().mockResolvedValue(mockCredentials);
 
     beforeEach(() => {
       // setup
@@ -47,24 +46,7 @@ describe('profile tests', () => {
 
       fs_mock.readFileSync.mockReturnValue(awsConfigContent);
 
-      CredentialProviderChainMock.mockImplementation(() => ({
-        providers: [],
-        resolvePromise: mockResolvePromise,
-        resolve: jest.fn(),
-      }));
-
-      ProcessCredentialsMock.mockImplementation(() => ({
-        accessKeyId: 'testAccessKey',
-        secretAccessKey: 'testSecret',
-        sessionToken: 'testSessionToken',
-        expireTime: new Date(1234),
-        expired: false,
-        get: jest.fn(),
-        getPromise: jest.fn(),
-        needsRefresh: jest.fn(),
-        refresh: jest.fn(),
-        refreshPromise: jest.fn(),
-      }));
+      fromProcessMock.mockReturnValue(mockCredentialProvider);
     });
 
     it('should use credential_process defined in config file', async () => {
@@ -73,24 +55,29 @@ describe('profile tests', () => {
 
       // expect
       expect(profile_config).toBeDefined();
-      expect(mockResolvePromise).toBeCalled();
+      expect(fromProcessMock).toHaveBeenCalledWith({ profile: 'fake' });
+      expect(mockCredentialProvider).toHaveBeenCalled();
       expect(profile_config.accessKeyId).toBe('chainTestAccessKey');
       expect(profile_config.secretAccessKey).toBe('chainTestSecret');
       expect(profile_config.sessionToken).toBe('chainTestSessionToken');
       expect(profile_config.expiration).toEqual(new Date(1234));
     });
 
-    it('sets AWS_SDK_LOAD_CONFIG while ProcessCredentials executes', async () => {
+    it('sets AWS_SDK_LOAD_CONFIG while credential provider executes', async () => {
       const sdkLoadConfigOriginal = process.env.AWS_SDK_LOAD_CONFIG;
-      mockResolvePromise.mockImplementationOnce(() => {
+      mockCredentialProvider.mockImplementationOnce(() => {
         expect(process.env.AWS_SDK_LOAD_CONFIG).toBeTruthy();
-
         return Promise.resolve({
           accessKeyId: 'chainTestAccessKey',
+          secretAccessKey: 'chainTestSecret',
+          sessionToken: 'chainTestSessionToken',
+          expiration: new Date(1234),
         });
       });
+
       await getProfiledAwsConfig(context_stub, 'fake');
-      expect(mockResolvePromise).toBeCalled();
+      expect(fromProcessMock).toHaveBeenCalledWith({ profile: 'fake' });
+      expect(mockCredentialProvider).toHaveBeenCalled();
       expect(process.env.AWS_SDK_LOAD_CONFIG).toStrictEqual(sdkLoadConfigOriginal);
     });
   });

packages/amplify-provider-awscloudformation/src/aws-utils/DynamoDBService.ts

@@ -1,5 +1,4 @@
 import { $TSAny, $TSContext } from '@aws-amplify/amplify-cli-core';
-import { NodeHttpHandler } from '@smithy/node-http-handler';
 import { IDynamoDBService } from '@aws-amplify/amplify-util-import';
 import {
   DynamoDBClient,

packages/amplify-provider-awscloudformation/src/system-config-manager.ts

@@ -1,6 +1,6 @@
 import { $TSAny, $TSContext, AmplifyError, JSONUtilities, pathManager, SecretFileMode, spinner } from '@aws-amplify/amplify-cli-core';
 
-import { STSClient, AssumeRoleCommand, AssumeRoleCommandInput, Credentials as STSCredentials } from '@aws-sdk/client-sts';
+import { STSClient, AssumeRoleCommand, AssumeRoleCommandInput } from '@aws-sdk/client-sts';
 import { fromProcess } from '@aws-sdk/credential-providers';
 import { NodeHttpHandler } from '@smithy/node-http-handler';
 import * as fs from 'fs-extra';