'use strict';

const {

ArrayPrototypeEvery,

ArrayPrototypePush,

ArrayPrototypePushApply,

ArrayPrototypeShift,

ArrayPrototypeSlice,

ArrayPrototypeSome,

ArrayPrototypeSplice,

ArrayPrototypeUnshift,

ArrayPrototypeUnshiftApply,

Error,

FunctionPrototype,

MathFloor,

MathMax,

Number,

NumberPrototypeToFixed,

ObjectKeys,

ObjectSeal,

Promise,

PromisePrototypeThen,

PromiseResolve,

PromiseWithResolvers,

ReflectApply,

RegExpPrototypeExec,

SafeMap,

SafePromiseAll,

SafePromiseAllReturnVoid,

SafePromiseRace,

SafeSet,

StringPrototypeStartsWith,

StringPrototypeTrim,

Symbol,

SymbolDispose,

} = primordials;

const { getCallerLocation } = internalBinding('util');

const { exitCodes: { kGenericUserError } } = internalBinding('errors');

const { addAbortListener } = require('internal/events/abort_listener');

const { queueMicrotask } = require('internal/process/task_queues');

const { AsyncResource } = require('async_hooks');

const { AbortController } = require('internal/abort_controller');

const {

AbortError,

codes: {

ERR_INVALID_ARG_TYPE,

ERR_INVALID_ARG_VALUE,

ERR_TEST_FAILURE,

},

} = require('internal/errors');

const { MockTracker } = require('internal/test_runner/mock/mock');

const { TestsStream } = require('internal/test_runner/tests_stream');

const {

createDeferredCallback,

createSeededGenerator,

countCompletedTest,

isTestFailureError,

reporterScope,

testChannel,

} = require('internal/test_runner/utils');

const {

kEmptyObject,

once: runOnce,

setOwnProperty,

} = require('internal/util');

const assert = require('assert');

const { isPromise, isRegExp } = require('internal/util/types');

const {

validateAbortSignal,

validateFunction,

validateNumber,

validateObject,

validateOneOf,

validateUint32,

} = require('internal/validators');

const {

clearTimeout,

setTimeout,

} = require('timers');

const { TIMEOUT_MAX } = require('internal/timers');

const { fileURLToPath } = require('internal/url');

const { relative } = require('path');

const { availableParallelism } = require('os');

const { innerOk } = require('internal/assert/utils');

const { bigint: hrtime } = process.hrtime;

const kCallbackAndPromisePresent = 'callbackAndPromisePresent';

const kCancelledByParent = 'cancelledByParent';

const kAborted = 'testAborted';

const kParentAlreadyFinished = 'parentAlreadyFinished';

const kSubtestsFailed = 'subtestsFailed';

const kTestCodeFailure = 'testCodeFailure';

const kTestTimeoutFailure = 'testTimeoutFailure';

const kExpectedFailure = 'expectedFailure';

const kHookFailure = 'hookFailed';

const kDefaultTimeout = null;

const noop = FunctionPrototype;

const kShouldAbort = Symbol('kShouldAbort');

const kHookNames = ObjectSeal(['before', 'after', 'beforeEach', 'afterEach']);

const kUnwrapErrors = new SafeSet()

.add(kTestCodeFailure).add(kHookFailure)

.add('uncaughtException').add('unhandledRejection');

let kResistStopPropagation;

let assertObj;

let findSourceMap;

let noopTestStream;

const kRunOnceOptions = { __proto__: null, preserveReturnValue: true };

function lazyFindSourceMap(file) {

if (findSourceMap === undefined) {

({ findSourceMap } = require('internal/source_map/source_map_cache'));

}

return findSourceMap(file);

}

function lazyAssertObject(harness) {

if (assertObj === undefined) {

const { getAssertionMap } = require('internal/test_runner/assert');

const { SnapshotManager } = require('internal/test_runner/snapshot');

assertObj = getAssertionMap();

harness.snapshotManager = new SnapshotManager(harness.config.updateSnapshots);

if (!assertObj.has('snapshot')) {

assertObj.set('snapshot', harness.snapshotManager.createAssert());

}

if (!assertObj.has('fileSnapshot')) {

assertObj.set('fileSnapshot', harness.snapshotManager.createFileAssert());

}

}

return assertObj;

}

function stopTest(timeout, signal) {

const deferred = PromiseWithResolvers();

const abortListener = addAbortListener(signal, deferred.resolve);

let timer;

let disposeFunction;

if (timeout === kDefaultTimeout) {

disposeFunction = abortListener[SymbolDispose];

} else {

timer = setTimeout(deferred.resolve, timeout);

timer.unref();

setOwnProperty(deferred, 'promise', PromisePrototypeThen(deferred.promise, () => {

throw new ERR_TEST_FAILURE(

`test timed out after ${timeout}ms`,

kTestTimeoutFailure,

);

}));

disposeFunction = () => {

abortListener[SymbolDispose]();

clearTimeout(timer);

};

}

setOwnProperty(deferred.promise, SymbolDispose, disposeFunction);

return deferred.promise;

}

function testMatchesPattern(test, patterns) {

const matchesByNameOrParent = ArrayPrototypeSome(patterns, (re) =>

RegExpPrototypeExec(re, test.name) !== null,

) || (test.parent && testMatchesPattern(test.parent, patterns));

if (matchesByNameOrParent) return true;

const testNameWithAncestors = StringPrototypeTrim(test.getTestNameWithAncestors());

return ArrayPrototypeSome(patterns, (re) =>

RegExpPrototypeExec(re, testNameWithAncestors) !== null,

);

}

class TestPlan {

#waitIndefinitely = false;

#planPromise = null;

#timeoutId = null;

constructor(count, options = kEmptyObject) {

validateUint32(count, 'count');

validateObject(options, 'options');

this.expected = count;

this.actual = 0;

const { wait } = options;

if (typeof wait === 'boolean') {

this.wait = wait;

this.#waitIndefinitely = wait;

} else if (typeof wait === 'number') {

validateNumber(wait, 'options.wait', 0, TIMEOUT_MAX);

this.wait = wait;

} else if (wait !== undefined) {

throw new ERR_INVALID_ARG_TYPE('options.wait', ['boolean', 'number'], wait);

}

}

#planMet() {

return this.actual === this.expected;

}

#createTimeout(reject) {

return setTimeout(() => {

const err = new ERR_TEST_FAILURE(

`plan timed out after ${this.wait}ms with ${this.actual} assertions when expecting ${this.expected}`,

kTestTimeoutFailure,

);

reject(err);

}, this.wait);

}

check() {

if (this.#planMet()) {

if (this.#timeoutId) {

clearTimeout(this.#timeoutId);

this.#timeoutId = null;

}

if (this.#planPromise) {

const { resolve } = this.#planPromise;

resolve();

this.#planPromise = null;

}

return;

}

if (!this.#shouldWait()) {

throw new ERR_TEST_FAILURE(

`plan expected ${this.expected} assertions but received ${this.actual}`,

kTestCodeFailure,

);

}

if (!this.#planPromise) {

const { promise, resolve, reject } = PromiseWithResolvers();

this.#planPromise = { __proto__: null, promise, resolve, reject };

if (!this.#waitIndefinitely) {

this.#timeoutId = this.#createTimeout(reject);

}

}

return this.#planPromise.promise;

}

count() {

this.actual++;

if (this.#planPromise) {

this.check();

}

}

#shouldWait() {

return this.wait !== undefined && this.wait !== false;

}

}

class TestContext {

#assert;

#test;

constructor(test) {

this.#test = test;

}

get signal() {

return this.#test.signal;

}

get name() {

return this.#test.name;

}

get filePath() {

return this.#test.entryFile;

}

get fullName() {

return getFullName(this.#test);

}

get error() {

return this.#test.error;

}

get passed() {

return this.#test.passed;

}

get attempt() {

return this.#test.attempt ?? 0;

}

get workerId() {

const envWorkerId = process.env.NODE_TEST_WORKER_ID;

return Number(envWorkerId) || undefined;

}

diagnostic(message) {

this.#test.diagnostic(message);

}

plan(count, options = kEmptyObject) {

if (this.#test.plan !== null) {

throw new ERR_TEST_FAILURE(

'cannot set plan more than once',

kTestCodeFailure,

);

}

this.#test.plan = new TestPlan(count, options);

}

get assert() {

if (this.#assert === undefined) {

const { plan } = this.#test;

const map = lazyAssertObject(this.#test.root.harness);

const assert = { __proto__: null };

this.#assert = assert;

map.forEach((method, name) => {

assert[name] = (...args) => {

if (plan !== null) {

plan.count();

}

return ReflectApply(method, this, args);

};

});

if (!map.has('ok')) {

// This is a hack. It allows the innerOk function to collect the

// stacktrace from the correct starting point.

function ok(...args) {

if (plan !== null) {

plan.count();

}

innerOk(ok, ...args);

}

assert.ok = ok;

}

}

return this.#assert;

}

get mock() {

this.#test.mock ??= new MockTracker();

return this.#test.mock;

}

runOnly(value) {

this.#test.runOnlySubtests = !!value;

}

skip(message) {

this.#test.skip(message);

}

todo(message) {

this.#test.todo(message);

}

test(name, options, fn) {

const overrides = {

__proto__: null,

loc: getCallerLocation(),

};

const { plan } = this.#test;

if (plan !== null) {

plan.count();

}

const subtest = this.#test.createSubtest(

// eslint-disable-next-line no-use-before-define

Test, name, options, fn, overrides,

);

return subtest.start();

}

before(fn, options) {

this.#test.createHook('before', fn, {

__proto__: null,

...options,

parent: this.#test,

hookType: 'before',

loc: getCallerLocation(),

});

}

after(fn, options) {

this.#test.createHook('after', fn, {

__proto__: null,

...options,

parent: this.#test,

hookType: 'after',

loc: getCallerLocation(),

});

}

beforeEach(fn, options) {

this.#test.createHook('beforeEach', fn, {

__proto__: null,

...options,

parent: this.#test,

hookType: 'beforeEach',

loc: getCallerLocation(),

});

}

afterEach(fn, options) {

this.#test.createHook('afterEach', fn, {

__proto__: null,

...options,

parent: this.#test,

hookType: 'afterEach',

loc: getCallerLocation(),

});

}

waitFor(condition, options = kEmptyObject) {

validateFunction(condition, 'condition');

validateObject(options, 'options');

const {

interval = 50,

timeout = 1000,

} = options;

validateNumber(interval, 'options.interval', 0, TIMEOUT_MAX);

validateNumber(timeout, 'options.timeout', 0, TIMEOUT_MAX);

const { promise, resolve, reject } = PromiseWithResolvers();

const noError = Symbol();

let cause = noError;

let pollerId;

let timeoutId;

const done = (err, result) => {

clearTimeout(pollerId);

clearTimeout(timeoutId);

if (err === noError) {

resolve(result);

} else {

reject(err);

}

};

timeoutId = setTimeout(() => {

// eslint-disable-next-line no-restricted-syntax

const err = new Error('waitFor() timed out');

if (cause !== noError) {

err.cause = cause;

}

done(err);

}, timeout);

const poller = async () => {

try {

const result = await condition();

done(noError, result);

} catch (err) {

cause = err;

pollerId = setTimeout(poller, interval);

}

};

poller();

return promise;

}

}

class SuiteContext {

#suite;

constructor(suite) {

this.#suite = suite;

}

get signal() {

return this.#suite.signal;

}

get name() {

return this.#suite.name;

}

get filePath() {

return this.#suite.entryFile;

}

get fullName() {

return getFullName(this.#suite);

}

get passed() {

return this.#suite.passed;

}

get attempt() {

return this.#suite.attempt ?? 0;

}

diagnostic(message) {

this.#suite.diagnostic(message);

}

}

function parseExpectFailure(expectFailure) {

if (expectFailure === undefined || expectFailure === false) {

return false;

}

if (typeof expectFailure === 'string') {

return { __proto__: null, label: expectFailure, match: undefined };

}

if (typeof expectFailure === 'function' || isRegExp(expectFailure)) {

return { __proto__: null, label: undefined, match: expectFailure };

}

if (typeof expectFailure !== 'object') {

return { __proto__: null, label: undefined, match: undefined };

}

const keys = ObjectKeys(expectFailure);

if (keys.length === 0) {

throw new ERR_INVALID_ARG_VALUE('options.expectFailure', expectFailure, 'must not be an empty object');

}

if (ArrayPrototypeEvery(keys, (k) => k === 'match' || k === 'label')) {

return {

__proto__: null,

label: expectFailure.label,

match: expectFailure.match,

};

}

return { __proto__: null, label: undefined, match: expectFailure };

}

class Test extends AsyncResource {

reportedType = 'test';

abortController;

outerSignal;

#reportedSubtest;

constructor(options) {

super('Test');

let { fn, name, parent } = options;

const { concurrency, entryFile, expectFailure, loc, only, timeout, todo, skip, signal, plan } = options;

if (typeof fn !== 'function') {

fn = noop;

}

if (typeof name !== 'string' || name === '') {

name = fn.name || '<anonymous>';

}

if (!(parent instanceof Test)) {

parent = null;

}

this.name = name;

this.parent = parent;

this.testNumber = 0;

this.outputSubtestCount = 0;

this.diagnostics = [];

this.filtered = false;

this.filteredByName = false;

this.hasOnlyTests = false;

if (parent === null) {

this.root = this;

this.harness = options.harness;

this.config = this.harness.config;

this.concurrency = 1;

this.nesting = 0;

this.only = this.config.only;

this.reporter = new TestsStream();

this.runOnlySubtests = this.only;

this.childNumber = 0;

this.timeout = kDefaultTimeout;

this.entryFile = entryFile;

this.testDisambiguator = new SafeMap();

this.nextTestId = 1;

this.testId = 0;

} else {

const nesting = parent.parent === null ? parent.nesting :

parent.nesting + 1;

const { config, isFilteringByName, isFilteringByOnly } = parent.root.harness;

this.root = parent.root;

this.harness = null;

this.config = config;

this.concurrency = parent.concurrency;

this.nesting = nesting;

this.only = only;

this.reporter = parent.reporter;

this.runOnlySubtests = false;

this.childNumber = parent.subtests.length + 1;

this.timeout = parent.timeout;

this.entryFile = parent.entryFile;

this.testId = this.root.nextTestId++;

if (isFilteringByName) {

this.filteredByName = this.willBeFilteredByName();

if (!this.filteredByName) {

for (let t = this.parent; t !== null && t.filteredByName; t = t.parent) {

t.filteredByName = false;

}

}

}

if (isFilteringByOnly) {

if (this.only) {

// If filtering impacts the tests within a suite, then the suite only

// runs those tests. If filtering does not impact the tests within a

// suite, then all tests are run.

this.parent.runOnlySubtests = true;

if (this.parent === this.root || this.parent.startTime === null) {

for (let t = this.parent; t !== null && !t.hasOnlyTests; t = t.parent) {

t.hasOnlyTests = true;

}

}

} else if (this.only === false) {

fn = noop;

}

} else if (only || this.parent.runOnlySubtests) {

const warning =

"'only' and 'runOnly' require the --test-only command-line option.";

this.diagnostic(warning);

}

}

switch (typeof concurrency) {

case 'number':

validateUint32(concurrency, 'options.concurrency', true);

this.concurrency = concurrency;

break;

case 'boolean':

if (concurrency) {

this.concurrency = parent === null ?

MathMax(availableParallelism() - 1, 1) : Infinity;

} else {

this.concurrency = 1;

}

break;

default:

if (concurrency != null)

throw new ERR_INVALID_ARG_TYPE('options.concurrency', ['boolean', 'number'], concurrency);

}

if (timeout != null && timeout !== Infinity) {

validateNumber(timeout, 'options.timeout', 0, TIMEOUT_MAX);

this.timeout = timeout;

} else if (timeout == null) {

const cliTimeout = this.config.timeout;

if (cliTimeout != null && cliTimeout !== Infinity) {

validateNumber(cliTimeout, 'this.config.timeout', 0, TIMEOUT_MAX);

this.timeout = cliTimeout;

}

}

if (skip) {

fn = noop;

}

this.abortController = new AbortController();

this.outerSignal = signal;

this.signal = this.abortController.signal;

validateAbortSignal(signal, 'options.signal');

if (signal) {

kResistStopPropagation ??= require('internal/event_target').kResistStopPropagation;

}

this.outerSignal?.addEventListener(

'abort',

this.#abortHandler,

{ __proto__: null, [kResistStopPropagation]: true },

);

this.fn = fn;

this.mock = null;

this.plan = null;

this.expectedAssertions = plan;

this.cancelled = false;

this.expectFailure = parseExpectFailure(expectFailure) || this.parent?.expectFailure;

this.skipped = skip !== undefined && skip !== false;

this.isTodo = (todo !== undefined && todo !== false) || this.parent?.isTodo;

this.startTime = null;

this.endTime = null;

this.passed = false;

this.error = null;

this.attempt = undefined;

this.passedAttempt = undefined;

this.message = typeof skip === 'string' ? skip :

typeof todo === 'string' ? todo : null;

this.activeSubtests = 0;

this.subtestQueueRandom = this.config.randomize ?

createSeededGenerator(this.config.randomSeed) :

null;

this.pendingSubtests = [];

this.pendingSubtestsScheduled = false;

this.readySubtests = new SafeMap();

this.unfinishedSubtests = new SafeSet();

this.subtestsPromise = null;

this.subtests = [];

this.nextReportOrder = 1;

this.reportOrder = 0;

this.waitingOn = 0;

this.finished = false;

this.hooks = {

__proto__: null,

before: [],

after: [],

beforeEach: [],

afterEach: [],

ownAfterEachCount: 0,

};

if (loc === undefined) {

this.loc = undefined;

} else {

this.loc = {

__proto__: null,

line: loc[0],

column: loc[1],

file: loc[2],

};

if (this.config.sourceMaps === true) {

const map = lazyFindSourceMap(this.loc.file);

const entry = map?.findEntry(this.loc.line - 1, this.loc.column - 1);

if (entry?.originalSource !== undefined) {

this.loc.line = entry.originalLine + 1;

this.loc.column = entry.originalColumn + 1;

this.loc.file = entry.originalSource;

}

}

if (StringPrototypeStartsWith(this.loc.file, 'file://')) {

this.loc.file = fileURLToPath(this.loc.file);

}

}

if (this.loc != null && this.root.harness.previousRuns != null) {

let testIdentifier = `${relative(this.config.cwd, this.loc.file)}:${this.loc.line}:${this.loc.column}`;

const disambiguator = this.root.testDisambiguator.get(testIdentifier);

if (disambiguator !== undefined) {

testIdentifier += `:(${disambiguator})`;

this.root.testDisambiguator.set(testIdentifier, disambiguator + 1);

} else {

this.root.testDisambiguator.set(testIdentifier, 1);

}

this.attempt = this.root.harness.previousRuns.length;

const previousAttempt = this.root.harness.previousRuns[this.attempt - 1]?.[testIdentifier];

if (previousAttempt != null) {

this.passedAttempt = previousAttempt.passed_on_attempt;

this.fn = () => {

for (let i = 0; i < (previousAttempt.children?.length ?? 0); i++) {

const child = previousAttempt.children[i];

const t = this.createSubtest(Test, child.name, { __proto__: null }, noop, {

__proto__: null,

loc: [child.line, child.column, child.file],

}, noop);

t.endTime = t.startTime = hrtime();

// For suites, Suite.run() starts the subtests via SafePromiseAll.

// Starting them here as well would run them twice, re-invoking the

// synthetic children-creator against a now-incremented disambiguator

// and producing spurious failures.

if (this.reportedType !== 'suite') {

t.start();

}

}

};

}

}

}

applyFilters() {

if (this.error) {

// Never filter out errors.

return;

}

if (this.filteredByName) {

this.filtered = true;

return;

}

if (this.root.harness.isFilteringByOnly && !this.only && !this.hasOnlyTests) {

if (this.parent.runOnlySubtests ||

this.parent.hasOnlyTests ||

this.only === false) {

this.filtered = true;

}

}

}

willBeFilteredByName() {

const { testNamePatterns, testSkipPatterns } = this.config;

if (testNamePatterns && !testMatchesPattern(this, testNamePatterns)) {

return true;

}

if (testSkipPatterns && testMatchesPattern(this, testSkipPatterns)) {

return true;

}

return false;

}

/**

* Returns a name of the test prefixed by name of all its ancestors in ascending order, separated by a space

* Ex."grandparent parent test"

*

* It's needed to match a single test with non-unique name by pattern

* @returns {string}

*/

getTestNameWithAncestors() {

if (!this.parent) return '';

return `${this.parent.getTestNameWithAncestors()} ${this.name}`;

}

/**

* @returns {boolean}

*/

hasConcurrency() {

return this.concurrency > this.activeSubtests;

}

/**

* @param {any} deferred

* @returns {void}

*/

addPendingSubtest(deferred) {

ArrayPrototypePush(this.pendingSubtests, deferred);

}

schedulePendingSubtests() {

if (this.pendingSubtestsScheduled) {

return;

}

this.pendingSubtestsScheduled = true;

queueMicrotask(() => {

this.pendingSubtestsScheduled = false;

this.processPendingSubtests();

});

}

/**

* Ensure each subtest has a contiguous, per-parent reporting order.

* This is assigned at dequeue time for randomized runs, but tests that are

* cancelled before dequeue still need an order to be reported.

* @param {Test} subtest

* @returns {void}

*/

assignReportOrder(subtest) {

if (subtest.reportOrder === 0) {

subtest.reportOrder = this.nextReportOrder++;

}

}

dequeuePendingSubtest() {

if (!this.subtestQueueRandom || this.pendingSubtests.length < 2) {

return ArrayPrototypeShift(this.pendingSubtests);

}

// Pick a uniformly random pending sibling when randomization is enabled.

const index = MathFloor(this.subtestQueueRandom() * this.pendingSubtests.length);

return ArrayPrototypeSplice(this.pendingSubtests, index, 1)[0];

}

/**

* @returns {Promise<void>}

*/

async processPendingSubtests() {

while (this.pendingSubtests.length > 0 && this.hasConcurrency()) {

const deferred = this.dequeuePendingSubtest();

const test = deferred.test;

this.assignReportOrder(test);

test.reporter.dequeue(test.nesting, test.loc, test.name, this.reportedType, test.testId);

await test.run();

deferred.resolve();

}

}

/**

* @param {any} subtest

* @returns {void}

*/

addReadySubtest(subtest) {

this.assignReportOrder(subtest);

this.readySubtests.set(subtest.reportOrder, subtest);

if (this.unfinishedSubtests.delete(subtest) &&

this.unfinishedSubtests.size === 0) {

this.subtestsPromise.resolve();

}

}

/**

* @param {boolean} canSend

* @returns {void}

*/

processReadySubtestRange(canSend) {

const start = this.waitingOn;

const end = start + this.readySubtests.size;

for (let i = start; i < end; i++) {

const subtest = this.readySubtests.get(i);

// Check if the specified subtest is in the map. If it is not, return

// early to avoid trying to process any more tests since they would be

// out of order.

if (subtest === undefined) {

return;

}

// Call isClearToSend() in the loop so that it is:

// - Only called if there are results to report in the correct order.

// - Guaranteed to only be called a maximum of once per call to

// processReadySubtestRange().

canSend ||= this.isClearToSend();

if (!canSend) {

return;

}

// Report the subtest's results and remove it from the ready map.

subtest.finalize();

this.readySubtests.delete(i);

}

}

createSubtest(Factory, name, options, fn, overrides) {

if (typeof name === 'function') {

fn = name;

} else if (name !== null && typeof name === 'object') {

fn = options;

options = name;

} else if (typeof options === 'function') {

fn = options;

}

if (options === null || typeof options !== 'object') {

options = kEmptyObject;

}

let parent = this;

// If this test has already ended, attach this test to the root test so

// that the error can be properly reported.

const preventAddingSubtests = this.finished || this.buildPhaseFinished;

if (preventAddingSubtests) {

while (parent.parent !== null) {

parent = parent.parent;

}

}

const test = new Factory({ __proto__: null, fn, name, parent, ...options, ...overrides });

if (parent.waitingOn === 0) {

parent.waitingOn = test.childNumber;

parent.subtestsPromise = PromiseWithResolvers();

}

if (preventAddingSubtests) {

test.fail(

new ERR_TEST_FAILURE(

'test could not be started because its parent finished',

kParentAlreadyFinished,

),

);

}

ArrayPrototypePush(parent.subtests, test);

return test;

}

#abortHandler = () => {

const error = this.outerSignal?.reason || new AbortError('The test was aborted');

error.failureType = kAborted;

this.#cancel(error);

};