Skip to content

Commit e40271e

Browse files
dgandhi62dgandhi62
committed
fix: remove 'as any' assertions from notification tests and add SIGKILL test to RUN_SOLO
1 parent 7fdd750 commit e40271e

4 files changed

Lines changed: 67 additions & 46 deletions

File tree

‎packages/amplify-category-notifications/src/__tests__/channel-apns.test.ts‎

Lines changed: 39 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@ jest.mock('../apns-cert-config');
1717
jest.mock('@aws-amplify/amplify-prompts');
1818
const prompterMock = prompter as jest.Mocked<typeof prompter>;
1919

20-
const mockPinpointClient = mockClient(PinpointClient as any);
20+
const mockPinpointClient = mockClient(PinpointClient);
2121

2222
class NoErrorThrownError extends Error {}
2323
// wrapper to avoid conditional error checks
@@ -48,8 +48,20 @@ describe('channel-APNS', () => {
4848
mockServiceOutput[channelName] = mockChannelOutput;
4949

5050
const mockPinpointResponseErr = new Error('channel-APNS.test.js error');
51-
const mockPinpointResponseData = {
52-
APNSChannelResponse: { Enabled: true, ApplicationId: 'test-app-id' },
51+
const mockApnsChannelResponseData = {
52+
APNSChannelResponse: {
53+
Enabled: true,
54+
ApplicationId: 'test-app-id',
55+
Platform: 'APNS' as const,
56+
},
57+
};
58+
59+
const mockApnsSandboxChannelResponseData = {
60+
APNSSandboxChannelResponse: {
61+
Enabled: true,
62+
ApplicationId: 'test-app-id',
63+
Platform: 'APNS_SANDBOX' as const,
64+
},
5365
};
5466

5567
const mockAPNSChannelResponseData = (status: boolean, action: ChannelAction, output: $TSAny): IChannelAPIResponse => ({
@@ -74,7 +86,7 @@ describe('channel-APNS', () => {
7486
serviceMeta: {
7587
output: mockServiceOutput,
7688
},
77-
pinpointClient: mockPinpointClient as any,
89+
pinpointClient: mockPinpointClient as unknown as PinpointClient,
7890
},
7991
print: {
8092
info: jest.fn(),
@@ -96,73 +108,73 @@ describe('channel-APNS', () => {
96108
});
97109

98110
test('configure', async () => {
99-
mockPinpointClient.on(UpdateApnsChannelCommand as any).resolves(mockPinpointResponseData as any);
100-
mockPinpointClient.on(UpdateApnsSandboxChannelCommand as any).resolves(mockPinpointResponseData as any);
111+
mockPinpointClient.on(UpdateApnsChannelCommand).resolves(mockApnsChannelResponseData);
112+
mockPinpointClient.on(UpdateApnsSandboxChannelCommand).resolves(mockApnsSandboxChannelResponseData);
101113

102114
mockChannelOutput.Enabled = true;
103115
prompterMock.yesOrNo.mockResolvedValueOnce(true);
104116
await channelAPNS.configure(mockContext);
105-
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsChannelCommand as any);
117+
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsChannelCommand);
106118

107119
mockChannelOutput.Enabled = true;
108120
prompterMock.yesOrNo.mockResolvedValueOnce(false);
109121
prompterMock.pick.mockResolvedValueOnce('Certificate');
110122
await channelAPNS.configure(mockContext);
111-
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsChannelCommand as any);
123+
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsChannelCommand);
112124

113125
mockChannelOutput.Enabled = false;
114126
prompterMock.yesOrNo.mockResolvedValueOnce(true);
115127
prompterMock.pick.mockResolvedValueOnce('Certificate');
116128
await channelAPNS.configure(mockContext);
117-
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsChannelCommand as any);
129+
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsChannelCommand);
118130
});
119131

120132
test('enable', async () => {
121-
mockPinpointClient.on(UpdateApnsChannelCommand as any).resolves(mockPinpointResponseData as any);
122-
mockPinpointClient.on(UpdateApnsSandboxChannelCommand as any).resolves(mockPinpointResponseData as any);
133+
mockPinpointClient.on(UpdateApnsChannelCommand).resolves(mockApnsChannelResponseData);
134+
mockPinpointClient.on(UpdateApnsSandboxChannelCommand).resolves(mockApnsSandboxChannelResponseData);
123135

124136
prompterMock.pick.mockResolvedValueOnce('Certificate');
125137
const disableData = await channelAPNS.enable(mockContext, 'successMessage');
126-
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsChannelCommand as any);
127-
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsSandboxChannelCommand as any);
128-
expect(disableData).toEqual(mockAPNSChannelResponseData(true, ChannelAction.ENABLE, mockPinpointResponseData.APNSChannelResponse));
138+
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsChannelCommand);
139+
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsSandboxChannelCommand);
140+
expect(disableData).toEqual(mockAPNSChannelResponseData(true, ChannelAction.ENABLE, mockApnsChannelResponseData.APNSChannelResponse));
129141

130142
prompterMock.pick.mockResolvedValueOnce('Key');
131143
const enableData = await channelAPNS.enable(mockContext, 'successMessage');
132-
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsChannelCommand as any);
133-
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsSandboxChannelCommand as any);
134-
expect(enableData).toEqual(mockAPNSChannelResponseData(true, ChannelAction.ENABLE, mockPinpointResponseData.APNSChannelResponse));
144+
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsChannelCommand);
145+
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsSandboxChannelCommand);
146+
expect(enableData).toEqual(mockAPNSChannelResponseData(true, ChannelAction.ENABLE, mockApnsChannelResponseData.APNSChannelResponse));
135147
});
136148

137149
test('enable unsuccessful', async () => {
138-
mockPinpointClient.on(UpdateApnsChannelCommand as any).rejects(mockPinpointResponseErr);
150+
mockPinpointClient.on(UpdateApnsChannelCommand).rejects(mockPinpointResponseErr);
139151

140152
prompterMock.pick.mockResolvedValueOnce('Certificate');
141153
const errCert: AmplifyFault = await getError(async () => channelAPNS.enable(mockContext, 'successMessage'));
142-
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsChannelCommand as any);
154+
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsChannelCommand);
143155
expect(errCert?.downstreamException?.message).toContain(mockPinpointResponseErr.message);
144156

145157
prompterMock.pick.mockResolvedValueOnce('Key');
146158
const errKey: AmplifyFault = await getError(async () => channelAPNS.enable(mockContext, 'successMessage'));
147-
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsChannelCommand as any);
159+
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsChannelCommand);
148160
expect(errKey?.downstreamException?.message).toContain(mockPinpointResponseErr.message);
149161
});
150162

151163
test('disable', async () => {
152-
mockPinpointClient.on(UpdateApnsChannelCommand as any).resolves(mockPinpointResponseData as any);
153-
mockPinpointClient.on(UpdateApnsSandboxChannelCommand as any).resolves(mockPinpointResponseData as any);
164+
mockPinpointClient.on(UpdateApnsChannelCommand).resolves(mockApnsChannelResponseData);
165+
mockPinpointClient.on(UpdateApnsSandboxChannelCommand).resolves(mockApnsSandboxChannelResponseData);
154166

155167
const data = await channelAPNS.disable(mockContext);
156-
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsChannelCommand as any);
157-
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsSandboxChannelCommand as any);
158-
expect(data).toEqual(mockAPNSChannelResponseData(true, ChannelAction.DISABLE, mockPinpointResponseData.APNSChannelResponse));
168+
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsChannelCommand);
169+
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsSandboxChannelCommand);
170+
expect(data).toEqual(mockAPNSChannelResponseData(true, ChannelAction.DISABLE, mockApnsChannelResponseData.APNSChannelResponse));
159171
});
160172

161173
test('disable unsuccessful', async () => {
162-
mockPinpointClient.on(UpdateApnsChannelCommand as any).rejects(mockPinpointResponseErr);
174+
mockPinpointClient.on(UpdateApnsChannelCommand).rejects(mockPinpointResponseErr);
163175

164176
const errKey: AmplifyFault = await getError(async () => channelAPNS.disable(mockContext));
165-
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsChannelCommand as any);
177+
expect(mockPinpointClient).toHaveReceivedCommand(UpdateApnsChannelCommand);
166178
expect(errKey?.downstreamException?.message).toContain(mockPinpointResponseErr.message);
167179
});
168180
});

‎packages/amplify-category-notifications/src/__tests__/channel-email.test.ts‎

Lines changed: 9 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,7 @@ jest.mock('@aws-amplify/amplify-cli-core', () => {
2222
jest.mock('@aws-amplify/amplify-prompts');
2323
const prompterMock = prompter as jest.Mocked<typeof prompter>;
2424

25-
const mockPinpointClient = mockClient(PinpointClient as any);
25+
const mockPinpointClient = mockClient(PinpointClient);
2626

2727
const mockPinpointResponseData = (status: boolean, action: ChannelAction, output: any): IChannelAPIResponse => ({
2828
action,
@@ -44,7 +44,7 @@ const mockContext = (output: $TSAny): $TSContext =>
4444
serviceMeta: {
4545
output,
4646
},
47-
pinpointClient: mockPinpointClient as any,
47+
pinpointClient: mockPinpointClient as unknown as PinpointClient,
4848
},
4949
print: {
5050
info: jest.fn(),
@@ -53,21 +53,25 @@ const mockContext = (output: $TSAny): $TSContext =>
5353
} as unknown as $TSContext);
5454

5555
describe('channel-Email', () => {
56-
const mockEmailChannelResponse = { Enabled: true, ApplicationId: 'test-app-id' };
56+
const mockEmailChannelResponse = {
57+
Enabled: true,
58+
ApplicationId: 'test-app-id',
59+
Platform: 'EMAIL' as const,
60+
};
5761

5862
beforeEach(() => {
5963
mockPinpointClient.reset();
6064
});
6165

6266
test('enable should store role arn', async () => {
63-
mockPinpointClient.on(UpdateEmailChannelCommand as any).resolves({ EmailChannelResponse: mockEmailChannelResponse } as any);
67+
mockPinpointClient.on(UpdateEmailChannelCommand).resolves({ EmailChannelResponse: mockEmailChannelResponse });
6468
prompterMock.input.mockResolvedValueOnce('fake@email.com');
6569
prompterMock.input.mockResolvedValueOnce('fake:arn:identity');
6670
prompterMock.input.mockResolvedValueOnce('fake:arn:role');
6771

6872
const mockContextObj = mockContext({ Enabled: true });
6973
const data = await channelEmail.enable(mockContextObj, 'successMessage');
70-
expect(mockPinpointClient).toHaveReceivedCommandWith(UpdateEmailChannelCommand as any, {
74+
expect(mockPinpointClient).toHaveReceivedCommandWith(UpdateEmailChannelCommand, {
7175
ApplicationId: undefined,
7276
EmailChannelRequest: {
7377
FromAddress: 'fake@email.com',

‎packages/amplify-category-notifications/src/__tests__/channel-fcm.test.ts‎

Lines changed: 18 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,7 @@ jest.mock('fs-extra', () => ({
2929
jest.mock('@aws-amplify/amplify-prompts');
3030
const prompterMock = prompter as jest.Mocked<typeof prompter>;
3131

32-
const mockPinpointClient = mockClient(PinpointClient as any);
32+
const mockPinpointClient = mockClient(PinpointClient);
3333

3434
class NoErrorThrownError extends Error {}
3535
const getError = async <TError>(call: () => unknown): Promise<TError> => {
@@ -62,7 +62,7 @@ const mockContext = (output: $TSAny): $TSContext =>
6262
serviceMeta: {
6363
output,
6464
},
65-
pinpointClient: mockPinpointClient as any,
65+
pinpointClient: mockPinpointClient as unknown as PinpointClient,
6666
},
6767
print: {
6868
info: jest.fn(),
@@ -76,42 +76,46 @@ describe('channel-FCM', () => {
7676
mockServiceOutput[channelName] = mockChannelEnabledOutput;
7777

7878
const mockPinpointResponseErr = new Error('channel-FCM.test.js error');
79-
const mockGCMChannelResponse = { Enabled: true, ApplicationId: 'test-app-id' };
79+
const mockGCMChannelResponse = {
80+
Enabled: true,
81+
ApplicationId: 'test-app-id',
82+
Platform: 'GCM' as const,
83+
};
8084

8185
beforeEach(() => {
8286
mockPinpointClient.reset();
8387
});
8488

8589
test('configure', async () => {
86-
mockPinpointClient.on(UpdateGcmChannelCommand as any).resolves({ GCMChannelResponse: mockGCMChannelResponse } as any);
90+
mockPinpointClient.on(UpdateGcmChannelCommand).resolves({ GCMChannelResponse: mockGCMChannelResponse });
8791

8892
mockChannelEnabledOutput.Enabled = true;
8993
prompterMock.yesOrNo.mockResolvedValueOnce(true);
9094
prompterMock.input.mockResolvedValueOnce(serviceJSONFilePath);
9195

9296
const mockContextObj = mockContext(mockChannelEnabledOutput);
9397
await channelFCM.configure(mockContextObj);
94-
expect(mockPinpointClient).toHaveReceivedCommand(UpdateGcmChannelCommand as any);
98+
expect(mockPinpointClient).toHaveReceivedCommand(UpdateGcmChannelCommand);
9599

96100
mockChannelEnabledOutput.Enabled = true;
97101
prompterMock.yesOrNo.mockResolvedValueOnce(false);
98102
prompterMock.input.mockResolvedValueOnce(serviceJSONFilePath);
99103
await channelFCM.configure(mockContext(mockChannelEnabledOutput));
100-
expect(mockPinpointClient).toHaveReceivedCommand(UpdateGcmChannelCommand as any);
104+
expect(mockPinpointClient).toHaveReceivedCommand(UpdateGcmChannelCommand);
101105

102106
mockChannelEnabledOutput.Enabled = false;
103107
prompterMock.yesOrNo.mockResolvedValueOnce(true);
104108
prompterMock.input.mockResolvedValueOnce(serviceJSONFilePath);
105109
await channelFCM.configure(mockContext(mockChannelEnabledOutput));
106-
expect(mockPinpointClient).toHaveReceivedCommand(UpdateGcmChannelCommand as any);
110+
expect(mockPinpointClient).toHaveReceivedCommand(UpdateGcmChannelCommand);
107111
});
108112

109113
test('enable', async () => {
110-
mockPinpointClient.on(UpdateGcmChannelCommand as any).resolves({ GCMChannelResponse: mockGCMChannelResponse } as any);
114+
mockPinpointClient.on(UpdateGcmChannelCommand).resolves({ GCMChannelResponse: mockGCMChannelResponse });
111115
prompterMock.input.mockResolvedValueOnce(serviceJSONFilePath);
112116
const mockContextObj = mockContext(mockChannelEnabledOutput);
113117
const data = await channelFCM.enable(mockContextObj, 'successMessage');
114-
expect(mockPinpointClient).toHaveReceivedCommandWith(UpdateGcmChannelCommand as any, {
118+
expect(mockPinpointClient).toHaveReceivedCommandWith(UpdateGcmChannelCommand, {
115119
ApplicationId: undefined,
116120
GCMChannelRequest: {
117121
ServiceJson: serviceAccountJson,
@@ -123,25 +127,25 @@ describe('channel-FCM', () => {
123127
});
124128

125129
test('enable unsuccessful', async () => {
126-
mockPinpointClient.on(UpdateGcmChannelCommand as any).rejects(mockPinpointResponseErr);
130+
mockPinpointClient.on(UpdateGcmChannelCommand).rejects(mockPinpointResponseErr);
127131
prompterMock.input.mockResolvedValueOnce(serviceJSONFilePath);
128132

129133
const context = mockContext(mockServiceOutput);
130134
const errCert: AmplifyFault = await getError(async () => channelFCM.enable(context, 'successMessage'));
131-
expect(mockPinpointClient).toHaveReceivedCommand(UpdateGcmChannelCommand as any);
135+
expect(mockPinpointClient).toHaveReceivedCommand(UpdateGcmChannelCommand);
132136
expect(errCert?.downstreamException?.message).toContain(mockPinpointResponseErr.message);
133137
});
134138

135139
test('disable', async () => {
136-
mockPinpointClient.on(UpdateGcmChannelCommand as any).resolves({ GCMChannelResponse: mockGCMChannelResponse } as any);
140+
mockPinpointClient.on(UpdateGcmChannelCommand).resolves({ GCMChannelResponse: mockGCMChannelResponse });
137141
prompterMock.input.mockResolvedValueOnce(serviceJSONFilePath);
138142
const data = await channelFCM.disable(mockContext(mockServiceOutput));
139-
expect(mockPinpointClient).toHaveReceivedCommand(UpdateGcmChannelCommand as any);
143+
expect(mockPinpointClient).toHaveReceivedCommand(UpdateGcmChannelCommand);
140144
expect(data).toEqual(mockPinpointResponseData(true, ChannelAction.DISABLE, mockGCMChannelResponse));
141145
});
142146

143147
test('disable unsuccessful', async () => {
144-
mockPinpointClient.on(UpdateGcmChannelCommand as any).rejects(mockPinpointResponseErr);
148+
mockPinpointClient.on(UpdateGcmChannelCommand).rejects(mockPinpointResponseErr);
145149
prompterMock.input.mockResolvedValueOnce(serviceJSONFilePath);
146150
await expect(channelFCM.disable(mockContext(mockServiceOutput))).rejects.toThrowError('Failed to disable the FCM channel');
147151
});

‎scripts/split-e2e-tests-codebuild.ts‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,7 @@ const RUN_SOLO = [
1818
'src/__tests__/function_2a.test.ts',
1919
'src/__tests__/geo-add-d.test.ts',
2020
'src/__tests__/geo-add-e.test.ts',
21+
'src/__tests__/migration/api.key.migration5.test.ts',
2122
'src/__tests__/geo-add-f.test.ts',
2223
'src/__tests__/geo-remove-1.test.ts',
2324
'src/__tests__/geo-remove-2.test.ts',

0 commit comments

Comments
 (0)