Asserts that the function throws an error when called.
function somethingThatThrows() {
throw new Error('The error message');
}
expect(function () {
somethingThatThrows();
}, 'to throw');
In case of a failing expectation you get the following output:
function willNotThrow() {
// ...
}
expect(function () {
willNotThrow();
}, 'to throw');
expected function () { willNotThrow(); } to throw
did not throw
Used with arrow functions this assertion is very elegant, and there are a couple of functionally equaivalent aliases provided to allow test suites using it be more explicit.
expect(() => somethingThatThrows(), 'to throw');
// aliases
expect(() => somethingThatThrows(), 'to throw error');
expect(() => somethingThatThrows(), 'to throw exception');
If you provide a string as the second parameter, it will be used to assert the thrown error has that message.
expect(
function() {
throw new Error('The error message');
},
'to throw',
'The error message'
);
In case of a failing expectation you get the following output:
expect(function () {
throw new Error('The error message!');
}, 'to throw', 'The error message');
expected
function () {
throw new Error('The error message!');
}
to throw 'The error message'
expected Error('The error message!') to satisfy 'The error message'
-The error message!
+The error message
By providing a regular expression as the second parameter you can assert the error message matches the given regular expression.
expect(
function() {
throw new Error('The error message');
},
'to throw',
/error message/
);
In case of a failing expectation you get the following output:
expect(function () {
throw new Error('The error message!');
}, 'to throw', /catastrophic failure/);
expected
function () {
throw new Error('The error message!');
}
to throw /catastrophic failure/
expected Error('The error message!') to satisfy /catastrophic failure/
That can also just supply an error object to validate against:
expect(
function() {
throw new TypeError('Invalid syntax');
},
'to throw',
new TypeError('Invalid syntax')
);
In case of a failing expectation you get the following output:
expect(function () {
throw new Error('Another error');
}, 'to throw', new TypeError('Invalid syntax'));
expected
function () {
throw new Error('Another error');
}
to throw TypeError('Invalid syntax')
expected Error('Another error') to satisfy TypeError('Invalid syntax')
expect(function() {
// Do some work that should not throw
}, 'not to throw');
In case of a failing expectation you get the following output:
expect(function () {
throw new Error('threw anyway');
}, 'not to throw');
expected
function () {
throw new Error('threw anyway');
}
not to throw
threw: Error('threw anyway')
To test functions that require input wrap the function invocation in an anonymous function:
function willThrow(input) {
if (input) throw new SyntaxError('The error message');
return input;
}
expect(
function() {
willThrow('input.here');
},
'to throw',
new SyntaxError('The error message')
);