/**
|
* The `assert` module provides a set of assertion functions for verifying
|
* invariants.
|
* @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/assert.js)
|
*/
|
declare module 'assert' {
|
/**
|
* An alias of {@link ok}.
|
* @since v0.5.9
|
* @param value The input that is checked for being truthy.
|
*/
|
function assert(value: unknown, message?: string | Error): asserts value;
|
namespace assert {
|
/**
|
* Indicates the failure of an assertion. All errors thrown by the `assert` module
|
* will be instances of the `AssertionError` class.
|
*/
|
class AssertionError extends Error {
|
actual: unknown;
|
expected: unknown;
|
operator: string;
|
generatedMessage: boolean;
|
code: 'ERR_ASSERTION';
|
constructor(options?: {
|
/** If provided, the error message is set to this value. */
|
message?: string | undefined;
|
/** The `actual` property on the error instance. */
|
actual?: unknown | undefined;
|
/** The `expected` property on the error instance. */
|
expected?: unknown | undefined;
|
/** The `operator` property on the error instance. */
|
operator?: string | undefined;
|
/** If provided, the generated stack trace omits frames before this function. */
|
// tslint:disable-next-line:ban-types
|
stackStartFn?: Function | undefined;
|
});
|
}
|
/**
|
* This feature is currently experimental and behavior might still change.
|
* @since v14.2.0, v12.19.0
|
* @experimental
|
*/
|
class CallTracker {
|
/**
|
* The wrapper function is expected to be called exactly `exact` times. If the
|
* function has not been called exactly `exact` times when `tracker.verify()` is called, then `tracker.verify()` will throw an
|
* error.
|
*
|
* ```js
|
* import assert from 'assert';
|
*
|
* // Creates call tracker.
|
* const tracker = new assert.CallTracker();
|
*
|
* function func() {}
|
*
|
* // Returns a function that wraps func() that must be called exact times
|
* // before tracker.verify().
|
* const callsfunc = tracker.calls(func);
|
* ```
|
* @since v14.2.0, v12.19.0
|
* @param [fn='A no-op function']
|
* @param [exact=1]
|
* @return that wraps `fn`.
|
*/
|
calls(exact?: number): () => void;
|
calls<Func extends (...args: any[]) => any>(fn?: Func, exact?: number): Func;
|
/**
|
* The arrays contains information about the expected and actual number of calls of
|
* the functions that have not been called the expected number of times.
|
*
|
* ```js
|
* import assert from 'assert';
|
*
|
* // Creates call tracker.
|
* const tracker = new assert.CallTracker();
|
*
|
* function func() {}
|
*
|
* function foo() {}
|
*
|
* // Returns a function that wraps func() that must be called exact times
|
* // before tracker.verify().
|
* const callsfunc = tracker.calls(func, 2);
|
*
|
* // Returns an array containing information on callsfunc()
|
* tracker.report();
|
* // [
|
* // {
|
* // message: 'Expected the func function to be executed 2 time(s) but was
|
* // executed 0 time(s).',
|
* // actual: 0,
|
* // expected: 2,
|
* // operator: 'func',
|
* // stack: stack trace
|
* // }
|
* // ]
|
* ```
|
* @since v14.2.0, v12.19.0
|
* @return of objects containing information about the wrapper functions returned by `calls`.
|
*/
|
report(): CallTrackerReportInformation[];
|
/**
|
* Iterates through the list of functions passed to `tracker.calls()` and will throw an error for functions that
|
* have not been called the expected number of times.
|
*
|
* ```js
|
* import assert from 'assert';
|
*
|
* // Creates call tracker.
|
* const tracker = new assert.CallTracker();
|
*
|
* function func() {}
|
*
|
* // Returns a function that wraps func() that must be called exact times
|
* // before tracker.verify().
|
* const callsfunc = tracker.calls(func, 2);
|
*
|
* callsfunc();
|
*
|
* // Will throw an error since callsfunc() was only called once.
|
* tracker.verify();
|
* ```
|
* @since v14.2.0, v12.19.0
|
*/
|
verify(): void;
|
}
|
interface CallTrackerReportInformation {
|
message: string;
|
/** The actual number of times the function was called. */
|
actual: number;
|
/** The number of times the function was expected to be called. */
|
expected: number;
|
/** The name of the function that is wrapped. */
|
operator: string;
|
/** A stack trace of the function. */
|
stack: object;
|
}
|
type AssertPredicate = RegExp | (new () => object) | ((thrown: unknown) => boolean) | object | Error;
|
/**
|
* 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 '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.
|
* @since v0.1.21
|
* @param [message='Failed']
|
*/
|
function fail(message?: string | Error): never;
|
/** @deprecated since v10.0.0 - use fail([message]) or other assert functions instead. */
|
function fail(
|
actual: unknown,
|
expected: unknown,
|
message?: string | Error,
|
operator?: string,
|
// tslint:disable-next-line:ban-types
|
stackStartFn?: Function
|
): never;
|
/**
|
* 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 '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 'assert/strict';
|
*
|
* // Using `assert()` works the same:
|
* assert(0);
|
* // AssertionError: The expression evaluated to a falsy value:
|
* //
|
* // assert(0)
|
* ```
|
* @since v0.1.21
|
*/
|
function ok(value: unknown, message?: string | Error): asserts value;
|
/**
|
* **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 [Abstract Equality Comparison](https://tc39.github.io/ecma262/#sec-abstract-equality-comparison) ( `==` ). `NaN` is special handled
|
* and treated as being identical in case both sides are `NaN`.
|
*
|
* ```js
|
* import assert from '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`.
|
* @since v0.1.21
|
*/
|
function equal(actual: unknown, expected: unknown, message?: string | 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 [Abstract Equality Comparison](https://tc39.github.io/ecma262/#sec-abstract-equality-comparison)(`!=` ). `NaN` is special handled and treated as
|
* being identical in case both
|
* sides are `NaN`.
|
*
|
* ```js
|
* import assert from '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`.
|
* @since v0.1.21
|
*/
|
function notEqual(actual: unknown, expected: unknown, message?: string | 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.
|
* @since v0.1.21
|
*/
|
function deepEqual(actual: unknown, expected: unknown, message?: string | 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 'assert';
|
*
|
* const obj1 = {
|
* a: {
|
* b: 1
|
* }
|
* };
|
* const obj2 = {
|
* a: {
|
* b: 2
|
* }
|
* };
|
* const obj3 = {
|
* a: {
|
* b: 1
|
* }
|
* };
|
* const obj4 = Object.create(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`.
|
* @since v0.1.21
|
*/
|
function notDeepEqual(actual: unknown, expected: unknown, message?: string | Error): void;
|
/**
|
* Tests strict equality between the `actual` and `expected` parameters as
|
* determined by the [SameValue Comparison](https://tc39.github.io/ecma262/#sec-samevalue).
|
*
|
* ```js
|
* import assert from '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`.
|
* @since v0.1.21
|
*/
|
function strictEqual<T>(actual: unknown, expected: T, message?: string | Error): asserts actual is T;
|
/**
|
* Tests strict inequality between the `actual` and `expected` parameters as
|
* determined by the [SameValue Comparison](https://tc39.github.io/ecma262/#sec-samevalue).
|
*
|
* ```js
|
* import assert from '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`.
|
* @since v0.1.21
|
*/
|
function notStrictEqual(actual: unknown, expected: unknown, message?: string | 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.
|
* @since v1.2.0
|
*/
|
function deepStrictEqual<T>(actual: unknown, expected: T, message?: string | Error): asserts actual is T;
|
/**
|
* Tests for deep strict inequality. Opposite of {@link deepStrictEqual}.
|
*
|
* ```js
|
* import assert from '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`.
|
* @since v1.2.0
|
*/
|
function notDeepStrictEqual(actual: unknown, expected: unknown, message?: string | 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 '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:
|
* 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:
|
* 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 '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 '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 '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 '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.
|
* @since v0.1.21
|
*/
|
function throws(block: () => unknown, message?: string | Error): void;
|
function throws(block: () => unknown, error: AssertPredicate, message?: string | 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 '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 '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 'assert/strict';
|
*
|
* assert.doesNotThrow(
|
* () => {
|
* throw new TypeError('Wrong value');
|
* },
|
* /Wrong value/,
|
* 'Whoops'
|
* );
|
* // Throws: AssertionError: Got unwanted exception: Whoops
|
* ```
|
* @since v0.1.21
|
*/
|
function doesNotThrow(block: () => unknown, message?: string | Error): void;
|
function doesNotThrow(block: () => unknown, error: AssertPredicate, message?: string | 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 '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
|
* ```
|
* @since v0.1.97
|
*/
|
function ifError(value: unknown): asserts value is null | 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 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 'assert/strict';
|
*
|
* await assert.rejects(
|
* async () => {
|
* throw new TypeError('Wrong value');
|
* },
|
* {
|
* name: 'TypeError',
|
* message: 'Wrong value'
|
* }
|
* );
|
* ```
|
*
|
* ```js
|
* import assert from '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 '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.
|
* @since v10.0.0
|
*/
|
function rejects(block: (() => Promise<unknown>) | Promise<unknown>, message?: string | Error): Promise<void>;
|
function rejects(block: (() => Promise<unknown>) | Promise<unknown>, error: AssertPredicate, message?: string | Error): Promise<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 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 'assert/strict';
|
*
|
* await assert.doesNotReject(
|
* async () => {
|
* throw new TypeError('Wrong value');
|
* },
|
* SyntaxError
|
* );
|
* ```
|
*
|
* ```js
|
* import assert from 'assert/strict';
|
*
|
* assert.doesNotReject(Promise.reject(new TypeError('Wrong value')))
|
* .then(() => {
|
* // ...
|
* });
|
* ```
|
* @since v10.0.0
|
*/
|
function doesNotReject(block: (() => Promise<unknown>) | Promise<unknown>, message?: string | Error): Promise<void>;
|
function doesNotReject(block: (() => Promise<unknown>) | Promise<unknown>, error: AssertPredicate, message?: string | Error): Promise<void>;
|
/**
|
* Expects the `string` input to match the regular expression.
|
*
|
* ```js
|
* import assert from '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`.
|
* @since v13.6.0, v12.16.0
|
*/
|
function match(value: string, regExp: RegExp, message?: string | Error): void;
|
/**
|
* Expects the `string` input not to match the regular expression.
|
*
|
* ```js
|
* import assert from '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`.
|
* @since v13.6.0, v12.16.0
|
*/
|
function doesNotMatch(value: string, regExp: RegExp, message?: string | Error): void;
|
const strict: Omit<typeof assert, 'equal' | 'notEqual' | 'deepEqual' | 'notDeepEqual' | 'ok' | 'strictEqual' | 'deepStrictEqual' | 'ifError' | 'strict'> & {
|
(value: unknown, message?: string | Error): asserts value;
|
equal: typeof strictEqual;
|
notEqual: typeof notStrictEqual;
|
deepEqual: typeof deepStrictEqual;
|
notDeepEqual: typeof notDeepStrictEqual;
|
// Mapped types and assertion functions are incompatible?
|
// TS2775: Assertions require every name in the call target
|
// to be declared with an explicit type annotation.
|
ok: typeof ok;
|
strictEqual: typeof strictEqual;
|
deepStrictEqual: typeof deepStrictEqual;
|
ifError: typeof ifError;
|
strict: typeof strict;
|
};
|
}
|
export = assert;
|
}
|
declare module 'node:assert' {
|
import assert = require('assert');
|
export = assert;
|
}
|
