Merge pull request #13 from blackflux/dev

[Gally]: master <- dev

README.md

@@ -53,3 +53,10 @@ Type: `number`<br>
 Default: `null`
 
 Set timestamp to freeze time to. Will modify the result of e.g. `new Date()`.
+
+#### recordConsole
+
+Type: `boolean`<br>
+Default: `false`
+
+When set to true, console logging calls are recorded and can be accessed by calling `getLogs()` from within the test.

src/index.js

@@ -1,3 +1,4 @@
 module.exports.desc = require('./util/desc');
 module.exports.EnvManager = require('./util/env-manager');
 module.exports.timeKeeper = require('./util/time-keeper');
+module.exports.ConsoleRecorder = require('./util/console-recorder');

src/util/console-recorder.js

@@ -0,0 +1,38 @@
+/* eslint-disable no-console */
+const assert = require('assert');
+
+module.exports = (verbose) => {
+  let consoleOriginal = null;
+  const logs = [];
+  const defaultLogs = [];
+  const errorLogs = [];
+  return {
+    inject: () => {
+      assert(consoleOriginal === null);
+      consoleOriginal = ['log', 'info', 'error', 'warn']
+        .reduce((p, c) => Object.assign(p, { [c]: console[c] }), {});
+      logs.length = 0;
+      defaultLogs.length = 0;
+      errorLogs.length = 0;
+      Object.keys(consoleOriginal).forEach((logLevel) => {
+        console[logLevel] = (...args) => {
+          if (verbose === true) {
+            consoleOriginal[logLevel](...args);
+          }
+          logs.push(...args);
+          (['log', 'info'].includes(logLevel) ? defaultLogs : errorLogs).push(...args);
+        };
+      });
+    },
+    release: () => {
+      assert(consoleOriginal !== null);
+      Object.assign(console, consoleOriginal);
+      consoleOriginal = null;
+    },
+    get: () => ({
+      logs: logs.slice(),
+      defaultLogs: defaultLogs.slice(),
+      errorLogs: errorLogs.slice()
+    })
+  };
+};

src/util/desc.js

@@ -7,6 +7,7 @@ const nockBack = require('nock').back;
 const Joi = require('joi-strict');
 const EnvManager = require('./env-manager');
 const timeKeeper = require('./time-keeper');
+const ConsoleRecorder = require('./console-recorder');
 
 const getParents = (test) => {
   const names = [];
@@ -38,19 +39,22 @@ module.exports = (suiteName, optsOrTests, testsOrNull = null) => {
     useTmpDir: Joi.boolean().optional(),
     useNock: Joi.boolean().optional(),
     envVars: Joi.object().optional().unknown(true).pattern(Joi.string(), Joi.string()),
-    timestamp: Joi.number().optional().min(0)
+    timestamp: Joi.number().optional().min(0),
+    recordConsole: Joi.boolean().optional()
   }), 'Bad Options Provided');
   const useTmpDir = get(opts, 'useTmpDir', false);
   const useNock = get(opts, 'useNock', false);
   const envVars = get(opts, 'envVars', null);
   const timestamp = get(opts, 'timestamp', null);
+  const recordConsole = get(opts, 'recordConsole', false);
 
   let dir = null;
   let nockDone = null;
   let envManagerFile = null;
   let envManagerDesc = null;
+  let consoleRecorder = null;
 
-  const getArgs = () => ({ dir });
+  const getArgs = () => ({ dir, ...(consoleRecorder === null ? {} : { getLogs: consoleRecorder.get }) });
   let beforeCb = () => {};
   let afterCb = () => {};
   let beforeEachCb = () => {};
@@ -102,18 +106,26 @@ module.exports = (suiteName, optsOrTests, testsOrNull = null) => {
           nockBack.fixtures = `${testFile}__cassettes/`;
           nockDone = await new Promise((resolve) => nockBack(genCassetteName(this.currentTest), {}, resolve));
         }
+        if (recordConsole === true) {
+          consoleRecorder = ConsoleRecorder(true);
+          consoleRecorder.inject();
+        }
         await beforeEachCb(getArgs());
       })();
     });
 
     afterEach(async () => {
-      if (dir !== null) {
-        dir = null;
+      if (consoleRecorder !== null) {
+        consoleRecorder.release();
+        consoleRecorder = null;
       }
       if (nockDone !== null) {
         nockDone();
         nockDone = null;
       }
+      if (dir !== null) {
+        dir = null;
+      }
       await afterEachCb(getArgs());
     });
 

test/index.spec.js

@@ -6,7 +6,8 @@ describe('Testing index.js', () => {
     expect(Object.keys(index)).to.deep.equal([
       'desc',
       'EnvManager',
-      'timeKeeper'
+      'timeKeeper',
+      'ConsoleRecorder'
     ]);
   });
 });

test/util/console-recorder.spec.js

@@ -0,0 +1,42 @@
+/* eslint-disable no-console */
+const expect = require('chai').expect;
+const ConsoleRecorder = require('../../src/util/console-recorder');
+
+const testConsole = (verbose) => {
+  const logs = [];
+  const consoleLogOriginal = console.log;
+  const consoleErrorOriginal = console.error;
+  console.log = (...args) => {
+    logs.push(...args);
+  };
+  console.error = (...args) => {
+    logs.push(...args);
+  };
+  const consoleRecorder = ConsoleRecorder(verbose);
+  consoleRecorder.inject();
+  console.log('test-log1');
+  console.log('test-log2');
+  console.error('test-log3');
+  consoleRecorder.release();
+  const result = consoleRecorder.get();
+  expect(result.logs).to.deep.equal(['test-log1', 'test-log2', 'test-log3']);
+  expect(result.defaultLogs).to.deep.equal(['test-log1', 'test-log2']);
+  expect(result.errorLogs).to.deep.equal(['test-log3']);
+  if (verbose === true) {
+    expect(logs).to.deep.equal(['test-log1', 'test-log2', 'test-log3']);
+  } else {
+    expect(logs).to.deep.equal([]);
+  }
+  console.log = consoleLogOriginal;
+  console.error = consoleErrorOriginal;
+};
+
+describe('Testing ConsoleRecorder', () => {
+  it('Testing Logging Silent', () => {
+    testConsole(false);
+  });
+
+  it('Testing Logging Verbose', () => {
+    testConsole(true);
+  });
+});

test/util/desc.spec.js

@@ -120,6 +120,36 @@ desc('Testing freezing time', { timestamp: 123456789 }, ({ it, before, after })
   });
 });
 
+desc('Testing console recording', { recordConsole: true }, ({ it }) => {
+  const logger = ['log', 'info', 'error', 'warn'].reduce((p, c) => Object.assign(p, {
+    // eslint-disable-next-line no-console
+    [c]: (...args) => console[c](...args)
+  }), {});
+
+  it('Testing recorded logs', ({ getLogs }) => {
+    expect(getLogs()).to.deep.equal({
+      defaultLogs: [],
+      errorLogs: [],
+      logs: []
+    });
+    logger.log('log');
+    logger.warn('warn');
+    logger.error('error');
+    logger.info('info');
+    expect(getLogs()).to.deep.equal({
+      defaultLogs: ['log', 'info'],
+      errorLogs: ['warn', 'error'],
+      logs: ['log', 'warn', 'error', 'info']
+    });
+  });
+
+  it('Testing recording resets', ({ getLogs }) => {
+    expect(getLogs().logs).to.deep.equal([]);
+    logger.log('log');
+    expect(getLogs().logs).to.deep.equal(['log']);
+  });
+});
+
 desc('Testing Before/After', ({
   before, after, beforeEach, afterEach, it
 }) => {