This function is used to create a mock function.
The following example creates a mock function that increments a counter by one
on each invocation. The times option is used to modify the mock behavior such
that the first two invocations add two to the counter instead of one.
test('mocks a counting function', (t) => {
let cnt = 0;
function addOne() {
cnt++;
return cnt;
}
function addTwo() {
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);
});
Optionaloriginal: FAn optional function to create a mock on.
Optionaloptions: MockFunctionOptionsOptional configuration options for the mock function.
The mocked function. The mocked function contains a special mock property, which is an instance of MockFunctionContext, and can be used for inspecting and changing the
behavior of the mocked function.
Optionaloriginal: FOptionalimplementation: ImplementationOptionaloptions: MockFunctionOptionsThis function is syntax sugar for MockTracker.method with options.getter set to true.
Optionaloptions: MockFunctionOptionsOptionalimplementation: ImplementationOptionaloptions: MockFunctionOptionsThis function is used to create a mock on an existing object method. The following example demonstrates how a mock is created on an existing object method.
test('spies on an object method', (t) => {
const number = {
value: 5,
subtract(a) {
return this.value - a;
},
};
t.mock.method(number, 'subtract');
assert.strictEqual(number.subtract.mock.calls.length, 0);
assert.strictEqual(number.subtract(3), 2);
assert.strictEqual(number.subtract.mock.calls.length, 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);
});
The object whose method is being mocked.
The identifier of the method on object to mock. If object[methodName] is not a function, an error is thrown.
Optionaloptions: MockFunctionOptionsOptional configuration options for the mock method.
The mocked method. The mocked method contains a special mock property, which is an instance of MockFunctionContext, and can be used for inspecting and changing the
behavior of the mocked method.
Optionaloptions: MockFunctionOptionsExperimentalThis function is used to mock the exports of ECMAScript modules, CommonJS modules, JSON modules, and
Node.js builtin modules. Any references to the original module prior to mocking are not impacted. In
order 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() { return 42; } },
});
let esmImpl = await import('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 = await import('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);
});
A string identifying the module to mock.
Optionaloptions: MockModuleOptionsOptional configuration options for the mock module.
This function restores the default behavior of all mocks that were previously
created by this MockTracker and disassociates the mocks from the MockTracker instance. Once disassociated, the mocks can still be used, but the MockTracker instance can no longer be
used to reset their behavior or
otherwise interact with them.
After each test completes, this function is called on the test context's MockTracker. If the global MockTracker is used extensively, calling this
function manually is recommended.
This function is syntax sugar for MockTracker.method with options.setter set to true.
Optionaloptions: MockFunctionOptionsOptionalimplementation: ImplementationOptionaloptions: MockFunctionOptions
The
MockTrackerclass is used to manage mocking functionality. The test runner module provides a top levelmockexport which is aMockTrackerinstance. Each test also provides its ownMockTrackerinstance via the test context'smockproperty.Since
v19.1.0, v18.13.0