cartodb4/log4js-node
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

simplified levels a bit, converted tests to mocha

Browse Source
This commit is contained in:
Gareth Jones
2013-08-21 08:02:37 +10:00
parent c60d629608
commit a8679aced1
2 changed files with 395 additions and 361 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/levels.js
+43 -27
View File
@@ -34,35 +34,51 @@ Level.prototype.toString = function() {
return this.levelStr; return this.levelStr;
}; };
Level.prototype.isLessThanOrEqualTo = function(otherLevel) { function convertAndCompare(comparison) {
if (typeof otherLevel === "string") { return function(otherLevel) {
otherLevel = toLevel(otherLevel); if (typeof otherLevel === "string") {
} otherLevel = toLevel(otherLevel);
return this.level <= otherLevel.level; }
}; return comparison.call(this, otherLevel);
};
}
Level.prototype.isGreaterThanOrEqualTo = function(otherLevel) { Level.prototype.isLessThanOrEqualTo = convertAndCompare(
if (typeof otherLevel === "string") { function(otherLevel) {
otherLevel = toLevel(otherLevel); return this.level <= otherLevel.level;
} }
return this.level >= otherLevel.level; );
};
Level.prototype.isEqualTo = function(otherLevel) { Level.prototype.isGreaterThanOrEqualTo = convertAndCompare(
if (typeof otherLevel == "string") { function(otherLevel) {
otherLevel = toLevel(otherLevel); return this.level >= otherLevel.level;
} }
return this.level === otherLevel.level; );
};
module.exports = { Level.prototype.isEqualTo = convertAndCompare(
ALL: new Level(Number.MIN_VALUE, "ALL"), function(otherLevel) {
TRACE: new Level(5000, "TRACE"), return this.level === otherLevel.level;
DEBUG: new Level(10000, "DEBUG"), }
INFO: new Level(20000, "INFO"), );
WARN: new Level(30000, "WARN"),
ERROR: new Level(40000, "ERROR"),
FATAL: new Level(50000, "FATAL"), exports.ALL = new Level(Number.MIN_VALUE, "ALL");
OFF: new Level(Number.MAX_VALUE, "OFF"), exports.TRACE = new Level(5000, "TRACE");
toLevel: toLevel exports.DEBUG = new Level(10000, "DEBUG");
}; exports.INFO = new Level(20000, "INFO");
exports.WARN = new Level(30000, "WARN");
exports.ERROR = new Level(40000, "ERROR");
exports.FATAL = new Level(50000, "FATAL");
exports.OFF = new Level(Number.MAX_VALUE, "OFF");
exports.levels = [
exports.OFF,
exports.TRACE,
exports.DEBUG,
exports.INFO,
exports.WARN,
exports.ERROR,
exports.FATAL
];
exports.toLevel = toLevel;
test/levels-test.js
+352 -334
View File
@@ -1,404 +1,422 @@
"use strict"; "use strict";
var vows = require('vows') var assert = require('assert')
, assert = require('assert') , should = require('should')
, levels = require('../lib/levels'); , levels = require('../lib/levels');
function assertThat(level) { function assertThat(level) {
function assertForEach(assertion, test, otherLevels) { function assertForEach(val, test, otherLevels) {
otherLevels.forEach(function(other) { otherLevels.forEach(function(other) {
assertion.call(assert, test.call(level, other)); test.call(level, other).should.eql(val);
}); });
} }
return { return {
isLessThanOrEqualTo: function(levels) { isLessThanOrEqualTo: function(levels) {
assertForEach(assert.isTrue, level.isLessThanOrEqualTo, levels); assertForEach(true, level.isLessThanOrEqualTo, levels);
}, },
isNotLessThanOrEqualTo: function(levels) { isNotLessThanOrEqualTo: function(levels) {
assertForEach(assert.isFalse, level.isLessThanOrEqualTo, levels); assertForEach(false, level.isLessThanOrEqualTo, levels);
}, },
isGreaterThanOrEqualTo: function(levels) { isGreaterThanOrEqualTo: function(levels) {
assertForEach(assert.isTrue, level.isGreaterThanOrEqualTo, levels); assertForEach(true, level.isGreaterThanOrEqualTo, levels);
}, },
isNotGreaterThanOrEqualTo: function(levels) { isNotGreaterThanOrEqualTo: function(levels) {
assertForEach(assert.isFalse, level.isGreaterThanOrEqualTo, levels); assertForEach(false, level.isGreaterThanOrEqualTo, levels);
}, },
isEqualTo: function(levels) { isEqualTo: function(levels) {
assertForEach(assert.isTrue, level.isEqualTo, levels); assertForEach(true, level.isEqualTo, levels);
}, },
isNotEqualTo: function(levels) { isNotEqualTo: function(levels) {
assertForEach(assert.isFalse, level.isEqualTo, levels); assertForEach(false, level.isEqualTo, levels);
} }
}; };
} }
vows.describe('levels').addBatch({ describe('../lib/levels', function() {
'values': { it('should define some levels', function() {
topic: levels, should.exist(levels.ALL);
'should define some levels': function(levels) { should.exist(levels.TRACE);
assert.isNotNull(levels.ALL); should.exist(levels.DEBUG);
assert.isNotNull(levels.TRACE); should.exist(levels.INFO);
assert.isNotNull(levels.DEBUG); should.exist(levels.WARN);
assert.isNotNull(levels.INFO); should.exist(levels.ERROR);
assert.isNotNull(levels.WARN); should.exist(levels.FATAL);
assert.isNotNull(levels.ERROR); should.exist(levels.OFF);
assert.isNotNull(levels.FATAL); });
assert.isNotNull(levels.OFF);
}, describe('ALL', function() {
'ALL': { var all = levels.ALL;
topic: levels.ALL,
'should be less than the other levels': function(all) { it('should be less than the other levels', function() {
assertThat(all).isLessThanOrEqualTo( assertThat(all).isLessThanOrEqualTo(
[ [
levels.ALL, levels.ALL,
levels.TRACE, levels.TRACE,
levels.DEBUG, levels.DEBUG,
levels.INFO, levels.INFO,
levels.WARN,
levels.ERROR,
levels.FATAL,
levels.OFF
]
);
},
'should be greater than no levels': function(all) {
assertThat(all).isNotGreaterThanOrEqualTo(
[
levels.TRACE,
levels.DEBUG,
levels.INFO,
levels.WARN,
levels.ERROR,
levels.FATAL,
levels.OFF
]
);
},
'should only be equal to ALL': function(all) {
assertThat(all).isEqualTo([levels.toLevel("ALL")]);
assertThat(all).isNotEqualTo(
[
levels.TRACE,
levels.DEBUG,
levels.INFO,
levels.WARN,
levels.ERROR,
levels.FATAL,
levels.OFF
]
);
}
},
'TRACE': {
topic: levels.TRACE,
'should be less than DEBUG': function(trace) {
assertThat(trace).isLessThanOrEqualTo(
[
levels.DEBUG,
levels.INFO,
levels.WARN,
levels.ERROR,
levels.FATAL,
levels.OFF
]
);
assertThat(trace).isNotLessThanOrEqualTo([levels.ALL]);
},
'should be greater than ALL': function(trace) {
assertThat(trace).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE]);
assertThat(trace).isNotGreaterThanOrEqualTo(
[
levels.DEBUG,
levels.INFO,
levels.WARN,
levels.ERROR,
levels.FATAL,
levels.OFF
]
);
},
'should only be equal to TRACE': function(trace) {
assertThat(trace).isEqualTo([levels.toLevel("TRACE")]);
assertThat(trace).isNotEqualTo(
[
levels.ALL,
levels.DEBUG,
levels.INFO,
levels.WARN,
levels.ERROR,
levels.FATAL,
levels.OFF
]
);
}
},
'DEBUG': {
topic: levels.DEBUG,
'should be less than INFO': function(debug) {
assertThat(debug).isLessThanOrEqualTo(
[
levels.INFO,
levels.WARN,
levels.ERROR,
levels.FATAL,
levels.OFF
]
);
assertThat(debug).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE]);
},
'should be greater than TRACE': function(debug) {
assertThat(debug).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE]);
assertThat(debug).isNotGreaterThanOrEqualTo(
[
levels.INFO,
levels.WARN,
levels.ERROR,
levels.FATAL,
levels.OFF
]
);
},
'should only be equal to DEBUG': function(trace) {
assertThat(trace).isEqualTo([levels.toLevel("DEBUG")]);
assertThat(trace).isNotEqualTo(
[
levels.ALL,
levels.TRACE,
levels.INFO,
levels.WARN,
levels.ERROR,
levels.FATAL,
levels.OFF
]
);
}
},
'INFO': {
topic: levels.INFO,
'should be less than WARN': function(info) {
assertThat(info).isLessThanOrEqualTo([
levels.WARN, levels.WARN,
levels.ERROR, levels.ERROR,
levels.FATAL, levels.FATAL,
levels.OFF levels.OFF
]); ]
assertThat(info).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG]); );
}, });
'should be greater than DEBUG': function(info) {
assertThat(info).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG]); it('should be greater than no levels', function() {
assertThat(info).isNotGreaterThanOrEqualTo([ assertThat(all).isNotGreaterThanOrEqualTo(
[
levels.TRACE,
levels.DEBUG,
levels.INFO,
levels.WARN, levels.WARN,
levels.ERROR, levels.ERROR,
levels.FATAL, levels.FATAL,
levels.OFF levels.OFF
]); ]
}, );
'should only be equal to INFO': function(trace) { });
assertThat(trace).isEqualTo([levels.toLevel("INFO")]);
assertThat(trace).isNotEqualTo([ it('should only be equal to ALL', function() {
levels.ALL, assertThat(all).isEqualTo([levels.toLevel("ALL")]);
assertThat(all).isNotEqualTo(
[
levels.TRACE, levels.TRACE,
levels.DEBUG, levels.DEBUG,
levels.INFO,
levels.WARN, levels.WARN,
levels.ERROR, levels.ERROR,
levels.FATAL, levels.FATAL,
levels.OFF levels.OFF
]); ]
} );
}, });
'WARN': { });
topic: levels.WARN,
'should be less than ERROR': function(warn) { describe('TRACE', function() {
assertThat(warn).isLessThanOrEqualTo([levels.ERROR, levels.FATAL, levels.OFF]); var trace = levels.TRACE;
assertThat(warn).isNotLessThanOrEqualTo([
levels.ALL, it('should be less than DEBUG', function() {
levels.TRACE, assertThat(trace).isLessThanOrEqualTo(
levels.DEBUG, [
levels.INFO
]);
},
'should be greater than INFO': function(warn) {
assertThat(warn).isGreaterThanOrEqualTo([
levels.ALL,
levels.TRACE,
levels.DEBUG,
levels.INFO
]);
assertThat(warn).isNotGreaterThanOrEqualTo([levels.ERROR, levels.FATAL, levels.OFF]);
},
'should only be equal to WARN': function(trace) {
assertThat(trace).isEqualTo([levels.toLevel("WARN")]);
assertThat(trace).isNotEqualTo([
levels.ALL,
levels.TRACE,
levels.DEBUG, levels.DEBUG,
levels.INFO, levels.INFO,
levels.WARN,
levels.ERROR, levels.ERROR,
levels.FATAL, levels.FATAL,
levels.OFF levels.OFF
]); ]
} );
}, assertThat(trace).isNotLessThanOrEqualTo([levels.ALL]);
'ERROR': { });
topic: levels.ERROR,
'should be less than FATAL': function(error) { it('should be greater than ALL', function() {
assertThat(error).isLessThanOrEqualTo([levels.FATAL, levels.OFF]); assertThat(trace).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE]);
assertThat(error).isNotLessThanOrEqualTo([ assertThat(trace).isNotGreaterThanOrEqualTo(
levels.ALL, [
levels.TRACE,
levels.DEBUG,
levels.INFO,
levels.WARN
]);
},
'should be greater than WARN': function(error) {
assertThat(error).isGreaterThanOrEqualTo([
levels.ALL,
levels.TRACE,
levels.DEBUG,
levels.INFO,
levels.WARN
]);
assertThat(error).isNotGreaterThanOrEqualTo([levels.FATAL, levels.OFF]);
},
'should only be equal to ERROR': function(trace) {
assertThat(trace).isEqualTo([levels.toLevel("ERROR")]);
assertThat(trace).isNotEqualTo([
levels.ALL,
levels.TRACE,
levels.DEBUG, levels.DEBUG,
levels.INFO, levels.INFO,
levels.WARN, levels.WARN,
levels.ERROR,
levels.FATAL, levels.FATAL,
levels.OFF levels.OFF
]); ]
} );
}, });
'FATAL': {
topic: levels.FATAL, it('should only be equal to TRACE', function() {
'should be less than OFF': function(fatal) { assertThat(trace).isEqualTo([levels.toLevel("TRACE")]);
assertThat(fatal).isLessThanOrEqualTo([levels.OFF]); assertThat(trace).isNotEqualTo(
assertThat(fatal).isNotLessThanOrEqualTo([ [
levels.ALL, levels.ALL,
levels.TRACE,
levels.DEBUG,
levels.INFO,
levels.WARN,
levels.ERROR
]);
},
'should be greater than ERROR': function(fatal) {
assertThat(fatal).isGreaterThanOrEqualTo([
levels.ALL,
levels.TRACE,
levels.DEBUG,
levels.INFO,
levels.WARN,
levels.ERROR
]);
assertThat(fatal).isNotGreaterThanOrEqualTo([levels.OFF]);
},
'should only be equal to FATAL': function(fatal) {
assertThat(fatal).isEqualTo([levels.toLevel("FATAL")]);
assertThat(fatal).isNotEqualTo([
levels.ALL,
levels.TRACE,
levels.DEBUG, levels.DEBUG,
levels.INFO, levels.INFO,
levels.WARN, levels.WARN,
levels.ERROR, levels.ERROR,
levels.FATAL,
levels.OFF levels.OFF
]); ]
} );
}, });
'OFF': {
topic: levels.OFF, });
'should not be less than anything': function(off) {
assertThat(off).isNotLessThanOrEqualTo([ describe('DEBUG', function() {
levels.ALL, var debug = levels.DEBUG;
levels.TRACE,
levels.DEBUG, it('should be less than INFO', function() {
assertThat(debug).isLessThanOrEqualTo(
[
levels.INFO, levels.INFO,
levels.WARN, levels.WARN,
levels.ERROR, levels.ERROR,
levels.FATAL levels.FATAL,
]); levels.OFF
}, ]
'should be greater than everything': function(off) { );
assertThat(off).isGreaterThanOrEqualTo([ assertThat(debug).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE]);
levels.ALL, });
levels.TRACE,
levels.DEBUG, it('should be greater than TRACE', function() {
assertThat(debug).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE]);
assertThat(debug).isNotGreaterThanOrEqualTo(
[
levels.INFO, levels.INFO,
levels.WARN, levels.WARN,
levels.ERROR, levels.ERROR,
levels.FATAL levels.FATAL,
]); levels.OFF
}, ]
'should only be equal to OFF': function(off) { );
assertThat(off).isEqualTo([levels.toLevel("OFF")]); });
assertThat(off).isNotEqualTo([
it('should only be equal to DEBUG', function() {
assertThat(debug).isEqualTo([levels.toLevel("DEBUG")]);
assertThat(debug).isNotEqualTo(
[
levels.ALL, levels.ALL,
levels.TRACE, levels.TRACE,
levels.DEBUG,
levels.INFO, levels.INFO,
levels.WARN, levels.WARN,
levels.ERROR, levels.ERROR,
levels.FATAL levels.FATAL,
]); levels.OFF
} ]
} );
}, });
'isGreaterThanOrEqualTo': { });
topic: levels.INFO,
'should handle string arguments': function(info) { describe('INFO', function() {
var info = levels.INFO;
it('should be less than WARN', function() {
assertThat(info).isLessThanOrEqualTo([
levels.WARN,
levels.ERROR,
levels.FATAL,
levels.OFF
]);
assertThat(info).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG]);
});
it('should be greater than DEBUG', function() {
assertThat(info).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG]);
assertThat(info).isNotGreaterThanOrEqualTo([
levels.WARN,
levels.ERROR,
levels.FATAL,
levels.OFF
]);
});
it('should only be equal to INFO', function() {
assertThat(info).isEqualTo([levels.toLevel("INFO")]);
assertThat(info).isNotEqualTo([
levels.ALL,
levels.TRACE,
levels.DEBUG,
levels.WARN,
levels.ERROR,
levels.FATAL,
levels.OFF
]);
});
});
describe('WARN', function() {
var warn = levels.WARN;
it('should be less than ERROR', function() {
assertThat(warn).isLessThanOrEqualTo([levels.ERROR, levels.FATAL, levels.OFF]);
assertThat(warn).isNotLessThanOrEqualTo([
levels.ALL,
levels.TRACE,
levels.DEBUG,
levels.INFO
]);
});
it('should be greater than INFO', function() {
assertThat(warn).isGreaterThanOrEqualTo([
levels.ALL,
levels.TRACE,
levels.DEBUG,
levels.INFO
]);
assertThat(warn).isNotGreaterThanOrEqualTo([levels.ERROR, levels.FATAL, levels.OFF]);
});
it('should only be equal to WARN', function() {
assertThat(warn).isEqualTo([levels.toLevel("WARN")]);
assertThat(warn).isNotEqualTo([
levels.ALL,
levels.TRACE,
levels.DEBUG,
levels.INFO,
levels.ERROR,
levels.FATAL,
levels.OFF
]);
});
});
describe('ERROR', function() {
var error = levels.ERROR;
it('should be less than FATAL', function() {
assertThat(error).isLessThanOrEqualTo([levels.FATAL, levels.OFF]);
assertThat(error).isNotLessThanOrEqualTo([
levels.ALL,
levels.TRACE,
levels.DEBUG,
levels.INFO,
levels.WARN
]);
});
it('should be greater than WARN', function() {
assertThat(error).isGreaterThanOrEqualTo([
levels.ALL,
levels.TRACE,
levels.DEBUG,
levels.INFO,
levels.WARN
]);
assertThat(error).isNotGreaterThanOrEqualTo([levels.FATAL, levels.OFF]);
});
it('should only be equal to ERROR', function() {
assertThat(error).isEqualTo([levels.toLevel("ERROR")]);
assertThat(error).isNotEqualTo([
levels.ALL,
levels.TRACE,
levels.DEBUG,
levels.INFO,
levels.WARN,
levels.FATAL,
levels.OFF
]);
});
});
describe('FATAL', function() {
var fatal = levels.FATAL;
it('should be less than OFF', function() {
assertThat(fatal).isLessThanOrEqualTo([levels.OFF]);
assertThat(fatal).isNotLessThanOrEqualTo([
levels.ALL,
levels.TRACE,
levels.DEBUG,
levels.INFO,
levels.WARN,
levels.ERROR
]);
});
it('should be greater than ERROR', function() {
assertThat(fatal).isGreaterThanOrEqualTo([
levels.ALL,
levels.TRACE,
levels.DEBUG,
levels.INFO,
levels.WARN,
levels.ERROR
]);
assertThat(fatal).isNotGreaterThanOrEqualTo([levels.OFF]);
});
it('should only be equal to FATAL', function() {
assertThat(fatal).isEqualTo([levels.toLevel("FATAL")]);
assertThat(fatal).isNotEqualTo([
levels.ALL,
levels.TRACE,
levels.DEBUG,
levels.INFO,
levels.WARN,
levels.ERROR,
levels.OFF
]);
});
});
describe('OFF', function() {
var off = levels.OFF;
it('should not be less than anything', function() {
assertThat(off).isNotLessThanOrEqualTo([
levels.ALL,
levels.TRACE,
levels.DEBUG,
levels.INFO,
levels.WARN,
levels.ERROR,
levels.FATAL
]);
});
it('should be greater than everything', function() {
assertThat(off).isGreaterThanOrEqualTo([
levels.ALL,
levels.TRACE,
levels.DEBUG,
levels.INFO,
levels.WARN,
levels.ERROR,
levels.FATAL
]);
});
it('should only be equal to OFF', function() {
assertThat(off).isEqualTo([levels.toLevel("OFF")]);
assertThat(off).isNotEqualTo([
levels.ALL,
levels.TRACE,
levels.DEBUG,
levels.INFO,
levels.WARN,
levels.ERROR,
levels.FATAL
]);
});
});
describe('isGreaterThanOrEqualTo', function() {
var info = levels.INFO;
it('should handle string arguments', function() {
assertThat(info).isGreaterThanOrEqualTo(["all", "trace", "debug"]); assertThat(info).isGreaterThanOrEqualTo(["all", "trace", "debug"]);
assertThat(info).isNotGreaterThanOrEqualTo(['warn', 'ERROR', 'Fatal', 'off']); assertThat(info).isNotGreaterThanOrEqualTo(['warn', 'ERROR', 'Fatal', 'off']);
} });
}, });
'isLessThanOrEqualTo': {
topic: levels.INFO, describe('isLessThanOrEqualTo', function() {
'should handle string arguments': function(info) { var info = levels.INFO;
it('should handle string arguments', function() {
assertThat(info).isNotLessThanOrEqualTo(["all", "trace", "debug"]); assertThat(info).isNotLessThanOrEqualTo(["all", "trace", "debug"]);
assertThat(info).isLessThanOrEqualTo(['warn', 'ERROR', 'Fatal', 'off']); assertThat(info).isLessThanOrEqualTo(['warn', 'ERROR', 'Fatal', 'off']);
} });
}, });
'isEqualTo': {
topic: levels.INFO, describe('isEqualTo', function() {
'should handle string arguments': function(info) { var info = levels.INFO;
it('should handle string arguments', function() {
assertThat(info).isEqualTo(["info", "INFO", "iNfO"]); assertThat(info).isEqualTo(["info", "INFO", "iNfO"]);
} });
}, });
'toLevel': {
'with lowercase argument': { describe('toLevel', function() {
topic: levels.toLevel("debug"), it('should ignore the case of arguments', function() {
'should take the string and return the corresponding level': function(level) { levels.toLevel("debug").should.eql(levels.DEBUG);
assert.equal(level, levels.DEBUG); levels.toLevel("DEBUG").should.eql(levels.DEBUG);
} levels.toLevel("DeBuG").should.eql(levels.DEBUG);
}, });
'with uppercase argument': {
topic: levels.toLevel("DEBUG"), it('should return undefined when argument is not recognised', function() {
'should take the string and return the corresponding level': function(level) { should.not.exist(levels.toLevel("cheese"));
assert.equal(level, levels.DEBUG); });
}
}, it('should return the default value if argument is not recognised', function() {
'with varying case': { levels.toLevel("cheese", levels.DEBUG).should.eql(levels.DEBUG);
topic: levels.toLevel("DeBuG"), });
'should take the string and return the corresponding level': function(level) { });
assert.equal(level, levels.DEBUG);
} });
},
'with unrecognised argument': {
topic: levels.toLevel("cheese"),
'should return undefined': function(level) {
assert.isUndefined(level);
}
},
'with unrecognised argument and default value': {
topic: levels.toLevel("cheese", levels.DEBUG),
'should return default value': function(level) {
assert.equal(level, levels.DEBUG);
}
}
}
}).export(module);