rename wrappers, finish tests

manwaring · manwaring · commit 0db70307ca66 · 2019-09-03T23:35:11.000-04:00
diff --git a/__mocks__/epsagon.ts b/__mocks__/epsagon.ts
@@ -4,3 +4,6 @@ const epsagon = jest.genMockFromModule('epsagon');
 epsagon.label = function(key: string) {};
 
 module.exports = epsagon;
+// module.exports = (function() {
+//   throw new Error();
+// })();
diff --git a/src/api/wrapper.test.ts b/src/api/wrapper.test.ts
@@ -1,5 +1,5 @@
 import createEvent from '@serverless/event-mocks';
-import { apiWrapper, ApiSignature } from './wrapper';
+import { api, ApiSignature } from './wrapper';
 
 describe('API wrapper', () => {
   // @ts-ignore
@@ -36,6 +36,6 @@ describe('API wrapper', () => {
       expect(redirect).toBeInstanceOf(Function);
       expect(error).toBeInstanceOf(Function);
     }
-    apiWrapper(mockHandler)(requestEvent);
+    api(mockHandler)(requestEvent);
   });
 });
diff --git a/src/api/wrapper.ts b/src/api/wrapper.ts
@@ -2,7 +2,7 @@ import { APIGatewayEvent } from 'aws-lambda';
 import { Request } from './parser';
 import { success, invalid, redirect, error } from './responses';
 
-export function apiWrapper<T extends Function>(fn: T): T {
+export function api<T extends Function>(fn: T): T {
   return <any>function(event: APIGatewayEvent) {
     const { body, path, query, auth, headers, testRequest } = new Request(event).getProperties();
 
diff --git a/src/authorizer/index.ts b/src/authorizer/index.ts
diff --git a/src/authorizer/responses.test.ts b/src/authorizer/responses.test.ts
@@ -43,6 +43,26 @@ describe('Lambda Authorizer responses', () => {
     });
   });
 
+  it('Handles valid response without jwt subs or claims', () => {
+    const jwt = {
+      name: 'John Doe',
+      admin: true
+    };
+    expect(valid(jwt)).toEqual({
+      principalId: '',
+      policyDocument: {
+        Version: '2012-10-17',
+        Statement: [
+          {
+            Action: 'execute-api:Invoke',
+            Effect: 'Allow',
+            Resource: 'arn:aws:execute-api:**'
+          }
+        ]
+      }
+    });
+  });
+
   it('Handles invalid response', () => {
     expect(() => invalid()).toThrow('Unauthorized');
   });
diff --git a/src/authorizer/responses.ts b/src/authorizer/responses.ts
diff --git a/src/authorizer/wrapper.test.ts b/src/authorizer/wrapper.test.ts
@@ -1,4 +1,4 @@
-import { authWrapper, AuthorizerSignature } from './wrapper';
+import { authorizer, AuthorizerSignature } from './wrapper';
 
 describe('Stream wrapper', () => {
   const requestEvent = {
@@ -16,6 +16,6 @@ describe('Stream wrapper', () => {
       expect(error).toBeInstanceOf(Function);
     }
     // @ts-ignore
-    authWrapper(mockHandler)(requestEvent);
+    authorizer(mockHandler)(requestEvent);
   });
 });
diff --git a/src/authorizer/wrapper.ts b/src/authorizer/wrapper.ts
@@ -4,7 +4,7 @@ import { valid, invalid, error } from './responses';
 
 const metrics = new Metrics('Lambda Authorizer');
 
-export function authWrapper<T extends Function>(fn: T): T {
+export function authorizer<T extends Function>(fn: T): T {
   return <any>function(event: CustomAuthorizerEvent) {
     metrics.common(event);
     const token = event.authorizationToken;
diff --git a/src/cloudformation/wrapper.test.ts b/src/cloudformation/wrapper.test.ts
@@ -1,4 +1,4 @@
-import { cloudFormationWrapper, CloudFormationSignature } from './wrapper';
+import { cloudFormation, CloudFormationSignature } from './wrapper';
 import { CloudFormationCustomResourceEvent } from 'aws-lambda';
 
 describe('Stream wrapper', () => {
@@ -22,6 +22,6 @@ describe('Stream wrapper', () => {
       expect(failure).toBeInstanceOf(Function);
     }
     // @ts-ignore
-    cloudFormationWrapper(mockHandler)(requestEvent);
+    cloudFormation(mockHandler)(requestEvent);
   });
 });
diff --git a/src/cloudformation/wrapper.ts b/src/cloudformation/wrapper.ts
@@ -4,7 +4,7 @@ import { successWrapper, failureWrapper } from './responses';
 
 const metrics = new Metrics('CloudFormation');
 
-export function cloudFormationWrapper<T extends Function>(fn: T): T {
+export function cloudFormation<T extends Function>(fn: T): T {
   return <any>function(event: CloudFormationCustomResourceEvent, context: Context) {
     metrics.common(event);
 
diff --git a/src/common/metrics.test.ts b/src/common/metrics.test.ts
@@ -60,3 +60,47 @@ describe('Metrics tagging', () => {
     expect(console.log).toHaveBeenCalledWith('failure', response);
   });
 });
+
+describe('Metrics tagging with missing libs', () => {
+  const ORIGINAL_ENVS = process.env;
+  const commonProps = { REVISION: 'ahf6e', STAGE: 'prod', AWS_REGION: 'us-east-1', LAMBDA_WRAPPER_LOG: 'true' };
+  const payload = { hello: 'world' };
+  const response = { goodbye: 'world' };
+  const type = 'Test';
+
+  afterEach(() => {
+    jest.resetModules();
+    process.env = ORIGINAL_ENVS;
+  });
+
+  it('Handles missing Epsagon', () => {
+    jest.doMock('epsagon', () => {
+      return {
+        __esModule: true,
+        default: (function() {
+          throw new Error();
+        })()
+      };
+    });
+    const { Metrics } = require('./metrics');
+    const metrics = new Metrics(type);
+    metrics.failure(response);
+    expect(console.debug).toHaveBeenCalledWith(`Failure processing ${type} event, responding with`, response);
+    expect(console.log).toHaveBeenCalledWith('failure', response);
+  });
+
+  it('Handles missing IOPipe', () => {
+    jest.doMock('@iopipe/iopipe', () => {
+      return {
+        __esModule: true,
+        default: (function() {
+          throw new Error();
+        })()
+      };
+    });
+    const metrics = new Metrics(type);
+    metrics.failure(response);
+    expect(console.debug).toHaveBeenCalledWith(`Failure processing ${type} event, responding with`, response);
+    expect(console.log).toHaveBeenCalledWith('failure', response);
+  });
+});
diff --git a/src/dynamodb-stream/index.ts b/src/dynamodb-stream/index.ts
diff --git a/src/dynamodb-stream/parser.test.ts b/src/dynamodb-stream/parser.test.ts
diff --git a/src/dynamodb-stream/parser.ts b/src/dynamodb-stream/parser.ts
diff --git a/src/dynamodb-stream/responses.test.ts b/src/dynamodb-stream/responses.test.ts
diff --git a/src/dynamodb-stream/responses.ts b/src/dynamodb-stream/responses.ts
diff --git a/src/dynamodb-stream/wrapper.test.ts b/src/dynamodb-stream/wrapper.test.ts
@@ -1,23 +1,23 @@
 import createEvent from '@serverless/event-mocks';
-import { streamWrapper } from './wrapper';
+import { dynamodbStream } from './wrapper';
 
-describe('Stream wrapper', () => {
+describe('DynamoDB Stream wrapper', () => {
   // @ts-ignore
   const event = createEvent('aws:dynamo', {});
 
   it('Handles success callback', () => {
     function mockHandler({ success }) {
       return success('success');
     }
-    expect(streamWrapper(mockHandler)(event)).toEqual('success');
+    expect(dynamodbStream(mockHandler)(event)).toEqual('success');
   });
 
   it('Handles error callback', () => {
     function mockHandler({ error }) {
       return error('error');
     }
     expect(() => {
-      streamWrapper(mockHandler)(event);
+      dynamodbStream(mockHandler)(event);
     }).toThrow('error');
   });
 });
diff --git a/src/dynamodb-stream/wrapper.ts b/src/dynamodb-stream/wrapper.ts
@@ -5,17 +5,17 @@ import { success, error } from './responses';
 
 const metrics = new Metrics('DynamoDB Stream');
 
-export function streamWrapper<T extends Function>(fn: T): T {
+export function dynamodbStream<T extends Function>(fn: T): T {
   return <any>function(event: DynamoDBStreams.GetRecordsOutput) {
     const { newVersions, oldVersions, versions } = new DynamoDBStreamParser(event).getVersions();
     metrics.common({ newVersions, oldVersions, versions });
 
-    const signature: StreamSignature = { event, newVersions, oldVersions, versions, success, error };
+    const signature: DynamoDBStreamSignature = { event, newVersions, oldVersions, versions, success, error };
     return fn(signature);
   };
 }
 
-export interface StreamSignature {
+export interface DynamoDBStreamSignature {
   event: DynamoDBStreams.GetRecordsOutput; // original event
   newVersions: any[]; // array of all unmarshalled javascript objects of new images
   oldVersions: any[]; // array of all unmarshalled javascript objects of old images
diff --git a/src/index.ts b/src/index.ts
@@ -1,6 +1,6 @@
 export * from './api';
-export * from './auth';
+export * from './authorizer';
 export * from './cloudformation';
 export * from './sns';
-export * from './stream';
+export * from './dynamodb-stream';
 export * from './generic';
diff --git a/src/sns/responses.ts b/src/sns/responses.ts
@@ -1,6 +1,6 @@
 import { Metrics } from '../common';
 
-const metrics = new Metrics('SNS');
+const metrics = new Metrics('Sns');
 
 export function success(message: any): void {
   metrics.success(message);
diff --git a/src/sns/wrapper.test.ts b/src/sns/wrapper.test.ts
@@ -1,5 +1,5 @@
 import createEvent from '@serverless/event-mocks';
-import { snsWrapper, SnsSignature } from './wrapper';
+import { sns, SnsSignature } from './wrapper';
 
 describe('Stream wrapper', () => {
   const Sns = {
@@ -15,6 +15,6 @@ describe('Stream wrapper', () => {
       expect(success).toBeInstanceOf(Function);
       expect(error).toBeInstanceOf(Function);
     }
-    snsWrapper(mockHandler)(requestEvent);
+    sns(mockHandler)(requestEvent);
   });
 });
diff --git a/src/sns/wrapper.ts b/src/sns/wrapper.ts
@@ -3,9 +3,9 @@ import { Metrics } from '../common';
 import { success, error } from './responses';
 import { SnsParser } from './parser';
 
-const metrics = new Metrics('SNS');
+const metrics = new Metrics('Sns');
 
-export function snsWrapper<T extends Function>(fn: T): T {
+export function sns<T extends Function>(fn: T): T {
   return <any>function(event: SNSEvent) {
     const message = new SnsParser(event).getMessage();
     metrics.common(message);
