refactor: unit tests

Author: aws-amplify-bot

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

@@ -1,21 +1,16 @@
-import { Amplify } from 'aws-sdk';
 import { stateManager } from '@aws-amplify/amplify-cli-core';
 import { getConfiguredAmplifyClient } from '../aws-utils/aws-amplify';
 import { checkAmplifyServiceIAMPermission } from '../amplify-service-permission-check';
 import { init } from '../amplify-service-manager';
+import { mockClient } from 'aws-sdk-client-mock';
+import 'aws-sdk-client-mock-jest';
+import { AmplifyClient, CreateAppCommand } from '@aws-sdk/client-amplify';
 
 jest.mock('../aws-utils/aws-amplify');
 jest.mock('../amplify-service-permission-check');
 
-const amplifyClientStub = {
-  createApp: jest.fn().mockReturnValue({
-    promise: jest.fn().mockRejectedValue({
-      code: 'LimitExceededException',
-    }),
-  }),
-} as unknown as Amplify;
+const mockAmplifyClient = mockClient(AmplifyClient);
 const getConfiguredAmplifyClientMock = getConfiguredAmplifyClient as jest.MockedFunction<typeof getConfiguredAmplifyClient>;
-getConfiguredAmplifyClientMock.mockResolvedValue(amplifyClientStub);
 
 const checkAmplifyServiceIAMPermissionMock = checkAmplifyServiceIAMPermission as jest.MockedFunction<
   typeof checkAmplifyServiceIAMPermission
@@ -25,7 +20,16 @@ checkAmplifyServiceIAMPermissionMock.mockResolvedValue(true);
 jest.spyOn(stateManager, 'teamProviderInfoExists').mockReturnValue(false);
 
 describe('init', () => {
+  beforeEach(() => {
+    getConfiguredAmplifyClientMock.mockClear();
+    mockAmplifyClient.reset();
+  });
   it('throws ProjectInitError if Amplify app limit has been reached', async () => {
+    mockAmplifyClient.on(CreateAppCommand).rejectsOnce({
+      name: 'LimitExceededException',
+    });
+    getConfiguredAmplifyClientMock.mockResolvedValue(mockAmplifyClient as unknown as AmplifyClient);
+
     const amplifyServiceParamsStub = {
       context: {},
       awsConfigInfo: {},
@@ -39,16 +43,11 @@ describe('init', () => {
   });
 
   it('throws Configutation error if config level is general and soorcing wrong credentials', async () => {
-    const amplifyClientGeneralConfigStub = {
-      createApp: jest.fn().mockReturnValue({
-        promise: jest.fn().mockRejectedValue({
-          code: 'ConfigError',
-          message: 'Missing Region in Config',
-        }),
-      }),
-    } as unknown as Amplify;
-    getConfiguredAmplifyClientMock.mockClear();
-    getConfiguredAmplifyClientMock.mockResolvedValue(amplifyClientGeneralConfigStub);
+    mockAmplifyClient.on(CreateAppCommand).rejectsOnce({
+      name: 'ConfigError',
+      message: 'Missing Region in Config',
+    });
+    getConfiguredAmplifyClientMock.mockResolvedValue(mockAmplifyClient as unknown as AmplifyClient);
 
     const amplifyServiceParamsStub = {
       context: {

packages/amplify-provider-awscloudformation/src/__tests__/aws-utils/cloudformation-error-serializer.test.ts

@@ -1,3 +1,4 @@
+import { ResourceStatus } from '@aws-sdk/client-cloudformation';
 import {
   deserializeErrorMessages,
   CFNErrorMessages,
@@ -11,7 +12,7 @@ const eventsWithFailure = [
     PhysicalResourceId: 'testStackId1',
     LogicalResourceId: 'testLogicalResourceId1',
     ResourceType: 'AWS::IAM::Role',
-    ResourceStatus: 'CREATE_FAILED',
+    ResourceStatus: ResourceStatus.CREATE_FAILED,
     ResourceStatusReason: 'Some valid reason 1',
     // below properties are useless since we don't use them in the code
     StackId: 'testStackId1',
@@ -23,7 +24,7 @@ const eventsWithFailure = [
     PhysicalResourceId: 'testStackId2',
     LogicalResourceId: 'testLogicalResourceId2',
     ResourceType: 'AWS::CloudFormation::Stack',
-    ResourceStatus: 'UPDATE_FAILED',
+    ResourceStatus: ResourceStatus.UPDATE_FAILED,
     ResourceStatusReason: 'Some valid reason 2',
     // below properties are useless since we don't use them in the code
     StackId: 'testStackId2',

packages/amplify-provider-awscloudformation/src/__tests__/display-helpful-urls.test.ts

@@ -1,8 +1,8 @@
 import { ApiCategoryFacade, BannerMessage, stateManager } from '@aws-amplify/amplify-cli-core';
-import { AWSError } from 'aws-sdk';
 import { printer } from '@aws-amplify/amplify-prompts';
 import { SNS } from '../aws-utils/aws-sns';
 import { showGraphQLTransformerVersion, showSMSSandboxWarning } from '../display-helpful-urls';
+import { AwsError } from 'aws-sdk-client-mock';
 
 jest.mock('../aws-utils/aws-sns');
 jest.mock('@aws-amplify/amplify-cli-core');
@@ -77,8 +77,8 @@ describe('showSMSSandBoxWarning', () => {
 
   describe('when IAM user is missing sandbox permission', () => {
     beforeEach(() => {
-      const authError = new Error() as AWSError;
-      authError.code = 'AuthorizationError';
+      const authError = new Error() as AwsError;
+      authError.name = 'AuthorizationError';
       mockedSNSClientInstance.isInSandboxMode.mockRejectedValue(authError);
     });
     it('should not show any warning if there is no message associated', async () => {
@@ -110,8 +110,8 @@ describe('showSMSSandBoxWarning', () => {
 
   describe('it should not show any warning message when the SNS API is not deployed', () => {
     beforeEach(() => {
-      const resourceNotFoundError = new Error() as AWSError;
-      resourceNotFoundError.code = 'ResourceNotFound';
+      const resourceNotFoundError = new Error() as AwsError;
+      resourceNotFoundError.name = 'ResourceNotFound';
       mockedSNSClientInstance.isInSandboxMode.mockRejectedValue(resourceNotFoundError);
     });
     it('should not print error', async () => {
@@ -127,8 +127,8 @@ describe('showSMSSandBoxWarning', () => {
 
   describe('it should not show any warning message when there is a network error', () => {
     beforeEach(() => {
-      const networkError = new Error() as AWSError;
-      networkError.code = 'UnknownEndpoint';
+      const networkError = new Error() as AwsError;
+      networkError.name = 'UnknownEndpoint';
       mockedSNSClientInstance.isInSandboxMode.mockRejectedValue(networkError);
     });
 

packages/amplify-provider-awscloudformation/src/__tests__/initialize-env.test.ts

@@ -18,7 +18,7 @@ describe('initialize environment', () => {
     },
   } as unknown as $TSContext;
   it('throws AmplifyError if the deployment bucket does not exist', async () => {
-    downloadZipMock.mockRejectedValueOnce({ code: 'NoSuchBucket' });
+    downloadZipMock.mockRejectedValueOnce({ name: 'NoSuchBucket' });
     const actual = await expect(run(contextStub, {})).rejects;
     await actual.toBeInstanceOf(AmplifyException);
     await actual.toMatchInlineSnapshot(

packages/amplify-provider-awscloudformation/src/__tests__/iterative-deployment/stack-event-monitor.test.ts

@@ -1,27 +1,26 @@
-import type { CloudFormation } from 'aws-sdk';
 import { StackEventMonitor } from '../../iterative-deployment/stack-event-monitor';
+import { mockClient } from 'aws-sdk-client-mock';
+import 'aws-sdk-client-mock-jest';
+import { CloudFormationClient, DescribeStackEventsCommand } from '@aws-sdk/client-cloudformation';
 
 const stackProgressPrinterStub = {
   printerFn: jest.fn(),
   addEventActivity: jest.fn(),
 };
 
-const cfn = {
-  describeStackEvents: () => ({
-    promise: () =>
-      Promise.resolve({
-        NextToken: undefined,
-      }),
-  }),
-} as unknown as CloudFormation;
+const mockCfnClient = mockClient(CloudFormationClient);
 
 jest.useFakeTimers();
 jest.spyOn(global, 'setTimeout');
 jest.spyOn(global, 'clearTimeout');
 
 describe('StackEventMonitor', () => {
+  mockCfnClient.on(DescribeStackEventsCommand).resolves({
+    NextToken: undefined,
+  });
+
   const monitor = new StackEventMonitor(
-    cfn,
+    mockCfnClient as unknown as CloudFormationClient,
     'testStackName',
     stackProgressPrinterStub.printerFn,
     stackProgressPrinterStub.addEventActivity,

packages/amplify-provider-awscloudformation/src/__tests__/permission-boundary/permissions-boundary.test.ts

@@ -1,8 +1,10 @@
 import { $TSContext, setPermissionsBoundaryArn, getPermissionsBoundaryArn, stateManager } from '@aws-amplify/amplify-cli-core';
 import { prompt } from 'inquirer';
-import { IAM } from 'aws-sdk';
+import { GetPolicyCommand, IAMClient as IAM } from '@aws-sdk/client-iam';
 import { configurePermissionsBoundaryForInit } from '../../permissions-boundary/permissions-boundary';
 import { IAMClient } from '../../aws-utils/aws-iam';
+import { mockClient } from 'aws-sdk-client-mock';
+import 'aws-sdk-client-mock-jest';
 
 const permissionsBoundaryArn = 'arn:aws:iam::123456789012:policy/some-policy-name';
 const argName = 'permissions-boundary';
@@ -25,6 +27,7 @@ const getPermissionsBoundaryArn_mock = getPermissionsBoundaryArn as jest.MockedF
 const prompt_mock = prompt as jest.MockedFunction<typeof prompt>;
 const IAMClient_mock = IAMClient as jest.Mocked<typeof IAMClient>;
 const stateManager_mock = stateManager as jest.Mocked<typeof stateManager>;
+const mockIAMClient = mockClient(IAM);
 
 stateManager_mock.getLocalEnvInfo.mockReturnValue({ envName: 'testenv' });
 
@@ -53,6 +56,7 @@ describe('configure permissions boundary on init', () => {
       },
     } as unknown as $TSContext;
     jest.clearAllMocks();
+    mockIAMClient.reset();
   });
   it('applies policy specifed in cmd arg when present', async () => {
     context_stub.input.options[argName] = permissionsBoundaryArn;
@@ -108,12 +112,9 @@ describe('configure permissions boundary on env add', () => {
   it('applies existing policy to new env when existing policy is accessible', async () => {
     getPermissionsBoundaryArn_mock.mockReturnValueOnce(permissionsBoundaryArn);
     IAMClient_mock.getInstance.mockResolvedValueOnce({
-      client: {
-        getPolicy: jest.fn().mockReturnValueOnce({
-          promise: jest.fn(),
-        }),
-      } as unknown as IAM,
+      client: mockIAMClient as unknown as IAM,
     });
+    mockIAMClient.on(GetPolicyCommand).resolvesOnce({});
     await configurePermissionsBoundaryForInit(context_stub);
     expect(setPermissionsBoundaryArn_mock.mock.calls[0][0]).toEqual(permissionsBoundaryArn);
     expect(prompt_mock).not.toHaveBeenCalled();
@@ -122,12 +123,9 @@ describe('configure permissions boundary on env add', () => {
   it('prompts for new policy when existing one is not accessible', async () => {
     getPermissionsBoundaryArn_mock.mockReturnValueOnce(permissionsBoundaryArn);
     IAMClient_mock.getInstance.mockResolvedValueOnce({
-      client: {
-        getPolicy: jest.fn().mockReturnValueOnce({
-          promise: jest.fn().mockRejectedValueOnce({ statusCode: 404, message: 'test error' }),
-        }),
-      } as unknown as IAM,
+      client: mockIAMClient as unknown as IAM,
     });
+    mockIAMClient.on(GetPolicyCommand).rejects({ name: 'NoSuchEntityException', message: 'test error' });
     const newPermissionsBoundaryArn = 'thisIsANewArn';
     prompt_mock.mockResolvedValueOnce({
       permissionsBoundaryArn: newPermissionsBoundaryArn,
@@ -140,12 +138,9 @@ describe('configure permissions boundary on env add', () => {
     context_stub.input.options.yes = true;
     getPermissionsBoundaryArn_mock.mockReturnValueOnce(permissionsBoundaryArn);
     IAMClient_mock.getInstance.mockResolvedValueOnce({
-      client: {
-        getPolicy: jest.fn().mockReturnValueOnce({
-          promise: jest.fn().mockRejectedValueOnce({ statusCode: 404, message: 'test error' }),
-        }),
-      } as unknown as IAM,
+      client: mockIAMClient as unknown as IAM,
     });
+    mockIAMClient.on(GetPolicyCommand).rejects({ name: 'NoSuchEntityException', message: 'test error' });
     await expect(configurePermissionsBoundaryForInit(context_stub)).rejects.toMatchInlineSnapshot(
       `[InputValidationError: A permissions boundary ARN must be specified using --permissions-boundary]`,
     );

packages/amplify-provider-awscloudformation/src/__tests__/utils/amplify-resource-state-utils.test.ts

@@ -1,45 +1,49 @@
+import { CloudFormationClient, DescribeStackResourcesCommand, DescribeStacksCommand } from '@aws-sdk/client-cloudformation';
 import { getTableNames, getPreviousDeploymentRecord } from '../../utils/amplify-resource-state-utils';
-import { CloudFormation } from 'aws-sdk';
+import { mockClient } from 'aws-sdk-client-mock';
+import 'aws-sdk-client-mock-jest';
 
-const cfnClientStub = {
-  describeStackResources: () => ({
-    promise: () =>
-      Promise.resolve({
-        StackResources: [
+const mockCfnClient = mockClient(CloudFormationClient);
+mockCfnClient
+  .on(DescribeStackResourcesCommand)
+  .resolves({
+    StackResources: [
+      {
+        LogicalResourceId: 'LogicalResourceIdTest1',
+        PhysicalResourceId: 'PhysicalResourceIdTest',
+        ResourceType: undefined,
+        Timestamp: undefined,
+        ResourceStatus: undefined,
+      },
+    ],
+  })
+  .on(DescribeStacksCommand)
+  .resolves({
+    Stacks: [
+      {
+        Outputs: [
           {
-            LogicalResourceId: 'LogicalResourceIdTest1',
-            PhysicalResourceId: 'PhysicalResourceIdTest',
+            OutputKey: 'GetAttLogicalResourceIdTest1TableName',
+            OutputValue: 'TestStackOutputValue1',
+          },
+          {
+            OutputKey: 'InvalidLogicalResourceIdTableName',
+            OutputValue: 'TestStackOutputValue2',
           },
         ],
-      }),
-  }),
-  describeStacks: () => ({
-    promise: () =>
-      Promise.resolve({
-        Stacks: [
+        Parameters: [
           {
-            Outputs: [
-              {
-                OutputKey: 'GetAttLogicalResourceIdTest1TableName',
-                OutputValue: 'TestStackOutputValue1',
-              },
-              {
-                OutputKey: 'InvalidLogicalResourceIdTableName',
-                OutputValue: 'TestStackOutputValue2',
-              },
-            ],
-            Parameters: [
-              {
-                ParameterKey: 'TestParameterKey1',
-                ParameterValue: 'TestParameterValue1',
-              },
-            ],
-            Capabilities: ['CAPABILITY_IAM'],
+            ParameterKey: 'TestParameterKey1',
+            ParameterValue: 'TestParameterValue1',
           },
         ],
-      }),
-  }),
-} as unknown as CloudFormation;
+        Capabilities: ['CAPABILITY_IAM'],
+        StackName: undefined,
+        CreationTime: undefined,
+        StackStatus: undefined,
+      },
+    ],
+  });
 
 describe('amplify-resource-state-utils', () => {
   const StackID = 'TestSTackID';
@@ -49,7 +53,7 @@ describe('amplify-resource-state-utils', () => {
     const expectedTableNameMap: Map<string, string> = new Map();
     expectedTableNameMap.set('LogicalResourceIdTest1', 'TestStackOutputValue1');
 
-    const tableNames = await getTableNames(cfnClientStub, tables, StackID);
+    const tableNames = await getTableNames(mockCfnClient as unknown as CloudFormationClient, tables, StackID);
     expect(tableNames).toEqual(expectedTableNameMap);
   });
 
@@ -58,7 +62,7 @@ describe('amplify-resource-state-utils', () => {
       capabilities: ['CAPABILITY_IAM'],
       parameters: { TestParameterKey1: 'TestParameterValue1' },
     };
-    const prevDeploymentRecord = await getPreviousDeploymentRecord(cfnClientStub, StackID);
+    const prevDeploymentRecord = await getPreviousDeploymentRecord(mockCfnClient as unknown as CloudFormationClient, StackID);
 
     expect(prevDeploymentRecord).toEqual(expectedPrevDeploymentRecord);
   });