update scheduler with async calls

Author: eduardomourar

src/scheduler.ts

@@ -18,12 +18,12 @@ const LOGGER = console;
  * @param handlerRequest additional context which the handler can provide itself
  *            for re-invocation
  */
-export function rescheduleAfterMinutes(
+export const rescheduleAfterMinutes = async (
     session: SessionProxy,
     functionArn: string,
     minutesFromNow: number,
     handlerRequest: HandlerRequest,
-): void {
+): Promise<void> => {
     const client: CloudWatchEvents = session.client('CloudWatchEvents') as CloudWatchEvents;
     const cron = minToCron(Math.max(minutesFromNow, 1));
     const identifier = uuidv4();
@@ -33,19 +33,19 @@ export function rescheduleAfterMinutes(
     handlerRequest.requestContext.cloudWatchEventsTargetId = targetId;
     const jsonRequest = JSON.stringify(handlerRequest);
     LOGGER.debug(`Scheduling re-invoke at ${cron} (${identifier})`);
-    client.putRule({
+    await client.putRule({
         Name: ruleName,
         ScheduleExpression: cron,
         State: 'ENABLED',
-    });
-    client.putTargets({
+    }).promise();
+    await client.putTargets({
         Rule: ruleName,
         Targets: [{
             Id: targetId,
             Arn: functionArn,
             Input: jsonRequest,
         }],
-    });
+    }).promise();
 }
 
 /**
@@ -56,16 +56,16 @@ export function rescheduleAfterMinutes(
  * @param ruleName the name of the CWE rule which triggered a re-invocation
  * @param targetId the target of the CWE rule which triggered a re-invocation
  */
-export function cleanupCloudwatchEvents(
+export const cleanupCloudwatchEvents = async (
     session: SessionProxy, ruleName: string, targetId: string
-): void {
+): Promise<void> => {
     const client: CloudWatchEvents = session.client('CloudWatchEvents') as CloudWatchEvents;
     try {
         if (targetId && ruleName) {
-            client.removeTargets({
+            await client.removeTargets({
                 Rule: ruleName,
                 Ids: [targetId],
-            });
+            }).promise();
         }
     } catch(err) {
         LOGGER.error(
@@ -75,10 +75,10 @@ export function cleanupCloudwatchEvents(
 
     try {
         if (ruleName) {
-            client.deleteRule({
+            await client.deleteRule({
                 Name: ruleName,
                 Force: true,
-            });
+            }).promise();
         }
     } catch(err) {
         LOGGER.error(

tests/lib/scheduler.test.ts

@@ -71,28 +71,28 @@ describe('when getting scheduler', () => {
         jest.restoreAllMocks();
     });
 
-    test('reschedule after minutes zero', () => {
+    test('reschedule after minutes zero', async () => {
         // if called with zero, should call cron with a 1
-        rescheduleAfterMinutes(session, 'arn:goes:here', 0, handlerRequest);
+        await rescheduleAfterMinutes(session, 'arn:goes:here', 0, handlerRequest);
 
         expect(cwEvents).toHaveBeenCalledTimes(1);
         expect(cwEvents).toHaveBeenCalledWith('CloudWatchEvents');
         expect(spyMinToCron).toHaveBeenCalledTimes(1);
         expect(spyMinToCron).toHaveBeenCalledWith(1);
     });
 
-    test('reschedule after minutes not zero', () => {
+    test('reschedule after minutes not zero', async () => {
         // if called with another number, should use that
-        rescheduleAfterMinutes(session, 'arn:goes:here', 2, handlerRequest);
+        await rescheduleAfterMinutes(session, 'arn:goes:here', 2, handlerRequest);
 
         expect(cwEvents).toHaveBeenCalledTimes(1);
         expect(cwEvents).toHaveBeenCalledWith('CloudWatchEvents');
         expect(spyMinToCron).toHaveBeenCalledTimes(1);
         expect(spyMinToCron).toHaveBeenCalledWith(2);
     });
 
-    test('reschedule after minutes success', () => {
-        rescheduleAfterMinutes(session, 'arn:goes:here', 2, handlerRequest);
+    test('reschedule after minutes success', async () => {
+        await rescheduleAfterMinutes(session, 'arn:goes:here', 2, handlerRequest);
 
         expect(cwEvents).toHaveBeenCalledTimes(1);
         expect(cwEvents).toHaveBeenCalledWith('CloudWatchEvents');
@@ -115,9 +115,9 @@ describe('when getting scheduler', () => {
         });
     });
 
-    test('cleanup cloudwatch events empty', () => {
+    test('cleanup cloudwatch events empty', async () => {
         // cleanup should silently pass if rule/target are empty
-        cleanupCloudwatchEvents(session, '', '');
+        await cleanupCloudwatchEvents(session, '', '');
 
         expect(cwEvents).toHaveBeenCalledTimes(1);
         expect(cwEvents).toHaveBeenCalledWith('CloudWatchEvents');
@@ -126,10 +126,10 @@ describe('when getting scheduler', () => {
         expect(spyConsoleError).toHaveBeenCalledTimes(0);
     });
 
-    test('cleanup cloudwatch events success', () => {
+    test('cleanup cloudwatch events success', async () => {
         // when rule_name and target_id are provided we should call events client and not
         // log errors if the deletion succeeds
-        cleanupCloudwatchEvents(session, 'rulename', 'targetid');
+        await cleanupCloudwatchEvents(session, 'rulename', 'targetid');
 
         expect(spyConsoleError).toHaveBeenCalledTimes(0);
         expect(cwEvents).toHaveBeenCalledTimes(1);
@@ -140,13 +140,13 @@ describe('when getting scheduler', () => {
         expect(spyConsoleError).toHaveBeenCalledTimes(0);
     });
 
-    test('cleanup cloudwatch events client error', () => {
+    test('cleanup cloudwatch events client error', async () => {
         // cleanup should catch and log client failures
         const error = awsUtil.error(new Error(), { code: '1' });
         mockRemoveTargets.mockImplementation(() => {throw error});
         mockDeleteRule.mockImplementation(() => {throw error});
 
-        cleanupCloudwatchEvents(session, 'rulename', 'targetid');
+        await cleanupCloudwatchEvents(session, 'rulename', 'targetid');
 
         expect(cwEvents).toHaveBeenCalledTimes(1);
         expect(cwEvents).toHaveBeenCalledWith('CloudWatchEvents');