refactor(lambda errors): do not throw errors when no lambda handler (#229)

- list API sends a bunch of events, only one of which we want to handle
  in this lambda, so we don't want to error on the others.

Author: jpetto

lambda/events/index.spec.ts

@@ -5,19 +5,28 @@ import { SQSEvent } from 'aws-lambda';
 import * as Sentry from '@sentry/serverless';
 
 describe('event handlers', () => {
-  let deleteStub: sinon.SinonStub;
+  let accountDeleteStub: sinon.SinonStub;
+  let saveDeleteStub: sinon.SinonStub;
   let sentryStub: sinon.SinonStub;
+
   beforeEach(() => {
     sinon.restore();
     sentryStub = sinon.stub(Sentry, 'captureException');
   });
+
   afterAll(() => sinon.restore());
+
   describe('with no handler errors', () => {
     beforeEach(() => {
-      deleteStub = sinon.stub(handlers, Event.ACCOUNT_DELETION).resolves();
+      accountDeleteStub = sinon
+        .stub(handlers, Event.ACCOUNT_DELETION)
+        .resolves();
+
+      saveDeleteStub = sinon.stub(handlers, Event.DELETE_ITEM).resolves();
     });
+
     it('routes to the correct handler function based on detail-type', async () => {
-      const records = {
+      let records = {
         Records: [
           {
             body: JSON.stringify({
@@ -28,32 +37,55 @@ describe('event handlers', () => {
           },
         ],
       };
+
       await processor(records as SQSEvent);
-      expect(deleteStub.callCount).toEqual(1);
-      expect(deleteStub.getCall(0).args).toEqual([records.Records[0]]);
+      expect(accountDeleteStub.callCount).toEqual(1);
+      expect(accountDeleteStub.getCall(0).args).toEqual([records.Records[0]]);
+
+      records = {
+        Records: [
+          {
+            body: JSON.stringify({
+              Message: JSON.stringify({
+                'detail-type': Event.DELETE_ITEM,
+              }),
+            }),
+          },
+        ],
+      };
+
+      await processor(records as SQSEvent);
+      expect(saveDeleteStub.callCount).toEqual(1);
+      expect(saveDeleteStub.getCall(0).args).toEqual([records.Records[0]]);
     });
-    it('returns batchItemFailure and logs to Sentry if handler does not exist', async () => {
+    it('is a NOOP if a handler does not exist', async () => {
       const records = {
         Records: [
           {
             body: JSON.stringify({
-              Message: JSON.stringify({ 'detail-type': 'NOT_A_TYPE' }),
+              Message: JSON.stringify({
+                'detail-type': 'NOT_A_TYPE_I_CAN_HANDLE',
+              }),
             }),
             messageId: 'abc',
           },
         ],
       };
+
       const res = await processor(records as SQSEvent);
-      expect(res.batchItemFailures).toEqual([{ itemIdentifier: 'abc' }]);
-      expect(sentryStub.callCount).toEqual(1);
-      expect(sentryStub.getCall(0).args[0].message).toEqual(
-        `Unable to retrieve handler for detail-type='NOT_A_TYPE'`
-      );
+
+      // no failures/errors
+      expect(res.batchItemFailures).toEqual([]);
+      expect(sentryStub.callCount).toEqual(0);
+
+      // no handlers were called
+      expect(accountDeleteStub.callCount).toEqual(0);
+      expect(saveDeleteStub.callCount).toEqual(0);
     });
   });
   describe('with handler errors', () => {
     beforeEach(() => {
-      deleteStub = sinon
+      accountDeleteStub = sinon
         .stub(handlers, Event.ACCOUNT_DELETION)
         .rejects(Error('got an error'));
     });

lambda/events/index.ts

@@ -11,21 +11,22 @@ import { handlers } from './handlers';
  */
 export async function processor(event: SQSEvent): Promise<SQSBatchResponse> {
   const batchFailures: SQSBatchItemFailure[] = [];
+
   for await (const record of event.Records) {
     try {
       const message = JSON.parse(JSON.parse(record.body).Message);
-      if (handlers[message['detail-type']] == null) {
-        throw new Error(
-          `Unable to retrieve handler for detail-type='${message['detail-type']}'`
-        );
+      const handler = handlers[message['detail-type']];
+
+      if (handler !== undefined) {
+        await handler(record);
       }
-      await handlers[message['detail-type']](record);
     } catch (error) {
       console.log(error);
       Sentry.captureException(error);
       batchFailures.push({ itemIdentifier: record.messageId });
     }
   }
+
   return { batchItemFailures: batchFailures };
 }