Merge pull request #159 from strongloop-forks/constructor-fix

Fix bad constructor guard

lib/bunyan.js

@@ -233,7 +233,7 @@ function resolveLevel(nameOrNum) {
  */
 function Logger(options, _childOptions, _childSimple) {
     xxx('Logger start:', options)
-    if (! this instanceof Logger) {
+    if (!(this instanceof Logger)) {
         return new Logger(options, _childOptions);
     }
 
@@ -242,7 +242,7 @@ function Logger(options, _childOptions, _childSimple) {
     if (_childOptions !== undefined) {
         parent = options;
         options = _childOptions;
-        if (! parent instanceof Logger) {
+        if (!(parent instanceof Logger)) {
             throw new TypeError(
                 'invalid Logger creation: do not pass a second arg');
         }

test/ctor.test.js

@@ -19,11 +19,11 @@ var test = tap4nodeunit.test;
 
 test('ensure Logger creation options', function (t) {
     t.throws(function () { new Logger(); },
-        'options (object) is required',
+        /options \(object\) is required/,
         'no options should throw');
 
     t.throws(function () { new Logger({}); },
-        'options.name (string) is required',
+        /options\.name \(string\) is required/,
         'no options.name should throw');
 
     t.doesNotThrow(function () { new Logger({name: 'foo'}); },
@@ -31,35 +31,44 @@ test('ensure Logger creation options', function (t) {
 
     var options = {name: 'foo', stream: process.stdout, streams: []};
     t.throws(function () { new Logger(options); },
+        /cannot mix "streams" and "stream" options/,
         'cannot use "stream" and "streams"');
 
     // https://github.com/trentm/node-bunyan/issues/3
     options = {name: 'foo', streams: {}};
     t.throws(function () { new Logger(options); },
-        'invalid options.streams: must be an array',
+        /invalid options.streams: must be an array/,
         '"streams" must be an array');
 
     options = {name: 'foo', serializers: 'a string'};
     t.throws(function () { new Logger(options); },
-        'invalid options.serializers: must be an object',
+        /invalid options.serializers: must be an object/,
         '"serializers" cannot be a string');
 
     options = {name: 'foo', serializers: [1, 2, 3]};
     t.throws(function () { new Logger(options); },
-        'invalid options.serializers: must be an object',
+        /invalid options.serializers: must be an object/,
         '"serializers" cannot be an array');
 
     t.end();
 });
 
 
+test('ensure Logger constructor is safe without new', function (t) {
+    t.doesNotThrow(function () { Logger({name: 'foo'}); },
+        'constructor should call self with new if necessary');
+
+    t.end();
+});
+
+
 test('ensure Logger creation options (createLogger)', function (t) {
     t.throws(function () { bunyan.createLogger(); },
-        'options (object) is required',
+        /options \(object\) is required/,
         'no options should throw');
 
     t.throws(function () { bunyan.createLogger({}); },
-        'options.name (string) is required',
+        /options\.name \(string\) is required/,
         'no options.name should throw');
 
     t.doesNotThrow(function () { bunyan.createLogger({name: 'foo'}); },
@@ -67,22 +76,23 @@ test('ensure Logger creation options (createLogger)', function (t) {
 
     var options = {name: 'foo', stream: process.stdout, streams: []};
     t.throws(function () { bunyan.createLogger(options); },
+        /cannot mix "streams" and "stream" options/,
         'cannot use "stream" and "streams"');
 
     // https://github.com/trentm/node-bunyan/issues/3
     options = {name: 'foo', streams: {}};
     t.throws(function () { bunyan.createLogger(options); },
-        'invalid options.streams: must be an array',
+        /invalid options.streams: must be an array/,
         '"streams" must be an array');
 
     options = {name: 'foo', serializers: 'a string'};
     t.throws(function () { bunyan.createLogger(options); },
-        'invalid options.serializers: must be an object',
+        /invalid options.serializers: must be an object/,
         '"serializers" cannot be a string');
 
     options = {name: 'foo', serializers: [1, 2, 3]};
     t.throws(function () { bunyan.createLogger(options); },
-        'invalid options.serializers: must be an object',
+        /invalid options.serializers: must be an object/,
         '"serializers" cannot be an array');
 
     t.end();
@@ -99,28 +109,43 @@ test('ensure Logger child() options', function (t) {
         'empty options should be fine too');
 
     t.throws(function () { log.child({name: 'foo'}); },
-        'invalid options.name: child cannot set logger name',
+        /invalid options.name: child cannot set logger name/,
         'child cannot change name');
 
     var options = {stream: process.stdout, streams: []};
     t.throws(function () { log.child(options); },
+        /cannot mix "streams" and "stream" options/,
         'cannot use "stream" and "streams"');
 
     // https://github.com/trentm/node-bunyan/issues/3
     options = {streams: {}};
     t.throws(function () { log.child(options); },
-        'invalid options.streams: must be an array',
+        /invalid options.streams: must be an array/,
         '"streams" must be an array');
 
     options = {serializers: 'a string'};
     t.throws(function () { log.child(options); },
-        'invalid options.serializers: must be an object',
+        /invalid options.serializers: must be an object/,
         '"serializers" cannot be a string');
 
     options = {serializers: [1, 2, 3]};
     t.throws(function () { log.child(options); },
-        'invalid options.serializers: must be an object',
+        /invalid options.serializers: must be an object/,
         '"serializers" cannot be an array');
 
     t.end();
 });
+
+
+test('ensure Logger() rejects non-Logger parents', function (t) {
+    var dad = new Logger({name: 'dad', streams: []});
+
+    t.throws(function () { new Logger({}, {}); },
+        /invalid Logger creation: do not pass a second arg/,
+        'Logger arguments must be valid');
+
+    t.doesNotThrow(function () { new Logger(dad, {}); },
+        'Logger allows Logger instance as parent');
+
+    t.end();
+});