737 lines
25 KiB
Haxe
737 lines
25 KiB
Haxe
package node;
|
|
|
|
/**
|
|
An alias of {@link ok}.
|
|
**/
|
|
@:jsRequire("assert") @valueModuleOnly extern class Assert {
|
|
/**
|
|
An alias of {@link ok}.
|
|
**/
|
|
@:selfCall
|
|
static function call(value:Any, ?message:ts.AnyOf2<String, js.lib.Error>):Void;
|
|
/**
|
|
Throws an `AssertionError` with the provided error message or a default
|
|
error message. If the `message` parameter is an instance of an `Error` then
|
|
it will be thrown instead of the `AssertionError`.
|
|
|
|
```js
|
|
import assert from 'node:assert/strict';
|
|
|
|
assert.fail();
|
|
// AssertionError [ERR_ASSERTION]: Failed
|
|
|
|
assert.fail('boom');
|
|
// AssertionError [ERR_ASSERTION]: boom
|
|
|
|
assert.fail(new TypeError('need array'));
|
|
// TypeError: need array
|
|
```
|
|
|
|
Using `assert.fail()` with more than two arguments is possible but deprecated.
|
|
See below for further details.
|
|
**/
|
|
@:overload(function(actual:Any, expected:Any, ?message:ts.AnyOf2<String, js.lib.Error>, ?operator_:String, ?stackStartFn:haxe.Constraints.Function):Any { })
|
|
static function fail(?message:ts.AnyOf2<String, js.lib.Error>):Any;
|
|
/**
|
|
Tests if `value` is truthy. It is equivalent to`assert.equal(!!value, true, message)`.
|
|
|
|
If `value` is not truthy, an `AssertionError` is thrown with a `message`property set equal to the value of the `message` parameter. If the `message`parameter is `undefined`, a default
|
|
error message is assigned. If the `message`parameter is an instance of an `Error` then it will be thrown instead of the`AssertionError`.
|
|
If no arguments are passed in at all `message` will be set to the string:`` 'No value argument passed to `assert.ok()`' ``.
|
|
|
|
Be aware that in the `repl` the error message will be different to the one
|
|
thrown in a file! See below for further details.
|
|
|
|
```js
|
|
import assert from 'node:assert/strict';
|
|
|
|
assert.ok(true);
|
|
// OK
|
|
assert.ok(1);
|
|
// OK
|
|
|
|
assert.ok();
|
|
// AssertionError: No value argument passed to `assert.ok()`
|
|
|
|
assert.ok(false, 'it\'s false');
|
|
// AssertionError: it's false
|
|
|
|
// In the repl:
|
|
assert.ok(typeof 123 === 'string');
|
|
// AssertionError: false == true
|
|
|
|
// In a file (e.g. test.js):
|
|
assert.ok(typeof 123 === 'string');
|
|
// AssertionError: The expression evaluated to a falsy value:
|
|
//
|
|
// assert.ok(typeof 123 === 'string')
|
|
|
|
assert.ok(false);
|
|
// AssertionError: The expression evaluated to a falsy value:
|
|
//
|
|
// assert.ok(false)
|
|
|
|
assert.ok(0);
|
|
// AssertionError: The expression evaluated to a falsy value:
|
|
//
|
|
// assert.ok(0)
|
|
```
|
|
|
|
```js
|
|
import assert from 'node:assert/strict';
|
|
|
|
// Using `assert()` works the same:
|
|
assert(0);
|
|
// AssertionError: The expression evaluated to a falsy value:
|
|
//
|
|
// assert(0)
|
|
```
|
|
**/
|
|
static function ok(value:Any, ?message:ts.AnyOf2<String, js.lib.Error>):Void;
|
|
/**
|
|
**Strict assertion mode**
|
|
|
|
An alias of {@link strictEqual}.
|
|
|
|
**Legacy assertion mode**
|
|
|
|
> Stability: 3 - Legacy: Use {@link strictEqual} instead.
|
|
|
|
Tests shallow, coercive equality between the `actual` and `expected` parameters
|
|
using the [`==` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Equality). `NaN` is specially handled
|
|
and treated as being identical if both sides are `NaN`.
|
|
|
|
```js
|
|
import assert from 'node:assert';
|
|
|
|
assert.equal(1, 1);
|
|
// OK, 1 == 1
|
|
assert.equal(1, '1');
|
|
// OK, 1 == '1'
|
|
assert.equal(NaN, NaN);
|
|
// OK
|
|
|
|
assert.equal(1, 2);
|
|
// AssertionError: 1 == 2
|
|
assert.equal({ a: { b: 1 } }, { a: { b: 1 } });
|
|
// AssertionError: { a: { b: 1 } } == { a: { b: 1 } }
|
|
```
|
|
|
|
If the values are not equal, an `AssertionError` is thrown with a `message`property set equal to the value of the `message` parameter. If the `message`parameter is undefined, a default
|
|
error message is assigned. If the `message`parameter is an instance of an `Error` then it will be thrown instead of the`AssertionError`.
|
|
**/
|
|
static function equal(actual:Any, expected:Any, ?message:ts.AnyOf2<String, js.lib.Error>):Void;
|
|
/**
|
|
**Strict assertion mode**
|
|
|
|
An alias of {@link notStrictEqual}.
|
|
|
|
**Legacy assertion mode**
|
|
|
|
> Stability: 3 - Legacy: Use {@link notStrictEqual} instead.
|
|
|
|
Tests shallow, coercive inequality with the [`!=` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Inequality). `NaN` is
|
|
specially handled and treated as being identical if both sides are `NaN`.
|
|
|
|
```js
|
|
import assert from 'node:assert';
|
|
|
|
assert.notEqual(1, 2);
|
|
// OK
|
|
|
|
assert.notEqual(1, 1);
|
|
// AssertionError: 1 != 1
|
|
|
|
assert.notEqual(1, '1');
|
|
// AssertionError: 1 != '1'
|
|
```
|
|
|
|
If the values are equal, an `AssertionError` is thrown with a `message`property set equal to the value of the `message` parameter. If the `message`parameter is undefined, a default error
|
|
message is assigned. If the `message`parameter is an instance of an `Error` then it will be thrown instead of the`AssertionError`.
|
|
**/
|
|
static function notEqual(actual:Any, expected:Any, ?message:ts.AnyOf2<String, js.lib.Error>):Void;
|
|
/**
|
|
**Strict assertion mode**
|
|
|
|
An alias of {@link deepStrictEqual}.
|
|
|
|
**Legacy assertion mode**
|
|
|
|
> Stability: 3 - Legacy: Use {@link deepStrictEqual} instead.
|
|
|
|
Tests for deep equality between the `actual` and `expected` parameters. Consider
|
|
using {@link deepStrictEqual} instead. {@link deepEqual} can have
|
|
surprising results.
|
|
|
|
_Deep equality_ means that the enumerable "own" properties of child objects
|
|
are also recursively evaluated by the following rules.
|
|
**/
|
|
static function deepEqual(actual:Any, expected:Any, ?message:ts.AnyOf2<String, js.lib.Error>):Void;
|
|
/**
|
|
**Strict assertion mode**
|
|
|
|
An alias of {@link notDeepStrictEqual}.
|
|
|
|
**Legacy assertion mode**
|
|
|
|
> Stability: 3 - Legacy: Use {@link notDeepStrictEqual} instead.
|
|
|
|
Tests for any deep inequality. Opposite of {@link deepEqual}.
|
|
|
|
```js
|
|
import assert from 'node:assert';
|
|
|
|
const obj1 = {
|
|
a: {
|
|
b: 1,
|
|
},
|
|
};
|
|
const obj2 = {
|
|
a: {
|
|
b: 2,
|
|
},
|
|
};
|
|
const obj3 = {
|
|
a: {
|
|
b: 1,
|
|
},
|
|
};
|
|
const obj4 = { __proto__: obj1 };
|
|
|
|
assert.notDeepEqual(obj1, obj1);
|
|
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
|
|
|
|
assert.notDeepEqual(obj1, obj2);
|
|
// OK
|
|
|
|
assert.notDeepEqual(obj1, obj3);
|
|
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
|
|
|
|
assert.notDeepEqual(obj1, obj4);
|
|
// OK
|
|
```
|
|
|
|
If the values are deeply equal, an `AssertionError` is thrown with a`message` property set equal to the value of the `message` parameter. If the`message` parameter is undefined, a default
|
|
error message is assigned. If the`message` parameter is an instance of an `Error` then it will be thrown
|
|
instead of the `AssertionError`.
|
|
**/
|
|
static function notDeepEqual(actual:Any, expected:Any, ?message:ts.AnyOf2<String, js.lib.Error>):Void;
|
|
/**
|
|
Tests strict equality between the `actual` and `expected` parameters as
|
|
determined by [`Object.is()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
|
|
|
|
```js
|
|
import assert from 'node:assert/strict';
|
|
|
|
assert.strictEqual(1, 2);
|
|
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
|
|
//
|
|
// 1 !== 2
|
|
|
|
assert.strictEqual(1, 1);
|
|
// OK
|
|
|
|
assert.strictEqual('Hello foobar', 'Hello World!');
|
|
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
|
|
// + actual - expected
|
|
//
|
|
// + 'Hello foobar'
|
|
// - 'Hello World!'
|
|
// ^
|
|
|
|
const apples = 1;
|
|
const oranges = 2;
|
|
assert.strictEqual(apples, oranges, `apples ${apples} !== oranges ${oranges}`);
|
|
// AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2
|
|
|
|
assert.strictEqual(1, '1', new TypeError('Inputs are not identical'));
|
|
// TypeError: Inputs are not identical
|
|
```
|
|
|
|
If the values are not strictly equal, an `AssertionError` is thrown with a`message` property set equal to the value of the `message` parameter. If the`message` parameter is undefined, a
|
|
default error message is assigned. If the`message` parameter is an instance of an `Error` then it will be thrown
|
|
instead of the `AssertionError`.
|
|
**/
|
|
static function strictEqual<T>(actual:Any, expected:T, ?message:ts.AnyOf2<String, js.lib.Error>):Void;
|
|
/**
|
|
Tests strict inequality between the `actual` and `expected` parameters as
|
|
determined by [`Object.is()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
|
|
|
|
```js
|
|
import assert from 'node:assert/strict';
|
|
|
|
assert.notStrictEqual(1, 2);
|
|
// OK
|
|
|
|
assert.notStrictEqual(1, 1);
|
|
// AssertionError [ERR_ASSERTION]: Expected "actual" to be strictly unequal to:
|
|
//
|
|
// 1
|
|
|
|
assert.notStrictEqual(1, '1');
|
|
// OK
|
|
```
|
|
|
|
If the values are strictly equal, an `AssertionError` is thrown with a`message` property set equal to the value of the `message` parameter. If the`message` parameter is undefined, a
|
|
default error message is assigned. If the`message` parameter is an instance of an `Error` then it will be thrown
|
|
instead of the `AssertionError`.
|
|
**/
|
|
static function notStrictEqual(actual:Any, expected:Any, ?message:ts.AnyOf2<String, js.lib.Error>):Void;
|
|
/**
|
|
Tests for deep equality between the `actual` and `expected` parameters.
|
|
"Deep" equality means that the enumerable "own" properties of child objects
|
|
are recursively evaluated also by the following rules.
|
|
**/
|
|
static function deepStrictEqual<T>(actual:Any, expected:T, ?message:ts.AnyOf2<String, js.lib.Error>):Void;
|
|
/**
|
|
Tests for deep strict inequality. Opposite of {@link deepStrictEqual}.
|
|
|
|
```js
|
|
import assert from 'node:assert/strict';
|
|
|
|
assert.notDeepStrictEqual({ a: 1 }, { a: '1' });
|
|
// OK
|
|
```
|
|
|
|
If the values are deeply and strictly equal, an `AssertionError` is thrown
|
|
with a `message` property set equal to the value of the `message` parameter. If
|
|
the `message` parameter is undefined, a default error message is assigned. If
|
|
the `message` parameter is an instance of an `Error` then it will be thrown
|
|
instead of the `AssertionError`.
|
|
**/
|
|
static function notDeepStrictEqual(actual:Any, expected:Any, ?message:ts.AnyOf2<String, js.lib.Error>):Void;
|
|
/**
|
|
Expects the function `fn` to throw an error.
|
|
|
|
If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes),
|
|
[`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions), a validation function,
|
|
a validation object where each property will be tested for strict deep equality,
|
|
or an instance of error where each property will be tested for strict deep
|
|
equality including the non-enumerable `message` and `name` properties. When
|
|
using an object, it is also possible to use a regular expression, when
|
|
validating against a string property. See below for examples.
|
|
|
|
If specified, `message` will be appended to the message provided by the`AssertionError` if the `fn` call fails to throw or in case the error validation
|
|
fails.
|
|
|
|
Custom validation object/error instance:
|
|
|
|
```js
|
|
import assert from 'node:assert/strict';
|
|
|
|
const err = new TypeError('Wrong value');
|
|
err.code = 404;
|
|
err.foo = 'bar';
|
|
err.info = {
|
|
nested: true,
|
|
baz: 'text',
|
|
};
|
|
err.reg = /abc/i;
|
|
|
|
assert.throws(
|
|
() => {
|
|
throw err;
|
|
},
|
|
{
|
|
name: 'TypeError',
|
|
message: 'Wrong value',
|
|
info: {
|
|
nested: true,
|
|
baz: 'text',
|
|
},
|
|
// Only properties on the validation object will be tested for.
|
|
// Using nested objects requires all properties to be present. Otherwise
|
|
// the validation is going to fail.
|
|
},
|
|
);
|
|
|
|
// Using regular expressions to validate error properties:
|
|
assert.throws(
|
|
() => {
|
|
throw err;
|
|
},
|
|
{
|
|
// The `name` and `message` properties are strings and using regular
|
|
// expressions on those will match against the string. If they fail, an
|
|
// error is thrown.
|
|
name: /^TypeError$/,
|
|
message: /Wrong/,
|
|
foo: 'bar',
|
|
info: {
|
|
nested: true,
|
|
// It is not possible to use regular expressions for nested properties!
|
|
baz: 'text',
|
|
},
|
|
// The `reg` property contains a regular expression and only if the
|
|
// validation object contains an identical regular expression, it is going
|
|
// to pass.
|
|
reg: /abc/i,
|
|
},
|
|
);
|
|
|
|
// Fails due to the different `message` and `name` properties:
|
|
assert.throws(
|
|
() => {
|
|
const otherErr = new Error('Not found');
|
|
// Copy all enumerable properties from `err` to `otherErr`.
|
|
for (const [key, value] of Object.entries(err)) {
|
|
otherErr[key] = value;
|
|
}
|
|
throw otherErr;
|
|
},
|
|
// The error's `message` and `name` properties will also be checked when using
|
|
// an error as validation object.
|
|
err,
|
|
);
|
|
```
|
|
|
|
Validate instanceof using constructor:
|
|
|
|
```js
|
|
import assert from 'node:assert/strict';
|
|
|
|
assert.throws(
|
|
() => {
|
|
throw new Error('Wrong value');
|
|
},
|
|
Error,
|
|
);
|
|
```
|
|
|
|
Validate error message using [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions):
|
|
|
|
Using a regular expression runs `.toString` on the error object, and will
|
|
therefore also include the error name.
|
|
|
|
```js
|
|
import assert from 'node:assert/strict';
|
|
|
|
assert.throws(
|
|
() => {
|
|
throw new Error('Wrong value');
|
|
},
|
|
/^Error: Wrong value$/,
|
|
);
|
|
```
|
|
|
|
Custom error validation:
|
|
|
|
The function must return `true` to indicate all internal validations passed.
|
|
It will otherwise fail with an `AssertionError`.
|
|
|
|
```js
|
|
import assert from 'node:assert/strict';
|
|
|
|
assert.throws(
|
|
() => {
|
|
throw new Error('Wrong value');
|
|
},
|
|
(err) => {
|
|
assert(err instanceof Error);
|
|
assert(/value/.test(err));
|
|
// Avoid returning anything from validation functions besides `true`.
|
|
// Otherwise, it's not clear what part of the validation failed. Instead,
|
|
// throw an error about the specific validation that failed (as done in this
|
|
// example) and add as much helpful debugging information to that error as
|
|
// possible.
|
|
return true;
|
|
},
|
|
'unexpected error',
|
|
);
|
|
```
|
|
|
|
`error` cannot be a string. If a string is provided as the second
|
|
argument, then `error` is assumed to be omitted and the string will be used for`message` instead. This can lead to easy-to-miss mistakes. Using the same
|
|
message as the thrown error message is going to result in an`ERR_AMBIGUOUS_ARGUMENT` error. Please read the example below carefully if using
|
|
a string as the second argument gets considered:
|
|
|
|
```js
|
|
import assert from 'node:assert/strict';
|
|
|
|
function throwingFirst() {
|
|
throw new Error('First');
|
|
}
|
|
|
|
function throwingSecond() {
|
|
throw new Error('Second');
|
|
}
|
|
|
|
function notThrowing() {}
|
|
|
|
// The second argument is a string and the input function threw an Error.
|
|
// The first case will not throw as it does not match for the error message
|
|
// thrown by the input function!
|
|
assert.throws(throwingFirst, 'Second');
|
|
// In the next example the message has no benefit over the message from the
|
|
// error and since it is not clear if the user intended to actually match
|
|
// against the error message, Node.js throws an `ERR_AMBIGUOUS_ARGUMENT` error.
|
|
assert.throws(throwingSecond, 'Second');
|
|
// TypeError [ERR_AMBIGUOUS_ARGUMENT]
|
|
|
|
// The string is only used (as message) in case the function does not throw:
|
|
assert.throws(notThrowing, 'Second');
|
|
// AssertionError [ERR_ASSERTION]: Missing expected exception: Second
|
|
|
|
// If it was intended to match for the error message do this instead:
|
|
// It does not throw because the error messages match.
|
|
assert.throws(throwingSecond, /Second$/);
|
|
|
|
// If the error message does not match, an AssertionError is thrown.
|
|
assert.throws(throwingFirst, /Second$/);
|
|
// AssertionError [ERR_ASSERTION]
|
|
```
|
|
|
|
Due to the confusing error-prone notation, avoid a string as the second
|
|
argument.
|
|
**/
|
|
@:overload(function(block:() -> Any, error:node.assert.AssertPredicate, ?message:ts.AnyOf2<String, js.lib.Error>):Void { })
|
|
static function throws(block:() -> Any, ?message:ts.AnyOf2<String, js.lib.Error>):Void;
|
|
/**
|
|
Asserts that the function `fn` does not throw an error.
|
|
|
|
Using `assert.doesNotThrow()` is actually not useful because there
|
|
is no benefit in catching an error and then rethrowing it. Instead, consider
|
|
adding a comment next to the specific code path that should not throw and keep
|
|
error messages as expressive as possible.
|
|
|
|
When `assert.doesNotThrow()` is called, it will immediately call the `fn`function.
|
|
|
|
If an error is thrown and it is the same type as that specified by the `error`parameter, then an `AssertionError` is thrown. If the error is of a
|
|
different type, or if the `error` parameter is undefined, the error is
|
|
propagated back to the caller.
|
|
|
|
If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes),
|
|
[`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions), or a validation
|
|
function. See {@link throws} for more details.
|
|
|
|
The following, for instance, will throw the `TypeError` because there is no
|
|
matching error type in the assertion:
|
|
|
|
```js
|
|
import assert from 'node:assert/strict';
|
|
|
|
assert.doesNotThrow(
|
|
() => {
|
|
throw new TypeError('Wrong value');
|
|
},
|
|
SyntaxError,
|
|
);
|
|
```
|
|
|
|
However, the following will result in an `AssertionError` with the message
|
|
'Got unwanted exception...':
|
|
|
|
```js
|
|
import assert from 'node:assert/strict';
|
|
|
|
assert.doesNotThrow(
|
|
() => {
|
|
throw new TypeError('Wrong value');
|
|
},
|
|
TypeError,
|
|
);
|
|
```
|
|
|
|
If an `AssertionError` is thrown and a value is provided for the `message`parameter, the value of `message` will be appended to the `AssertionError` message:
|
|
|
|
```js
|
|
import assert from 'node:assert/strict';
|
|
|
|
assert.doesNotThrow(
|
|
() => {
|
|
throw new TypeError('Wrong value');
|
|
},
|
|
/Wrong value/,
|
|
'Whoops',
|
|
);
|
|
// Throws: AssertionError: Got unwanted exception: Whoops
|
|
```
|
|
**/
|
|
@:overload(function(block:() -> Any, error:node.assert.AssertPredicate, ?message:ts.AnyOf2<String, js.lib.Error>):Void { })
|
|
static function doesNotThrow(block:() -> Any, ?message:ts.AnyOf2<String, js.lib.Error>):Void;
|
|
/**
|
|
Throws `value` if `value` is not `undefined` or `null`. This is useful when
|
|
testing the `error` argument in callbacks. The stack trace contains all frames
|
|
from the error passed to `ifError()` including the potential new frames for`ifError()` itself.
|
|
|
|
```js
|
|
import assert from 'node:assert/strict';
|
|
|
|
assert.ifError(null);
|
|
// OK
|
|
assert.ifError(0);
|
|
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 0
|
|
assert.ifError('error');
|
|
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 'error'
|
|
assert.ifError(new Error());
|
|
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: Error
|
|
|
|
// Create some random error frames.
|
|
let err;
|
|
(function errorFrame() {
|
|
err = new Error('test error');
|
|
})();
|
|
|
|
(function ifErrorFrame() {
|
|
assert.ifError(err);
|
|
})();
|
|
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error
|
|
// at ifErrorFrame
|
|
// at errorFrame
|
|
```
|
|
**/
|
|
static function ifError(value:Any):Void;
|
|
/**
|
|
Awaits the `asyncFn` promise or, if `asyncFn` is a function, immediately
|
|
calls the function and awaits the returned promise to complete. It will then
|
|
check that the promise is rejected.
|
|
|
|
If `asyncFn` is a function and it throws an error synchronously,`assert.rejects()` will return a rejected `Promise` with that error. If the
|
|
function does not return a promise, `assert.rejects()` will return a rejected`Promise` with an `ERR_INVALID_RETURN_VALUE` error. In both cases the error
|
|
handler is skipped.
|
|
|
|
Besides the async nature to await the completion behaves identically to {@link throws}.
|
|
|
|
If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes),
|
|
[`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions), a validation function,
|
|
an object where each property will be tested for, or an instance of error where
|
|
each property will be tested for including the non-enumerable `message` and`name` properties.
|
|
|
|
If specified, `message` will be the message provided by the `AssertionError` if the `asyncFn` fails to reject.
|
|
|
|
```js
|
|
import assert from 'node:assert/strict';
|
|
|
|
await assert.rejects(
|
|
async () => {
|
|
throw new TypeError('Wrong value');
|
|
},
|
|
{
|
|
name: 'TypeError',
|
|
message: 'Wrong value',
|
|
},
|
|
);
|
|
```
|
|
|
|
```js
|
|
import assert from 'node:assert/strict';
|
|
|
|
await assert.rejects(
|
|
async () => {
|
|
throw new TypeError('Wrong value');
|
|
},
|
|
(err) => {
|
|
assert.strictEqual(err.name, 'TypeError');
|
|
assert.strictEqual(err.message, 'Wrong value');
|
|
return true;
|
|
},
|
|
);
|
|
```
|
|
|
|
```js
|
|
import assert from 'node:assert/strict';
|
|
|
|
assert.rejects(
|
|
Promise.reject(new Error('Wrong value')),
|
|
Error,
|
|
).then(() => {
|
|
// ...
|
|
});
|
|
```
|
|
|
|
`error` cannot be a string. If a string is provided as the second
|
|
argument, then `error` is assumed to be omitted and the string will be used for`message` instead. This can lead to easy-to-miss mistakes. Please read the
|
|
example in {@link throws} carefully if using a string as the second
|
|
argument gets considered.
|
|
**/
|
|
@:overload(function(block:ts.AnyOf2<() -> js.lib.Promise<Any>, js.lib.Promise<Any>>, error:node.assert.AssertPredicate, ?message:ts.AnyOf2<String, js.lib.Error>):js.lib.Promise<ts.Undefined> { })
|
|
static function rejects(block:ts.AnyOf2<js.lib.Promise<Any>, () -> js.lib.Promise<Any>>, ?message:ts.AnyOf2<String, js.lib.Error>):js.lib.Promise<ts.Undefined>;
|
|
/**
|
|
Awaits the `asyncFn` promise or, if `asyncFn` is a function, immediately
|
|
calls the function and awaits the returned promise to complete. It will then
|
|
check that the promise is not rejected.
|
|
|
|
If `asyncFn` is a function and it throws an error synchronously,`assert.doesNotReject()` will return a rejected `Promise` with that error. If
|
|
the function does not return a promise, `assert.doesNotReject()` will return a
|
|
rejected `Promise` with an `ERR_INVALID_RETURN_VALUE` error. In both cases
|
|
the error handler is skipped.
|
|
|
|
Using `assert.doesNotReject()` is actually not useful because there is little
|
|
benefit in catching a rejection and then rejecting it again. Instead, consider
|
|
adding a comment next to the specific code path that should not reject and keep
|
|
error messages as expressive as possible.
|
|
|
|
If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes),
|
|
[`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions), or a validation
|
|
function. See {@link throws} for more details.
|
|
|
|
Besides the async nature to await the completion behaves identically to {@link doesNotThrow}.
|
|
|
|
```js
|
|
import assert from 'node:assert/strict';
|
|
|
|
await assert.doesNotReject(
|
|
async () => {
|
|
throw new TypeError('Wrong value');
|
|
},
|
|
SyntaxError,
|
|
);
|
|
```
|
|
|
|
```js
|
|
import assert from 'node:assert/strict';
|
|
|
|
assert.doesNotReject(Promise.reject(new TypeError('Wrong value')))
|
|
.then(() => {
|
|
// ...
|
|
});
|
|
```
|
|
**/
|
|
@:overload(function(block:ts.AnyOf2<js.lib.Promise<Any>, () -> js.lib.Promise<Any>>, error:node.assert.AssertPredicate, ?message:ts.AnyOf2<String, js.lib.Error>):js.lib.Promise<ts.Undefined> { })
|
|
static function doesNotReject(block:ts.AnyOf2<js.lib.Promise<Any>, () -> js.lib.Promise<Any>>, ?message:ts.AnyOf2<String, js.lib.Error>):js.lib.Promise<ts.Undefined>;
|
|
/**
|
|
Expects the `string` input to match the regular expression.
|
|
|
|
```js
|
|
import assert from 'node:assert/strict';
|
|
|
|
assert.match('I will fail', /pass/);
|
|
// AssertionError [ERR_ASSERTION]: The input did not match the regular ...
|
|
|
|
assert.match(123, /pass/);
|
|
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.
|
|
|
|
assert.match('I will pass', /pass/);
|
|
// OK
|
|
```
|
|
|
|
If the values do not match, or if the `string` argument is of another type than`string`, an `AssertionError` is thrown with a `message` property set equal
|
|
to the value of the `message` parameter. If the `message` parameter is
|
|
undefined, a default error message is assigned. If the `message` parameter is an
|
|
instance of an `Error` then it will be thrown instead of the `AssertionError`.
|
|
**/
|
|
static function match(value:String, regExp:js.lib.RegExp, ?message:ts.AnyOf2<String, js.lib.Error>):Void;
|
|
/**
|
|
Expects the `string` input not to match the regular expression.
|
|
|
|
```js
|
|
import assert from 'node:assert/strict';
|
|
|
|
assert.doesNotMatch('I will fail', /fail/);
|
|
// AssertionError [ERR_ASSERTION]: The input was expected to not match the ...
|
|
|
|
assert.doesNotMatch(123, /pass/);
|
|
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.
|
|
|
|
assert.doesNotMatch('I will pass', /different/);
|
|
// OK
|
|
```
|
|
|
|
If the values do match, or if the `string` argument is of another type than`string`, an `AssertionError` is thrown with a `message` property set equal
|
|
to the value of the `message` parameter. If the `message` parameter is
|
|
undefined, a default error message is assigned. If the `message` parameter is an
|
|
instance of an `Error` then it will be thrown instead of the `AssertionError`.
|
|
**/
|
|
static function doesNotMatch(value:String, regExp:js.lib.RegExp, ?message:ts.AnyOf2<String, js.lib.Error>):Void;
|
|
static final strict : Dynamic;
|
|
} |