Browse Source

test: validate more properties in expectsError

PR-URL: https://github.com/nodejs/node/pull/14058
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Refael Ackermann <refack@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Gibson Fahnestock <gibfahn@gmail.com>
v6
Ruben Bridgewater 7 years ago
committed by Refael Ackermann
parent
commit
2a621d4051
No known key found for this signature in database GPG Key ID: CD704BD80FDDDB64
  1. 43
      test/common/README.md
  2. 43
      test/common/index.js
  3. 2
      test/parallel/test-internal-errors.js

43
test/common/README.md

@ -51,28 +51,41 @@ Platform normalizes the `dd` command
Check if there is more than 1gb of total memory. Check if there is more than 1gb of total memory.
### expectsError([fn, ]settings[, exact]) ### expectsError([fn, ]settings[, exact])
* `fn` [&lt;Function>] * `fn` [&lt;Function>] a function that should throw.
* `settings` [&lt;Object>] * `settings` [&lt;Object>]
with the following optional properties: that must contain the `code` property plus any of the other following
properties (some properties only apply for `AssertionError`):
* `code` [&lt;String>] * `code` [&lt;String>]
expected error must have this value for its `code` property expected error must have this value for its `code` property.
* `type` [&lt;Function>] * `type` [&lt;Function>]
expected error must be an instance of `type` expected error must be an instance of `type` and must be an Error subclass.
* `message` [&lt;String>] * `message` [&lt;String>] or [&lt;RegExp>]
or [&lt;RegExp>]
if a string is provided for `message`, expected error must have it for its if a string is provided for `message`, expected error must have it for its
`message` property; if a regular expression is provided for `message`, the `message` property; if a regular expression is provided for `message`, the
regular expression must match the `message` property of the expected error regular expression must match the `message` property of the expected error.
* `name` [&lt;String>]
expected error must have this value for its `name` property.
* `generatedMessage` [&lt;String>]
(`AssertionError` only) expected error must have this value for its
`generatedMessage` property.
* `actual` &lt;any>
(`AssertionError` only) expected error must have this value for its
`actual` property.
* `expected` &lt;any>
(`AssertionError` only) expected error must have this value for its
`expected` property.
* `operator` &lt;any>
(`AssertionError` only) expected error must have this value for its
`operator` property.
* `exact` [&lt;Number>] default = 1 * `exact` [&lt;Number>] default = 1
* return [&lt;Function>]
* return function suitable for use as a validation function passed as the second If `fn` is provided, it will be passed to `assert.throws` as first argument
argument to e.g. `assert.throws()`. If the returned function has not been and `undefined` will be returned.
called exactly `exact` number of times when the test is complete, then the Otherwise a function suitable as callback or for use as a validation function
test will fail. passed as the second argument to `assert.throws()` will be returned. If the
returned function has not been called exactly `exact` number of times when the
If `fn` is provided, it will be passed to `assert.throws` as first argument. test is complete, then the test will fail.
The expected error should be [subclassed by the `internal/errors` module](https://github.com/nodejs/node/blob/master/doc/guides/using-internal-errors.md#api).
### expectWarning(name, expected) ### expectWarning(name, expected)
* `name` [&lt;String>] * `name` [&lt;String>]

43
test/common/index.js

@ -696,24 +696,43 @@ Object.defineProperty(exports, 'hasSmallICU', {
}); });
// Useful for testing expected internal/error objects // Useful for testing expected internal/error objects
exports.expectsError = function expectsError(fn, options, exact) { exports.expectsError = function expectsError(fn, settings, exact) {
if (typeof fn !== 'function') { if (typeof fn !== 'function') {
exact = options; exact = settings;
options = fn; settings = fn;
fn = undefined; fn = undefined;
} }
const { code, type, message } = options;
const innerFn = exports.mustCall(function(error) { const innerFn = exports.mustCall(function(error) {
assert.strictEqual(error.code, code); assert.strictEqual(error.code, settings.code);
if (type !== undefined) { if ('type' in settings) {
const type = settings.type;
if (type !== Error && !Error.isPrototypeOf(type)) {
throw new TypeError('`settings.type` must inherit from `Error`');
}
assert(error instanceof type, assert(error instanceof type,
`${error} is not the expected type ${type}`); `${error.name} is not instance of ${type.name}`);
}
if ('message' in settings) {
const message = settings.message;
if (typeof message === 'string') {
assert.strictEqual(error.message, message);
} else {
assert(message.test(error.message),
`${error.message} does not match ${message}`);
}
} }
if (message instanceof RegExp) { if ('name' in settings) {
assert(message.test(error.message), assert.strictEqual(error.name, settings.name);
`${error.message} does not match ${message}`); }
} else if (typeof message === 'string') { if (error.constructor.name === 'AssertionError') {
assert.strictEqual(error.message, message); ['generatedMessage', 'actual', 'expected', 'operator'].forEach((key) => {
if (key in settings) {
const actual = error[key];
const expected = settings[key];
assert.strictEqual(actual, expected,
`${key}: expected ${expected}, not ${actual}`);
}
});
} }
return true; return true;
}, exact); }, exact);

2
test/parallel/test-internal-errors.js

@ -166,7 +166,7 @@ assert.throws(() => {
}, common.expectsError({ code: 'TEST_ERROR_1', type: RangeError })); }, common.expectsError({ code: 'TEST_ERROR_1', type: RangeError }));
}, common.expectsError({ }, common.expectsError({
code: 'ERR_ASSERTION', code: 'ERR_ASSERTION',
message: /^.+ is not the expected type \S/ message: /^.+ is not instance of \S/
})); }));
assert.throws(() => { assert.throws(() => {

Loading…
Cancel
Save