add tests to generic and cloudformation wrappers

Author: manwaring

src/cloudformation/index.ts

@@ -1 +1 @@
-export * from './cloudformation';
+export * from './wrapper';

src/cloudformation/responses.test.ts

@@ -0,0 +1,48 @@
+import { Context, CloudFormationCustomResourceEvent } from 'aws-lambda';
+import { send } from 'cfn-response';
+import { successWrapper, failureWrapper } from './responses';
+
+jest.mock('cfn-response');
+
+describe('Cloudformation responses', () => {
+  const event: CloudFormationCustomResourceEvent = {
+    RequestType: 'Create',
+    ServiceToken: 'token',
+    ResponseURL: 'url',
+    StackId: 'stackId',
+    RequestId: 'requestId',
+    LogicalResourceId: 'resourceId',
+    ResourceType: 'resourceType',
+    ResourceProperties: {
+      ServiceToken: 'serviceToken'
+    }
+  };
+  const context: Context = {
+    callbackWaitsForEmptyEventLoop: false,
+    functionName: 'function-name',
+    functionVersion: '$LATEST',
+    invokedFunctionArn: 'arn:',
+    memoryLimitInMB: 128,
+    awsRequestId: 'request',
+    logGroupName: 'group',
+    logStreamName: 'stream',
+    getRemainingTimeInMillis: () => 2,
+    done: () => {},
+    fail: () => {},
+    succeed: () => {}
+  };
+
+  it('Handles successWrapper response', () => {
+    const success = successWrapper(event, context);
+    expect(success).toBeInstanceOf(Function);
+    success('success');
+    expect(send).toBeCalled();
+  });
+
+  it('Handles failureWrapper response', () => {
+    const failure = failureWrapper(event, context);
+    expect(failure).toBeInstanceOf(Function);
+    failure('failure');
+    expect(send).toBeCalled();
+  });
+});

src/cloudformation/responses.ts

@@ -0,0 +1,18 @@
+import { Context, CloudFormationCustomResourceEvent } from 'aws-lambda';
+import { send, SUCCESS, FAILED } from 'cfn-response';
+import { Metrics } from '../common';
+
+const metrics = new Metrics('Cloudformation');
+
+export function successWrapper(event: CloudFormationCustomResourceEvent, context: Context) {
+  return function success(message?: any): void {
+    metrics.success(message);
+    return send(event, context, SUCCESS);
+  };
+}
+export function failureWrapper(event: CloudFormationCustomResourceEvent, context: Context) {
+  return function failure(message: any): void {
+    metrics.failure(message);
+    return send(event, context, FAILED);
+  };
+}

src/cloudformation/wrapper.test.ts

@@ -0,0 +1,27 @@
+import { cloudFormationWrapper, CloudFormationSignature } from './wrapper';
+import { CloudFormationCustomResourceEvent } from 'aws-lambda';
+
+describe('Stream wrapper', () => {
+  const requestEvent: CloudFormationCustomResourceEvent = {
+    RequestType: 'Create',
+    ServiceToken: 'token',
+    ResponseURL: 'url',
+    StackId: 'stackId',
+    RequestId: 'requestId',
+    LogicalResourceId: 'resourceId',
+    ResourceType: 'resourceType',
+    ResourceProperties: {
+      ServiceToken: 'serviceToken'
+    }
+  };
+
+  it('Has expected properties and response funtions', () => {
+    function mockHandler({ event, success, failure }: CloudFormationSignature) {
+      expect(event).toEqual(requestEvent);
+      expect(success).toBeInstanceOf(Function);
+      expect(failure).toBeInstanceOf(Function);
+    }
+    // @ts-ignore
+    cloudFormationWrapper(mockHandler)(requestEvent);
+  });
+});

src/cloudformation/cloudformation.ts renamed to src/cloudformation/wrapper.ts

@@ -1,24 +1,19 @@
-import { CloudFormationCustomResourceEvent, Context, Callback } from 'aws-lambda';
-import { send, SUCCESS, FAILED } from 'cfn-response';
+import { CloudFormationCustomResourceEvent, Context } from 'aws-lambda';
 import { Metrics } from '../common';
+import { successWrapper, failureWrapper } from './responses';
 
 const metrics = new Metrics('CloudFormation');
 
 export function cloudFormationWrapper<T extends Function>(fn: T): T {
-  return <any>function(event: CloudFormationCustomResourceEvent, context: Context, callback: Callback) {
+  return <any>function(event: CloudFormationCustomResourceEvent, context: Context) {
     metrics.common(event);
 
-    function success(message?: any): void {
-      metrics.success(message);
-      return send(event, context, SUCCESS);
-    }
-
-    function failure(message: any): void {
-      metrics.failure(message);
-      return send(event, context, FAILED);
-    }
-
-    const signature: CloudFormationSignature = { event, success, failure };
+    const signature: CloudFormationSignature = {
+      event,
+      // We need to call these response wrappers so that we can pass in context (necessary for CloudFormation responses) so that
+      success: successWrapper(event, context),
+      failure: failureWrapper(event, context)
+    };
     return fn(signature);
   };
 }

src/generic/index.ts

@@ -1 +1 @@
-export * from './generic';
+export * from './wrapper';

src/generic/responses.test.ts

@@ -0,0 +1,11 @@
+import { success, error } from './responses';
+
+describe('Generic responses', () => {
+  it('Handles success response', () => {
+    expect(success('success')).toEqual('success');
+  });
+
+  it('Handles error response', () => {
+    expect(() => error('error')).toThrow('error');
+  });
+});

src/generic/responses.ts

@@ -0,0 +1,13 @@
+import { Metrics } from '../common';
+
+const metrics = new Metrics('Generic');
+
+export function success(message: any): void {
+  metrics.success(message);
+  return message;
+}
+
+export function error(error: any): void {
+  metrics.error(error);
+  throw new Error(error);
+}

src/generic/wrapper.test.ts

@@ -0,0 +1,15 @@
+import { wrapper, WrapperSignature } from './wrapper';
+
+describe('Stream wrapper', () => {
+  const requestEvent = { hello: 'world' };
+
+  it('Has expected properties and response funtions', () => {
+    function mockHandler({ event, success, error }: WrapperSignature) {
+      expect(event).toEqual(requestEvent);
+      expect(success).toBeInstanceOf(Function);
+      expect(error).toBeInstanceOf(Function);
+    }
+    // @ts-ignore
+    wrapper(mockHandler)(requestEvent);
+  });
+});

src/generic/generic.ts renamed to src/generic/wrapper.ts

@@ -1,22 +1,11 @@
-import { Context, Callback } from 'aws-lambda';
 import { Metrics } from '../common';
+import { success, error } from './responses';
 
 const metrics = new Metrics('Generic');
 
 export function wrapper<T extends Function>(fn: T): T {
-  return <any>function(event, context: Context, callback: Callback) {
+  return <any>function(event) {
     metrics.common(event);
-
-    function success(message: any = ''): void {
-      metrics.success(message);
-      return callback(null, message);
-    }
-
-    function error(error: any = ''): void {
-      metrics.error(error);
-      return callback(error);
-    }
-
     const signature: WrapperSignature = { event, success, error };
     return fn(signature);
   };