conditional
Version:
A preconditions package based on Google's Preconditions library
222 lines (214 loc) • 8.49 kB
JavaScript
(function() {
var FORCED_ERROR, IllegalArgumentError, IllegalStateError, IllegalValueError, InvalidTypeError, UndefinedValueError, UnknownValueError, checkArgument, checkContains, checkDefined, checkDoesNotContain, checkDoesNotEqual, checkEmpty, checkEquals, checkNotEmpty, checkNotNull, checkNotNumberType, checkNull, checkNumberType, checkState, checkUndefined, executors, runTests;
require('./helpers/test_helper');
checkArgument = preconditions.checkArgument, checkNumberType = preconditions.checkNumberType, checkNotNumberType = preconditions.checkNotNumberType, checkContains = preconditions.checkContains, checkDoesNotContain = preconditions.checkDoesNotContain, checkEquals = preconditions.checkEquals, checkDoesNotEqual = preconditions.checkDoesNotEqual, checkDefined = preconditions.checkDefined, checkUndefined = preconditions.checkUndefined, checkEmpty = preconditions.checkEmpty, checkNotEmpty = preconditions.checkNotEmpty, checkState = preconditions.checkState, checkNull = preconditions.checkNull, checkNotNull = preconditions.checkNotNull, IllegalArgumentError = preconditions.IllegalArgumentError, InvalidTypeError = preconditions.InvalidTypeError, UnknownValueError = preconditions.UnknownValueError, UndefinedValueError = preconditions.UndefinedValueError, IllegalValueError = preconditions.IllegalValueError, IllegalStateError = preconditions.IllegalStateError;
FORCED_ERROR = 'this must fail';
executors = [
{
name: 'argument',
execFail: function(errorMessage, callback) {
return checkArgument(false, errorMessage, callback);
},
execPass: function(callback) {
return checkArgument(true, callback);
},
errorType: IllegalArgumentError,
defaultErrorMessage: 'invalid argument'
}, {
name: 'type',
execFail: function(errorMessage, callback) {
return checkNumberType('string', errorMessage, callback);
},
execPass: function(callback) {
return checkNumberType(123, callback);
},
errorType: InvalidTypeError,
defaultErrorMessage: 'invalid type'
}, {
name: 'not-type',
execFail: function(errorMessage, callback) {
return checkNotNumberType(123, errorMessage, callback);
},
execPass: function(callback) {
return checkNotNumberType('string', callback);
},
errorType: InvalidTypeError,
defaultErrorMessage: 'invalid type'
}, {
name: 'contains',
execFail: function(errorMessage, callback) {
return checkContains('d', ['a', 'b', 'c'], errorMessage, callback);
},
execPass: function(callback) {
return checkContains('a', ['a'], callback);
},
errorType: UnknownValueError,
defaultErrorMessage: "unknown value 'd'"
}, {
name: 'not-contains',
execFail: function(errorMessage, callback) {
return checkDoesNotContain('a', ['a'], errorMessage, callback);
},
execPass: function(callback) {
return checkDoesNotContain('d', ['a', 'b', 'c'], callback);
},
errorType: UnknownValueError,
defaultErrorMessage: "'a' is a known value"
}, {
name: 'equals',
execFail: function(errorMessage, callback) {
return checkEquals('a', 'b', errorMessage, callback);
},
execPass: function(callback) {
return checkEquals(true, true, callback);
},
errorType: UnknownValueError,
defaultErrorMessage: "expected 'b' but got 'a'"
}, {
name: 'not-equals',
execFail: function(errorMessage, callback) {
return checkDoesNotEqual(true, true, errorMessage, callback);
},
execPass: function(callback) {
return checkDoesNotEqual('a', 'b', callback);
},
errorType: UnknownValueError,
defaultErrorMessage: "did not expect value 'true'"
}, {
name: 'defined',
execFail: function(errorMessage, callback) {
return checkDefined({}.undefined, errorMessage, callback);
},
execPass: function(callback) {
return checkDefined(true, callback);
},
errorType: UndefinedValueError,
defaultErrorMessage: 'undefined value'
}, {
name: 'not-defined',
execFail: function(errorMessage, callback) {
return checkUndefined(true, errorMessage, callback);
},
execPass: function(callback) {
return checkUndefined({}.undefined, callback);
},
errorType: UndefinedValueError,
defaultErrorMessage: "'true' is a defined value"
}, {
name: 'empty',
execFail: function(errorMessage, callback) {
return checkEmpty('string', errorMessage, callback);
},
execPass: function(callback) {
return checkEmpty('', callback);
},
errorType: IllegalValueError,
defaultErrorMessage: "'string' is not empty"
}, {
name: 'not-empty',
execFail: function(errorMessage, callback) {
return checkNotEmpty('', errorMessage, callback);
},
execPass: function(callback) {
return checkNotEmpty('string', callback);
},
errorType: IllegalValueError,
defaultErrorMessage: 'illegal value'
}, {
name: 'state',
execFail: function(errorMessage, callback) {
return checkState(false, errorMessage, callback);
},
execPass: function(callback) {
return checkState(true, callback);
},
errorType: IllegalStateError,
defaultErrorMessage: 'illegal state'
}, {
name: 'null',
execFail: function(errorMessage, callback) {
return checkNull('string', errorMessage, callback);
},
execPass: function(callback) {
return checkNull(null, callback);
},
errorType: IllegalValueError,
defaultErrorMessage: "'string' is not null"
}, {
name: 'not-null',
execFail: function(errorMessage, callback) {
return checkNotNull(null, errorMessage, callback);
},
execPass: function(callback) {
return checkNotNull('string', callback);
},
errorType: IllegalValueError,
defaultErrorMessage: 'value is null'
}
];
runTests = function(test) {
var executor, _i, _len, _results;
_results = [];
for (_i = 0, _len = executors.length; _i < _len; _i++) {
executor = executors[_i];
_results.push(test(executor));
}
return _results;
};
describe('common tests for preconditions', function() {
describe('error message can be controlled by precondition call', function() {
return runTests(function(executor) {
return it("" + executor.name + " check", function() {
var wrapper;
wrapper = function() {
return executor.execFail(FORCED_ERROR);
};
return assert.throws(wrapper, executor.errorType, FORCED_ERROR);
});
});
});
describe('preconditions return a default error message if none present', function() {
return runTests(function(executor) {
return it("" + executor.name + " check", function() {
var e;
try {
executor.execFail();
return assert.fail('expected an exception to be thrown');
} catch (_error) {
e = _error;
assert.instanceOf(e, executor.errorType);
return assert.equal(e.message, executor.defaultErrorMessage);
}
});
});
});
describe('can call precondition with a callback', function() {
return runTests(function(executor) {
return it("" + executor.name + " check", function(done) {
return executor.execFail(FORCED_ERROR, function(err) {
assert.equal(FORCED_ERROR, err.message);
assert.instanceOf(err, executor.errorType);
return done();
});
});
});
});
describe('happy path test', function() {
return runTests(function(executor) {
return it("" + executor.name + " check", function() {
return assert.doesNotThrow(executor.execPass);
});
});
});
return describe('happy path test with a callback', function() {
return runTests(function(executor) {
return it("" + executor.name + " check", function(done) {
return executor.execPass(function(err) {
assert.isNull(err, 'no error should be thrown in happy path');
return done();
});
});
});
});
});
}).call(this);