Server : Apache/2.4.6 (CentOS) OpenSSL/1.0.2k-fips PHP/7.4.20 System : Linux st2.domain.com 3.10.0-1127.10.1.el7.x86_64 #1 SMP Wed Jun 3 14:28:03 UTC 2020 x86_64 User : apache ( 48) PHP Version : 7.4.20 Disable Function : NONE Directory : /proc/self/cwd/usr/lib/node_modules/forever/node_modules/winston/test/ |
/*
* logger-test.js: Tests for instances of the winston Logger
*
* (C) 2010 Charlie Robbins
* MIT LICENSE
*
*/
var path = require('path'),
vows = require('vows'),
assert = require('assert'),
util = require('util'),
winston = require('../lib/winston'),
helpers = require('./helpers'),
transport = require('./transports/transport');
vows.describe('winton/logger').addBatch({
"An instance of winston.Logger": {
"with transports": {
topic: new (winston.Logger)({ transports: [new (winston.transports.Console)({ level: 'info' })] }),
"should have the correct methods / properties defined": function (logger) {
helpers.assertLogger(logger);
},
"the add() with an unsupported transport": {
"should throw an error": function () {
assert.throws(function () { logger.add('unsupported') }, Error);
}
}
},
"with no transports": {
topic: new winston.Logger(),
"the log method": {
topic: function (logger) {
var that = this;
logger.log('error', 'This should be an error', function (err) {
that.callback(null, err);
});
},
"should respond with the appropriate error": function (err) {
assert.instanceOf(err, Error);
}
}
}
}
}).addBatch({
"An instance of winston.Logger": {
topic: new (winston.Logger)({ transports: [new (winston.transports.Console)({ level: 'info' })] }),
"the log() method": {
"when listening for the 'logging' event": {
topic: function (logger) {
logger.once('logging', this.callback);
logger.log('info', 'test message');
},
"should emit the 'log' event with the appropriate transport": function (transport, ign) {
helpers.assertConsole(transport);
}
},
"when listening for the 'logged' event": {
topic: function (logger) {
logger.once('logged', this.callback);
logger.log('info', 'test message');
},
"should emit the 'logged' event": function (level, msg, meta) {
assert.equal(level, 'info');
assert.equal(msg, 'test message');
}
},
}
}
}).addBatch({
"An instance of winston.Logger with no transports": {
topic: new (winston.Logger)({ emitErrs: true }),
"the log() method should throw an error": function (logger) {
assert.throws(function () { logger.log('anything') }, Error);
},
"the extend() method called on an empty object": {
topic: function (logger) {
var empty = {};
logger.extend(empty);
return empty;
},
"should define the appropriate methods": function (extended) {
['log', 'profile', 'startTimer'].concat(Object.keys(winston.config.npm.levels)).forEach(function (method) {
assert.isFunction(extended[method]);
});
}
},
"the add() method with a supported transport": {
topic: function (logger) {
return logger.add(winston.transports.Console);
},
"should add the console Transport onto transports": function (logger) {
assert.equal(helpers.size(logger.transports), 1);
helpers.assertConsole(logger.transports.console);
},
"should throw an error when the same Transport is added": function (logger) {
assert.throws(function () { logger.add(winston.transports.Console) }, Error);
},
"the profile() method": {
"when passed a callback": {
topic: function (logger) {
var cb = this.callback;
logger.profile('test1');
setTimeout(function () {
logger.profile('test1', function (err, level, msg, meta) {
cb(err, level, msg, meta, logger);
});
}, 50);
},
"should respond with the appropriate profile message": function (err, level, msg, meta, logger) {
assert.isNull(err);
assert.equal(level, 'info');
assert.match(meta.duration, /(\d+)ms/);
assert.isTrue(typeof logger.profilers['test'] === 'undefined');
},
"when passed some metadata": {
topic: function () {
var logger = arguments[arguments.length - 1];
var cb = this.callback.bind(null, null);
logger.profile('test3');
setTimeout(function () {
logger.once('logging', cb);
logger.profile('test3', {
some: 'data'
});
}, 50);
},
"should respond with the right metadata": function (err, transport, level, msg, meta) {
assert.equal(msg, 'test3');
assert.isNull(err);
assert.equal(level, 'info');
assert.match(meta.duration, /(\d+)ms/);
assert.equal(meta.some, 'data');
},
"when not passed a callback": {
topic: function () {
var logger = arguments[arguments.length - 1];
var cb = this.callback.bind(null, null);
logger.profile('test2');
setTimeout(function () {
logger.once('logging', cb);
logger.profile('test2');
}, 50);
},
"should respond with the appropriate profile message": function (err, transport, level, msg, meta) {
assert.isNull(err);
assert.equal(msg, 'test2');
assert.equal(level, 'info');
assert.match(meta.duration, /(\d+)ms/);
}
}
}
}
},
"the startTimer() method": {
"when passed a callback": {
topic: function (logger) {
var that = this;
var timer = logger.startTimer()
setTimeout(function () {
timer.done('test', function (err, level, msg, meta) {
that.callback(err, level, msg, meta, logger);
});
}, 500);
},
"should respond with the appropriate message": function (err, level, msg, meta, logger) {
assert.isNull(err);
assert.equal(level, 'info');
assert.match(meta.duration, /(\d+)ms/);
}
},
"when not passed a callback": {
topic: function (logger) {
var that = this;
var timer = logger.startTimer()
logger.once('logging', that.callback.bind(null, null));
setTimeout(function () {
timer.done();
}, 500);
},
"should respond with the appropriate message": function (err, transport, level, msg, meta) {
assert.isNull(err);
assert.equal(level, 'info');
assert.match(meta.duration, /(\d+)ms/);
var duration = parseInt(meta.duration);
assert.isNumber(duration);
assert.isTrue(duration >= 50 && duration < 100);
}
}
},
"and adding an additional transport": {
topic: function (logger) {
return logger.add(winston.transports.File, {
filename: path.join(__dirname, 'fixtures', 'logs', 'testfile2.log')
});
},
"should be able to add multiple transports": function (logger) {
assert.equal(helpers.size(logger.transports), 2);
helpers.assertConsole(logger.transports.console);
helpers.assertFile(logger.transports.file);
}
}
}
}
}).addBatch({
"The winston logger": {
topic: new (winston.Logger)({
transports: [
new (winston.transports.Console)(),
new (winston.transports.File)({ filename: path.join(__dirname, 'fixtures', 'logs', 'filelog.log' )})
]
}),
"should return have two transports": function (logger) {
assert.equal(helpers.size(logger.transports), 2);
},
"the remove() with an unadded transport": {
"should throw an Error": function (logger) {
assert.throws(function () { logger.remove(winston.transports.Webhook) }, Error);
}
},
"the remove() method with an added transport": {
topic: function (logger) {
return logger.remove(winston.transports.Console);
},
"should remove the Console transport from transports": function (logger) {
assert.equal(helpers.size(logger.transports), 1);
helpers.assertFile(logger.transports.file);
},
"and removing an additional transport": {
topic: function (logger) {
return logger.remove(winston.transports.File);
},
"should remove File transport from transports": function (logger) {
assert.equal(helpers.size(logger.transports), 0);
}
}
}
}
}).addBatch({
"The winston logger": {
topic: new (winston.Logger)({
transports: [
new (winston.transports.Console)(),
new (winston.transports.File)({ filename: path.join(__dirname, 'fixtures', 'logs', 'filelog.log' )})
]
}),
"the clear() method": {
"should remove all transports": function (logger) {
logger.clear();
assert.equal(helpers.size(logger.transports), 0);
}
}
}
}).addBatch({
"The winston logger": {
topic: new (winston.Logger)({
exceptionHandlers: [
new (winston.transports.Console)(),
new (winston.transports.File)({ filename: path.join(__dirname, 'fixtures', 'logs', 'filelog.log' )})
]
}),
"the unhandleExceptions() method": {
"should remove all transports": function (logger) {
assert.equal(helpers.size(logger.exceptionHandlers), 2);
logger.unhandleExceptions();
assert.equal(helpers.size(logger.exceptionHandlers), 0);
}
}
}
}).addBatch({
"The winston logger": {
topic: new (winston.Logger)({
transports: [
new (winston.transports.Console)()
]
}),
"the log() method": {
"when passed a string placeholder": {
topic: function (logger) {
logger.once('logging', this.callback);
logger.log('info', 'test message %s', 'my string');
},
"should interpolate": function (transport, level, msg, meta) {
assert.strictEqual(msg, 'test message my string');
},
},
"when passed a number placeholder": {
topic: function (logger) {
logger.once('logging', this.callback);
logger.log('info', 'test message %d', 123);
},
"should interpolate": function (transport, level, msg, meta) {
assert.strictEqual(msg, 'test message 123');
},
},
"when passed a json placholder and an empty object": {
topic: function (logger) {
logger.once('logging', this.callback);
logger.log('info', 'test message %j', {number: 123}, {});
},
"should interpolate": function (transport, level, msg, meta) {
assert.strictEqual(msg, 'test message {"number":123}');
},
},
"when passed a escaped percent sign": {
topic: function (logger) {
logger.once('logging', this.callback);
logger.log('info', 'test message %%', {number: 123});
},
"should not interpolate": function (transport, level, msg, meta) {
assert.strictEqual(msg, util.format('test message %%'));
assert.deepEqual(meta, {number: 123});
},
},
"when passed interpolation strings and a meta object": {
topic: function (logger) {
logger.once('logging', this.callback);
logger.log('info', 'test message %s, %s', 'first', 'second' ,{number: 123});
},
"should interpolate and have a meta object": function (transport, level, msg, meta) {
assert.strictEqual(msg, 'test message first, second');
assert.deepEqual(meta, {number: 123});
},
},
"when passed multiple strings and a meta object": {
topic: function (logger) {
logger.once('logging', this.callback);
logger.log('info', 'test message', 'first', 'second' , {number: 123});
},
"should join and have a meta object": function (transport, level, msg, meta) {
assert.strictEqual(msg, 'test message first second');
assert.deepEqual(meta, {number: 123});
},
},
"when passed interpolations strings, meta object and a callback": {
topic: function (logger) {
var that = this;
logger.log('info', 'test message %s, %s', 'first', 'second' , {number: 123}, function(transport, level, msg, meta){
that.callback(transport, level, msg, meta)
});
},
"should interpolate and have a meta object": function (transport, level, msg, meta) {
assert.strictEqual(msg, 'test message first, second');
assert.deepEqual(meta, {number: 123});
},
},
"when passed multiple strings, a meta object and a callback": {
topic: function (logger) {
var that = this;
logger.log('info', 'test message', 'first', 'second' , {number: 123}, function(transport, level, msg, meta){
that.callback(transport, level, msg, meta)
});
},
"should join and have a meta object": function (transport, level, msg, meta) {
assert.strictEqual(msg, 'test message first second');
assert.deepEqual(meta, {number: 123});
},
}
}
}
}).export(module);