@types/node
Version:
TypeScript definitions for node
1,054 lines • 104 kB
TypeScript
/**
* The `node:test` module facilitates the creation of JavaScript tests.
* To access it:
*
* ```js
* import test from 'node:test';
* ```
*
* This module is only available under the `node:` scheme. The following will not
* work:
*
* ```js
* import test from 'node:test';
* ```
*
* Tests created via the `test` module consist of a single function that is
* processed in one of three ways:
*
* 1. A synchronous function that is considered failing if it throws an exception,
* and is considered passing otherwise.
* 2. A function that returns a `Promise` that is considered failing if the `Promise` rejects, and is considered passing if the `Promise` fulfills.
* 3. A function that receives a callback function. If the callback receives any
* truthy value as its first argument, the test is considered failing. If a
* falsy value is passed as the first argument to the callback, the test is
* considered passing. If the test function receives a callback function and
* also returns a `Promise`, the test will fail.
*
* The following example illustrates how tests are written using the `test` module.
*
* ```js
* test('synchronous passing test', (t) => {
* // This test passes because it does not throw an exception.
* assert.strictEqual(1, 1);
* });
*
* test('synchronous failing test', (t) => {
* // This test fails because it throws an exception.
* assert.strictEqual(1, 2);
* });
*
* test('asynchronous passing test', async (t) => {
* // This test passes because the Promise returned by the async
* // function is settled and not rejected.
* assert.strictEqual(1, 1);
* });
*
* test('asynchronous failing test', async (t) => {
* // This test fails because the Promise returned by the async
* // function is rejected.
* assert.strictEqual(1, 2);
* });
*
* test('failing test using Promises', (t) => {
* // Promises can be used directly as well.
* return new Promise((resolve, reject) => {
* setImmediate(() => {
* reject(new Error('this will cause the test to fail'));
* });
* });
* });
*
* test('callback passing test', (t, done) => {
* // done() is the callback function. When the setImmediate() runs, it invokes
* // done() with no arguments.
* setImmediate(done);
* });
*
* test('callback failing test', (t, done) => {
* // When the setImmediate() runs, done() is invoked with an Error object and
* // the test fails.
* setImmediate(() => {
* done(new Error('callback failure'));
* });
* });
* ```
*
* If any tests fail, the process exit code is set to `1`.
* @since v18.0.0, v16.17.0
* @see [source](https://github.com/nodejs/node/blob/v24.x/lib/test.js)
*/
declare module "node:test" {
import { Readable } from "node:stream";
import TestFn = test.TestFn;
import TestOptions = test.TestOptions;
/**
* The `test()` function is the value imported from the `test` module. Each
* invocation of this function results in reporting the test to the `TestsStream`.
*
* The `TestContext` object passed to the `fn` argument can be used to perform
* actions related to the current test. Examples include skipping the test, adding
* additional diagnostic information, or creating subtests.
*
* `test()` returns a `Promise` that fulfills once the test completes.
* if `test()` is called within a suite, it fulfills immediately.
* The return value can usually be discarded for top level tests.
* However, the return value from subtests should be used to prevent the parent
* test from finishing first and cancelling the subtest
* as shown in the following example.
*
* ```js
* test('top level test', async (t) => {
* // The setTimeout() in the following subtest would cause it to outlive its
* // parent test if 'await' is removed on the next line. Once the parent test
* // completes, it will cancel any outstanding subtests.
* await t.test('longer running subtest', async (t) => {
* return new Promise((resolve, reject) => {
* setTimeout(resolve, 1000);
* });
* });
* });
* ```
*
* The `timeout` option can be used to fail the test if it takes longer than `timeout` milliseconds to complete. However, it is not a reliable mechanism for
* canceling tests because a running test might block the application thread and
* thus prevent the scheduled cancellation.
* @since v18.0.0, v16.17.0
* @param name The name of the test, which is displayed when reporting test results.
* Defaults to the `name` property of `fn`, or `'<anonymous>'` if `fn` does not have a name.
* @param options Configuration options for the test.
* @param fn The function under test. The first argument to this function is a {@link TestContext} object.
* If the test uses callbacks, the callback function is passed as the second argument.
* @return Fulfilled with `undefined` once the test completes, or immediately if the test runs within a suite.
*/
function test(name?: string, fn?: TestFn): Promise<void>;
function test(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
function test(options?: TestOptions, fn?: TestFn): Promise<void>;
function test(fn?: TestFn): Promise<void>;
namespace test {
export { test };
export { suite as describe, test as it };
}
namespace test {
/**
* **Note:** `shard` is used to horizontally parallelize test running across
* machines or processes, ideal for large-scale executions across varied
* environments. It's incompatible with `watch` mode, tailored for rapid
* code iteration by automatically rerunning tests on file changes.
*
* ```js
* import { tap } from 'node:test/reporters';
* import { run } from 'node:test';
* import process from 'node:process';
* import path from 'node:path';
*
* run({ files: [path.resolve('./tests/test.js')] })
* .compose(tap)
* .pipe(process.stdout);
* ```
* @since v18.9.0, v16.19.0
* @param options Configuration options for running tests.
*/
function run(options?: RunOptions): TestsStream;
/**
* The `suite()` function is imported from the `node:test` module.
* @param name The name of the suite, which is displayed when reporting test results.
* Defaults to the `name` property of `fn`, or `'<anonymous>'` if `fn` does not have a name.
* @param options Configuration options for the suite. This supports the same options as {@link test}.
* @param fn The suite function declaring nested tests and suites. The first argument to this function is a {@link SuiteContext} object.
* @return Immediately fulfilled with `undefined`.
* @since v20.13.0
*/
function suite(name?: string, options?: TestOptions, fn?: SuiteFn): Promise<void>;
function suite(name?: string, fn?: SuiteFn): Promise<void>;
function suite(options?: TestOptions, fn?: SuiteFn): Promise<void>;
function suite(fn?: SuiteFn): Promise<void>;
namespace suite {
/**
* Shorthand for skipping a suite. This is the same as calling {@link suite} with `options.skip` set to `true`.
* @since v20.13.0
*/
function skip(name?: string, options?: TestOptions, fn?: SuiteFn): Promise<void>;
function skip(name?: string, fn?: SuiteFn): Promise<void>;
function skip(options?: TestOptions, fn?: SuiteFn): Promise<void>;
function skip(fn?: SuiteFn): Promise<void>;
/**
* Shorthand for marking a suite as `TODO`. This is the same as calling {@link suite} with `options.todo` set to `true`.
* @since v20.13.0
*/
function todo(name?: string, options?: TestOptions, fn?: SuiteFn): Promise<void>;
function todo(name?: string, fn?: SuiteFn): Promise<void>;
function todo(options?: TestOptions, fn?: SuiteFn): Promise<void>;
function todo(fn?: SuiteFn): Promise<void>;
/**
* Shorthand for marking a suite as `only`. This is the same as calling {@link suite} with `options.only` set to `true`.
* @since v20.13.0
*/
function only(name?: string, options?: TestOptions, fn?: SuiteFn): Promise<void>;
function only(name?: string, fn?: SuiteFn): Promise<void>;
function only(options?: TestOptions, fn?: SuiteFn): Promise<void>;
function only(fn?: SuiteFn): Promise<void>;
}
/**
* Shorthand for skipping a test. This is the same as calling {@link test} with `options.skip` set to `true`.
* @since v20.2.0
*/
function skip(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
function skip(name?: string, fn?: TestFn): Promise<void>;
function skip(options?: TestOptions, fn?: TestFn): Promise<void>;
function skip(fn?: TestFn): Promise<void>;
/**
* Shorthand for marking a test as `TODO`. This is the same as calling {@link test} with `options.todo` set to `true`.
* @since v20.2.0
*/
function todo(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
function todo(name?: string, fn?: TestFn): Promise<void>;
function todo(options?: TestOptions, fn?: TestFn): Promise<void>;
function todo(fn?: TestFn): Promise<void>;
/**
* Shorthand for marking a test as `only`. This is the same as calling {@link test} with `options.only` set to `true`.
* @since v20.2.0
*/
function only(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
function only(name?: string, fn?: TestFn): Promise<void>;
function only(options?: TestOptions, fn?: TestFn): Promise<void>;
function only(fn?: TestFn): Promise<void>;
/**
* The type of a function passed to {@link test}. The first argument to this function is a {@link TestContext} object.
* If the test uses callbacks, the callback function is passed as the second argument.
*/
type TestFn = (t: TestContext, done: (result?: any) => void) => void | Promise<void>;
/**
* The type of a suite test function. The argument to this function is a {@link SuiteContext} object.
*/
type SuiteFn = (s: SuiteContext) => void | Promise<void>;
interface TestShard {
/**
* A positive integer between 1 and `total` that specifies the index of the shard to run.
*/
index: number;
/**
* A positive integer that specifies the total number of shards to split the test files to.
*/
total: number;
}
interface RunOptions {
/**
* If a number is provided, then that many test processes would run in parallel, where each process corresponds to one test file.
* If `true`, it would run `os.availableParallelism() - 1` test files in parallel. If `false`, it would only run one test file at a time.
* @default false
*/
concurrency?: number | boolean | undefined;
/**
* Specifies the current working directory to be used by the test runner.
* Serves as the base path for resolving files according to the
* [test runner execution model](https://nodejs.org/docs/latest-v24.x/api/test.html#test-runner-execution-model).
* @since v23.0.0
* @default process.cwd()
*/
cwd?: string | undefined;
/**
* An array containing the list of files to run. If omitted, files are run according to the
* [test runner execution model](https://nodejs.org/docs/latest-v24.x/api/test.html#test-runner-execution-model).
*/
files?: readonly string[] | undefined;
/**
* Configures the test runner to exit the process once all known
* tests have finished executing even if the event loop would
* otherwise remain active.
* @default false
*/
forceExit?: boolean | undefined;
/**
* An array containing the list of glob patterns to match test files.
* This option cannot be used together with `files`. If omitted, files are run according to the
* [test runner execution model](https://nodejs.org/docs/latest-v24.x/api/test.html#test-runner-execution-model).
* @since v22.6.0
*/
globPatterns?: readonly string[] | undefined;
/**
* Sets inspector port of test child process.
* This can be a number, or a function that takes no arguments and returns a
* number. If a nullish value is provided, each process gets its own port,
* incremented from the primary's `process.debugPort`. This option is ignored
* if the `isolation` option is set to `'none'` as no child processes are
* spawned.
* @default undefined
*/
inspectPort?: number | (() => number) | undefined;
/**
* Configures the type of test isolation. If set to
* `'process'`, each test file is run in a separate child process. If set to
* `'none'`, all test files run in the current process.
* @default 'process'
* @since v22.8.0
*/
isolation?: "process" | "none" | undefined;
/**
* If truthy, the test context will only run tests that have the `only` option set
*/
only?: boolean | undefined;
/**
* A function that accepts the `TestsStream` instance and can be used to setup listeners before any tests are run.
* @default undefined
*/
setup?: ((reporter: TestsStream) => void | Promise<void>) | undefined;
/**
* An array of CLI flags to pass to the `node` executable when
* spawning the subprocesses. This option has no effect when `isolation` is `'none`'.
* @since v22.10.0
* @default []
*/
execArgv?: readonly string[] | undefined;
/**
* An array of CLI flags to pass to each test file when spawning the
* subprocesses. This option has no effect when `isolation` is `'none'`.
* @since v22.10.0
* @default []
*/
argv?: readonly string[] | undefined;
/**
* Allows aborting an in-progress test execution.
*/
signal?: AbortSignal | undefined;
/**
* If provided, only run tests whose name matches the provided pattern.
* Strings are interpreted as JavaScript regular expressions.
* @default undefined
*/
testNamePatterns?: string | RegExp | ReadonlyArray<string | RegExp> | undefined;
/**
* A String, RegExp or a RegExp Array, that can be used to exclude running tests whose
* name matches the provided pattern. Test name patterns are interpreted as JavaScript
* regular expressions. For each test that is executed, any corresponding test hooks,
* such as `beforeEach()`, are also run.
* @default undefined
* @since v22.1.0
*/
testSkipPatterns?: string | RegExp | ReadonlyArray<string | RegExp> | undefined;
/**
* The number of milliseconds after which the test execution will fail.
* If unspecified, subtests inherit this value from their parent.
* @default Infinity
*/
timeout?: number | undefined;
/**
* Whether to run in watch mode or not.
* @default false
*/
watch?: boolean | undefined;
/**
* Running tests in a specific shard.
* @default undefined
*/
shard?: TestShard | undefined;
/**
* enable [code coverage](https://nodejs.org/docs/latest-v24.x/api/test.html#collecting-code-coverage) collection.
* @since v22.10.0
* @default false
*/
coverage?: boolean | undefined;
/**
* Excludes specific files from code coverage
* using a glob pattern, which can match both absolute and relative file paths.
* This property is only applicable when `coverage` was set to `true`.
* If both `coverageExcludeGlobs` and `coverageIncludeGlobs` are provided,
* files must meet **both** criteria to be included in the coverage report.
* @since v22.10.0
* @default undefined
*/
coverageExcludeGlobs?: string | readonly string[] | undefined;
/**
* Includes specific files in code coverage
* using a glob pattern, which can match both absolute and relative file paths.
* This property is only applicable when `coverage` was set to `true`.
* If both `coverageExcludeGlobs` and `coverageIncludeGlobs` are provided,
* files must meet **both** criteria to be included in the coverage report.
* @since v22.10.0
* @default undefined
*/
coverageIncludeGlobs?: string | readonly string[] | undefined;
/**
* Require a minimum percent of covered lines. If code
* coverage does not reach the threshold specified, the process will exit with code `1`.
* @since v22.10.0
* @default 0
*/
lineCoverage?: number | undefined;
/**
* Require a minimum percent of covered branches. If code
* coverage does not reach the threshold specified, the process will exit with code `1`.
* @since v22.10.0
* @default 0
*/
branchCoverage?: number | undefined;
/**
* Require a minimum percent of covered functions. If code
* coverage does not reach the threshold specified, the process will exit with code `1`.
* @since v22.10.0
* @default 0
*/
functionCoverage?: number | undefined;
}
/**
* A successful call to `run()` will return a new `TestsStream` object, streaming a series of events representing the execution of the tests.
*
* Some of the events are guaranteed to be emitted in the same order as the tests are defined, while others are emitted in the order that the tests execute.
* @since v18.9.0, v16.19.0
*/
interface TestsStream extends Readable {
addListener(event: "test:coverage", listener: (data: EventData.TestCoverage) => void): this;
addListener(event: "test:complete", listener: (data: EventData.TestComplete) => void): this;
addListener(event: "test:dequeue", listener: (data: EventData.TestDequeue) => void): this;
addListener(event: "test:diagnostic", listener: (data: EventData.TestDiagnostic) => void): this;
addListener(event: "test:enqueue", listener: (data: EventData.TestEnqueue) => void): this;
addListener(event: "test:fail", listener: (data: EventData.TestFail) => void): this;
addListener(event: "test:pass", listener: (data: EventData.TestPass) => void): this;
addListener(event: "test:plan", listener: (data: EventData.TestPlan) => void): this;
addListener(event: "test:start", listener: (data: EventData.TestStart) => void): this;
addListener(event: "test:stderr", listener: (data: EventData.TestStderr) => void): this;
addListener(event: "test:stdout", listener: (data: EventData.TestStdout) => void): this;
addListener(event: "test:summary", listener: (data: EventData.TestSummary) => void): this;
addListener(event: "test:watch:drained", listener: () => void): this;
addListener(event: string, listener: (...args: any[]) => void): this;
emit(event: "test:coverage", data: EventData.TestCoverage): boolean;
emit(event: "test:complete", data: EventData.TestComplete): boolean;
emit(event: "test:dequeue", data: EventData.TestDequeue): boolean;
emit(event: "test:diagnostic", data: EventData.TestDiagnostic): boolean;
emit(event: "test:enqueue", data: EventData.TestEnqueue): boolean;
emit(event: "test:fail", data: EventData.TestFail): boolean;
emit(event: "test:pass", data: EventData.TestPass): boolean;
emit(event: "test:plan", data: EventData.TestPlan): boolean;
emit(event: "test:start", data: EventData.TestStart): boolean;
emit(event: "test:stderr", data: EventData.TestStderr): boolean;
emit(event: "test:stdout", data: EventData.TestStdout): boolean;
emit(event: "test:summary", data: EventData.TestSummary): boolean;
emit(event: "test:watch:drained"): boolean;
emit(event: string | symbol, ...args: any[]): boolean;
on(event: "test:coverage", listener: (data: EventData.TestCoverage) => void): this;
on(event: "test:complete", listener: (data: EventData.TestComplete) => void): this;
on(event: "test:dequeue", listener: (data: EventData.TestDequeue) => void): this;
on(event: "test:diagnostic", listener: (data: EventData.TestDiagnostic) => void): this;
on(event: "test:enqueue", listener: (data: EventData.TestEnqueue) => void): this;
on(event: "test:fail", listener: (data: EventData.TestFail) => void): this;
on(event: "test:pass", listener: (data: EventData.TestPass) => void): this;
on(event: "test:plan", listener: (data: EventData.TestPlan) => void): this;
on(event: "test:start", listener: (data: EventData.TestStart) => void): this;
on(event: "test:stderr", listener: (data: EventData.TestStderr) => void): this;
on(event: "test:stdout", listener: (data: EventData.TestStdout) => void): this;
on(event: "test:summary", listener: (data: EventData.TestSummary) => void): this;
on(event: "test:watch:drained", listener: () => void): this;
on(event: string, listener: (...args: any[]) => void): this;
once(event: "test:coverage", listener: (data: EventData.TestCoverage) => void): this;
once(event: "test:complete", listener: (data: EventData.TestComplete) => void): this;
once(event: "test:dequeue", listener: (data: EventData.TestDequeue) => void): this;
once(event: "test:diagnostic", listener: (data: EventData.TestDiagnostic) => void): this;
once(event: "test:enqueue", listener: (data: EventData.TestEnqueue) => void): this;
once(event: "test:fail", listener: (data: EventData.TestFail) => void): this;
once(event: "test:pass", listener: (data: EventData.TestPass) => void): this;
once(event: "test:plan", listener: (data: EventData.TestPlan) => void): this;
once(event: "test:start", listener: (data: EventData.TestStart) => void): this;
once(event: "test:stderr", listener: (data: EventData.TestStderr) => void): this;
once(event: "test:stdout", listener: (data: EventData.TestStdout) => void): this;
once(event: "test:summary", listener: (data: EventData.TestSummary) => void): this;
once(event: "test:watch:drained", listener: () => void): this;
once(event: string, listener: (...args: any[]) => void): this;
prependListener(event: "test:coverage", listener: (data: EventData.TestCoverage) => void): this;
prependListener(event: "test:complete", listener: (data: EventData.TestComplete) => void): this;
prependListener(event: "test:dequeue", listener: (data: EventData.TestDequeue) => void): this;
prependListener(event: "test:diagnostic", listener: (data: EventData.TestDiagnostic) => void): this;
prependListener(event: "test:enqueue", listener: (data: EventData.TestEnqueue) => void): this;
prependListener(event: "test:fail", listener: (data: EventData.TestFail) => void): this;
prependListener(event: "test:pass", listener: (data: EventData.TestPass) => void): this;
prependListener(event: "test:plan", listener: (data: EventData.TestPlan) => void): this;
prependListener(event: "test:start", listener: (data: EventData.TestStart) => void): this;
prependListener(event: "test:stderr", listener: (data: EventData.TestStderr) => void): this;
prependListener(event: "test:stdout", listener: (data: EventData.TestStdout) => void): this;
prependListener(event: "test:summary", listener: (data: EventData.TestSummary) => void): this;
prependListener(event: "test:watch:drained", listener: () => void): this;
prependListener(event: string, listener: (...args: any[]) => void): this;
prependOnceListener(event: "test:coverage", listener: (data: EventData.TestCoverage) => void): this;
prependOnceListener(event: "test:complete", listener: (data: EventData.TestComplete) => void): this;
prependOnceListener(event: "test:dequeue", listener: (data: EventData.TestDequeue) => void): this;
prependOnceListener(event: "test:diagnostic", listener: (data: EventData.TestDiagnostic) => void): this;
prependOnceListener(event: "test:enqueue", listener: (data: EventData.TestEnqueue) => void): this;
prependOnceListener(event: "test:fail", listener: (data: EventData.TestFail) => void): this;
prependOnceListener(event: "test:pass", listener: (data: EventData.TestPass) => void): this;
prependOnceListener(event: "test:plan", listener: (data: EventData.TestPlan) => void): this;
prependOnceListener(event: "test:start", listener: (data: EventData.TestStart) => void): this;
prependOnceListener(event: "test:stderr", listener: (data: EventData.TestStderr) => void): this;
prependOnceListener(event: "test:stdout", listener: (data: EventData.TestStdout) => void): this;
prependOnceListener(event: "test:summary", listener: (data: EventData.TestSummary) => void): this;
prependOnceListener(event: "test:watch:drained", listener: () => void): this;
prependOnceListener(event: string, listener: (...args: any[]) => void): this;
}
namespace EventData {
interface Error extends globalThis.Error {
cause: globalThis.Error;
}
interface LocationInfo {
/**
* The column number where the test is defined, or
* `undefined` if the test was run through the REPL.
*/
column?: number;
/**
* The path of the test file, `undefined` if test was run through the REPL.
*/
file?: string;
/**
* The line number where the test is defined, or `undefined` if the test was run through the REPL.
*/
line?: number;
}
interface TestDiagnostic extends LocationInfo {
/**
* The diagnostic message.
*/
message: string;
/**
* The nesting level of the test.
*/
nesting: number;
}
interface TestCoverage {
/**
* An object containing the coverage report.
*/
summary: {
/**
* An array of coverage reports for individual files.
*/
files: Array<{
/**
* The absolute path of the file.
*/
path: string;
/**
* The total number of lines.
*/
totalLineCount: number;
/**
* The total number of branches.
*/
totalBranchCount: number;
/**
* The total number of functions.
*/
totalFunctionCount: number;
/**
* The number of covered lines.
*/
coveredLineCount: number;
/**
* The number of covered branches.
*/
coveredBranchCount: number;
/**
* The number of covered functions.
*/
coveredFunctionCount: number;
/**
* The percentage of lines covered.
*/
coveredLinePercent: number;
/**
* The percentage of branches covered.
*/
coveredBranchPercent: number;
/**
* The percentage of functions covered.
*/
coveredFunctionPercent: number;
/**
* An array of functions representing function coverage.
*/
functions: Array<{
/**
* The name of the function.
*/
name: string;
/**
* The line number where the function is defined.
*/
line: number;
/**
* The number of times the function was called.
*/
count: number;
}>;
/**
* An array of branches representing branch coverage.
*/
branches: Array<{
/**
* The line number where the branch is defined.
*/
line: number;
/**
* The number of times the branch was taken.
*/
count: number;
}>;
/**
* An array of lines representing line numbers and the number of times they were covered.
*/
lines: Array<{
/**
* The line number.
*/
line: number;
/**
* The number of times the line was covered.
*/
count: number;
}>;
}>;
/**
* An object containing whether or not the coverage for
* each coverage type.
* @since v22.9.0
*/
thresholds: {
/**
* The function coverage threshold.
*/
function: number;
/**
* The branch coverage threshold.
*/
branch: number;
/**
* The line coverage threshold.
*/
line: number;
};
/**
* An object containing a summary of coverage for all files.
*/
totals: {
/**
* The total number of lines.
*/
totalLineCount: number;
/**
* The total number of branches.
*/
totalBranchCount: number;
/**
* The total number of functions.
*/
totalFunctionCount: number;
/**
* The number of covered lines.
*/
coveredLineCount: number;
/**
* The number of covered branches.
*/
coveredBranchCount: number;
/**
* The number of covered functions.
*/
coveredFunctionCount: number;
/**
* The percentage of lines covered.
*/
coveredLinePercent: number;
/**
* The percentage of branches covered.
*/
coveredBranchPercent: number;
/**
* The percentage of functions covered.
*/
coveredFunctionPercent: number;
};
/**
* The working directory when code coverage began. This
* is useful for displaying relative path names in case
* the tests changed the working directory of the Node.js process.
*/
workingDirectory: string;
};
/**
* The nesting level of the test.
*/
nesting: number;
}
interface TestComplete extends LocationInfo {
/**
* Additional execution metadata.
*/
details: {
/**
* Whether the test passed or not.
*/
passed: boolean;
/**
* The duration of the test in milliseconds.
*/
duration_ms: number;
/**
* An error wrapping the error thrown by the test if it did not pass.
*/
error?: Error;
/**
* The type of the test, used to denote whether this is a suite.
*/
type?: "suite";
};
/**
* The test name.
*/
name: string;
/**
* The nesting level of the test.
*/
nesting: number;
/**
* The ordinal number of the test.
*/
testNumber: number;
/**
* Present if `context.todo` is called.
*/
todo?: string | boolean;
/**
* Present if `context.skip` is called.
*/
skip?: string | boolean;
}
interface TestDequeue extends LocationInfo {
/**
* The test name.
*/
name: string;
/**
* The nesting level of the test.
*/
nesting: number;
/**
* The test type. Either `'suite'` or `'test'`.
* @since v22.15.0
*/
type: "suite" | "test";
}
interface TestEnqueue extends LocationInfo {
/**
* The test name.
*/
name: string;
/**
* The nesting level of the test.
*/
nesting: number;
/**
* The test type. Either `'suite'` or `'test'`.
* @since v22.15.0
*/
type: "suite" | "test";
}
interface TestFail extends LocationInfo {
/**
* Additional execution metadata.
*/
details: {
/**
* The duration of the test in milliseconds.
*/
duration_ms: number;
/**
* An error wrapping the error thrown by the test.
*/
error: Error;
/**
* The type of the test, used to denote whether this is a suite.
* @since v20.0.0, v19.9.0, v18.17.0
*/
type?: "suite";
};
/**
* The test name.
*/
name: string;
/**
* The nesting level of the test.
*/
nesting: number;
/**
* The ordinal number of the test.
*/
testNumber: number;
/**
* Present if `context.todo` is called.
*/
todo?: string | boolean;
/**
* Present if `context.skip` is called.
*/
skip?: string | boolean;
}
interface TestPass extends LocationInfo {
/**
* Additional execution metadata.
*/
details: {
/**
* The duration of the test in milliseconds.
*/
duration_ms: number;
/**
* The type of the test, used to denote whether this is a suite.
* @since 20.0.0, 19.9.0, 18.17.0
*/
type?: "suite";
};
/**
* The test name.
*/
name: string;
/**
* The nesting level of the test.
*/
nesting: number;
/**
* The ordinal number of the test.
*/
testNumber: number;
/**
* Present if `context.todo` is called.
*/
todo?: string | boolean;
/**
* Present if `context.skip` is called.
*/
skip?: string | boolean;
}
interface TestPlan extends LocationInfo {
/**
* The nesting level of the test.
*/
nesting: number;
/**
* The number of subtests that have ran.
*/
count: number;
}
interface TestStart extends LocationInfo {
/**
* The test name.
*/
name: string;
/**
* The nesting level of the test.
*/
nesting: number;
}
interface TestStderr {
/**
* The path of the test file.
*/
file: string;
/**
* The message written to `stderr`.
*/
message: string;
}
interface TestStdout {
/**
* The path of the test file.
*/
file: string;
/**
* The message written to `stdout`.
*/
message: string;
}
interface TestSummary {
/**
* An object containing the counts of various test results.
*/
counts: {
/**
* The total number of cancelled tests.
*/
cancelled: number;
/**
* The total number of passed tests.
*/
passed: number;
/**
* The total number of skipped tests.
*/
skipped: number;
/**
* The total number of suites run.
*/
suites: number;
/**
* The total number of tests run, excluding suites.
*/
tests: number;
/**
* The total number of TODO tests.
*/
todo: number;
/**
* The total number of top level tests and suites.
*/
topLevel: number;
};
/**
* The duration of the test run in milliseconds.
*/
duration_ms: number;
/**
* The path of the test file that generated the
* summary. If the summary corresponds to multiple files, this value is
* `undefined`.
*/
file: string | undefined;
/**
* Indicates whether or not the test run is considered
* successful or not. If any error condition occurs, such as a failing test or
* unmet coverage threshold, this value will be set to `false`.
*/
success: boolean;
}
}
/**
* An instance of `TestContext` is passed to each test function in order to
* interact with the test runner. However, the `TestContext` constructor is not
* exposed as part of the API.
* @since v18.0.0, v16.17.0
*/
interface TestContext {
/**
* An object containing assertion methods bound to the test context.
* The top-level functions from the `node:assert` module are exposed here for the purpose of creating test plans.
*
* **Note:** Some of the functions from `node:assert` contain type assertions. If these are called via the
* TestContext `assert` object, then the context parameter in the test's function signature **must be explicitly typed**
* (ie. the parameter must have a type annotation), otherwise an error will be raised by the TypeScript compiler:
* ```ts
* import { test, type TestContext } from 'node:test';
*
* // The test function's context parameter must have a type annotation.
* test('example', (t: TestContext) => {
* t.assert.deepStrictEqual(actual, expected);
* });
*
* // Omitting the type annotation will result in a compilation error.
* test('example', t => {
* t.assert.deepStrictEqual(actual, expected); // Error: 't' needs an explicit type annotation.
* });
* ```
* @since v22.2.0, v20.15.0
*/
readonly assert: TestContextAssert;
/**
* This function is used to create a hook running before subtest of the current test.
* @param fn The hook function. The first argument to this function is a `TestContext` object.
* If the hook uses callbacks, the callback function is passed as the second argument.
* @param options Configuration options for the hook.
* @since v20.1.0, v18.17.0
*/
before(fn?: TestContextHookFn, options?: HookOptions): void;
/**
* This function is used to create a hook running before each subtest of the current test.
* @param fn The hook function. The first argument to this function is a `TestContext` object.
* If the hook uses callbacks, the callback function is passed as the second argument.
* @param options Configuration options for the hook.
* @since v18.8.0
*/
beforeEach(fn?: TestContextHookFn, options?: HookOptions): void;
/**
* This function is used to create a hook that runs after the current test finishes.
* @param fn The hook function. The first argument to this function is a `TestContext` object.
* If the hook uses callbacks, the callback function is passed as the second argument.
* @param options Configuration options for the hook.
* @since v18.13.0
*/
after(fn?: TestContextHookFn, options?: HookOptions): void;
/**
* This function is used to create a hook running after each subtest of the current test.
* @param fn The hook function. The first argument to this function is a `TestContext` object.
* If the hook uses callbacks, the callback function is passed as the second argument.
* @param options Configuration options for the hook.
* @since v18.8.0
*/
afterEach(fn?: TestContextHookFn, options?: HookOptions): void;
/**
* This function is used to write diagnostics to the output. Any diagnostic
* information is included at the end of the test's results. This function does
* not return a value.
*
* ```js
* test('top level test', (t) => {
* t.diagnostic('A diagnostic message');
* });
* ```
* @since v18.0.0, v16.17.0
* @param message Message to be reported.
*/
diagnostic(message: string): void;
/**
* The absolute path of the test file that created the current test. If a test file imports
* additional modules that generate tests, the imported tests will return the path of the root test file.
* @since v22.6.0
*/
readonly filePath: string | undefined;
/**
* The name of the test and each of its ancestors, separated by `>`.
* @since v22.3.0
*/
readonly fullName: string;
/**
* The name of the test.
* @since v18.8.0, v16.18.0
*/
readonly name: string;
/**
* This function is used to set the number of assertions and subtests that are expected to run
* within the test. If the number of assertions and subtests that run does not match the
* expected count, the test will fail.
*
* > Note: To make sure assertions are tracked, `t.assert` must be used instead of `assert` directly.
*
* ```js
* test('top level test', (t) => {
* t.plan(2);
* t.assert.ok('some relevant assertion here');
* t.test('subtest', () => {});
* });
* ```
*
* When working with asynchronous code, the `plan` function can be used to ensure that the
* correct number of assertions are run:
*
* ```js
* test('planning with streams', (t, done) => {
* function* generate() {
* yield 'a';
* yield 'b';
* yield 'c';
* }
* const expected = ['a', 'b', 'c'];
* t.plan(expected.length);
* const stream = Readable.from(generate());
* stream.on('data', (chunk) => {
* t.assert.strictEqual(chunk, expected.shift());
* });
*
* stream.on('end', () => {
* done();
* });
* });
* ```
*
* When using the `wait` option, you can control how long the test will wait for the expected assertions.
* For example, setting a maximum wait time ensures that the test will wait for asynchronous assertions
* to complete within the specified timeframe:
*
* `