warren/jasmine
1
0
Fork 0
Code Issues Pull Requests Actions 9 Packages Projects Releases Wiki Activity

build distribution for toThrowError refactor

Browse Source
This commit is contained in:
slackersoft
2014-09-24 18:27:40 -07:00
parent 6d10f97151
commit f703539942
1 changed files with 97 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

212
lib/jasmine-core/jasmine.js
View File

@@ -2410,18 +2410,13 @@ getJasmineRequireObj().toThrowError = function(j$) {
var threw = false,
pass = {pass: true},
fail = {pass: false},
thrown,
errorType,
message,
regexp,
name,
constructorName;
thrown;
if (typeof actual != 'function') {
throw new Error('Actual is not a Function');
}
extractExpectedParams.apply(null, arguments);
var errorMatcher = getMatcher.apply(null, arguments);
try {
actual();
@@ -2440,121 +2435,108 @@ getJasmineRequireObj().toThrowError = function(j$) {
return fail;
}
if (arguments.length == 1) {
if (errorMatcher.hasNoSpecifics()) {
pass.message = 'Expected function not to throw an Error, but it threw ' + fnNameFor(thrown) + '.';
return pass;
}
if (errorType) {
name = fnNameFor(errorType);
constructorName = fnNameFor(thrown.constructor);
}
if (errorType && message) {
if (thrown.constructor == errorType && util.equals(thrown.message, message)) {
pass.message = function() { return 'Expected function not to throw ' + name + ' with message ' + j$.pp(message) + '.'; };
return pass;
} else {
fail.message = function() { return 'Expected function to throw ' + name + ' with message ' + j$.pp(message) +
', but it threw ' + constructorName + ' with message ' + j$.pp(thrown.message) + '.'; };
return fail;
}
}
if (errorType && regexp) {
if (thrown.constructor == errorType && regexp.test(thrown.message)) {
pass.message = function() { return 'Expected function not to throw ' + name + ' with message matching ' + j$.pp(regexp) + '.'; };
return pass;
} else {
fail.message = function() { return 'Expected function to throw ' + name + ' with message matching ' + j$.pp(regexp) +
', but it threw ' + constructorName + ' with message ' + j$.pp(thrown.message) + '.'; };
return fail;
}
}
if (errorType) {
if (thrown.constructor == errorType) {
pass.message = 'Expected function not to throw ' + name + '.';
return pass;
} else {
fail.message = 'Expected function to throw ' + name + ', but it threw ' + constructorName + '.';
return fail;
}
}
if (message) {
if (thrown.message == message) {
pass.message = function() { return 'Expected function not to throw an exception with message ' + j$.pp(message) + '.'; };
return pass;
} else {
fail.message = function() { return 'Expected function to throw an exception with message ' + j$.pp(message) +
', but it threw an exception with message ' + j$.pp(thrown.message) + '.'; };
return fail;
}
}
if (regexp) {
if (regexp.test(thrown.message)) {
pass.message = function() { return 'Expected function not to throw an exception with a message matching ' + j$.pp(regexp) + '.'; };
return pass;
} else {
fail.message = function() { return 'Expected function to throw an exception with a message matching ' + j$.pp(regexp) +
', but it threw an exception with message ' + j$.pp(thrown.message) + '.'; };
return fail;
}
}
function fnNameFor(func) {
return func.name || func.toString().match(/^\s*function\s*(\w*)\s*\(/)[1];
}
function extractExpectedParams() {
if (arguments.length == 1) {
return;
}
if (arguments.length == 2) {
var expected = arguments[1];
if (expected instanceof RegExp) {
regexp = expected;
} else if (typeof expected == 'string') {
message = expected;
} else if (checkForAnErrorType(expected)) {
errorType = expected;
}
if (!(errorType || message || regexp)) {
throw new Error('Expected is not an Error, string, or RegExp.');
}
} else {
if (checkForAnErrorType(arguments[1])) {
errorType = arguments[1];
} else {
throw new Error('Expected error type is not an Error.');
}
if (arguments[2] instanceof RegExp) {
regexp = arguments[2];
} else if (typeof arguments[2] == 'string') {
message = arguments[2];
} else {
throw new Error('Expected error message is not a string or RegExp.');
}
}
}
function checkForAnErrorType(type) {
if (typeof type !== 'function') {
return false;
}
var Surrogate = function() {};
Surrogate.prototype = type.prototype;
return (new Surrogate()) instanceof Error;
if (errorMatcher.matches(thrown)) {
pass.message = function() {
return 'Expected function not to throw ' + errorMatcher.errorTypeDescription + errorMatcher.messageDescription() + '.';
};
return pass;
} else {
fail.message = function() {
return 'Expected function to throw ' + errorMatcher.errorTypeDescription + errorMatcher.messageDescription() +
', but it threw ' + errorMatcher.thrownDescription(thrown) + '.';
};
return fail;
}
}
};
function getMatcher() {
var expected = null,
errorType = null;
if (arguments.length == 2) {
expected = arguments[1];
if (isAnErrorType(expected)) {
errorType = expected;
expected = null;
}
} else if (arguments.length > 2) {
errorType = arguments[1];
expected = arguments[2];
if (!isAnErrorType(errorType)) {
throw new Error('Expected error type is not an Error.');
}
}
if (expected && !isStringOrRegExp(expected)) {
if (errorType) {
throw new Error('Expected error message is not a string or RegExp.');
} else {
throw new Error('Expected is not an Error, string, or RegExp.');
}
}
function messageMatch(message) {
if (typeof expected == 'string') {
return expected == message;
} else {
return expected.test(message);
}
}
return {
errorTypeDescription: errorType ? fnNameFor(errorType) : 'an exception',
thrownDescription: function(thrown) {
var thrownName = errorType ? fnNameFor(thrown.constructor) : 'an exception',
thrownMessage = '';
if (expected) {
thrownMessage = ' with message ' + j$.pp(thrown.message);
}
return thrownName + thrownMessage;
},
messageDescription: function() {
if (expected === null) {
return '';
} else if (expected instanceof RegExp) {
return ' with a message matching ' + j$.pp(expected);
} else {
return ' with message ' + j$.pp(expected);
}
},
hasNoSpecifics: function() {
return expected === null && errorType === null;
},
matches: function(error) {
return (errorType === null || error.constructor === errorType) &&
(expected === null || messageMatch(error.message));
}
};
}
function fnNameFor(func) {
return func.name || func.toString().match(/^\s*function\s*(\w*)\s*\(/)[1];
}
function isStringOrRegExp(potential) {
return potential instanceof RegExp || (typeof potential == 'string');
}
function isAnErrorType(type) {
if (typeof type !== 'function') {
return false;
}
var Surrogate = function() {};
Surrogate.prototype = type.prototype;
return (new Surrogate()) instanceof Error;
}
}
return toThrowError;