Test runner execution model#

When process-level test isolation is enabled, each matching test file isexecuted in a separate child process. The maximum number of child processesrunning at any time is controlled by the--test-concurrency flag. If thechild process finishes with an exit code of 0, the test is considered passing.Otherwise, the test is considered to be a failure. Test files must be executableby Node.js, but are not required to use thenode:test module internally.

Each test file is executed as if it was a regular script. That is, if the testfile itself usesnode:test to define tests, all of those tests will beexecuted within a single application thread, regardless of the value of theconcurrency option oftest().

When process-level test isolation is disabled, each matching test file isimported into the test runner process. Once all test files have been loaded, thetop level tests are executed with a concurrency of one. Because the test filesare all run within the same context, it is possible for tests to interact witheach other in ways that are not possible when isolation is enabled. For example,if a test relies on global state, it is possible for that state to be modifiedby a test originating from another file.

Coverage reporters#

The tap and spec reporters will print a summary of the coverage statistics.There is also an lcov reporter that will generate an lcov file which can beused as an in depth coverage report.

node --test --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.infocopy

• No test results are reported by this reporter.
• This reporter should ideally be used alongside another reporter.

Timers#

Mocking timers is a technique commonly used in software testing to simulate andcontrol the behavior of timers, such assetInterval andsetTimeout,without actually waiting for the specified time intervals.

Refer to theMockTimers class for a full list of methods and features.

This allows developers to write more reliable andpredictable tests for time-dependent functionality.

The example below shows how to mocksetTimeout.Using.enable({ apis: ['setTimeout'] });it will mock thesetTimeout functions in thenode:timers andnode:timers/promises modules,as well as from the Node.js global context.

Note: Destructuring functions such asimport { setTimeout } from 'node:timers'is currently not supported by this API.

import assertfrom'node:assert';import { mock, test }from'node:test';test('mocks setTimeout to be executed synchronously without having to actually wait for it',() => {const fn = mock.fn();// Optionally choose what to mock  mock.timers.enable({apis: ['setTimeout'] });setTimeout(fn,9999);  assert.strictEqual(fn.mock.callCount(),0);// Advance in time  mock.timers.tick(9999);  assert.strictEqual(fn.mock.callCount(),1);// Reset the globally tracked mocks.  mock.timers.reset();// If you call reset mock instance, it will also reset timers instance  mock.reset();});const assert =require('node:assert');const { mock, test } =require('node:test');test('mocks setTimeout to be executed synchronously without having to actually wait for it',() => {const fn = mock.fn();// Optionally choose what to mock  mock.timers.enable({apis: ['setTimeout'] });setTimeout(fn,9999);  assert.strictEqual(fn.mock.callCount(),0);// Advance in time  mock.timers.tick(9999);  assert.strictEqual(fn.mock.callCount(),1);// Reset the globally tracked mocks.  mock.timers.reset();// If you call reset mock instance, it will also reset timers instance  mock.reset();});copy

The same mocking functionality is also exposed in the mock property on theTestContext objectof each test. The benefit of mocking via the test context isthat the test runner will automatically restore all mocked timersfunctionality once the test finishes.

import assertfrom'node:assert';import { test }from'node:test';test('mocks setTimeout to be executed synchronously without having to actually wait for it',(context) => {const fn = context.mock.fn();// Optionally choose what to mock  context.mock.timers.enable({apis: ['setTimeout'] });setTimeout(fn,9999);  assert.strictEqual(fn.mock.callCount(),0);// Advance in time  context.mock.timers.tick(9999);  assert.strictEqual(fn.mock.callCount(),1);});const assert =require('node:assert');const { test } =require('node:test');test('mocks setTimeout to be executed synchronously without having to actually wait for it',(context) => {const fn = context.mock.fn();// Optionally choose what to mock  context.mock.timers.enable({apis: ['setTimeout'] });setTimeout(fn,9999);  assert.strictEqual(fn.mock.callCount(),0);// Advance in time  context.mock.timers.tick(9999);  assert.strictEqual(fn.mock.callCount(),1);});copy

Dates#

The mock timers API also allows the mocking of theDate object. This is auseful feature for testing time-dependent functionality, or to simulateinternal calendar functions such asDate.now().

The dates implementation is also part of theMockTimers class. Refer to itfor a full list of methods and features.

Note: Dates and timers are dependent when mocked together. This means thatif you have both theDate andsetTimeout mocked, advancing the time willalso advance the mocked date as they simulate a single internal clock.

The example below show how to mock theDate object and obtain the currentDate.now() value.

import assertfrom'node:assert';import { test }from'node:test';test('mocks the Date object',(context) => {// Optionally choose what to mock  context.mock.timers.enable({apis: ['Date'] });// If not specified, the initial date will be based on 0 in the UNIX epoch  assert.strictEqual(Date.now(),0);// Advance in time will also advance the date  context.mock.timers.tick(9999);  assert.strictEqual(Date.now(),9999);});const assert =require('node:assert');const { test } =require('node:test');test('mocks the Date object',(context) => {// Optionally choose what to mock  context.mock.timers.enable({apis: ['Date'] });// If not specified, the initial date will be based on 0 in the UNIX epoch  assert.strictEqual(Date.now(),0);// Advance in time will also advance the date  context.mock.timers.tick(9999);  assert.strictEqual(Date.now(),9999);});copy

If there is no initial epoch set, the initial date will be based on 0 in theUnix epoch. This is January 1st, 1970, 00:00:00 UTC. You can set an initial dateby passing anow property to the.enable() method. This value will be usedas the initial date for the mockedDate object. It can either be a positiveinteger, or another Date object.

import assertfrom'node:assert';import { test }from'node:test';test('mocks the Date object with initial time',(context) => {// Optionally choose what to mock  context.mock.timers.enable({apis: ['Date'],now:100 });  assert.strictEqual(Date.now(),100);// Advance in time will also advance the date  context.mock.timers.tick(200);  assert.strictEqual(Date.now(),300);});const assert =require('node:assert');const { test } =require('node:test');test('mocks the Date object with initial time',(context) => {// Optionally choose what to mock  context.mock.timers.enable({apis: ['Date'],now:100 });  assert.strictEqual(Date.now(),100);// Advance in time will also advance the date  context.mock.timers.tick(200);  assert.strictEqual(Date.now(),300);});copy

You can use the.setTime() method to manually move the mocked date to anothertime. This method only accepts a positive integer.

Note: This method willnot execute any mocked timers that are in the pastfrom the new time.

In the below example we are setting a new time for the mocked date.

import assertfrom'node:assert';import { test }from'node:test';test('sets the time of a date object',(context) => {// Optionally choose what to mock  context.mock.timers.enable({apis: ['Date'],now:100 });  assert.strictEqual(Date.now(),100);// Advance in time will also advance the date  context.mock.timers.setTime(1000);  context.mock.timers.tick(200);  assert.strictEqual(Date.now(),1200);});const assert =require('node:assert');const { test } =require('node:test');test('sets the time of a date object',(context) => {// Optionally choose what to mock  context.mock.timers.enable({apis: ['Date'],now:100 });  assert.strictEqual(Date.now(),100);// Advance in time will also advance the date  context.mock.timers.setTime(1000);  context.mock.timers.tick(200);  assert.strictEqual(Date.now(),1200);});copy

Timers scheduled in the past willnot run when you callsetTime(). To execute those timers, you can usethe.tick() method to move forward from the new time.

import assertfrom'node:assert';import { test }from'node:test';test('setTime does not execute timers',(context) => {// Optionally choose what to mock  context.mock.timers.enable({apis: ['setTimeout','Date'] });const fn = context.mock.fn();setTimeout(fn,1000);  context.mock.timers.setTime(800);// Timer is not executed as the time is not yet reached  assert.strictEqual(fn.mock.callCount(),0);  assert.strictEqual(Date.now(),800);  context.mock.timers.setTime(1200);// Timer is still not executed  assert.strictEqual(fn.mock.callCount(),0);// Advance in time to execute the timer  context.mock.timers.tick(0);  assert.strictEqual(fn.mock.callCount(),1);  assert.strictEqual(Date.now(),1200);});const assert =require('node:assert');const { test } =require('node:test');test('runs timers as setTime passes ticks',(context) => {// Optionally choose what to mock  context.mock.timers.enable({apis: ['setTimeout','Date'] });const fn = context.mock.fn();setTimeout(fn,1000);  context.mock.timers.setTime(800);// Timer is not executed as the time is not yet reached  assert.strictEqual(fn.mock.callCount(),0);  assert.strictEqual(Date.now(),800);  context.mock.timers.setTime(1200);// Timer is executed as the time is now reached  assert.strictEqual(fn.mock.callCount(),1);  assert.strictEqual(Date.now(),1200);});copy

Using.runAll() will execute all timers that are currently in the queue. Thiswill also advance the mocked date to the time of the last timer that wasexecuted as if the time has passed.

import assertfrom'node:assert';import { test }from'node:test';test('runs timers as setTime passes ticks',(context) => {// Optionally choose what to mock  context.mock.timers.enable({apis: ['setTimeout','Date'] });const fn = context.mock.fn();setTimeout(fn,1000);setTimeout(fn,2000);setTimeout(fn,3000);  context.mock.timers.runAll();// All timers are executed as the time is now reached  assert.strictEqual(fn.mock.callCount(),3);  assert.strictEqual(Date.now(),3000);});const assert =require('node:assert');const { test } =require('node:test');test('runs timers as setTime passes ticks',(context) => {// Optionally choose what to mock  context.mock.timers.enable({apis: ['setTimeout','Date'] });const fn = context.mock.fn();setTimeout(fn,1000);setTimeout(fn,2000);setTimeout(fn,3000);  context.mock.timers.runAll();// All timers are executed as the time is now reached  assert.strictEqual(fn.mock.callCount(),3);  assert.strictEqual(Date.now(),3000);});copy

Custom reporters#

--test-reporter can be used to specify a path to custom reporter.A custom reporter is a module that exports a valueaccepted bystream.compose.Reporters should transform events emitted by a<TestsStream>

Example of a custom reporter using<stream.Transform>:

import {Transform }from'node:stream';const customReporter =newTransform({writableObjectMode:true,transform(event, encoding, callback) {switch (event.type) {case'test:dequeue':callback(null,`test${event.data.name} dequeued`);break;case'test:enqueue':callback(null,`test${event.data.name} enqueued`);break;case'test:watch:drained':callback(null,'test watch queue drained');break;case'test:watch:restarted':callback(null,'test watch restarted due to file change');break;case'test:start':callback(null,`test${event.data.name} started`);break;case'test:pass':callback(null,`test${event.data.name} passed`);break;case'test:fail':callback(null,`test${event.data.name} failed`);break;case'test:plan':callback(null,'test plan');break;case'test:diagnostic':case'test:stderr':case'test:stdout':callback(null, event.data.message);break;case'test:coverage': {const { totalLineCount } = event.data.summary.totals;callback(null,`total line count:${totalLineCount}\n`);break;      }    }  },});exportdefault customReporter;const {Transform } =require('node:stream');const customReporter =newTransform({writableObjectMode:true,transform(event, encoding, callback) {switch (event.type) {case'test:dequeue':callback(null,`test${event.data.name} dequeued`);break;case'test:enqueue':callback(null,`test${event.data.name} enqueued`);break;case'test:watch:drained':callback(null,'test watch queue drained');break;case'test:watch:restarted':callback(null,'test watch restarted due to file change');break;case'test:start':callback(null,`test${event.data.name} started`);break;case'test:pass':callback(null,`test${event.data.name} passed`);break;case'test:fail':callback(null,`test${event.data.name} failed`);break;case'test:plan':callback(null,'test plan');break;case'test:diagnostic':case'test:stderr':case'test:stdout':callback(null, event.data.message);break;case'test:coverage': {const { totalLineCount } = event.data.summary.totals;callback(null,`total line count:${totalLineCount}\n`);break;      }    }  },});module.exports = customReporter;copy

Example of a custom reporter using a generator function:

exportdefaultasyncfunction *customReporter(source) {forawait (const eventof source) {switch (event.type) {case'test:dequeue':yield`test${event.data.name} dequeued\n`;break;case'test:enqueue':yield`test${event.data.name} enqueued\n`;break;case'test:watch:drained':yield'test watch queue drained\n';break;case'test:watch:restarted':yield'test watch restarted due to file change\n';break;case'test:start':yield`test${event.data.name} started\n`;break;case'test:pass':yield`test${event.data.name} passed\n`;break;case'test:fail':yield`test${event.data.name} failed\n`;break;case'test:plan':yield'test plan\n';break;case'test:diagnostic':case'test:stderr':case'test:stdout':yield`${event.data.message}\n`;break;case'test:coverage': {const { totalLineCount } = event.data.summary.totals;yield`total line count:${totalLineCount}\n`;break;      }    }  }}module.exports =asyncfunction *customReporter(source) {forawait (const eventof source) {switch (event.type) {case'test:dequeue':yield`test${event.data.name} dequeued\n`;break;case'test:enqueue':yield`test${event.data.name} enqueued\n`;break;case'test:watch:drained':yield'test watch queue drained\n';break;case'test:watch:restarted':yield'test watch restarted due to file change\n';break;case'test:start':yield`test${event.data.name} started\n`;break;case'test:pass':yield`test${event.data.name} passed\n`;break;case'test:fail':yield`test${event.data.name} failed\n`;break;case'test:plan':yield'test plan\n';break;case'test:diagnostic':case'test:stderr':case'test:stdout':yield`${event.data.message}\n`;break;case'test:coverage': {const { totalLineCount } = event.data.summary.totals;yield`total line count:${totalLineCount}\n`;break;      }    }  }};copy

The value provided to--test-reporter should be a string like one used in animport() in JavaScript code, or a value provided for--import.

Multiple reporters#

The--test-reporter flag can be specified multiple times to report testresults in several formats. In this situationit is required to specify a destination for each reporterusing--test-reporter-destination.Destination can bestdout,stderr, or a file path.Reporters and destinations are paired accordingto the order they were specified.

In the following example, thespec reporter will output tostdout,and thedot reporter will output tofile.txt:

node --test-reporter=spec --test-reporter=dot --test-reporter-destination=stdout --test-reporter-destination=file.txtcopy

When a single reporter is specified, the destination will default tostdout,unless a destination is explicitly provided.

assert.register(name, fn)#

Defines a new assertion function with the provided name and function. If anassertion already exists with the same name, it is overwritten.

snapshot.setDefaultSnapshotSerializers(serializers)#

• serializers<Array> An array of synchronous functions used as the defaultserializers for snapshot tests.

This function is used to customize the default serialization mechanism used bythe test runner. By default, the test runner performs serialization by callingJSON.stringify(value, null, 2) on the provided value.JSON.stringify() doeshave limitations regarding circular structures and supported data types. If amore robust serialization mechanism is required, this function should be used.

snapshot.setResolveSnapshotPath(fn)#

• fn<Function> A function used to compute the location of the snapshot file.The function receives the path of the test file as its only argument. If thetest is not associated with a file (for example in the REPL), the input isundefined.fn() must return a string specifying the location of the snapshotsnapshot file.

This function is used to customize the location of the snapshot file used forsnapshot testing. By default, the snapshot filename is the same as the entrypoint filename with a.snapshot file extension.

ctx.calls#

• Type:<Array>

A getter that returns a copy of the internal array used to track calls to themock. Each entry in the array is an object with the following properties.

• arguments<Array> An array of the arguments passed to the mock function.
• error<any> If the mocked function threw then this property contains thethrown value.Default:undefined.
• result<any> The value returned by the mocked function.
• stack<Error> AnError object whose stack can be used to determine thecallsite of the mocked function invocation.
• target<Function> |<undefined> If the mocked function is a constructor, thisfield contains the class being constructed. Otherwise this will beundefined.
• this<any> The mocked function'sthis value.

ctx.callCount()#

• Returns:<integer> The number of times that this mock has been invoked.

This function returns the number of times that this mock has been invoked. Thisfunction is more efficient than checkingctx.calls.length becausectx.callsis a getter that creates a copy of the internal call tracking array.

ctx.mockImplementation(implementation)#

• implementation<Function> |<AsyncFunction> The function to be used as themock's new implementation.

This function is used to change the behavior of an existing mock.

The following example creates a mock function usingt.mock.fn(), calls themock function, and then changes the mock implementation to a different function.

test('changes a mock behavior',(t) => {let cnt =0;functionaddOne() {    cnt++;return cnt;  }functionaddTwo() {    cnt +=2;return cnt;  }const fn = t.mock.fn(addOne);  assert.strictEqual(fn(),1);  fn.mock.mockImplementation(addTwo);  assert.strictEqual(fn(),3);  assert.strictEqual(fn(),5);});copy

ctx.mockImplementationOnce(implementation[, onCall])#

• implementation<Function> |<AsyncFunction> The function to be used as themock's implementation for the invocation number specified byonCall.
• onCall<integer> The invocation number that will useimplementation. Ifthe specified invocation has already occurred then an exception is thrown.Default: The number of the next invocation.

This function is used to change the behavior of an existing mock for a singleinvocation. Once invocationonCall has occurred, the mock will revert towhatever behavior it would have used hadmockImplementationOnce() not beencalled.

The following example creates a mock function usingt.mock.fn(), calls themock function, changes the mock implementation to a different function for thenext invocation, and then resumes its previous behavior.

test('changes a mock behavior once',(t) => {let cnt =0;functionaddOne() {    cnt++;return cnt;  }functionaddTwo() {    cnt +=2;return cnt;  }const fn = t.mock.fn(addOne);  assert.strictEqual(fn(),1);  fn.mock.mockImplementationOnce(addTwo);  assert.strictEqual(fn(),3);  assert.strictEqual(fn(),4);});copy

ctx.resetCalls()#

Resets the call history of the mock function.

ctx.restore()#

Resets the implementation of the mock function to its original behavior. Themock can still be used after calling this function.

ctx.restore()#

Resets the implementation of the mock module.

ctx.accesses#

• Type:<Array>

A getter that returns a copy of the internal array used to track accesses (get/set) tothe mocked property. Each entry in the array is an object with the following properties:

• type<string> Either'get' or'set', indicating the type of access.
• value<any> The value that was read (for'get') or written (for'set').
• stack<Error> AnError object whose stack can be used to determine thecallsite of the mocked function invocation.

ctx.accessCount()#

• Returns:<integer> The number of times that the property was accessed (read or written).

This function returns the number of times that the property was accessed.This function is more efficient than checkingctx.accesses.length becausectx.accesses is a getter that creates a copy of the internal access tracking array.

ctx.mockImplementation(value)#

• value<any> The new value to be set as the mocked property value.

This function is used to change the value returned by the mocked property getter.

ctx.mockImplementationOnce(value[, onAccess])#

• value<any> The value to be used as the mock'simplementation for the invocation number specified byonAccess.
• onAccess<integer> The invocation number that will usevalue. Ifthe specified invocation has already occurred then an exception is thrown.Default: The number of the next invocation.

This function is used to change the behavior of an existing mock for a singleinvocation. Once invocationonAccess has occurred, the mock will revert towhatever behavior it would have used hadmockImplementationOnce() not beencalled.

The following example creates a mock function usingt.mock.property(), calls themock property, changes the mock implementation to a different value for thenext invocation, and then resumes its previous behavior.

test('changes a mock behavior once',(t) => {const obj = {foo:1 };const prop = t.mock.property(obj,'foo',5);  assert.strictEqual(obj.foo,5);  prop.mock.mockImplementationOnce(25);  assert.strictEqual(obj.foo,25);  assert.strictEqual(obj.foo,5);});copy

ctx.resetAccesses()#

Resets the access history of the mocked property.

ctx.restore()#

Resets the implementation of the mock property to its original behavior. Themock can still be used after calling this function.

mock.fn([original[, implementation]][, options])#

• original<Function> |<AsyncFunction> An optional function to create a mock on.Default: A no-op function.
• implementation<Function> |<AsyncFunction> An optional function used as themock implementation fororiginal. This is useful for creating mocks thatexhibit one behavior for a specified number of calls and then restore thebehavior oforiginal.Default: The function specified byoriginal.
• options<Object> Optional configuration options for the mock function. Thefollowing properties are supported:
  • times<integer> The number of times that the mock will use the behavior ofimplementation. Once the mock function has been calledtimes times, itwill automatically restore the behavior oforiginal. This value must be aninteger greater than zero.Default:Infinity.
• Returns:<Proxy> The mocked function. The mocked function contains a specialmock property, which is an instance ofMockFunctionContext, and canbe used for inspecting and changing the behavior of the mocked function.

This function is used to create a mock function.

The following example creates a mock function that increments a counter by oneon each invocation. Thetimes option is used to modify the mock behavior suchthat the first two invocations add two to the counter instead of one.

test('mocks a counting function',(t) => {let cnt =0;functionaddOne() {    cnt++;return cnt;  }functionaddTwo() {    cnt +=2;return cnt;  }const fn = t.mock.fn(addOne, addTwo, {times:2 });  assert.strictEqual(fn(),2);  assert.strictEqual(fn(),4);  assert.strictEqual(fn(),5);  assert.strictEqual(fn(),6);});copy

mock.getter(object, methodName[, implementation][, options])#

This function is syntax sugar forMockTracker.method withoptions.getterset totrue.

mock.method(object, methodName[, implementation][, options])#

• object<Object> The object whose method is being mocked.
• methodName<string> |<symbol> The identifier of the method onobject to mock.Ifobject[methodName] is not a function, an error is thrown.
• implementation<Function> |<AsyncFunction> An optional function used as themock implementation forobject[methodName].Default: The original methodspecified byobject[methodName].
• options<Object> Optional configuration options for the mock method. Thefollowing properties are supported:
  • getter<boolean> Iftrue,object[methodName] is treated as a getter.This option cannot be used with thesetter option.Default: false.
  • setter<boolean> Iftrue,object[methodName] is treated as a setter.This option cannot be used with thegetter option.Default: false.
  • times<integer> The number of times that the mock will use the behavior ofimplementation. Once the mocked method has been calledtimes times, itwill automatically restore the original behavior. This value must be aninteger greater than zero.Default:Infinity.
• Returns:<Proxy> The mocked method. The mocked method contains a specialmock property, which is an instance ofMockFunctionContext, and canbe used for inspecting and changing the behavior of the mocked method.

This function is used to create a mock on an existing object method. Thefollowing example demonstrates how a mock is created on an existing objectmethod.

test('spies on an object method',(t) => {const number = {value:5,subtract(a) {returnthis.value - a;    },  };  t.mock.method(number,'subtract');  assert.strictEqual(number.subtract.mock.callCount(),0);  assert.strictEqual(number.subtract(3),2);  assert.strictEqual(number.subtract.mock.callCount(),1);const call = number.subtract.mock.calls[0];  assert.deepStrictEqual(call.arguments, [3]);  assert.strictEqual(call.result,2);  assert.strictEqual(call.error,undefined);  assert.strictEqual(call.target,undefined);  assert.strictEqual(call.this, number);});copy

mock.module(specifier[, options])#

• specifier<string> |<URL> A string identifying the module to mock.
• options<Object> Optional configuration options for the mock module. Thefollowing properties are supported:
  • cache<boolean> Iffalse, each call torequire() orimport()generates a new mock module. Iftrue, subsequent calls will return the samemodule mock, and the mock module is inserted into the CommonJS cache.Default: false.
  • defaultExport<any> An optional value used as the mocked module's defaultexport. If this value is not provided, ESM mocks do not include a defaultexport. If the mock is a CommonJS or builtin module, this setting is used asthe value ofmodule.exports. If this value is not provided, CJS and builtinmocks use an empty object as the value ofmodule.exports.
  • namedExports<Object> An optional object whose keys and values are used tocreate the named exports of the mock module. If the mock is a CommonJS orbuiltin module, these values are copied ontomodule.exports. Therefore, if amock is created with both named exports and a non-object default export, themock will throw an exception when used as a CJS or builtin module.
• Returns:<MockModuleContext> An object that can be used to manipulate the mock.

This function is used to mock the exports of ECMAScript modules, CommonJS modules, JSON modules, andNode.js builtin modules. Any references to the original module prior to mocking are not impacted. Inorder to enable module mocking, Node.js must be started with the--experimental-test-module-mocks command-line flag.

The following example demonstrates how a mock is created for a module.

test('mocks a builtin module in both module systems',async (t) => {// Create a mock of 'node:readline' with a named export named 'fn', which// does not exist in the original 'node:readline' module.const mock = t.mock.module('node:readline', {namedExports: {fn() {return42; } },  });let esmImpl =awaitimport('node:readline');let cjsImpl =require('node:readline');// cursorTo() is an export of the original 'node:readline' module.  assert.strictEqual(esmImpl.cursorTo,undefined);  assert.strictEqual(cjsImpl.cursorTo,undefined);  assert.strictEqual(esmImpl.fn(),42);  assert.strictEqual(cjsImpl.fn(),42);  mock.restore();// The mock is restored, so the original builtin module is returned.  esmImpl =awaitimport('node:readline');  cjsImpl =require('node:readline');  assert.strictEqual(typeof esmImpl.cursorTo,'function');  assert.strictEqual(typeof cjsImpl.cursorTo,'function');  assert.strictEqual(esmImpl.fn,undefined);  assert.strictEqual(cjsImpl.fn,undefined);});copy

mock.property(object, propertyName[, value])#

• object<Object> The object whose value is being mocked.
• propertyName<string> |<symbol> The identifier of the property onobject to mock.
• value<any> An optional value used as the mock valueforobject[propertyName].Default: The original property value.
• Returns:<Proxy> A proxy to the mocked object. The mocked object contains aspecialmock property, which is an instance ofMockPropertyContext, andcan be used for inspecting and changing the behavior of the mocked property.

Creates a mock for a property value on an object. This allows you to track and control access to a specific property,including how many times it is read (getter) or written (setter), and to restore the original value after mocking.

test('mocks a property value',(t) => {const obj = {foo:42 };const prop = t.mock.property(obj,'foo',100);  assert.strictEqual(obj.foo,100);  assert.strictEqual(prop.mock.accessCount(),1);  assert.strictEqual(prop.mock.accesses[0].type,'get');  assert.strictEqual(prop.mock.accesses[0].value,100);  obj.foo =200;  assert.strictEqual(prop.mock.accessCount(),2);  assert.strictEqual(prop.mock.accesses[1].type,'set');  assert.strictEqual(prop.mock.accesses[1].value,200);  prop.mock.restore();  assert.strictEqual(obj.foo,42);});copy

mock.reset()#

This function restores the default behavior of all mocks that were previouslycreated by thisMockTracker and disassociates the mocks from theMockTracker instance. Once disassociated, the mocks can still be used, but theMockTracker instance can no longer be used to reset their behavior orotherwise interact with them.

After each test completes, this function is called on the test context'sMockTracker. If the globalMockTracker is used extensively, calling thisfunction manually is recommended.

mock.restoreAll()#

This function restores the default behavior of all mocks that were previouslycreated by thisMockTracker. Unlikemock.reset(),mock.restoreAll() doesnot disassociate the mocks from theMockTracker instance.

mock.setter(object, methodName[, implementation][, options])#

This function is syntax sugar forMockTracker.method withoptions.setterset totrue.

timers.enable([enableOptions])#

Enables timer mocking for the specified timers.

• enableOptions<Object> Optional configuration options for enabling timermocking. The following properties are supported:
  • apis<Array> An optional array containing the timers to mock.The currently supported timer values are'setInterval','setTimeout','setImmediate',and'Date'.Default:['setInterval', 'setTimeout', 'setImmediate', 'Date'].If no array is provided, all time related APIs ('setInterval','clearInterval','setTimeout','clearTimeout','setImmediate','clearImmediate', and'Date') will be mocked by default.
  • now<number> |<Date> An optional number or Date object representing theinitial time (in milliseconds) to use as the valueforDate.now().Default:0.

Note: When you enable mocking for a specific timer, its associatedclear function will also be implicitly mocked.

Note: MockingDate will affect the behavior of the mocked timersas they use the same internal clock.

Example usage without setting initial time:

import { mock }from'node:test';mock.timers.enable({apis: ['setInterval'] });const { mock } =require('node:test');mock.timers.enable({apis: ['setInterval'] });copy

The above example enables mocking for thesetInterval timer andimplicitly mocks theclearInterval function. Only thesetIntervalandclearInterval functions fromnode:timers,node:timers/promises, andglobalThis will be mocked.

Example usage with initial time set

import { mock }from'node:test';mock.timers.enable({apis: ['Date'],now:1000 });const { mock } =require('node:test');mock.timers.enable({apis: ['Date'],now:1000 });copy

Example usage with initial Date object as time set

import { mock }from'node:test';mock.timers.enable({apis: ['Date'],now:newDate() });const { mock } =require('node:test');mock.timers.enable({apis: ['Date'],now:newDate() });copy

Alternatively, if you callmock.timers.enable() without any parameters:

All timers ('setInterval','clearInterval','setTimeout','clearTimeout','setImmediate', and'clearImmediate') will be mocked. ThesetInterval,clearInterval,setTimeout,clearTimeout,setImmediate, andclearImmediate functions fromnode:timers,node:timers/promises, andglobalThis will be mocked. As well as the globalDate object.

timers.reset()#

This function restores the default behavior of all mocks that were previouslycreated by thisMockTimers instance and disassociates the mocksfrom theMockTracker instance.

Note: After each test completes, this function is called onthe test context'sMockTracker.

import { mock }from'node:test';mock.timers.reset();const { mock } =require('node:test');mock.timers.reset();copy

timers[Symbol.dispose]()#

Callstimers.reset().

timers.tick([milliseconds])#

Advances time for all mocked timers.

• milliseconds<number> The amount of time, in milliseconds,to advance the timers.Default:1.

Note: This diverges from howsetTimeout in Node.js behaves and acceptsonly positive numbers. In Node.js,setTimeout with negative numbers isonly supported for web compatibility reasons.

The following example mocks asetTimeout function andby using.tick advances intime triggering all pending timers.

import assertfrom'node:assert';import { test }from'node:test';test('mocks setTimeout to be executed synchronously without having to actually wait for it',(context) => {const fn = context.mock.fn();  context.mock.timers.enable({apis: ['setTimeout'] });setTimeout(fn,9999);  assert.strictEqual(fn.mock.callCount(),0);// Advance in time  context.mock.timers.tick(9999);  assert.strictEqual(fn.mock.callCount(),1);});const assert =require('node:assert');const { test } =require('node:test');test('mocks setTimeout to be executed synchronously without having to actually wait for it',(context) => {const fn = context.mock.fn();  context.mock.timers.enable({apis: ['setTimeout'] });setTimeout(fn,9999);  assert.strictEqual(fn.mock.callCount(),0);// Advance in time  context.mock.timers.tick(9999);  assert.strictEqual(fn.mock.callCount(),1);});copy

Alternatively, the.tick function can be called many times

import assertfrom'node:assert';import { test }from'node:test';test('mocks setTimeout to be executed synchronously without having to actually wait for it',(context) => {const fn = context.mock.fn();  context.mock.timers.enable({apis: ['setTimeout'] });const nineSecs =9000;setTimeout(fn, nineSecs);const threeSeconds =3000;  context.mock.timers.tick(threeSeconds);  context.mock.timers.tick(threeSeconds);  context.mock.timers.tick(threeSeconds);  assert.strictEqual(fn.mock.callCount(),1);});const assert =require('node:assert');const { test } =require('node:test');test('mocks setTimeout to be executed synchronously without having to actually wait for it',(context) => {const fn = context.mock.fn();  context.mock.timers.enable({apis: ['setTimeout'] });const nineSecs =9000;setTimeout(fn, nineSecs);const threeSeconds =3000;  context.mock.timers.tick(threeSeconds);  context.mock.timers.tick(threeSeconds);  context.mock.timers.tick(threeSeconds);  assert.strictEqual(fn.mock.callCount(),1);});copy

Advancing time using.tick will also advance the time for anyDate objectcreated after the mock was enabled (ifDate was also set to be mocked).

import assertfrom'node:assert';import { test }from'node:test';test('mocks setTimeout to be executed synchronously without having to actually wait for it',(context) => {const fn = context.mock.fn();  context.mock.timers.enable({apis: ['setTimeout','Date'] });setTimeout(fn,9999);  assert.strictEqual(fn.mock.callCount(),0);  assert.strictEqual(Date.now(),0);// Advance in time  context.mock.timers.tick(9999);  assert.strictEqual(fn.mock.callCount(),1);  assert.strictEqual(Date.now(),9999);});const assert =require('node:assert');const { test } =require('node:test');test('mocks setTimeout to be executed synchronously without having to actually wait for it',(context) => {const fn = context.mock.fn();  context.mock.timers.enable({apis: ['setTimeout','Date'] });setTimeout(fn,9999);  assert.strictEqual(fn.mock.callCount(),0);  assert.strictEqual(Date.now(),0);// Advance in time  context.mock.timers.tick(9999);  assert.strictEqual(fn.mock.callCount(),1);  assert.strictEqual(Date.now(),9999);});copy

import assertfrom'node:assert';import { test }from'node:test';test('mocks setTimeout to be executed synchronously without having to actually wait for it',(context) => {const fn = context.mock.fn();// Optionally choose what to mock  context.mock.timers.enable({apis: ['setTimeout'] });const id =setTimeout(fn,9999);// Implicitly mocked as wellclearTimeout(id);  context.mock.timers.tick(9999);// As that setTimeout was cleared the mock function will never be called  assert.strictEqual(fn.mock.callCount(),0);});const assert =require('node:assert');const { test } =require('node:test');test('mocks setTimeout to be executed synchronously without having to actually wait for it',(context) => {const fn = context.mock.fn();// Optionally choose what to mock  context.mock.timers.enable({apis: ['setTimeout'] });const id =setTimeout(fn,9999);// Implicitly mocked as wellclearTimeout(id);  context.mock.timers.tick(9999);// As that setTimeout was cleared the mock function will never be called  assert.strictEqual(fn.mock.callCount(),0);});copy

import assertfrom'node:assert';import { test }from'node:test';import nodeTimersfrom'node:timers';import nodeTimersPromisesfrom'node:timers/promises';test('mocks setTimeout to be executed synchronously without having to actually wait for it',async (context) => {const globalTimeoutObjectSpy = context.mock.fn();const nodeTimerSpy = context.mock.fn();const nodeTimerPromiseSpy = context.mock.fn();// Optionally choose what to mock  context.mock.timers.enable({apis: ['setTimeout'] });setTimeout(globalTimeoutObjectSpy,9999);  nodeTimers.setTimeout(nodeTimerSpy,9999);const promise = nodeTimersPromises.setTimeout(9999).then(nodeTimerPromiseSpy);// Advance in time  context.mock.timers.tick(9999);  assert.strictEqual(globalTimeoutObjectSpy.mock.callCount(),1);  assert.strictEqual(nodeTimerSpy.mock.callCount(),1);await promise;  assert.strictEqual(nodeTimerPromiseSpy.mock.callCount(),1);});const assert =require('node:assert');const { test } =require('node:test');const nodeTimers =require('node:timers');const nodeTimersPromises =require('node:timers/promises');test('mocks setTimeout to be executed synchronously without having to actually wait for it',async (context) => {const globalTimeoutObjectSpy = context.mock.fn();const nodeTimerSpy = context.mock.fn();const nodeTimerPromiseSpy = context.mock.fn();// Optionally choose what to mock  context.mock.timers.enable({apis: ['setTimeout'] });setTimeout(globalTimeoutObjectSpy,9999);  nodeTimers.setTimeout(nodeTimerSpy,9999);const promise = nodeTimersPromises.setTimeout(9999).then(nodeTimerPromiseSpy);// Advance in time  context.mock.timers.tick(9999);  assert.strictEqual(globalTimeoutObjectSpy.mock.callCount(),1);  assert.strictEqual(nodeTimerSpy.mock.callCount(),1);await promise;  assert.strictEqual(nodeTimerPromiseSpy.mock.callCount(),1);});copy

import assertfrom'node:assert';import { test }from'node:test';import nodeTimersPromisesfrom'node:timers/promises';test('should tick five times testing a real use case',async (context) => {  context.mock.timers.enable({apis: ['setInterval'] });const expectedIterations =3;const interval =1000;const startedAt =Date.now();asyncfunctionrun() {const times = [];forawait (const timeof nodeTimersPromises.setInterval(interval, startedAt)) {      times.push(time);if (times.length === expectedIterations)break;    }return times;  }const r =run();  context.mock.timers.tick(interval);  context.mock.timers.tick(interval);  context.mock.timers.tick(interval);const timeResults =await r;  assert.strictEqual(timeResults.length, expectedIterations);for (let it =1; it < expectedIterations; it++) {    assert.strictEqual(timeResults[it -1], startedAt + (interval * it));  }});const assert =require('node:assert');const { test } =require('node:test');const nodeTimersPromises =require('node:timers/promises');test('should tick five times testing a real use case',async (context) => {  context.mock.timers.enable({apis: ['setInterval'] });const expectedIterations =3;const interval =1000;const startedAt =Date.now();asyncfunctionrun() {const times = [];forawait (const timeof nodeTimersPromises.setInterval(interval, startedAt)) {      times.push(time);if (times.length === expectedIterations)break;    }return times;  }const r =run();  context.mock.timers.tick(interval);  context.mock.timers.tick(interval);  context.mock.timers.tick(interval);const timeResults =await r;  assert.strictEqual(timeResults.length, expectedIterations);for (let it =1; it < expectedIterations; it++) {    assert.strictEqual(timeResults[it -1], startedAt + (interval * it));  }});copy

timers.runAll()#

Triggers all pending mocked timers immediately. If theDate object is alsomocked, it will also advance theDate object to the furthest timer's time.

The example below triggers all pending timers immediately,causing them to execute without any delay.

import assertfrom'node:assert';import { test }from'node:test';test('runAll functions following the given order',(context) => {  context.mock.timers.enable({apis: ['setTimeout','Date'] });const results = [];setTimeout(() => results.push(1),9999);// Notice that if both timers have the same timeout,// the order of execution is guaranteedsetTimeout(() => results.push(3),8888);setTimeout(() => results.push(2),8888);  assert.deepStrictEqual(results, []);  context.mock.timers.runAll();  assert.deepStrictEqual(results, [3,2,1]);// The Date object is also advanced to the furthest timer's time  assert.strictEqual(Date.now(),9999);});const assert =require('node:assert');const { test } =require('node:test');test('runAll functions following the given order',(context) => {  context.mock.timers.enable({apis: ['setTimeout','Date'] });const results = [];setTimeout(() => results.push(1),9999);// Notice that if both timers have the same timeout,// the order of execution is guaranteedsetTimeout(() => results.push(3),8888);setTimeout(() => results.push(2),8888);  assert.deepStrictEqual(results, []);  context.mock.timers.runAll();  assert.deepStrictEqual(results, [3,2,1]);// The Date object is also advanced to the furthest timer's time  assert.strictEqual(Date.now(),9999);});copy

Note: TherunAll() function is specifically designed fortriggering timers in the context of timer mocking.It does not have any effect on real-time systemclocks or actual timers outside of the mocking environment.

timers.setTime(milliseconds)#

Sets the current Unix timestamp that will be used as reference for any mockedDate objects.

import assertfrom'node:assert';import { test }from'node:test';test('runAll functions following the given order',(context) => {const now =Date.now();const setTime =1000;// Date.now is not mocked  assert.deepStrictEqual(Date.now(), now);  context.mock.timers.enable({apis: ['Date'] });  context.mock.timers.setTime(setTime);// Date.now is now 1000  assert.strictEqual(Date.now(), setTime);});const assert =require('node:assert');const { test } =require('node:test');test('setTime replaces current time',(context) => {const now =Date.now();const setTime =1000;// Date.now is not mocked  assert.deepStrictEqual(Date.now(), now);  context.mock.timers.enable({apis: ['Date'] });  context.mock.timers.setTime(setTime);// Date.now is now 1000  assert.strictEqual(Date.now(), setTime);});copy

import assertfrom'node:assert';import { test }from'node:test';test('runAll functions following the given order',(context) => {  context.mock.timers.enable({apis: ['setTimeout','Date'] });const results = [];setTimeout(() => results.push(1),9999);  assert.deepStrictEqual(results, []);  context.mock.timers.setTime(12000);  assert.deepStrictEqual(results, []);// The date is advanced but the timers don't tick  assert.strictEqual(Date.now(),12000);});const assert =require('node:assert');const { test } =require('node:test');test('runAll functions following the given order',(context) => {  context.mock.timers.enable({apis: ['setTimeout','Date'] });const results = [];setTimeout(() => results.push(1),9999);  assert.deepStrictEqual(results, []);  context.mock.timers.setTime(12000);  assert.deepStrictEqual(results, []);// The date is advanced but the timers don't tick  assert.strictEqual(Date.now(),12000);});copy

Event:'test:coverage'#

• data<Object>
  • summary<Object> An object containing the coverage report.
    • files<Array> An array of coverage reports for individual files. Eachreport is an object with the following schema:
      • path<string> The absolute path of the file.
      • totalLineCount<number> The total number of lines.
      • totalBranchCount<number> The total number of branches.
      • totalFunctionCount<number> The total number of functions.
      • coveredLineCount<number> The number of covered lines.
      • coveredBranchCount<number> The number of covered branches.
      • coveredFunctionCount<number> The number of covered functions.
      • coveredLinePercent<number> The percentage of lines covered.
      • coveredBranchPercent<number> The percentage of branches covered.
      • coveredFunctionPercent<number> The percentage of functions covered.
      • functions<Array> An array of functions representing functioncoverage.
        • name<string> The name of the function.
        • line<number> The line number where the function is defined.
        • count<number> The number of times the function was called.
      • branches<Array> An array of branches representing branch coverage.
        • line<number> The line number where the branch is defined.
        • count<number> The number of times the branch was taken.
      • lines<Array> An array of lines representing linenumbers and the number of times they were covered.
        • line<number> The line number.
        • count<number> The number of times the line was covered.
    • thresholds<Object> An object containing whether or not the coverage foreach coverage type.
      • function<number> The function coverage threshold.
      • branch<number> The branch coverage threshold.
      • line<number> The line coverage threshold.
    • totals<Object> An object containing a summary of coverage for allfiles.
      • totalLineCount<number> The total number of lines.
      • totalBranchCount<number> The total number of branches.
      • totalFunctionCount<number> The total number of functions.
      • coveredLineCount<number> The number of covered lines.
      • coveredBranchCount<number> The number of covered branches.
      • coveredFunctionCount<number> The number of covered functions.
      • coveredLinePercent<number> The percentage of lines covered.
      • coveredBranchPercent<number> The percentage of branches covered.
      • coveredFunctionPercent<number> The percentage of functions covered.
    • workingDirectory<string> The working directory when code coveragebegan. This is useful for displaying relative path names in case the testschanged the working directory of the Node.js process.
  • nesting<number> The nesting level of the test.

Emitted when code coverage is enabled and all tests have completed.

Event:'test:complete'#

• data<Object>
  • column<number> |<undefined> The column number where the test is defined, orundefined if the test was run through the REPL.
  • details<Object> Additional execution metadata.
    • passed<boolean> Whether the test passed or not.
    • duration_ms<number> The duration of the test in milliseconds.
    • error<Error> |<undefined> An error wrapping the error thrown by the testif it did not pass.
      • cause<Error> The actual error thrown by the test.
    • type<string> |<undefined> The type of the test, used to denote whetherthis is a suite.
  • file<string> |<undefined> The path of the test file,undefined if test was run through the REPL.
  • line<number> |<undefined> The line number where the test is defined, orundefined if the test was run through the REPL.
  • name<string> The test name.
  • nesting<number> The nesting level of the test.
  • testNumber<number> The ordinal number of the test.
  • todo<string> |<boolean> |<undefined> Present ifcontext.todo is called
  • skip<string> |<boolean> |<undefined> Present ifcontext.skip is called

Emitted when a test completes its execution.This event is not emitted in the same order as the tests aredefined.The corresponding declaration ordered events are'test:pass' and'test:fail'.

Event:'test:dequeue'#

• data<Object>
  • column<number> |<undefined> The column number where the test is defined, orundefined if the test was run through the REPL.
  • file<string> |<undefined> The path of the test file,undefined if test was run through the REPL.
  • line<number> |<undefined> The line number where the test is defined, orundefined if the test was run through the REPL.
  • name<string> The test name.
  • nesting<number> The nesting level of the test.
  • type<string> The test type. Either'suite' or'test'.

Emitted when a test is dequeued, right before it is executed.This event is not guaranteed to be emitted in the same order as the tests aredefined. The corresponding declaration ordered event is'test:start'.

Event:'test:diagnostic'#

• data<Object>
  • column<number> |<undefined> The column number where the test is defined, orundefined if the test was run through the REPL.
  • file<string> |<undefined> The path of the test file,undefined if test was run through the REPL.
  • line<number> |<undefined> The line number where the test is defined, orundefined if the test was run through the REPL.
  • message<string> The diagnostic message.
  • nesting<number> The nesting level of the test.
  • level<string> The severity level of the diagnostic message.Possible values are:
    • 'info': Informational messages.
    • 'warn': Warnings.
    • 'error': Errors.

Emitted whencontext.diagnostic is called.This event is guaranteed to be emitted in the same order as the tests aredefined.

Event:'test:enqueue'#

• data<Object>
  • column<number> |<undefined> The column number where the test is defined, orundefined if the test was run through the REPL.
  • file<string> |<undefined> The path of the test file,undefined if test was run through the REPL.
  • line<number> |<undefined> The line number where the test is defined, orundefined if the test was run through the REPL.
  • name<string> The test name.
  • nesting<number> The nesting level of the test.
  • type<string> The test type. Either'suite' or'test'.

Emitted when a test is enqueued for execution.

Event:'test:fail'#

• data<Object>
  • column<number> |<undefined> The column number where the test is defined, orundefined if the test was run through the REPL.
  • details<Object> Additional execution metadata.
    • duration_ms<number> The duration of the test in milliseconds.
    • error<Error> An error wrapping the error thrown by the test.
      • cause<Error> The actual error thrown by the test.
    • type<string> |<undefined> The type of the test, used to denote whetherthis is a suite.
    • attempt<number> |<undefined> The attempt number of the test run,present only when using the--test-rerun-failures flag.
  • file<string> |<undefined> The path of the test file,undefined if test was run through the REPL.
  • line<number> |<undefined> The line number where the test is defined, orundefined if the test was run through the REPL.
  • name<string> The test name.
  • nesting<number> The nesting level of the test.
  • testNumber<number> The ordinal number of the test.
  • todo<string> |<boolean> |<undefined> Present ifcontext.todo is called
  • skip<string> |<boolean> |<undefined> Present ifcontext.skip is called

Emitted when a test fails.This event is guaranteed to be emitted in the same order as the tests aredefined.The corresponding execution ordered event is'test:complete'.

Event:'test:pass'#

• data<Object>
  • column<number> |<undefined> The column number where the test is defined, orundefined if the test was run through the REPL.
  • details<Object> Additional execution metadata.
    • duration_ms<number> The duration of the test in milliseconds.
    • type<string> |<undefined> The type of the test, used to denote whetherthis is a suite.
    • attempt<number> |<undefined> The attempt number of the test run,present only when using the--test-rerun-failures flag.
    • passed_on_attempt<number> |<undefined> The attempt number the test passed on,present only when using the--test-rerun-failures flag.
  • file<string> |<undefined> The path of the test file,undefined if test was run through the REPL.
  • line<number> |<undefined> The line number where the test is defined, orundefined if the test was run through the REPL.
  • name<string> The test name.
  • nesting<number> The nesting level of the test.
  • testNumber<number> The ordinal number of the test.
  • todo<string> |<boolean> |<undefined> Present ifcontext.todo is called
  • skip<string> |<boolean> |<undefined> Present ifcontext.skip is called

Emitted when a test passes.This event is guaranteed to be emitted in the same order as the tests aredefined.The corresponding execution ordered event is'test:complete'.

Event:'test:plan'#

• data<Object>
  • column<number> |<undefined> The column number where the test is defined, orundefined if the test was run through the REPL.
  • file<string> |<undefined> The path of the test file,undefined if test was run through the REPL.
  • line<number> |<undefined> The line number where the test is defined, orundefined if the test was run through the REPL.
  • nesting<number> The nesting level of the test.
  • count<number> The number of subtests that have ran.

Emitted when all subtests have completed for a given test.This event is guaranteed to be emitted in the same order as the tests aredefined.

Event:'test:start'#

• data<Object>
  • column<number> |<undefined> The column number where the test is defined, orundefined if the test was run through the REPL.
  • file<string> |<undefined> The path of the test file,undefined if test was run through the REPL.
  • line<number> |<undefined> The line number where the test is defined, orundefined if the test was run through the REPL.
  • name<string> The test name.
  • nesting<number> The nesting level of the test.

Emitted when a test starts reporting its own and its subtests status.This event is guaranteed to be emitted in the same order as the tests aredefined.The corresponding execution ordered event is'test:dequeue'.

Event:'test:stderr'#

• data<Object>
  • file<string> The path of the test file.
  • message<string> The message written tostderr.

Emitted when a running test writes tostderr.This event is only emitted if--test flag is passed.This event is not guaranteed to be emitted in the same order as the tests aredefined.

Event:'test:stdout'#

• data<Object>
  • file<string> The path of the test file.
  • message<string> The message written tostdout.

Emitted when a running test writes tostdout.This event is only emitted if--test flag is passed.This event is not guaranteed to be emitted in the same order as the tests aredefined.

Event:'test:summary'#

• data<Object>
  • counts<Object> An object containing the counts of various test results.
    • cancelled<number> The total number of cancelled tests.
    • failed<number> The total number of failed tests.
    • passed<number> The total number of passed tests.
    • skipped<number> The total number of skipped tests.
    • suites<number> The total number of suites run.
    • tests<number> The total number of tests run, excluding suites.
    • todo<number> The total number of TODO tests.
    • topLevel<number> The total number of top level tests and suites.
  • duration_ms<number> The duration of the test run in milliseconds.
  • file<string> |<undefined> The path of the test file that generated thesummary. If the summary corresponds to multiple files, this value isundefined.
  • success<boolean> Indicates whether or not the test run is consideredsuccessful or not. If any error condition occurs, such as a failing test orunmet coverage threshold, this value will be set tofalse.

Emitted when a test run completes. This event contains metrics pertaining tothe completed test run, and is useful for determining if a test run passed orfailed. If process-level test isolation is used, a'test:summary' event isgenerated for each test file in addition to a final cumulative summary.

Event:'test:watch:drained'#

Emitted when no more tests are queued for execution in watch mode.

Event:'test:watch:restarted'#

Emitted when one or more tests are restarted due to a file change in watch mode.

context.before([fn][, options])#

• fn<Function> |<AsyncFunction> The hook function. The first argumentto this function is aTestContext object. If the hook uses callbacks,the callback function is passed as the second argument.Default: A no-opfunction.
• options<Object> Configuration options for the hook. The followingproperties are supported:
  • signal<AbortSignal> Allows aborting an in-progress hook.
  • timeout<number> A number of milliseconds the hook will fail after.If unspecified, subtests inherit this value from their parent.Default:Infinity.

This function is used to create a hook running beforesubtest of the current test.

context.beforeEach([fn][, options])#

• fn<Function> |<AsyncFunction> The hook function. The first argumentto this function is aTestContext object. If the hook uses callbacks,the callback function is passed as the second argument.Default: A no-opfunction.
• options<Object> Configuration options for the hook. The followingproperties are supported:
  • signal<AbortSignal> Allows aborting an in-progress hook.
  • timeout<number> A number of milliseconds the hook will fail after.If unspecified, subtests inherit this value from their parent.Default:Infinity.

This function is used to create a hook runningbefore each subtest of the current test.

test('top level test',async (t) => {  t.beforeEach((t) => t.diagnostic(`about to run${t.name}`));await t.test('This is a subtest',(t) => {// Some relevant assertion here    },  );});copy

context.after([fn][, options])#

• fn<Function> |<AsyncFunction> The hook function. The first argumentto this function is aTestContext object. If the hook uses callbacks,the callback function is passed as the second argument.Default: A no-opfunction.
• options<Object> Configuration options for the hook. The followingproperties are supported:
  • signal<AbortSignal> Allows aborting an in-progress hook.
  • timeout<number> A number of milliseconds the hook will fail after.If unspecified, subtests inherit this value from their parent.Default:Infinity.

This function is used to create a hook that runs after the current testfinishes.

test('top level test',async (t) => {  t.after((t) => t.diagnostic(`finished running${t.name}`));// Some relevant assertion here});copy

context.afterEach([fn][, options])#

• fn<Function> |<AsyncFunction> The hook function. The first argumentto this function is aTestContext object. If the hook uses callbacks,the callback function is passed as the second argument.Default: A no-opfunction.
• options<Object> Configuration options for the hook. The followingproperties are supported:
  • signal<AbortSignal> Allows aborting an in-progress hook.
  • timeout<number> A number of milliseconds the hook will fail after.If unspecified, subtests inherit this value from their parent.Default:Infinity.

This function is used to create a hook runningafter each subtest of the current test.

test('top level test',async (t) => {  t.afterEach((t) => t.diagnostic(`finished running${t.name}`));await t.test('This is a subtest',(t) => {// Some relevant assertion here    },  );});copy

context.assert#

An object containing assertion methods bound tocontext. The top-levelfunctions from thenode:assert module are exposed here for the purpose ofcreating test plans.

test('test',(t) => {  t.plan(1);  t.assert.strictEqual(true,true);});copy

test('snapshot test with default serialization',(t) => {  t.assert.fileSnapshot({value1:1,value2:2 },'./snapshots/snapshot.json');});copy

test('snapshot test with default serialization',(t) => {  t.assert.snapshot({value1:1,value2:2 });});test('snapshot test with custom serialization',(t) => {  t.assert.snapshot({value3:3,value4:4 }, {serializers: [(value) =>JSON.stringify(value)],  });});copy

context.diagnostic(message)#

• message<string> Message to be reported.

This function is used to write diagnostics to the output. Any diagnosticinformation is included at the end of the test's results. This function doesnot return a value.

test('top level test',(t) => {  t.diagnostic('A diagnostic message');});copy

context.filePath#

The absolute path of the test file that created the current test. If a test fileimports additional modules that generate tests, the imported tests will returnthe path of the root test file.

context.fullName#

The name of the test and each of its ancestors, separated by>.

context.name#

The name of the test.

context.passed#

• Type:<boolean>false before the test is executed, e.g. in abeforeEach hook.

Indicated whether the test succeeded.

context.error#

• Type:<Error> |<null>

The failure reason for the test/case; wrapped and available viacontext.error.cause.

context.attempt#

• Type:<number>

Number of times the test has been attempted.

context.plan(count[,options])#

• count<number> The number of assertions and subtests that are expected to run.
• options<Object> Additional options for the plan.
  • wait<boolean> |<number> The wait time for the plan:
    • Iftrue, the plan waits indefinitely for all assertions and subtests to run.
    • Iffalse, the plan performs an immediate check after the test function completes,without waiting for any pending assertions or subtests.Any assertions or subtests that complete after this check will not be counted towards the plan.
    • If a number, it specifies the maximum wait time in millisecondsbefore timing out while waiting for expected assertions and subtests to be matched.If the timeout is reached, the test will fail.Default:false.

This function is used to set the number of assertions and subtests that are expected to runwithin the test. If the number of assertions and subtests that run does not match theexpected count, the test will fail.

Note: To make sure assertions are tracked,t.assert must be used instead ofassert directly.

test('top level test',(t) => {  t.plan(2);  t.assert.ok('some relevant assertion here');  t.test('subtest',() => {});});copy

When working with asynchronous code, theplan function can be used to ensure that thecorrect number of assertions are run:

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();  });});copy

When using thewait 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 assertionsto complete within the specified timeframe:

test('plan with wait: 2000 waits for async assertions',(t) => {  t.plan(1, {wait:2000 });// Waits for up to 2 seconds for the assertion to complete.constasyncActivity = () => {setTimeout(() => {      t.assert.ok(true,'Async assertion completed within the wait time');    },1000);// Completes after 1 second, within the 2-second wait time.  };asyncActivity();// The test will pass because the assertion is completed in time.});copy

Note: If await timeout is specified, it begins counting down only after the test function finishes executing.

context.runOnly(shouldRunOnlyTests)#

• shouldRunOnlyTests<boolean> Whether or not to runonly tests.

IfshouldRunOnlyTests is truthy, the test context will only run tests thathave theonly option set. Otherwise, all tests are run. If Node.js was notstarted with the--test-only command-line option, this function is ano-op.

test('top level test',(t) => {// The test context can be set to run subtests with the 'only' option.  t.runOnly(true);returnPromise.all([    t.test('this subtest is now skipped'),    t.test('this subtest is run', {only:true }),  ]);});copy

context.signal#

• Type:<AbortSignal>

Can be used to abort test subtasks when the test has been aborted.

test('top level test',async (t) => {awaitfetch('some/uri', {signal: t.signal });});copy

context.skip([message])#

• message<string> Optional skip message.

This function causes the test's output to indicate the test as skipped. Ifmessage is provided, it is included in the output. Callingskip() doesnot terminate execution of the test function. This function does not return avalue.

test('top level test',(t) => {// Make sure to return here as well if the test contains additional logic.  t.skip('this is skipped');});copy

context.todo([message])#

• message<string> OptionalTODO message.

This function adds aTODO directive to the test's output. Ifmessage isprovided, it is included in the output. Callingtodo() does not terminateexecution of the test function. This function does not return a value.

test('top level test',(t) => {// This test is marked as `TODO`  t.todo('this is a todo');});copy

context.test([name][, options][, fn])#

• name<string> The name of the subtest, which is displayed when reportingtest results.Default: Thename property offn, or'<anonymous>' iffn does not have a name.
• options<Object> Configuration options for the subtest. The followingproperties are supported:
  • concurrency<number> |<boolean> |<null> If a number is provided,then that many tests would run asynchronously (they are still managed by the single-threaded event loop).Iftrue, it would run all subtests in parallel.Iffalse, it would only run one test at a time.If unspecified, subtests inherit this value from their parent.Default:null.
  • only<boolean> If truthy, and the test context is configured to runonly tests, then this test will be run. Otherwise, the test is skipped.Default:false.
  • signal<AbortSignal> Allows aborting an in-progress test.
  • skip<boolean> |<string> If truthy, the test is skipped. If a string isprovided, that string is displayed in the test results as the reason forskipping the test.Default:false.
  • todo<boolean> |<string> If truthy, the test marked asTODO. If a stringis provided, that string is displayed in the test results as the reason whythe test isTODO.Default:false.
  • timeout<number> A number of milliseconds the test will fail after.If unspecified, subtests inherit this value from their parent.Default:Infinity.
  • plan<number> The number of assertions and subtests expected to be run in the test.If the number of assertions run in the test does not match the numberspecified in the plan, the test will fail.Default:undefined.
• fn<Function> |<AsyncFunction> The function under test. The first argumentto this function is aTestContext object. If the test uses callbacks,the callback function is passed as the second argument.Default: A no-opfunction.
• Returns:<Promise> Fulfilled withundefined once the test completes.

This function is used to create subtests under the current test. This functionbehaves in the same fashion as the top leveltest() function.

test('top level test',async (t) => {await t.test('This is a subtest',    {only:false,skip:false,concurrency:1,todo:false,plan:1 },(t) => {      t.assert.ok('some relevant assertion here');    },  );});copy

context.waitFor(condition[, options])#

• condition<Function> |<AsyncFunction> An assertion function that is invokedperiodically until it completes successfully or the defined polling timeoutelapses. Successful completion is defined as not throwing or rejecting. Thisfunction does not accept any arguments, and is allowed to return any value.
• options<Object> An optional configuration object for the polling operation.The following properties are supported:
  • interval<number> The number of milliseconds to wait after an unsuccessfulinvocation ofcondition before trying again.Default:50.
  • timeout<number> The poll timeout in milliseconds. Ifcondition has notsucceeded by the time this elapses, an error occurs.Default:1000.
• Returns:<Promise> Fulfilled with the value returned bycondition.

This method polls acondition function until that function either returnssuccessfully or the operation times out.

context.filePath#

The absolute path of the test file that created the current suite. If a testfile imports additional modules that generate suites, the imported suites willreturn the path of the root test file.

context.fullName#

The name of the suite and each of its ancestors, separated by>.

context.name#

The name of the suite.

context.signal#

• Type:<AbortSignal>

Can be used to abort test subtasks when the test has been aborted.