winston-middleware 1.1.0 → 1.3.0

package/test/test.js

@@ -1,15 +1,15 @@
-var should = require('should');
 var util = require('util');
-var _ = require('underscore');
 
 var mocks = require('node-mocks-http');
+var Promise = require('promise/lib/es6-extensions');
+var should = require('should');
+var _ = require('underscore');
 var winston = require('winston');
 
 var expressWinston = require('../index.js');
 
 expressWinston.ignoredRoutes.push('/ignored');
 expressWinston.responseWhitelist.push('body');
-
 expressWinston.bodyBlacklist.push('potato');
 
 var MockTransport = function (test, options) {
@@ -28,13 +28,8 @@ var MockTransport = function (test, options) {
 };
 util.inherits(MockTransport, winston.Transport);
 
-var req = {};
-var res = {};
-
-var setUp = function (options) {
-  options = options || {};
-
-  var reqSpec = {
+function mockReq(reqMock) {
+  var reqSpec = _.extend({
     method: 'GET',
     url: '/hello',
     headers: {
@@ -46,84 +41,104 @@ var setUp = function (options) {
     params: {
       id: 20
     },
-  };
-
-  if (options.body) reqSpec.body = options.body;
+  }, reqMock);
 
-  if (options.ignoreRoute) reqSpec.url = '/ignored';
-  if (options.url) reqSpec.url = options.url;
+  return mocks.createRequest(reqSpec);
+}
 
-  req = mocks.createRequest(reqSpec);
-
-  req.route = {
-    path: reqSpec.url,
-    methods: {
-      get: true
-    }
-  };
-
-  if (options.routePath) req.route.path = options.routePath;
-
-  res = mocks.createResponse();
+function mockRes() {
+  var res = mocks.createResponse();
   res.status(200);
-};
-
-describe('expressWinston', function () {
-  it('should contain an array with all the properties whitelisted in the req object', function () {
-    expressWinston.requestWhitelist.should.be.an.Array;
-  });
-
-  it('should contain an array with all the properties whitelisted in the res object', function () {
-    expressWinston.responseWhitelist.should.be.an.Array;
-  });
+  return res;
+}
+
+function loggerTestHelper(providedOptions) {
+  var options = _.extend({
+    loggerOptions: null,
+    req: null,
+    res: null,
+    transportOptions: null,
+    next: function (req, res, next) {
+      res.end('{ "message": "Hi!  I\'m a chunk!" }');
+    }
+  }, providedOptions);
 
-  it('should contain an array for all the ignored routes', function () {
-    expressWinston.ignoredRoutes.should.be.an.Array;
-  });
+  var req = mockReq(options.req);
+  var res = _.extend(mockRes(), options.res);
 
-  it('should contain an array with all the properties whitelisted in the body object', function () {
-    expressWinston.bodyWhitelist.should.be.an.Array;
-  });
+  var result = {
+    req: req,
+    res: res,
+    log: {}
+  };
 
-  it('should contain a default request filter function', function () {
-    expressWinston.defaultRequestFilter.should.be.a.Function;
-  });
+  return new Promise(function (resolve, reject) {
+    var middleware = expressWinston.logger(_.extend({
+      transports: [new MockTransport(result, options.transportOptions)]
+    }, options.loggerOptions));
 
-  it('should contain a default response filter function', function () {
-    expressWinston.defaultResponseFilter.should.be.a.Function;
+    middleware(req, res, function (_req, _res, next) {
+      options.next(req, res, next);
+      resolve(result);
+    });
   });
+}
+
+function errorLoggerTestHelper(providedOptions) {
+  var options = _.extend({
+    loggerOptions: null,
+    originalError: new Error('This is the Error'),
+    req: null,
+    res: null,
+    transportOptions: null,
+    next: function () {}
+  }, providedOptions);
+
+  var req = mockReq(options.req);
+  var res = _.extend(mockRes(), options.res);
+
+  var result = {
+    req: req,
+    res: res,
+    log: {},
+    originalError: options.originalError,
+    pipelineError: null
+  };
 
-  it('should contain a default skip function', function () {
-    expressWinston.defaultSkip.should.be.a.Function;
-  });
+  return new Promise(function (resolve, reject) {
+    var middleware = expressWinston.errorLogger(_.extend({
+      transports: [new MockTransport(result, options.transportOptions)]
+    }, options.loggerOptions));
 
-  it('should export a function for the creation of request logger middlewares', function () {
-    expressWinston.logger.should.be.a.Function;
+    middleware(options.originalError, req, res, function (pipelineError) {
+      options.next(pipelineError);
+      result.pipelineError = pipelineError;
+      resolve(result);
+    });
   });
+}
 
+describe('winston-middleware', function () {
   describe('.errorLogger()', function () {
     it('should be a function', function () {
-      expressWinston.errorLogger.should.be.a.Function;
+      expressWinston.errorLogger.should.be.a.Function();
     });
 
-    it('should throw an error without options', function () {
-      (function () {
-        expressWinston.errorLogger();
-      }).should.throwError();
+    it('should throw an error when no options are provided', function () {
+      var errorLoggerFn = expressWinston.errorLogger.bind(expressWinston);
+      errorLoggerFn.should.throw();
     });
 
-    it('should throw an error without any transport specified', function () {
-      (function () {
-        expressWinston.errorLogger({});
-      }).should.throwError();
+    it('should throw an error when no transport is specified', function () {
+      var errorLoggerFn = expressWinston.errorLogger.bind(expressWinston, {});
+      errorLoggerFn.should.throw();
     });
 
-    it('should throw an error with an empty list of transports', function () {
-      (function () {
-        expressWinston.errorLogger({
-          transports: []
-        });
-      }).should.throwError();
+    it('should throw an error when provided with an empty list of transports', function () {
+      var errorLoggerFn = expressWinston.errorLogger.bind(expressWinston, {
+        transports: []
+      });
+      errorLoggerFn.should.throw();
     });
 
     it('should return a middleware function with four arguments that fit (err, req, res, next)', function () {
@@ -134,52 +149,61 @@ describe('expressWinston', function () {
       middleware.length.should.eql(4);
     });
 
-    describe('errorLogger() middleware()', function () {
-      var result;
-
-      before(function (done) {
-        setUp();
+    it('should use the exported requestWhitelist', function() {
+      var originalWhitelist = expressWinston.requestWhitelist;
+      expressWinston.requestWhitelist = ['foo'];
 
-        var originalError = new Error('This is the Error');
-
-        var test = {
-          req: req,
-          res: res,
-          log: {},
-          originalError: originalError,
-          pipelineError: null
-        };
+      var options = {
+        req: {foo: "bar"}
+      };
+      return errorLoggerTestHelper(options).then(function (result) {
+        // Return to the original value for later tests
+        expressWinston.requestWhitelist = originalWhitelist;
 
-        function next(pipelineError) {
-          test.pipelineError = pipelineError;
-
-          result = test;
+        result.log.meta.req.should.have.property('foo');
+        result.log.meta.req.should.not.have.property('url');
+      });
+    });
 
-          return done();
-        };
+    it('should use the exported defaultRequestFilter', function() {
+      var originalRequestFilter = expressWinston.defaultRequestFilter;
+      expressWinston.defaultRequestFilter = function() {
+        return 'foo';
+      };
 
-        var middleware = expressWinston.errorLogger({
-          transports: [new MockTransport(test)]
-        });
+      var options = {
+        req: {foo: "bar"}
+      };
+      return errorLoggerTestHelper(options).then(function (result) {
+        // Return to the original value for later tests
+        expressWinston.defaultRequestFilter = originalRequestFilter;
 
-        middleware(originalError, req, res, next);
+        result.log.meta.req.url.should.equal('foo');
       });
+    });
 
-      describe('encountering an error in the pipeline', function () {
-        it('should invoke the transport', function () {
+    describe('when middleware function encounters an error in the pipeline', function () {
+      it('should invoke the transport', function () {
+        return errorLoggerTestHelper().then(function (result) {
           result.transportInvoked.should.eql(true);
         });
+      });
 
-        it('should find an error level of "error"', function () {
+      it('should find an error level of "error"', function () {
+        return errorLoggerTestHelper().then(function (result) {
           result.log.level.should.eql('error');
         });
+      });
 
-        it('should find a message of "middlewareError"', function () {
+      it('should find a message of "middlewareError"', function () {
+        return errorLoggerTestHelper().then(function (result) {
           result.log.msg.should.eql('middlewareError');
         });
+      });
 
-        it('should contain a filtered request', function () {
-          result.log.meta.req.should.be.ok;
+      it('should contain a filtered request', function () {
+        return errorLoggerTestHelper().then(function (result) {
+          result.log.meta.req.should.be.ok();
           result.log.meta.req.method.should.eql('GET');
           result.log.meta.req.query.should.eql({
             val: '1'
@@ -187,47 +211,70 @@ describe('expressWinston', function () {
 
           result.log.meta.req.should.not.have.property('nonWhitelistedProperty');
         });
+      });
 
-        it('should not swallow the pipline error', function () {
-          result.pipelineError.should.be.ok;
+      it('should not swallow the pipeline error', function () {
+        return errorLoggerTestHelper().then(function (result) {
+          result.pipelineError.should.be.ok();
           result.pipelineError.should.eql(result.originalError);
         });
       });
     });
+
+    describe('metaField option', function () {
+      it('should, when using a custom metaField, log the custom metaField', function () {
+        var testHelperOptions = {loggerOptions: {metaField: 'metaField'}};
+        return errorLoggerTestHelper(testHelperOptions).then(function (result) {
+          result.log.meta.metaField.req.should.be.ok();
+        });
+      });
+    });
+
+    describe('requestWhitelist option', function () {
+      it('should default to global requestWhitelist', function () {
+        var options = {
+          req: {foo: "bar"}
+        };
+        return errorLoggerTestHelper(options).then(function (result) {
+          result.log.meta.req.should.not.have.property('foo');
+        });
+      });
+
+      it('should use specified requestWhitelist', function () {
+        var options = {
+          req: {foo: "bar"},
+          loggerOptions: {
+            requestWhitelist: ['foo']
+          }
+        };
+        return errorLoggerTestHelper(options).then(function (result) {
+          result.log.meta.req.should.have.property('foo');
+          result.log.meta.req.should.not.have.property('method');
+        });
+      });
+    });
   });
 
   describe('.logger()', function () {
     it('should be a function', function () {
-      expressWinston.logger.should.be.a.Function;
+      expressWinston.logger.should.be.a.Function();
     });
 
-    it('should throw an error without options', function () {
-      (function () {
-        expressWinston.logger();
-      }).should.throwError();
+    it('should throw an error when no options are provided', function () {
+      var loggerFn = expressWinston.logger.bind(expressWinston);
+      loggerFn.should.throw();
     });
 
-    it('should throw an error without any transport specified', function () {
-      (function () {
-        expressWinston.logger({});
-      }).should.throwError();
+    it('should throw an error when no transport is specified', function () {
+      var loggerFn = expressWinston.logger.bind(expressWinston, {});
+      loggerFn.should.throw();
     });
 
-    it('should throw an error with an empty list of transports', function () {
-      (function () {
-        expressWinston.logger({
-          transports: []
-        });
-      }).should.throwError();
-    });
-
-    it('should throw an error if ignoreRoute option is not a function', function () {
-      (function () {
-        expressWinston.logger({
-          transports: [new MockTransport({})],
-          ignoreRoute: 'not a function'
-        });
-      }).should.throwError();
+    it('should throw an error when provided with an empty list of transports', function () {
+      var loggerFn = expressWinston.logger.bind(expressWinston, {
+        transports: []
+      });
+      loggerFn.should.throw();
     });
 
     it('should return a middleware function with three arguments that fit (req, res, next)', function () {
@@ -238,423 +285,627 @@ describe('expressWinston', function () {
       middleware.length.should.eql(3);
     });
 
-    describe('logger() middleware()', function () {
-      describe('v0.1.x API', function () {
-        describe('when invoked on a route', function () {
-          var result;
-
-          before(function (done) {
-            setUp();
-
-            var test = {
-              req: req,
-              res: res,
-              log: {}
-            };
-
-            function next(_req, _res, next) {
-              res.end('{ "message": "Hi!  I\'m a chunk!" }');
-              result = test;
-              return done();
-            };
-
-            var middleware = expressWinston.logger({
-              transports: [new MockTransport(test)]
-            });
-
-            middleware(req, res, next);
-          });
-
-          it('should invoke the transport', function () {
-            result.transportInvoked.should.eql(true);
-          });
-
-          it('should contain a filtered request', function () {
-            result.log.meta.req.should.be.ok;
-            result.log.meta.req.method.should.eql('GET');
-            result.log.meta.req.query.should.eql({
-              val: '1'
-            });
-
-            result.log.meta.req.should.not.have.property('nonWhitelistedProperty');
-          });
-        });
-
-        describe('when invoked on a route that should be ignored', function () {
-          var result;
+    it('should not have an empty body in meta.req when invoked on a route with an empty response body', function () {
+      function next(req, res, next) {
+        res.end();
+      }
+      var testHelperOptions = {
+        next: next,
+        req: {
+          body: {},
+          routeLevelAddedProperty: 'value that should be logged',
+          url: '/hello'
+        },
+      };
+      return loggerTestHelper(testHelperOptions).then(function (result) {
+        Object.keys(result.log.meta.req).indexOf('body').should.eql(-1);
+      });
+    });
 
-          before(function (done) {
-            setUp({
-              ignoreRoute: true
-            });
+    it('should not invoke the transport when invoked on a route with transport level of "error"', function () {
+      function next(req, res, next) {
+        req._routeWhitelists.req = ['routeLevelAddedProperty'];
+        req._routeWhitelists.res = ['routeLevelAddedProperty'];
+
+        res.end('{ "message": "Hi!  I\'m a chunk!" }');
+      }
+      var testHelperOptions = {
+        next: next,
+        loggerOptions: {
+          statusLevels: true
+        },
+        req: {
+          body: {},
+          routeLevelAddedProperty: 'value that should be logged',
+          url: '/hello',
+        },
+        res: {
+          nonWhitelistedProperty: 'value that should not be logged',
+          routeLevelAddedProperty: 'value that should be logged'
+        },
+        transportOptions: {
+          level: 'error'
+        }
+      };
+      return loggerTestHelper(testHelperOptions).then(function (result) {
+        result.transportInvoked.should.eql(false);
+      });
+    });
 
-            var test = {
-              req: req,
-              res: res,
-              log: {}
-            };
+    it('should use the exported requestWhitelist', function() {
+      var originalWhitelist = expressWinston.requestWhitelist;
+      expressWinston.requestWhitelist = ['foo'];
 
-            function next(_req, _res, next) {
-              res.end('{ "message": "Hi!  I\'m a chunk!" }');
-              result = test;
-              return done();
-            };
+      var options = {
+        req: {foo: "bar"}
+      };
+      return loggerTestHelper(options).then(function (result) {
+        // Return to the original value for later tests
+        expressWinston.requestWhitelist = originalWhitelist;
 
-            var middleware = expressWinston.logger({
-              transports: [new MockTransport(test)]
-            });
+        result.log.meta.req.should.have.property('foo');
+        result.log.meta.req.should.not.have.property('url');
+      });
+    });
 
-            middleware(req, res, next);
-          });
+    it('should use the exported bodyWhitelist', function() {
+      var originalWhitelist = expressWinston.bodyWhitelist;
+      expressWinston.bodyWhitelist = ['foo'];
 
-          it('should not invoke the transport', function () {
-            result.transportInvoked.should.eql(false);
-          });
+      var options = {
+        req: {body: {foo: 'bar', baz: 'qux'}}
+      };
+      return loggerTestHelper(options).then(function (result) {
+        // Return to the original value for later tests
+        expressWinston.bodyWhitelist = originalWhitelist;
 
-          it('should contain a filtered request', function () {
-            result.log.should.be.empty;
-          });
-        });
+        result.log.meta.req.body.should.have.property('foo');
+        result.log.meta.req.body.should.not.have.property('baz');
       });
+    });
 
-      describe('v0.2.x API', function () {
-        describe('when invoked on a route', function () {
-          var result;
-
-          before(function (done) {
-            setUp({
-              body: {
-                username: "bobby",
-                password: "top-secret",
-                age: 42,
-                potato: 'Russet'
-              }
-            });
+    it('should use the exported bodyBlacklist', function() {
+      var originalWhitelist = expressWinston.bodyBlacklist;
+      expressWinston.bodyBlacklist = ['foo'];
 
-            req.routeLevelAddedProperty = 'value that should be logged';
+      var options = {
+        req: {body: {foo: 'bar', baz: 'qux'}}
+      };
+      return loggerTestHelper(options).then(function (result) {
+        // Return to the original value for later tests
+        expressWinston.bodyBlacklist = originalWhitelist;
 
-            res.nonWhitelistedProperty = 'value that should not be logged';
-            res.routeLevelAddedProperty = 'value that should be logged';
+        result.log.meta.req.body.should.not.have.property('foo');
+        result.log.meta.req.body.should.have.property('baz');
+      });
+    });
 
-            var test = {
-              req: req,
-              res: res,
-              log: {}
-            };
+    it('should use the exported responseWhitelist', function() {
+      var originalWhitelist = expressWinston.responseWhitelist;
+      expressWinston.responseWhitelist = ['foo'];
 
-            function next(_req, _res, next) {
-              req._startTime = (new Date) - 125;
+      var options = {
+        res: {foo: 'bar', baz: 'qux'}
+      };
+      return loggerTestHelper(options).then(function (result) {
+        // Return to the original value for later tests
+        expressWinston.responseWhitelist = originalWhitelist;
 
-              req._routeWhitelists.req = ['routeLevelAddedProperty'];
-              req._routeWhitelists.res = ['routeLevelAddedProperty'];
+        result.log.meta.res.should.have.property('foo');
+        result.log.meta.res.should.not.have.property('baz');
+      });
+    });
 
-              req._routeWhitelists.body = ['username'];
-              req._routeBlacklists.body = ['age'];
+    it('should use the exported defaultRequestFilter', function() {
+      var originalRequestFilter = expressWinston.defaultRequestFilter;
+      expressWinston.defaultRequestFilter = function() {
+        return 'foo';
+      };
 
-              res.end('{ "message": "Hi!  I\'m a chunk!" }');
+      var options = {
+        req: {foo: "bar"}
+      };
+      return loggerTestHelper(options).then(function (result) {
+        // Return to the original value for later tests
+        expressWinston.defaultRequestFilter = originalRequestFilter;
 
-              result = test;
+        result.log.meta.req.url.should.equal('foo');
+      });
+    });
 
-              return done();
-            };
+    it('should use the exported defaultResponseFilter', function() {
+      var originalResponseFilter = expressWinston.defaultResponseFilter;
+      expressWinston.defaultResponseFilter = function() {
+        return 'foo';
+      };
 
-            var middleware = expressWinston.logger({
-              transports: [new MockTransport(test)]
-            });
+      var options = {
+        req: {foo: "bar"}
+      };
+      return loggerTestHelper(options).then(function (result) {
+        // Return to the original value for later tests
+        expressWinston.defaultResponseFilter = originalResponseFilter;
 
-            middleware(req, res, next);
-          });
+        result.log.meta.res.statusCode.should.equal('foo');
+      });
+    });
 
-          it('should invoke the transport', function () {
-            result.transportInvoked.should.eql(true);
-          });
+    it('should use the exported defaultSkip', function() {
+      var originalSkip = expressWinston.defaultSkip;
+      expressWinston.defaultSkip = function() {
+        return true;
+      };
 
-          it('should contain a filtered request', function () {
-            result.log.meta.req.should.be.ok;
-            result.log.meta.req.method.should.eql('GET');
-            result.log.meta.req.query.should.eql({
-              val: '1'
-            });
+      var options = {
+        req: {foo: "bar"}
+      };
+      return loggerTestHelper(options).then(function (result) {
+        // Return to the original value for later tests
+        expressWinston.defaultSkip = originalSkip;
 
-            result.log.meta.req.body.should.not.have.property('age');
-            result.log.meta.req.body.should.not.have.property('potato');
-          });
+        result.transportInvoked.should.eql(false);
+      });
+    });
 
-          it('should contain a filtered response', function () {
-            result.log.meta.res.should.be.ok;
+    it('should use the exported ignoredRoutes', function() {
+      var originalIgnoredRoutes = expressWinston.ignoredRoutes;
+      expressWinston.ignoredRoutes = ['/foo-route'];
 
-            result.log.meta.res.statusCode.should.eql(200);
-            result.log.meta.res.routeLevelAddedProperty.should.be.ok;
+      var options = {
+        req: {url: '/foo-route'}
+      };
+      return loggerTestHelper(options).then(function (result) {
+        // Return to the original value for later tests
+        expressWinston.ignoredRoutes = originalIgnoredRoutes;
 
-            result.log.meta.res.should.not.have.property('nonWhitelistedProperty');
-          });
+        result.transportInvoked.should.eql(false);
+      });
+    });
 
-          it('should contain a response time', function () {
-            result.log.meta.responseTime.should.be.within(120, 130);
-          });
+    describe('when middleware function is invoked on a route', function () {
+      function next(req, res, next) {
+        req._startTime = (new Date()) - 125;
+
+        req._routeWhitelists.req = ['routeLevelAddedProperty'];
+        req._routeWhitelists.res = ['routeLevelAddedProperty'];
+
+        req._routeWhitelists.body = ['username'];
+        req._routeBlacklists.body = ['age'];
+
+        res.end('{ "message": "Hi!  I\'m a chunk!" }');
+      }
+      var testHelperOptions = {
+        next: next,
+        req: {
+          body: {
+            username: "bobby",
+            password: "top-secret",
+            age: 42,
+            potato: 'Russet'
+          },
+          routeLevelAddedProperty: 'value that should be logged'
+        },
+        res: {
+          nonWhitelistedProperty: 'value that should not be logged',
+          routeLevelAddedProperty: 'value that should be logged'
+        },
+      };
+
+      it('should invoke the transport', function () {
+        return loggerTestHelper(testHelperOptions).then(function (result) {
+          result.transportInvoked.should.eql(true);
         });
+      });
 
-        describe('when invoked on a route with an empty response body', function () {
-          var result;
-
-          before(function (done) {
-            setUp({
-              url: '/hello',
-              body: {}
-            });
-
-            req.routeLevelAddedProperty = 'value that should be logged';
-
-            var test = {
-              req: req,
-              res: res,
-              log: {}
-            };
-
-            function next(_req, _res, next) {
-              res.end();
-
-              result = test;
-
-              return done();
-            };
-
-            var middleware = expressWinston.logger({
-              transports: [new MockTransport(test)]
-            });
-
-            middleware(req, res, next);
+      it('should contain a filtered request', function () {
+        return loggerTestHelper(testHelperOptions).then(function (result) {
+          result.log.meta.req.should.be.ok();
+          result.log.meta.req.method.should.eql('GET');
+          result.log.meta.req.query.should.eql({
+            val: '1'
           });
 
-          it('should not have an empty body in meta.req', function () {
-            result.log.meta.res.should.not.have.property('body');
-          });
+          result.log.meta.req.body.should.not.have.property('age');
+          result.log.meta.req.body.should.not.have.property('potato');
         });
+      });
 
-        describe('when invoked on a route with transport level of "error"', function () {
-          var result;
-
-          before(function (done) {
-            setUp({
-              url: "/hello",
-              body: {}
-            });
-
-            req.routeLevelAddedProperty = 'value that should be logged';
-
-            res.nonWhitelistedProperty = 'value that should not be logged';
-            res.routeLevelAddedProperty = 'value that should be logged';
-
-            var test = {
-              req: req,
-              res: res,
-              log: {}
-            };
+      it('should contain a filtered response', function () {
+        return loggerTestHelper(testHelperOptions).then(function (result) {
+          result.log.meta.res.should.be.ok();
 
-            function next(_req, _res, next) {
-              req._routeWhitelists.req = ['routeLevelAddedProperty'];
-              req._routeWhitelists.res = ['routeLevelAddedProperty'];
+          result.log.meta.res.statusCode.should.eql(200);
+          result.log.meta.res.routeLevelAddedProperty.should.be.ok();
 
-              res.end('{ "message": "Hi!  I\'m a chunk!" }');
-              result = test;
-              return done();
-            };
+          result.log.meta.res.should.not.have.property('nonWhitelistedProperty');
+        });
+      });
 
-            var middleware = expressWinston.logger({
-              transports: [new MockTransport(test, {
-                level: 'error'
-              })],
-              statusLevels: true
-            });
+      it('should contain a response time', function () {
+        return loggerTestHelper(testHelperOptions).then(function (result) {
+          result.log.meta.responseTime.should.be.within(120, 130);
+        });
+      });
+    });
 
-            middleware(req, res, next);
-          });
+    describe('when middleware function is invoked on a route that should be ignored (by .ignoredRoutes)', function () {
+      var testHelperOptions = {
+        req: {url: '/ignored'}
+      };
 
-          it('should not invoke the transport', function () {
-            result.transportInvoked.should.eql(false);
-          });
+      it('should not invoke the transport', function () {
+        return loggerTestHelper(testHelperOptions).then(function (result) {
+          result.transportInvoked.should.eql(false);
         });
+      });
 
-        describe('when invoked on a route that should be ignored (options.ignoreRoute)', function () {
-          var result;
-
-          before(function (done) {
-            setUp({
-              url: '/is-not-logged'
-            });
-            req.skip = true;
-            var test = {
-              req: req,
-              res: res,
-              log: {}
-            };
-
-            function next(_req, _res, next) {
-              res.end('{ "message": "Hi!  I\'m a chunk!" }');
-              result = test;
-              return done();
-            };
-
-            var middleware = expressWinston.logger({
-              transports: [new MockTransport(test)],
-              ignoreRoute: function (req, res) {
-                return req.skip === true && req.url.match(/^\/is-not-log/);
-              }
-            });
-
-            middleware(req, res, next);
-          });
-
-          it('should not invoke the transport', function () {
-            result.transportInvoked.should.eql(false);
-          });
+      it('should contain a filtered request', function () {
+        return loggerTestHelper(testHelperOptions).then(function (result) {
+          result.log.should.be.empty();
+        });
+      });
+    });
 
-          it('should contain a filtered request', function () {
-            result.log.should.be.empty;
-          });
+    describe('expressFormat option', function () {
+      it('should match the Express format when logging', function () {
+        var testHelperOptions = {
+          loggerOptions: {
+            expressFormat: true
+          },
+          req: {
+            url: '/all-the-things'
+          }
+        };
+        return loggerTestHelper(testHelperOptions).then(function (result) {
+          var resultMsg = result.log.msg;
+          resultMsg.should.startWith('\u001b[90mGET /all-the-things\u001b[39m \u001b[32m200\u001b[39m \u001b[90m');
+          resultMsg.should.endWith('ms\u001b[39m');
         });
       });
+    });
 
-      describe('log.msg', function () {
-        var result;
+    describe('msg option', function () {
+      it('should have a default log msg', function () {
+        var testHelperOptions = {
+          req: {
+            url: '/url-of-sandwich'
+          }
+        };
+        return loggerTestHelper(testHelperOptions).then(function (result) {
+          result.log.msg.should.eql('HTTP GET /url-of-sandwich');
+        });
+      });
 
-        function logMsgSetup(url, msg, expressFormat, done) {
-          setUp({
-            url: url || '/an-url'
-          });
+      it('should match the custom format when a custom format is provided', function () {
+        var testHelperOptions = {
+          loggerOptions: {
+            msg: 'Foo {{ req.method }} {{ req.url }}'
+          },
+          req: {
+            url: '/all-the-things'
+          }
+        };
+        return loggerTestHelper(testHelperOptions).then(function (result) {
+          result.log.msg.should.eql('Foo GET /all-the-things');
+        });
+      });
+    });
 
-          var test = {
-            req: req,
-            res: res,
-            log: {}
-          };
+    describe('ignoreRoute option', function () {
+      var testHelperOptions = {
+        req: {
+          shouldSkip: true,
+          url: '/is-not-logged'
+        },
+        loggerOptions: {
+          ignoreRoute: function (req, res) {
+            return req.shouldSkip === true && req.url.match(/^\/is-not-log/);
+          }
+        }
+      };
 
-          function next(_req, _res, next) {
-            res.end('{ "message": "Hi!  I\'m a chunk!" }');
+      it('should throw an error if ignoreRoute option is provided but not a function', function () {
+        var loggerFn = expressWinston.logger.bind(expressWinston, {
+          transports: [new MockTransport({})],
+          ignoreRoute: 'not a function'
+        });
+        loggerFn.should.throw();
+      });
 
-            result = test;
+      it('should not invoke the transport when invoked on a route that should be ignored', function () {
+        return loggerTestHelper(testHelperOptions).then(function (result) {
+          result.transportInvoked.should.eql(false);
+        });
+      });
 
-            return done();
-          };
+      it('should contain a filtered request when invoked on a route that should be ignored', function () {
+        return loggerTestHelper(testHelperOptions).then(function (result) {
+          result.log.should.be.empty();
+        });
+      });
+    });
 
-          var loggerOptions = {
-            transports: [new MockTransport(test)]
-          };
+    describe('metaField option', function () {
+      it('should have a default meta field', function () {
+        return loggerTestHelper().then(function (result) {
+          result.log.meta.req.should.be.ok();
+        });
+      });
 
-          if (msg) {
-            loggerOptions.msg = msg;
+      it('should use provided custom metaField', function () {
+        var testHelperOptions = {
+          loggerOptions: {
+            metaField: 'foobar'
           }
+        };
+        return loggerTestHelper(testHelperOptions).then(function (result) {
+          result.log.meta.foobar.req.should.be.ok();
+        });
+      });
+    });
 
-          if (expressFormat) {
-            delete loggerOptions.msg;
-            loggerOptions.expressFormat = true;
+    describe('skip option', function () {
+      it('should not be logged when using custom function returning true', function () {
+        var testHelperOptions = {
+          loggerOptions: {
+            skip: function (req, res) {
+              return req.url.indexOf('sandwich') != -1
+            }
+          },
+          req: {
+            url: '/url-of-sandwich'
           }
+        };
+        return loggerTestHelper(testHelperOptions).then(function (result) {
+          should.not.exist(result.log.msg);
+        });
+      });
 
-          var middleware = expressWinston.logger(loggerOptions);
-
-          middleware(req, res, next);
-        }
+      it('should be logged when using custom function returning false', function () {
+        var testHelperOptions = {
+          loggerOptions: {
+            skip: function (req, res) {
+              return req.url.indexOf('sandwich') != -1
+            }
+          },
+          req: {
+            url: '/hello'
+          }
+        };
+        return loggerTestHelper(testHelperOptions).then(function (result) {
+          result.log.msg.should.eql('HTTP GET /hello');
+        });
+      });
+    });
 
-        describe('when default', function () {
+    describe('statusLevels option', function () {
+      it('should have status level of "info" by default', function () {
+        var testHelperOptions = {
+          next: function (req, res, next) {
+            res.status(403).end('{ "message": "Hi!  I\'m a chunk!" }');
+          }
+        };
+        return loggerTestHelper(testHelperOptions).then(function (result) {
+          result.log.level.should.equal('info');
+        });
+      });
 
-          before(function (done) {
-            logMsgSetup('/url-of-sandwich', null, false, done);
+      describe('when statusLevels set to true', function () {
+        it('should have status level of "info" when 100 <= statusCode < 400', function () {
+          var testHelperOptions = {
+            next: function (req, res, next) {
+              res.status(200).end('{ "message": "Hi!  I\'m a chunk!" }');
+            },
+            loggerOptions: {
+              statusLevels: true
+            },
+            req: {
+              url: '/url-of-sandwich'
+            }
+          };
+          return loggerTestHelper(testHelperOptions).then(function (result) {
+            result.log.level.should.equal('info');
           });
+        });
 
-          it('should match the custom format', function () {
-            result.log.msg.should.eql('HTTP GET /url-of-sandwich');
+        it('should have status level of "warn" when 400 <= statusCode < 500', function () {
+          var testHelperOptions = {
+            next: function (req, res, next) {
+              res.status(403).end('{ "message": "Hi!  I\'m a chunk!" }');
+            },
+            loggerOptions: {
+              statusLevels: true
+            }
+          };
+          return loggerTestHelper(testHelperOptions).then(function (result) {
+            result.log.level.should.equal('warn');
           });
         });
 
-        describe('using Express format', function () {
-          before(function (done) {
-            logMsgSetup('/all-the-things', null, true, done);
+        it('should have status level of "error" when statusCode >= 500', function () {
+          var testHelperOptions = {
+            next: function (req, res, next) {
+              res.status(500).end('{ "message": "Hi!  I\'m a chunk!" }');
+            },
+            loggerOptions: {
+              statusLevels: true
+            }
+          };
+          return loggerTestHelper(testHelperOptions).then(function (result) {
+            result.log.level.should.equal('error');
           });
+        });
+      });
 
-          it('should match the Express format', function () {
-            var resultMsg = result.log.msg;
-            resultMsg.should.startWith('\u001b[90mGET /all-the-things\u001b[39m \u001b[32m200\u001b[39m \u001b[90m');
-            resultMsg.should.endWith('ms\u001b[39m');
+      describe('when statusLevels set to an object', function () {
+        it('should have custom status level provided by "success" key of object when 100 <= statusCode < 400', function () {
+          var testHelperOptions = {
+            next: function (req, res, next) {
+              res.status(200).end('{ "message": "Hi!  I\'m a chunk!" }');
+            },
+            loggerOptions: {
+              statusLevels: {success: 'silly'}
+            },
+            transportOptions: {
+              level: 'silly'
+            }
+          };
+          return loggerTestHelper(testHelperOptions).then(function (result) {
+            result.log.level.should.equal('silly');
           });
         });
 
-        describe('when customized', function () {
-          before(function (done) {
-            logMsgSetup('/all-the-things', 'Foo {{ req.method }} {{ req.url }}', false, done);
+        it('should have status level provided by "warn" key of object when 400 <= statusCode < 500', function () {
+          var testHelperOptions = {
+            next: function (req, res, next) {
+              res.status(403).end('{ "message": "Hi!  I\'m a chunk!" }');
+            },
+            loggerOptions: {
+              statusLevels: {warn: 'debug'}
+            },
+            transportOptions: {
+              level: 'silly'
+            }
+          };
+          return loggerTestHelper(testHelperOptions).then(function (result) {
+            result.log.level.should.equal('debug');
           });
+        });
 
-          it('should match the custom format', function () {
-            result.log.msg.should.eql('Foo GET /all-the-things');
+        it('should have status level provided by "error" key of object when statusCode >= 500', function () {
+          var testHelperOptions = {
+            next: function (req, res, next) {
+              res.status(500).end('{ "message": "Hi!  I\'m a chunk!" }');
+            },
+            loggerOptions: {
+              statusLevels: {error: 'verbose'}
+            },
+            transportOptions: {
+              level: 'silly'
+            }
+          };
+          return loggerTestHelper(testHelperOptions).then(function (result) {
+            result.log.level.should.equal('verbose');
           });
         });
       });
-      
-      describe('log.skip', function () {
-        var result;
-
-        function logSkipSetup(url, skip, done) {
-          setUp({
-            url: url || '/an-url'
-          });
+    });
 
-          var test = {
-            req: req,
-            res: res,
-            log: {}
-          };
+    describe('requestWhitelist option', function () {
+      it('should default to global requestWhitelist', function () {
+        var options = {
+          req: {foo: "bar"}
+        };
+        return loggerTestHelper(options).then(function (result) {
+          result.log.meta.req.should.not.have.property('foo');
+        });
+      });
 
-          function next(_req, _res, next) {
-            res.end('{ "message": "Hi!  I\'m a chunk!" }');
+      it('should use specified requestWhitelist', function () {
+        var options = {
+          req: {foo: "bar"},
+          loggerOptions: {
+            requestWhitelist: ['foo']
+          }
+        };
+        return loggerTestHelper(options).then(function (result) {
+          result.log.meta.req.should.have.property('foo');
+          result.log.meta.req.should.not.have.property('method');
+        });
+      });
+    });
 
-            result = test;
+    describe('responseWhitelist option', function () {
+      it('should default to global responseWhitelist', function () {
+        var options = {
+          res: {foo: "bar"}
+        };
+        return loggerTestHelper(options).then(function (result) {
+          result.log.meta.res.should.not.have.property('foo');
+        });
+      });
 
-            return done();
-          };
+      it('should use specified responseWhitelist', function () {
+        var options = {
+          res: {foo: "bar"},
+          loggerOptions: {
+            responseWhitelist: ['foo']
+          }
+        };
+        return loggerTestHelper(options).then(function (result) {
+          result.log.meta.res.should.have.property('foo');
+          result.log.meta.res.should.not.have.property('method');
+        });
+      });
+    });
 
-          var loggerOptions = {
-            transports: [new MockTransport(test)]
-          };
+    describe('ignoredRoutes option', function () {
+      it('should default to global ignoredRoutes', function () {
+        var options = {
+          req: {url: "/ignored"}
+        };
+        return loggerTestHelper(options).then(function (result) {
+          result.transportInvoked.should.eql(false);
+        });
+      });
 
-          if (skip) {
-            loggerOptions.skip = skip;
+      it('should use specified ignoredRoutes', function () {
+        var options = {
+          req: {url: "/ignored-option"},
+          loggerOptions: {
+            ignoredRoutes: ['/ignored-option']
           }
+        };
+        return loggerTestHelper(options).then(function (result) {
+          result.transportInvoked.should.eql(false);
+        });
+      });
+    });
+  });
 
-          var middleware = expressWinston.logger(loggerOptions);
+  describe('.requestWhitelist', function () {
+    it('should be an array with all the properties whitelisted in the req object', function () {
+      expressWinston.requestWhitelist.should.be.an.Array();
+    });
+  });
 
-          middleware(req, res, next);
-        }
+  describe('.bodyWhitelist', function () {
+    it('should be an array with all the properties whitelisted in the body object', function () {
+      expressWinston.bodyWhitelist.should.be.an.Array();
+    });
+  });
 
-        describe('when default', function () {
+  describe('.bodyBlacklist', function () {
 
-          before(function (done) {
-            logSkipSetup('/url-of-sandwich', null, done);
-          });
+  });
 
-          it('should be logged', function () {
-            result.log.msg.should.eql('HTTP GET /url-of-sandwich');
-          });
-        });
+  describe('.responseWhitelist', function () {
+    it('should be an array with all the properties whitelisted in the res object', function () {
+      expressWinston.responseWhitelist.should.be.an.Array();
+    });
+  });
 
-        describe('when using custom function returning true', function () {
-          before(function (done) {
-            logSkipSetup('/url-of-sandwich', function(req, res) { return req.url.indexOf('sandwich') != -1 }, done);
-          });
+  describe('.defaultRequestFilter', function () {
+    it('should be a function', function () {
+      expressWinston.defaultRequestFilter.should.be.a.Function();
+    });
+  });
 
-          it('should not be logged', function () {
-            should.not.exist(result.log.msg);
-          });
-        });
+  describe('.defaultResponseFilter', function () {
+    it('should be a function', function () {
+      expressWinston.defaultResponseFilter.should.be.a.Function();
+    });
+  });
 
-        describe('when using custom function returning false', function () {
-          before(function (done) {
-            logSkipSetup('/hello', function(req, res) { return req.url.indexOf('sandwich') != -1 }, done);
-          });
+  describe('.defaultSkip', function () {
+    it('should be a function', function () {
+      expressWinston.defaultSkip.should.be.a.Function();
+    });
+  });
 
-          it('should be logged', function () {
-            result.log.msg.should.eql('HTTP GET /hello');
-          });
-        });
-      });
+  describe('.ignoredRoutes', function () {
+    it('should be an array for all the ignored routes', function () {
+      expressWinston.ignoredRoutes.should.be.an.Array();
     });
   });
 });