finish api wrapper unit tests

Author: manwaring

src/api/api-parser.test.ts

@@ -0,0 +1,77 @@
+import { stringify } from 'querystring';
+import createEvent from '@serverless/event-mocks';
+import { Request, Body } from './api-parser';
+
+describe('Body parsing', () => {
+  it('Parses json body', () => {
+    const json = { hello: 'world' };
+    const headers = { 'content-type': 'application/json' };
+    const body = new Body(JSON.stringify(json), headers).getParsedBody();
+    expect(body).toEqual(json);
+  });
+
+  it('Parses form url encoded body', () => {
+    const form = { hello: 'world' };
+    const headers = { 'content-type': 'application/x-www-form-urlencoded' };
+    const body = new Body(stringify(form), headers).getParsedBody();
+    expect(body).toEqual(form);
+  });
+
+  it("Passes body through when content type isn't specified", () => {
+    const json = { hello: 'world' };
+    const headers = {};
+    const body = new Body(JSON.stringify(json), headers).getParsedBody();
+    expect(body).toEqual(JSON.stringify(json));
+  });
+
+  it("Errors when encoding and content-type don't match", () => {
+    const invalid = '2["test" : 123]4}{';
+    const headers = { 'content-type': 'application/json' };
+    const body = new Body(invalid, headers).getParsedBody();
+    expect(body).toEqual(invalid);
+  });
+
+  it('Returns empty body when none given', () => {
+    let empty;
+    const headers = { 'content-type': 'application/x-www-form-urlencoded' };
+    const body = new Body(empty, headers).getParsedBody();
+    expect(body).toEqual(empty);
+  });
+});
+
+describe('Request parsing', () => {
+  it('Gets all fields with optional parameters', () => {
+    // @ts-ignore
+    const event = createEvent('aws:apiGateway', {
+      body: JSON.stringify({ hello: 'world' }),
+      pathParameters: { proxy: 'not today' },
+      queryStringParameters: { name: 'a test' },
+      headers: { 'content-type': 'application/json', 'Test-Request': 'true' }
+    });
+    const { body, path, query, auth, headers, testRequest } = new Request(event).getProperties();
+
+    expect(body).toEqual({ hello: 'world' });
+    expect(path).toEqual({ proxy: 'not today' });
+    expect(query).toEqual({ name: 'a test' });
+    expect(headers['content-type']).toEqual('application/json');
+    expect(testRequest).toEqual(true);
+    expect(auth).toBeFalsy();
+  });
+
+  it("Get's falsy fields when optional parameters not used", () => {
+    // @ts-ignore
+    const event = createEvent('aws:apiGateway', {});
+    delete event.body;
+    delete event.headers;
+    delete event.pathParameters;
+    delete event.queryStringParameters;
+    const { body, path, query, auth, headers, testRequest } = new Request(event).getProperties();
+
+    expect(body).toBeFalsy();
+    expect(path).toBeFalsy();
+    expect(query).toBeFalsy();
+    expect(auth).toBeFalsy();
+    expect(headers).toBeFalsy();
+    expect(testRequest).toBeFalsy();
+  });
+});

src/api/body.ts renamed to src/api/api-parser.ts

@@ -1,5 +1,25 @@
+import { APIGatewayEvent } from 'aws-lambda';
 import { parse } from 'querystring';
-import { logger } from '../common/log';
+import { Metrics, logger } from '../common';
+
+const metrics = new Metrics('API Gateway');
+
+export class Request {
+  constructor(private event: APIGatewayEvent) {}
+
+  getProperties(): any {
+    const event = this.event;
+    const path = event.pathParameters ? event.pathParameters : null;
+    const query = event.queryStringParameters ? event.queryStringParameters : null;
+    const auth = event.requestContext && event.requestContext.authorizer ? event.requestContext.authorizer : null;
+    const headers = event.headers ? event.headers : null;
+    const body = new Body(event.body, headers).getParsedBody();
+    const TEST_REQUEST_HEADER = process.env.TEST_REQUEST_HEADER || 'Test-Request';
+    const testRequest = headers && headers[TEST_REQUEST_HEADER] ? JSON.parse(headers[TEST_REQUEST_HEADER]) : false;
+    metrics.common({ body, path, query, auth, headers, testRequest });
+    return { body, path, query, auth, headers, testRequest };
+  }
+}
 
 export class Body {
   constructor(private body: any, private headers: { [name: string]: string }) {}

src/api/api-responses.test.ts

@@ -0,0 +1,34 @@
+import createEvent from '@serverless/event-mocks';
+import { success, error, invalid, redirect } from './api-responses';
+
+describe('API responses', () => {
+  // @ts-ignore
+  const event = createEvent('aws:apiGateway', {});
+
+  it('Handles success response', () => {
+    expect(success('success')).toEqual({
+      body: JSON.stringify('success'),
+      headers: { 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Credentials': true },
+      statusCode: 200
+    });
+  });
+
+  it('Handles error response', () => {
+    expect(() => error('error')).toThrow('error');
+  });
+
+  it('Handles invalid response', () => {
+    expect(invalid(['invalid'])).toEqual({
+      body: JSON.stringify({ errors: ['invalid'] }),
+      headers: { 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Credentials': true },
+      statusCode: 400
+    });
+  });
+
+  it('Handles redirect response', () => {
+    expect(redirect('url')).toEqual({
+      headers: { 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Credentials': true, Location: 'url' },
+      statusCode: 302
+    });
+  });
+});

src/api/api-responses.ts

@@ -0,0 +1,35 @@
+import { Metrics } from '../common';
+
+const metrics = new Metrics('API Gateway');
+
+const HEADERS = {
+  'Access-Control-Allow-Origin': '*',
+  'Access-Control-Allow-Credentials': true
+};
+
+export function success(payload: any = null) {
+  const response = { statusCode: 200, headers: HEADERS };
+  if (payload) {
+    response['body'] = JSON.stringify(payload);
+  }
+  metrics.success(payload);
+  return response;
+}
+
+export function invalid(errors: string[] = []) {
+  const response = { statusCode: 400, headers: HEADERS, body: JSON.stringify({ errors }) };
+  metrics.invalid(response);
+  return response;
+}
+
+export function redirect(url: string) {
+  HEADERS['Location'] = url;
+  const response = { statusCode: 302, headers: HEADERS };
+  metrics.redirect(response);
+  return response;
+}
+
+export function error(error: any = '') {
+  metrics.error(error);
+  throw new Error(error);
+}

src/api/api-wrapper.test.ts

@@ -3,46 +3,39 @@ import { apiWrapper, ApiSignature } from './api-wrapper';
 
 describe('API wrapper', () => {
   // @ts-ignore
-  const event = createEvent('aws:apiGateway', {});
-
-  it('Handles success callback', () => {
-    function mockHandler({ success }: ApiSignature) {
-      return success('success');
-    }
-    expect(apiWrapper(mockHandler)(event)).toEqual({
-      body: JSON.stringify('success'),
-      headers: { 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Credentials': true },
-      statusCode: 200
-    });
-  });
-
-  it('Handles error callback', () => {
-    function mockHandler({ error }: ApiSignature) {
-      return error('error');
-    }
-    expect(() => {
-      apiWrapper(mockHandler)(event);
-    }).toThrow('error');
-  });
-
-  it('Handles invalid callback', () => {
-    function mockHandler({ invalid }: ApiSignature) {
-      return invalid(['invalid']);
-    }
-    expect(apiWrapper(mockHandler)(event)).toEqual({
-      body: JSON.stringify({ errors: ['invalid'], event }),
-      headers: { 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Credentials': true },
-      statusCode: 400
-    });
+  const requestEvent = createEvent('aws:apiGateway', {
+    body: JSON.stringify({ hello: 'world' }),
+    pathParameters: { proxy: 'not today' },
+    queryStringParameters: { name: 'a test' },
+    headers: { 'content-type': 'application/json', 'Test-Request': 'true' }
   });
 
-  it('Handles redirect callback', () => {
-    function mockHandler({ redirect }: ApiSignature) {
-      return redirect('url');
+  it('Has expected properties and response functions', () => {
+    function mockHandler({
+      event,
+      body,
+      path,
+      query,
+      headers,
+      testRequest,
+      auth,
+      success,
+      invalid,
+      redirect,
+      error
+    }: ApiSignature) {
+      expect(event).toEqual(requestEvent);
+      expect(body).toEqual({ hello: 'world' });
+      expect(path).toEqual({ proxy: 'not today' });
+      expect(query).toEqual({ name: 'a test' });
+      expect(headers['content-type']).toEqual('application/json');
+      expect(testRequest).toEqual(true);
+      expect(auth).toBeFalsy();
+      expect(success).toBeInstanceOf(Function);
+      expect(invalid).toBeInstanceOf(Function);
+      expect(redirect).toBeInstanceOf(Function);
+      expect(error).toBeInstanceOf(Function);
     }
-    expect(apiWrapper(mockHandler)(event)).toEqual({
-      headers: { 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Credentials': true, Location: 'url' },
-      statusCode: 302
-    });
+    apiWrapper(mockHandler)(requestEvent);
   });
 });

src/api/api-wrapper.ts

@@ -1,45 +1,10 @@
-import { APIGatewayEvent, Context, Callback } from 'aws-lambda';
-import { Metrics } from '../common';
-import { Body } from './body';
-
-const metrics = new Metrics('API Gateway');
-
-const HEADERS = {
-  'Access-Control-Allow-Origin': '*',
-  'Access-Control-Allow-Credentials': true
-};
+import { APIGatewayEvent } from 'aws-lambda';
+import { Request } from './api-parser';
+import { success, invalid, redirect, error } from './api-responses';
 
 export function apiWrapper<T extends Function>(fn: T): T {
   return <any>function(event: APIGatewayEvent) {
-    const { body, path, query, request, auth, headers, testRequest } = getRequestFields(event);
-    metrics.common(request);
-
-    function success(payload: any = null) {
-      const response = { statusCode: 200, headers: HEADERS };
-      if (payload) {
-        response['body'] = JSON.stringify(payload);
-      }
-      metrics.success(payload);
-      return response;
-    }
-
-    function invalid(errors: string[] = []) {
-      const response = { statusCode: 400, headers: HEADERS, body: JSON.stringify({ errors, event }) };
-      metrics.invalid(response);
-      return response;
-    }
-
-    function redirect(url: string) {
-      HEADERS['Location'] = url;
-      const response = { statusCode: 302, headers: HEADERS };
-      metrics.redirect(response);
-      return response;
-    }
-
-    function error(error: any = '') {
-      metrics.error(error);
-      throw new Error(error);
-    }
+    const { body, path, query, auth, headers, testRequest } = new Request(event).getProperties();
 
     const signature: ApiSignature = {
       event,
@@ -58,18 +23,6 @@ export function apiWrapper<T extends Function>(fn: T): T {
   };
 }
 
-function getRequestFields(event: APIGatewayEvent): any {
-  const path = event.pathParameters ? event.pathParameters : null;
-  const query = event.queryStringParameters ? event.queryStringParameters : null;
-  const auth = event.requestContext && event.requestContext.authorizer ? event.requestContext.authorizer : null;
-  const headers = event.headers ? event.headers : null;
-  const body = new Body(event.body, headers).getParsedBody();
-  const TEST_REQUEST_HEADER = process.env.TEST_REQUEST_HEADER || 'Test-Request';
-  const testRequest = headers && headers[TEST_REQUEST_HEADER] ? JSON.parse(headers[TEST_REQUEST_HEADER]) : false;
-  const request = { body, path, query, auth, headers, testRequest };
-  return { body, path, query, auth, request, headers, testRequest };
-}
-
 export interface ApiSignature {
   event: APIGatewayEvent; // original event
   body: any; // JSON parsed body payload if exists (otherwise null)