simplified levels a bit, converted tests to mocha
This commit is contained in:
Gareth Jones
parent
c60d629608
commit
a8679aced1
@ -34,35 +34,51 @@ Level.prototype.toString = function() {
|
||||
return this.levelStr;
|
||||
};
|
||||
|
||||
Level.prototype.isLessThanOrEqualTo = function(otherLevel) {
|
||||
if (typeof otherLevel === "string") {
|
||||
otherLevel = toLevel(otherLevel);
|
||||
}
|
||||
return this.level <= otherLevel.level;
|
||||
};
|
||||
function convertAndCompare(comparison) {
|
||||
return function(otherLevel) {
|
||||
if (typeof otherLevel === "string") {
|
||||
otherLevel = toLevel(otherLevel);
|
||||
}
|
||||
return comparison.call(this, otherLevel);
|
||||
};
|
||||
}
|
||||
|
||||
Level.prototype.isGreaterThanOrEqualTo = function(otherLevel) {
|
||||
if (typeof otherLevel === "string") {
|
||||
otherLevel = toLevel(otherLevel);
|
||||
Level.prototype.isLessThanOrEqualTo = convertAndCompare(
|
||||
function(otherLevel) {
|
||||
return this.level <= otherLevel.level;
|
||||
}
|
||||
return this.level >= otherLevel.level;
|
||||
};
|
||||
);
|
||||
|
||||
Level.prototype.isEqualTo = function(otherLevel) {
|
||||
if (typeof otherLevel == "string") {
|
||||
otherLevel = toLevel(otherLevel);
|
||||
Level.prototype.isGreaterThanOrEqualTo = convertAndCompare(
|
||||
function(otherLevel) {
|
||||
return this.level >= otherLevel.level;
|
||||
}
|
||||
return this.level === otherLevel.level;
|
||||
};
|
||||
);
|
||||
|
||||
module.exports = {
|
||||
ALL: new Level(Number.MIN_VALUE, "ALL"),
|
||||
TRACE: new Level(5000, "TRACE"),
|
||||
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"),
|
||||
OFF: new Level(Number.MAX_VALUE, "OFF"),
|
||||
toLevel: toLevel
|
||||
};
|
||||
Level.prototype.isEqualTo = convertAndCompare(
|
||||
function(otherLevel) {
|
||||
return this.level === otherLevel.level;
|
||||
}
|
||||
);
|
||||
|
||||
|
||||
exports.ALL = new Level(Number.MIN_VALUE, "ALL");
|
||||
exports.TRACE = new Level(5000, "TRACE");
|
||||
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;
|
||||
|
||||
@ -1,404 +1,422 @@
|
||||
"use strict";
|
||||
var vows = require('vows')
|
||||
, assert = require('assert')
|
||||
var assert = require('assert')
|
||||
, should = require('should')
|
||||
, levels = require('../lib/levels');
|
||||
|
||||
function assertThat(level) {
|
||||
function assertForEach(assertion, test, otherLevels) {
|
||||
function assertForEach(val, test, otherLevels) {
|
||||
otherLevels.forEach(function(other) {
|
||||
assertion.call(assert, test.call(level, other));
|
||||
test.call(level, other).should.eql(val);
|
||||
});
|
||||
}
|
||||
|
||||
return {
|
||||
isLessThanOrEqualTo: function(levels) {
|
||||
assertForEach(assert.isTrue, level.isLessThanOrEqualTo, levels);
|
||||
assertForEach(true, level.isLessThanOrEqualTo, levels);
|
||||
},
|
||||
isNotLessThanOrEqualTo: function(levels) {
|
||||
assertForEach(assert.isFalse, level.isLessThanOrEqualTo, levels);
|
||||
assertForEach(false, level.isLessThanOrEqualTo, levels);
|
||||
},
|
||||
isGreaterThanOrEqualTo: function(levels) {
|
||||
assertForEach(assert.isTrue, level.isGreaterThanOrEqualTo, levels);
|
||||
assertForEach(true, level.isGreaterThanOrEqualTo, levels);
|
||||
},
|
||||
isNotGreaterThanOrEqualTo: function(levels) {
|
||||
assertForEach(assert.isFalse, level.isGreaterThanOrEqualTo, levels);
|
||||
assertForEach(false, level.isGreaterThanOrEqualTo, levels);
|
||||
},
|
||||
isEqualTo: function(levels) {
|
||||
assertForEach(assert.isTrue, level.isEqualTo, levels);
|
||||
assertForEach(true, level.isEqualTo, levels);
|
||||
},
|
||||
isNotEqualTo: function(levels) {
|
||||
assertForEach(assert.isFalse, level.isEqualTo, levels);
|
||||
assertForEach(false, level.isEqualTo, levels);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
vows.describe('levels').addBatch({
|
||||
'values': {
|
||||
topic: levels,
|
||||
'should define some levels': function(levels) {
|
||||
assert.isNotNull(levels.ALL);
|
||||
assert.isNotNull(levels.TRACE);
|
||||
assert.isNotNull(levels.DEBUG);
|
||||
assert.isNotNull(levels.INFO);
|
||||
assert.isNotNull(levels.WARN);
|
||||
assert.isNotNull(levels.ERROR);
|
||||
assert.isNotNull(levels.FATAL);
|
||||
assert.isNotNull(levels.OFF);
|
||||
},
|
||||
'ALL': {
|
||||
topic: levels.ALL,
|
||||
'should be less than the other levels': function(all) {
|
||||
assertThat(all).isLessThanOrEqualTo(
|
||||
[
|
||||
levels.ALL,
|
||||
levels.TRACE,
|
||||
levels.DEBUG,
|
||||
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([
|
||||
describe('../lib/levels', function() {
|
||||
it('should define some levels', function() {
|
||||
should.exist(levels.ALL);
|
||||
should.exist(levels.TRACE);
|
||||
should.exist(levels.DEBUG);
|
||||
should.exist(levels.INFO);
|
||||
should.exist(levels.WARN);
|
||||
should.exist(levels.ERROR);
|
||||
should.exist(levels.FATAL);
|
||||
should.exist(levels.OFF);
|
||||
});
|
||||
|
||||
describe('ALL', function() {
|
||||
var all = levels.ALL;
|
||||
|
||||
it('should be less than the other levels', function() {
|
||||
assertThat(all).isLessThanOrEqualTo(
|
||||
[
|
||||
levels.ALL,
|
||||
levels.TRACE,
|
||||
levels.DEBUG,
|
||||
levels.INFO,
|
||||
levels.WARN,
|
||||
levels.ERROR,
|
||||
levels.FATAL,
|
||||
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]);
|
||||
assertThat(info).isNotGreaterThanOrEqualTo([
|
||||
]
|
||||
);
|
||||
});
|
||||
|
||||
it('should be greater than no levels', function() {
|
||||
assertThat(all).isNotGreaterThanOrEqualTo(
|
||||
[
|
||||
levels.TRACE,
|
||||
levels.DEBUG,
|
||||
levels.INFO,
|
||||
levels.WARN,
|
||||
levels.ERROR,
|
||||
levels.FATAL,
|
||||
levels.OFF
|
||||
]);
|
||||
},
|
||||
'should only be equal to INFO': function(trace) {
|
||||
assertThat(trace).isEqualTo([levels.toLevel("INFO")]);
|
||||
assertThat(trace).isNotEqualTo([
|
||||
levels.ALL,
|
||||
]
|
||||
);
|
||||
});
|
||||
|
||||
it('should only be equal to ALL', function() {
|
||||
assertThat(all).isEqualTo([levels.toLevel("ALL")]);
|
||||
assertThat(all).isNotEqualTo(
|
||||
[
|
||||
levels.TRACE,
|
||||
levels.DEBUG,
|
||||
levels.INFO,
|
||||
levels.WARN,
|
||||
levels.ERROR,
|
||||
levels.FATAL,
|
||||
levels.OFF
|
||||
]);
|
||||
}
|
||||
},
|
||||
'WARN': {
|
||||
topic: levels.WARN,
|
||||
'should be less than ERROR': function(warn) {
|
||||
assertThat(warn).isLessThanOrEqualTo([levels.ERROR, levels.FATAL, levels.OFF]);
|
||||
assertThat(warn).isNotLessThanOrEqualTo([
|
||||
levels.ALL,
|
||||
levels.TRACE,
|
||||
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,
|
||||
]
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('TRACE', function() {
|
||||
var trace = levels.TRACE;
|
||||
|
||||
it('should be less than DEBUG', function() {
|
||||
assertThat(trace).isLessThanOrEqualTo(
|
||||
[
|
||||
levels.DEBUG,
|
||||
levels.INFO,
|
||||
levels.WARN,
|
||||
levels.ERROR,
|
||||
levels.FATAL,
|
||||
levels.OFF
|
||||
]);
|
||||
}
|
||||
},
|
||||
'ERROR': {
|
||||
topic: levels.ERROR,
|
||||
'should be less than FATAL': function(error) {
|
||||
assertThat(error).isLessThanOrEqualTo([levels.FATAL, levels.OFF]);
|
||||
assertThat(error).isNotLessThanOrEqualTo([
|
||||
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,
|
||||
]
|
||||
);
|
||||
assertThat(trace).isNotLessThanOrEqualTo([levels.ALL]);
|
||||
});
|
||||
|
||||
it('should be greater than ALL', function() {
|
||||
assertThat(trace).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE]);
|
||||
assertThat(trace).isNotGreaterThanOrEqualTo(
|
||||
[
|
||||
levels.DEBUG,
|
||||
levels.INFO,
|
||||
levels.WARN,
|
||||
levels.ERROR,
|
||||
levels.FATAL,
|
||||
levels.OFF
|
||||
]);
|
||||
}
|
||||
},
|
||||
'FATAL': {
|
||||
topic: levels.FATAL,
|
||||
'should be less than OFF': function(fatal) {
|
||||
assertThat(fatal).isLessThanOrEqualTo([levels.OFF]);
|
||||
assertThat(fatal).isNotLessThanOrEqualTo([
|
||||
]
|
||||
);
|
||||
});
|
||||
|
||||
it('should only be equal to TRACE', function() {
|
||||
assertThat(trace).isEqualTo([levels.toLevel("TRACE")]);
|
||||
assertThat(trace).isNotEqualTo(
|
||||
[
|
||||
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.INFO,
|
||||
levels.WARN,
|
||||
levels.ERROR,
|
||||
levels.FATAL,
|
||||
levels.OFF
|
||||
]);
|
||||
}
|
||||
},
|
||||
'OFF': {
|
||||
topic: levels.OFF,
|
||||
'should not be less than anything': function(off) {
|
||||
assertThat(off).isNotLessThanOrEqualTo([
|
||||
levels.ALL,
|
||||
levels.TRACE,
|
||||
levels.DEBUG,
|
||||
]
|
||||
);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('DEBUG', function() {
|
||||
var debug = levels.DEBUG;
|
||||
|
||||
it('should be less than INFO', function() {
|
||||
assertThat(debug).isLessThanOrEqualTo(
|
||||
[
|
||||
levels.INFO,
|
||||
levels.WARN,
|
||||
levels.ERROR,
|
||||
levels.FATAL
|
||||
]);
|
||||
},
|
||||
'should be greater than everything': function(off) {
|
||||
assertThat(off).isGreaterThanOrEqualTo([
|
||||
levels.ALL,
|
||||
levels.TRACE,
|
||||
levels.DEBUG,
|
||||
levels.FATAL,
|
||||
levels.OFF
|
||||
]
|
||||
);
|
||||
assertThat(debug).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE]);
|
||||
});
|
||||
|
||||
it('should be greater than TRACE', function() {
|
||||
assertThat(debug).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE]);
|
||||
assertThat(debug).isNotGreaterThanOrEqualTo(
|
||||
[
|
||||
levels.INFO,
|
||||
levels.WARN,
|
||||
levels.ERROR,
|
||||
levels.FATAL
|
||||
]);
|
||||
},
|
||||
'should only be equal to OFF': function(off) {
|
||||
assertThat(off).isEqualTo([levels.toLevel("OFF")]);
|
||||
assertThat(off).isNotEqualTo([
|
||||
levels.FATAL,
|
||||
levels.OFF
|
||||
]
|
||||
);
|
||||
});
|
||||
|
||||
it('should only be equal to DEBUG', function() {
|
||||
assertThat(debug).isEqualTo([levels.toLevel("DEBUG")]);
|
||||
assertThat(debug).isNotEqualTo(
|
||||
[
|
||||
levels.ALL,
|
||||
levels.TRACE,
|
||||
levels.DEBUG,
|
||||
levels.INFO,
|
||||
levels.WARN,
|
||||
levels.ERROR,
|
||||
levels.FATAL
|
||||
]);
|
||||
}
|
||||
}
|
||||
},
|
||||
'isGreaterThanOrEqualTo': {
|
||||
topic: levels.INFO,
|
||||
'should handle string arguments': function(info) {
|
||||
levels.FATAL,
|
||||
levels.OFF
|
||||
]
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
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).isNotGreaterThanOrEqualTo(['warn', 'ERROR', 'Fatal', 'off']);
|
||||
}
|
||||
},
|
||||
'isLessThanOrEqualTo': {
|
||||
topic: levels.INFO,
|
||||
'should handle string arguments': function(info) {
|
||||
});
|
||||
});
|
||||
|
||||
describe('isLessThanOrEqualTo', function() {
|
||||
var info = levels.INFO;
|
||||
it('should handle string arguments', function() {
|
||||
assertThat(info).isNotLessThanOrEqualTo(["all", "trace", "debug"]);
|
||||
assertThat(info).isLessThanOrEqualTo(['warn', 'ERROR', 'Fatal', 'off']);
|
||||
}
|
||||
},
|
||||
'isEqualTo': {
|
||||
topic: levels.INFO,
|
||||
'should handle string arguments': function(info) {
|
||||
});
|
||||
});
|
||||
|
||||
describe('isEqualTo', function() {
|
||||
var info = levels.INFO;
|
||||
it('should handle string arguments', function() {
|
||||
assertThat(info).isEqualTo(["info", "INFO", "iNfO"]);
|
||||
}
|
||||
},
|
||||
'toLevel': {
|
||||
'with lowercase argument': {
|
||||
topic: levels.toLevel("debug"),
|
||||
'should take the string and return the corresponding level': function(level) {
|
||||
assert.equal(level, levels.DEBUG);
|
||||
}
|
||||
},
|
||||
'with uppercase argument': {
|
||||
topic: levels.toLevel("DEBUG"),
|
||||
'should take the string and return the corresponding level': function(level) {
|
||||
assert.equal(level, levels.DEBUG);
|
||||
}
|
||||
},
|
||||
'with varying case': {
|
||||
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);
|
||||
});
|
||||
});
|
||||
|
||||
describe('toLevel', function() {
|
||||
it('should ignore the case of arguments', function() {
|
||||
levels.toLevel("debug").should.eql(levels.DEBUG);
|
||||
levels.toLevel("DEBUG").should.eql(levels.DEBUG);
|
||||
levels.toLevel("DeBuG").should.eql(levels.DEBUG);
|
||||
});
|
||||
|
||||
it('should return undefined when argument is not recognised', function() {
|
||||
should.not.exist(levels.toLevel("cheese"));
|
||||
});
|
||||
|
||||
it('should return the default value if argument is not recognised', function() {
|
||||
levels.toLevel("cheese", levels.DEBUG).should.eql(levels.DEBUG);
|
||||
});
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
Loading…
Reference in New Issue
Block a user