GeezerVison

Configures the test runner to exit the process once all known tests have

finished executing even if the event loop would otherwise remain active.

Specify a module that will be evaluated before all tests are executed and

can be used to setup global state or fixtures for tests.

See the documentation on [global setup and teardown][] for more details.

* `--test-coverage-functions`

* `--test-coverage-include`

* `--test-coverage-lines`

* `--test-global-setup`

* `--test-isolation`

* `--test-name-pattern`

* `--test-only`

[emit_warning]: process.md#processemitwarningwarning-options

[environment_variables]: #environment-variables

[filtering tests by name]: test.md#filtering-tests-by-name

[global setup and teardown]: test.md#global-setup-and-teardown

[jitless]: https://v8.dev/blog/jitless

[libuv threadpool documentation]: https://docs.libuv.org/en/latest/threadpool.html

[module compile cache]: module.md#module-compile-cache

rerun the tests affected by the change.

The test runner will continue to run until the process is terminated.

The test runner supports specifying a module that will be evaluated before all tests are executed and

can be used to setup global state or fixtures for tests. This is useful for preparing resources or setting up

shared state that is required by multiple tests.

This module can export any of the following:

* A `globalSetup` function which runs once before all tests start

* A `globalTeardown` function which runs once after all tests complete

The module is specified using the `--test-global-setup` flag when running tests from the command line.

async function globalSetup() {

// Setup shared resources, state, or environment

console.log('Global setup executed');

// Run servers, create files, prepare databases, etc.

}

async function globalTeardown() {

// Clean up resources, state, or environment

console.log('Global teardown executed');

// Close servers, remove files, disconnect from databases, etc.

}

module.exports = { globalSetup, globalTeardown };

export async function globalSetup() {

// Setup shared resources, state, or environment

console.log('Global setup executed');

// Run servers, create files, prepare databases, etc.

}

export async function globalTeardown() {

// Clean up resources, state, or environment

console.log('Global teardown executed');

// Close servers, remove files, disconnect from databases, etc.

}

If the global setup function throws an error, no tests will be run and the process will exit with a non-zero exit code.

The global teardown function will not be called in this case.

The Node.js test runner can be invoked from the command line by passing the

"test-coverage-lines": {

"type": "number"

},

"test-global-setup": {

"type": "string"

},

"test-isolation": {

"type": "string"

},

Configures the test runner to exit the process once all known tests have

finished executing even if the event loop would otherwise remain active.

.It Fl -test-global-setup

Specifies a module containing global setup and teardown functions for the test runner.

.It Fl -test-isolation Ns = Ns Ar mode

Configures the type of test isolation used in the test runner.

parseCommandLine,

reporterScope,

shouldColorizeTestFiles,

setupGlobalSetupTeardownFunctions,

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

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

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

const { clearInterval, setInterval } = require('timers');

const { bigint: hrtime } = process.hrtime;

const resolvedPromise = PromiseResolve();

const testResources = new SafeMap();

let globalRoot;

let globalSetupExecuted = false;

testResources.set(reporterScope.asyncId(), reporterScope);

function createTestTree(rootTestOptions, globalOptions) {

const buildPhaseDeferred = PromiseWithResolvers();

const isFilteringByName = globalOptions.testNamePatterns ||

globalOptions.testSkipPatterns;

globalOptions.testSkipPatterns;

const isFilteringByOnly = (globalOptions.isolation === 'process' || process.env.NODE_TEST_CONTEXT) ?

globalOptions.only : true;

const harness = {

__proto__: null,

buildPromise: buildPhaseDeferred.promise,

buildSuites: [],

isWaitingForBuildPhase: false,

bootstrapPromise: resolvedPromise,

watching: false,

config: globalOptions,

coverage: null,

snapshotManager: null,

isFilteringByName,

isFilteringByOnly,

async runBootstrap() {

if (globalSetupExecuted) {

return PromiseResolve();

}

globalSetupExecuted = true;

const globalSetupFunctions = await setupGlobalSetupTeardownFunctions(

globalOptions.globalSetupPath,

globalOptions.cwd,

);

harness.globalTeardownFunction = globalSetupFunctions.globalTeardownFunction;

if (typeof globalSetupFunctions.globalSetupFunction === 'function') {

return globalSetupFunctions.globalSetupFunction();

}

return PromiseResolve();

},

async waitForBuildPhase() {

if (harness.buildSuites.length > 0) {

await SafePromiseAllReturnVoid(harness.buildSuites);

};

harness.resetCounters();

harness.bootstrapPromise = harness.runBootstrap();

globalRoot = new Test({

__proto__: null,

...rootTestOptions,

'Promise resolution is still pending but the event loop has already resolved',

kCancelledByParent));

if (root.harness.globalTeardownFunction) {

await root.harness.globalTeardownFunction();

root.harness.globalTeardownFunction = null;

}

hook.disable();

process.removeListener('uncaughtException', exceptionHandler);

process.removeListener('unhandledRejection', rejectionHandler);

process.exitCode = kGenericUserError;

}

});

globalRoot.harness.bootstrapPromise = globalOptions.setup(globalRoot.reporter);

globalRoot.harness.bootstrapPromise = SafePromiseAllReturnVoid([

globalRoot.harness.bootstrapPromise,

globalOptions.setup(globalRoot.reporter),

]);

}

return globalRoot;

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

const { Glob } = require('internal/fs/glob');

const { once } = require('events');

const { validatePath } = require('internal/fs/utils');

const {

triggerUncaughtException,

exitCodes: { kGenericUserError },

isolation = 'process',

watch,

setup,

globalSetupPath,

only,

globPatterns,

coverage = false,

validateStringArray(argv, 'options.argv');

validateStringArray(execArgv, 'options.execArgv');

if (globalSetupPath != null) {

validatePath(globalSetupPath, 'options.globalSetupPath');

}

const rootTestOptions = { __proto__: null, concurrency, timeout, signal };

const globalOptions = {

__proto__: null,

branchCoverage: branchCoverage,

functionCoverage: functionCoverage,

cwd,

globalSetupPath,

};

const root = createTestTree(rootTestOptions, globalOptions);

let testFiles = files ?? createTestFileList(globPatterns, cwd);

const cascadedLoader = esmLoader.getOrInitializeCascadedLoader();

let topLevelTestCount = 0;

root.harness.bootstrapPromise = promise;

root.harness.bootstrapPromise = root.harness.bootstrapPromise ?

SafePromiseAllReturnVoid([root.harness.bootstrapPromise, promise]) :

promise;

const userImports = getOptionValue('--import');

for (let i = 0; i < userImports.length; i++) {

debug('beginning test execution');

root.entryFile = null;

finishBootstrap();

root.processPendingSubtests();

return root.processPendingSubtests();

};

}

}

const runChain = async () => {

if (root.harness?.bootstrapPromise) {

await root.harness.bootstrapPromise;

}

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

await setup(root.reporter);

}

} = primordials;

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

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

const { relative, sep, resolve } = require('path');

const { createWriteStream } = require('fs');

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

const { getOptionValue } = require('internal/options');

kIsNodeError,

} = require('internal/errors');

const { compose } = require('stream');

const { validateInteger } = require('internal/validators');

const {

validateInteger,

validateFunction,

} = require('internal/validators');

const { validatePath } = require('internal/fs/utils');

const { kEmptyObject } = require('internal/util');

const coverageColors = {

__proto__: null,

const timeout = getOptionValue('--test-timeout') || Infinity;

const isChildProcess = process.env.NODE_TEST_CONTEXT === 'child';

const isChildProcessV8 = process.env.NODE_TEST_CONTEXT === 'child-v8';

let globalSetupPath;

let concurrency;

let coverageExcludeGlobs;

let coverageIncludeGlobs;

} else {

destinations = getOptionValue('--test-reporter-destination');

reporters = getOptionValue('--test-reporter');

globalSetupPath = getOptionValue('--test-global-setup');

if (reporters.length === 0 && destinations.length === 0) {

ArrayPrototypePush(reporters, kDefaultReporter);

}

only,

reporters,

setup,

globalSetupPath,

shard,

sourceMaps,

testNamePatterns,

return report;

async function setupGlobalSetupTeardownFunctions(globalSetupPath, cwd) {

let globalSetupFunction;

let globalTeardownFunction;

if (globalSetupPath) {

validatePath(globalSetupPath, 'options.globalSetupPath');

const fileURL = pathToFileURL(resolve(cwd, globalSetupPath));

const cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader();

const globalSetupModule = await cascadedLoader

.import(fileURL, pathToFileURL(cwd + sep).href, kEmptyObject);

if (globalSetupModule.globalSetup) {

validateFunction(globalSetupModule.globalSetup, 'globalSetupModule.globalSetup');

globalSetupFunction = globalSetupModule.globalSetup;

}

if (globalSetupModule.globalTeardown) {

validateFunction(globalSetupModule.globalTeardown, 'globalSetupModule.globalTeardown');

globalTeardownFunction = globalSetupModule.globalTeardown;

}

}

return { __proto__: null, globalSetupFunction, globalTeardownFunction };

module.exports = {

convertStringToRegExp,

countCompletedTest,

reporterScope,

shouldColorizeTestFiles,

getCoverageReport,

setupGlobalSetupTeardownFunctions,

"exclude files from coverage report that match this glob pattern",

&EnvironmentOptions::coverage_exclude_pattern,

kAllowedInEnvvar);

AddOption("--test-global-setup",

"specifies the path to the global setup file",

&EnvironmentOptions::test_global_setup_path,

kAllowedInEnvvar);

AddOption("--test-udp-no-try-send", "", // For testing only.

&EnvironmentOptions::test_udp_no_try_send);

AddOption("--throw-deprecation",

std::vector<std::string> test_name_pattern;

std::vector<std::string> test_reporter;

std::vector<std::string> test_reporter_destination;

std::string test_global_setup_path;

bool test_only = false;

bool test_udp_no_try_send = false;

std::string test_isolation = "process";

const test = require('node:test');

const assert = require('node:assert');

const fs = require('node:fs');

test('Another test that verifies setup flag existance', (t) => {

const setupFlagPath = process.env.SETUP_FLAG_PATH;

assert.ok(fs.existsSync(setupFlagPath), 'Setup flag file should exist');

const content = fs.readFileSync(setupFlagPath, 'utf8');

assert.strictEqual(content, 'Setup was executed');