Merge pull request #37 from erezrokah/expose_cloudwatch_starttime

Expose cloudwatch startTime, startTime should be in UTC

Author: erezrokah

package.json

@@ -1,6 +1,6 @@
 {
   "name": "aws-testing-library",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Chai and Jest matchers for aws services",
   "scripts": {
     "lint": "tslint 'src/**/*.ts'",

src/chai/README.md

@@ -91,6 +91,7 @@ Asserts log message of a lambda function
 await expect({
   region: 'us-east-1',
   function: 'functionName',
+  startTime: 0 /* optional (millis since epoch in UTC, defaults to now-1 hour) */,
   timeout: 0 /* optional (defaults to 2500) */,
   pollEvery: 0 /* optional (defaults to 500) */,
 }).to.have.log(

src/chai/cloudwatch.test.ts

@@ -1,21 +1,26 @@
 import chai = require('chai');
+import * as common from '../common';
 import './';
 import cloudwatch from './cloudwatch';
 
-jest.mock('../common');
 jest.mock('../utils/cloudwatch');
 jest.mock('./utils', () => {
   return { wrapWithRetries: jest.fn(f => f) };
 });
 
+jest.spyOn(Date, 'parse').mockImplementation(() => 12 * 60 * 60 * 1000);
+jest.spyOn(common, 'verifyProps');
+jest.spyOn(common, 'epochDateMinusHours');
+
 chai.use(cloudwatch);
 
 describe('cloudwatch', () => {
   describe('log', () => {
     const region = 'region';
     const functionName = 'functionName';
+    const startTime = 12 * 60 * 60 * 1000;
 
-    const props = { region, function: functionName };
+    const props = { region, function: functionName, startTime };
     const pattern = 'pattern';
 
     beforeEach(() => {
@@ -52,11 +57,37 @@ describe('cloudwatch', () => {
       expect(filterLogEvents).toHaveBeenCalledWith(
         region,
         functionName,
+        startTime,
         pattern,
       );
       expect(wrapWithRetries).toHaveBeenCalledTimes(1);
     });
 
+    test('startTime should be defaulted when not passed in', async () => {
+      const { epochDateMinusHours, verifyProps } = require('../common');
+      const { filterLogEvents } = require('../utils/cloudwatch');
+
+      filterLogEvents.mockReturnValue(Promise.resolve({ events: ['event'] }));
+      epochDateMinusHours.mockReturnValue(11 * 60 * 60 * 1000);
+
+      const propsNoTime = { region, function: functionName };
+      await chai.expect(propsNoTime).to.have.log(pattern);
+
+      expect(filterLogEvents).toHaveBeenCalledTimes(1);
+      expect(filterLogEvents).toHaveBeenCalledWith(
+        propsNoTime.region,
+        propsNoTime.function,
+        11 * 60 * 60 * 1000,
+        pattern,
+      );
+      expect(verifyProps).toHaveBeenCalledTimes(1);
+      expect(verifyProps).toHaveBeenCalledWith({ ...propsNoTime, pattern }, [
+        'region',
+        'function',
+        'pattern',
+      ]);
+    });
+
     test('should pass on have log', async () => {
       const { filterLogEvents } = require('../utils/cloudwatch');
 

src/chai/cloudwatch.ts

@@ -1,4 +1,4 @@
-import { verifyProps } from '../common';
+import { epochDateMinusHours, verifyProps } from '../common';
 import { expectedProps, ICloudwatchProps } from '../common/cloudwatch';
 import { filterLogEvents } from '../utils/cloudwatch';
 import { wrapWithRetries } from './utils';
@@ -8,8 +8,17 @@ const attemptCloudwatch = async function(this: any, pattern: string) {
 
   verifyProps({ ...props, pattern }, expectedProps);
 
-  const { region, function: functionName } = props;
-  const { events } = await filterLogEvents(region, functionName, pattern);
+  const {
+    region,
+    function: functionName,
+    startTime = epochDateMinusHours(1),
+  } = props;
+  const { events } = await filterLogEvents(
+    region,
+    functionName,
+    startTime,
+    pattern,
+  );
   const found = events.length > 0;
 
   return {

src/common/cloudwatch.ts

@@ -2,6 +2,7 @@ import { ICommonProps } from './';
 
 export interface ICloudwatchProps extends ICommonProps {
   function: string;
+  startTime?: number;
 }
 
 export const expectedProps = ['region', 'function', 'pattern'];

src/common/index.test.ts

@@ -1,4 +1,4 @@
-import { sleep, verifyProps } from './';
+import { epochDateMinusHours, sleep, verifyProps } from './';
 
 jest.useFakeTimers();
 
@@ -26,4 +26,14 @@ describe('common', () => {
       expect(() => verifyProps({ id: 'value' }, ['id'])).not.toThrow();
     });
   });
+
+  describe('epochDateMinusHours', () => {
+    jest.spyOn(Date, 'now').mockImplementation(() => 12 * 60 * 60 * 1000);
+
+    test('test implementation', () => {
+      const actual = epochDateMinusHours(1);
+
+      expect(actual).toEqual(11 * 60 * 60 * 1000);
+    });
+  });
 });

src/common/index.ts

@@ -16,3 +16,9 @@ export const verifyProps = (props: any, expectedProps: string[]) => {
     }
   }
 };
+
+const hoursToMilliseconds = (hours: number) => hours * 60 * 60 * 1000;
+
+export const epochDateMinusHours = (hours: number) => {
+  return Date.now() - hoursToMilliseconds(hours);
+};

src/jest/README.md

@@ -98,6 +98,7 @@ expect.assertions(1); // makes sure the assertion was called
 await expect({
   region: 'us-east-1',
   function: 'functionName',
+  startTime: 0 /* optional (millis since epoch in UTC, defaults to now-1 hour) */,
   timeout: 0 /* optional (defaults to 2500) */,
   pollEvery: 0 /* optional (defaults to 500) */,
 }).toHaveLog(

src/jest/cloudwatch.test.ts

@@ -1,11 +1,15 @@
 import * as originalUtils from 'jest-matcher-utils';
 import { EOL } from 'os';
+import * as common from '../common';
 import { toHaveLog } from './cloudwatch';
 
-jest.mock('../common');
 jest.mock('../utils/cloudwatch');
 jest.spyOn(console, 'error');
 
+jest.spyOn(Date, 'parse').mockImplementation(() => 12 * 60 * 60 * 1000);
+jest.spyOn(common, 'verifyProps');
+jest.spyOn(common, 'epochDateMinusHours');
+
 describe('cloudwatch matchers', () => {
   describe('toHaveLog', () => {
     const matcherUtils = {
@@ -23,7 +27,8 @@ describe('cloudwatch matchers', () => {
     };
     const region = 'region';
     const functionName = 'functionName';
-    const props = { region, function: functionName };
+    const startTime = 12 * 60 * 60 * 1000;
+    const props = { region, function: functionName, startTime };
     const pattern = 'pattern';
 
     beforeEach(() => {
@@ -45,6 +50,7 @@ describe('cloudwatch matchers', () => {
       expect(filterLogEvents).toHaveBeenCalledWith(
         props.region,
         props.function,
+        startTime,
         pattern,
       );
       expect(console.error).toHaveBeenCalledTimes(1);
@@ -59,6 +65,33 @@ describe('cloudwatch matchers', () => {
       ]);
     });
 
+    test('startTime should be defaulted when not passed in', async () => {
+      const { epochDateMinusHours, verifyProps } = require('../common');
+      const { filterLogEvents } = require('../utils/cloudwatch');
+
+      const events: string[] = [];
+      filterLogEvents.mockReturnValue(Promise.resolve({ events }));
+
+      epochDateMinusHours.mockReturnValue(11 * 60 * 60 * 1000);
+
+      const propsNoTime = { region, function: functionName };
+      await toHaveLog.bind(matcherUtils)(propsNoTime, pattern);
+
+      expect(filterLogEvents).toHaveBeenCalledTimes(1);
+      expect(filterLogEvents).toHaveBeenCalledWith(
+        propsNoTime.region,
+        propsNoTime.function,
+        11 * 60 * 60 * 1000,
+        pattern,
+      );
+      expect(verifyProps).toHaveBeenCalledTimes(1);
+      expect(verifyProps).toHaveBeenCalledWith({ ...propsNoTime, pattern }, [
+        'region',
+        'function',
+        'pattern',
+      ]);
+    });
+
     test('should not pass when no events found', async () => {
       const { filterLogEvents } = require('../utils/cloudwatch');
 

src/jest/cloudwatch.ts

@@ -1,6 +1,6 @@
 import { EOL } from 'os';
-import { verifyProps } from '../common';
 import { expectedProps, ICloudwatchProps } from '../common/cloudwatch';
+import { epochDateMinusHours, verifyProps } from '../common/index';
 import { filterLogEvents } from '../utils/cloudwatch';
 
 export const toHaveLog = async function(
@@ -9,8 +9,11 @@ export const toHaveLog = async function(
   pattern: string,
 ) {
   verifyProps({ ...props, pattern }, expectedProps);
-
-  const { region, function: functionName } = props;
+  const {
+    region,
+    function: functionName,
+    startTime = epochDateMinusHours(1),
+  } = props;
 
   try {
     const printFunctionName = this.utils.printExpected(functionName);
@@ -20,7 +23,12 @@ export const toHaveLog = async function(
     const notHint = this.utils.matcherHint('.not.toHaveLog') + EOL + EOL;
     const hint = this.utils.matcherHint('.toHaveLog') + EOL + EOL;
 
-    const { events } = await filterLogEvents(region, functionName, pattern);
+    const { events } = await filterLogEvents(
+      region,
+      functionName,
+      startTime,
+      pattern,
+    );
     const found = events.length > 0;
     if (found) {
       // matching log found