import fs from 'node:fs';
import { pathToFileURL } from 'node:url';
import vm from 'node:vm';
import { processError } from '@vitest/utils/error';
import { normalize as normalize$1, relative } from 'pathe';
import { ViteNodeRunner, DEFAULT_REQUEST_STUBS } from 'vite-node/client';
import { isInternalRequest, isNodeBuiltin as isNodeBuiltin$1, toFilePath, isPrimitive } from 'vite-node/utils';
import { distDir } from '../path.js';
import { resolve as resolve$1, isAbsolute as isAbsolute$1 } from 'node:path';
import { MockerRegistry, mockObject, RedirectedModule, AutomockedModule } from '@vitest/mocker';
import { builtinModules } from 'node:module';
import { highlight } from '@vitest/utils';
const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
function normalizeWindowsPath(input = "") {
if (!input) {
return input;
}
return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
}
const _UNC_REGEX = /^[/\\]{2}/;
const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
const normalize = function(path) {
if (path.length === 0) {
return ".";
}
path = normalizeWindowsPath(path);
const isUNCPath = path.match(_UNC_REGEX);
const isPathAbsolute = isAbsolute(path);
const trailingSeparator = path[path.length - 1] === "/";
path = normalizeString(path, !isPathAbsolute);
if (path.length === 0) {
if (isPathAbsolute) {
return "/";
}
return trailingSeparator ? "./" : ".";
}
if (trailingSeparator) {
path += "/";
}
if (_DRIVE_LETTER_RE.test(path)) {
path += "/";
}
if (isUNCPath) {
if (!isPathAbsolute) {
return `//./${path}`;
}
return `//${path}`;
}
return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
};
const join = function(...arguments_) {
if (arguments_.length === 0) {
return ".";
}
let joined;
for (const argument of arguments_) {
if (argument && argument.length > 0) {
if (joined === void 0) {
joined = argument;
} else {
joined += `/${argument}`;
}
}
}
if (joined === void 0) {
return ".";
}
return normalize(joined.replace(/\/\/+/g, "/"));
};
function cwd() {
if (typeof process !== "undefined" && typeof process.cwd === "function") {
return process.cwd().replace(/\\/g, "/");
}
return "/";
}
const resolve = function(...arguments_) {
arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
let resolvedPath = "";
let resolvedAbsolute = false;
for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
const path = index >= 0 ? arguments_[index] : cwd();
if (!path || path.length === 0) {
continue;
}
resolvedPath = `${path}/${resolvedPath}`;
resolvedAbsolute = isAbsolute(path);
}
resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
return `/${resolvedPath}`;
}
return resolvedPath.length > 0 ? resolvedPath : ".";
};
function normalizeString(path, allowAboveRoot) {
let res = "";
let lastSegmentLength = 0;
let lastSlash = -1;
let dots = 0;
let char = null;
for (let index = 0; index <= path.length; ++index) {
if (index < path.length) {
char = path[index];
} else if (char === "/") {
break;
} else {
char = "/";
}
if (char === "/") {
if (lastSlash === index - 1 || dots === 1) ;
else if (dots === 2) {
if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
if (res.length > 2) {
const lastSlashIndex = res.lastIndexOf("/");
if (lastSlashIndex === -1) {
res = "";
lastSegmentLength = 0;
} else {
res = res.slice(0, lastSlashIndex);
lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
}
lastSlash = index;
dots = 0;
continue;
} else if (res.length > 0) {
res = "";
lastSegmentLength = 0;
lastSlash = index;
dots = 0;
continue;
}
}
if (allowAboveRoot) {
res += res.length > 0 ? "/.." : "..";
lastSegmentLength = 2;
}
} else {
if (res.length > 0) {
res += `/${path.slice(lastSlash + 1, index)}`;
} else {
res = path.slice(lastSlash + 1, index);
}
lastSegmentLength = index - lastSlash - 1;
}
lastSlash = index;
dots = 0;
} else if (char === "." && dots !== -1) {
++dots;
} else {
dots = -1;
}
}
return res;
}
const isAbsolute = function(p) {
return _IS_ABSOLUTE_RE.test(p);
};
const _EXTNAME_RE = /.(\.[^./]+)$/;
const extname = function(p) {
const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
return match && match[1] || "";
};
const dirname = function(p) {
const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) {
segments[0] += "/";
}
return segments.join("/") || (isAbsolute(p) ? "/" : ".");
};
const basename = function(p, extension) {
const lastSegment = normalizeWindowsPath(p).split("/").pop();
return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
};
const { existsSync, readdirSync, statSync } = fs;
function findMockRedirect(root, mockPath, external) {
const path = external || mockPath;
if (external || isNodeBuiltin(mockPath) || !existsSync(mockPath)) {
let findFile2 = function(mockFolder2, baseOriginal2) {
const files = readdirSync(mockFolder2);
for (const file of files) {
const baseFile = basename(file, extname(file));
if (baseFile === baseOriginal2) {
const path2 = resolve(mockFolder2, file);
if (statSync(path2).isFile()) {
return path2;
} else {
const indexFile = findFile2(path2, "index");
if (indexFile) {
return indexFile;
}
}
}
}
return null;
};
const mockDirname = dirname(path);
const mockFolder = join(root, "__mocks__", mockDirname);
if (!existsSync(mockFolder)) {
return null;
}
const baseOriginal = basename(path);
return findFile2(mockFolder, baseOriginal);
}
const dir = dirname(path);
const baseId = basename(path);
const fullPath = resolve(dir, "__mocks__", baseId);
return existsSync(fullPath) ? fullPath : null;
}
const builtins = /* @__PURE__ */ new Set([
...builtinModules,
"assert/strict",
"diagnostics_channel",
"dns/promises",
"fs/promises",
"path/posix",
"path/win32",
"readline/promises",
"stream/consumers",
"stream/promises",
"stream/web",
"timers/promises",
"util/types",
"wasi"
]);
const prefixedBuiltins = /* @__PURE__ */ new Set(["node:test", "node:sqlite"]);
const NODE_BUILTIN_NAMESPACE = "node:";
function isNodeBuiltin(id) {
if (prefixedBuiltins.has(id)) {
return true;
}
return builtins.has(
id.startsWith(NODE_BUILTIN_NAMESPACE) ? id.slice(NODE_BUILTIN_NAMESPACE.length) : id
);
}
const spyModulePath = resolve$1(distDir, "spy.js");
class VitestMocker {
constructor(executor) {
this.executor = executor;
const context = this.executor.options.context;
if (context) {
this.primitives = vm.runInContext(
"({ Object, Error, Function, RegExp, Symbol, Array, Map })",
context
);
} else {
this.primitives = {
Object,
Error,
Function,
RegExp,
Symbol: globalThis.Symbol,
Array,
Map
};
}
const Symbol2 = this.primitives.Symbol;
this.filterPublicKeys = [
"__esModule",
Symbol2.asyncIterator,
Symbol2.hasInstance,
Symbol2.isConcatSpreadable,
Symbol2.iterator,
Symbol2.match,
Symbol2.matchAll,
Symbol2.replace,
Symbol2.search,
Symbol2.split,
Symbol2.species,
Symbol2.toPrimitive,
Symbol2.toStringTag,
Symbol2.unscopables
];
}
static pendingIds = [];
spyModule;
primitives;
filterPublicKeys;
registries = /* @__PURE__ */ new Map();
mockContext = {
callstack: null
};
get root() {
return this.executor.options.root;
}
get moduleCache() {
return this.executor.moduleCache;
}
get moduleDirectories() {
return this.executor.options.moduleDirectories || [];
}
async initializeSpyModule() {
this.spyModule = await this.executor.executeId(spyModulePath);
}
getMockerRegistry() {
const suite = this.getSuiteFilepath();
if (!this.registries.has(suite)) {
this.registries.set(suite, new MockerRegistry());
}
return this.registries.get(suite);
}
reset() {
this.registries.clear();
}
deleteCachedItem(id) {
const mockId = this.getMockPath(id);
if (this.moduleCache.has(mockId)) {
this.moduleCache.delete(mockId);
}
}
isModuleDirectory(path) {
return this.moduleDirectories.some((dir) => path.includes(dir));
}
getSuiteFilepath() {
return this.executor.state.filepath || "global";
}
createError(message, codeFrame) {
const Error2 = this.primitives.Error;
const error = new Error2(message);
Object.assign(error, { codeFrame });
return error;
}
async resolvePath(rawId, importer) {
let id;
let fsPath;
try {
[id, fsPath] = await this.executor.originalResolveUrl(rawId, importer);
} catch (error) {
if (error.code === "ERR_MODULE_NOT_FOUND") {
const { id: unresolvedId } = error[Symbol.for("vitest.error.not_found.data")];
id = unresolvedId;
fsPath = unresolvedId;
} else {
throw error;
}
}
const external = !isAbsolute$1(fsPath) || this.isModuleDirectory(fsPath) ? rawId : null;
return {
id,
fsPath,
external: external ? this.normalizePath(external) : external
};
}
async resolveMocks() {
if (!VitestMocker.pendingIds.length) {
return;
}
await Promise.all(
VitestMocker.pendingIds.map(async (mock) => {
const { fsPath, external } = await this.resolvePath(
mock.id,
mock.importer
);
if (mock.action === "unmock") {
this.unmockPath(fsPath);
}
if (mock.action === "mock") {
this.mockPath(
mock.id,
fsPath,
external,
mock.type,
mock.factory
);
}
})
);
VitestMocker.pendingIds = [];
}
async callFunctionMock(dep, mock) {
const cached = this.moduleCache.get(dep)?.exports;
if (cached) {
return cached;
}
const exports = await mock.resolve();
const moduleExports = new Proxy(exports, {
get: (target, prop) => {
const val = target[prop];
if (prop === "then") {
if (target instanceof Promise) {
return target.then.bind(target);
}
} else if (!(prop in target)) {
if (this.filterPublicKeys.includes(prop)) {
return void 0;
}
throw this.createError(
`[vitest] No "${String(prop)}" export is defined on the "${mock.raw}" mock. Did you forget to return it from "vi.mock"?
If you need to partially mock a module, you can use "importOriginal" helper inside:
`,
highlight(`vi.mock(import("${mock.raw}"), async (importOriginal) => {
const actual = await importOriginal()
return {
...actual,
// your mocked methods
}
})`)
);
}
return val;
}
});
this.moduleCache.set(dep, { exports: moduleExports });
return moduleExports;
}
// public method to avoid circular dependency
getMockContext() {
return this.mockContext;
}
// path used to store mocked dependencies
getMockPath(dep) {
return `mock:${dep}`;
}
getDependencyMock(id) {
const registry = this.getMockerRegistry();
return registry.get(id);
}
normalizePath(path) {
return this.moduleCache.normalizePath(path);
}
resolveMockPath(mockPath, external) {
return findMockRedirect(this.root, mockPath, external);
}
mockObject(object, mockExports = {}, behavior = "automock") {
const spyOn = this.spyModule?.spyOn;
if (!spyOn) {
throw this.createError(
"[vitest] `spyModule` is not defined. This is a Vitest error. Please open a new issue with reproduction."
);
}
return mockObject({
globalConstructors: this.primitives,
spyOn,
type: behavior
}, object, mockExports);
}
unmockPath(path) {
const registry = this.getMockerRegistry();
const id = this.normalizePath(path);
registry.delete(id);
this.deleteCachedItem(id);
}
mockPath(originalId, path, external, mockType, factory) {
const registry = this.getMockerRegistry();
const id = this.normalizePath(path);
if (mockType === "manual") {
registry.register("manual", originalId, id, factory);
} else if (mockType === "autospy") {
registry.register("autospy", originalId, id);
} else {
const redirect = this.resolveMockPath(id, external);
if (redirect) {
registry.register("redirect", originalId, id, redirect);
} else {
registry.register("automock", originalId, id);
}
}
this.deleteCachedItem(id);
}
async importActual(rawId, importer, callstack) {
const { id, fsPath } = await this.resolvePath(rawId, importer);
const result = await this.executor.cachedRequest(
id,
fsPath,
callstack || [importer]
);
return result;
}
async importMock(rawId, importee) {
const { id, fsPath, external } = await this.resolvePath(rawId, importee);
const normalizedId = this.normalizePath(fsPath);
let mock = this.getDependencyMock(normalizedId);
if (!mock) {
const redirect = this.resolveMockPath(normalizedId, external);
if (redirect) {
mock = new RedirectedModule(rawId, normalizedId, redirect);
} else {
mock = new AutomockedModule(rawId, normalizedId);
}
}
if (mock.type === "automock" || mock.type === "autospy") {
const mod = await this.executor.cachedRequest(id, fsPath, [importee]);
return this.mockObject(mod, {}, mock.type);
}
if (mock.type === "manual") {
return this.callFunctionMock(fsPath, mock);
}
return this.executor.dependencyRequest(mock.redirect, mock.redirect, [importee]);
}
async requestWithMock(url, callstack) {
const id = this.normalizePath(url);
const mock = this.getDependencyMock(id);
if (!mock) {
return;
}
const mockPath = this.getMockPath(id);
if (mock.type === "automock" || mock.type === "autospy") {
const cache = this.moduleCache.get(mockPath);
if (cache.exports) {
return cache.exports;
}
const exports = {};
this.moduleCache.set(mockPath, { exports });
const mod = await this.executor.directRequest(url, url, callstack);
this.mockObject(mod, exports, mock.type);
return exports;
}
if (mock.type === "manual" && !callstack.includes(mockPath) && !callstack.includes(url)) {
try {
callstack.push(mockPath);
this.mockContext.callstack = callstack;
return await this.callFunctionMock(mockPath, mock);
} finally {
this.mockContext.callstack = null;
const indexMock = callstack.indexOf(mockPath);
callstack.splice(indexMock, 1);
}
} else if (mock.type === "redirect" && !callstack.includes(mock.redirect)) {
return mock.redirect;
}
}
queueMock(id, importer, factoryOrOptions) {
const mockType = getMockType(factoryOrOptions);
VitestMocker.pendingIds.push({
action: "mock",
id,
importer,
factory: typeof factoryOrOptions === "function" ? factoryOrOptions : void 0,
type: mockType
});
}
queueUnmock(id, importer) {
VitestMocker.pendingIds.push({
action: "unmock",
id,
importer
});
}
}
function getMockType(factoryOrOptions) {
if (!factoryOrOptions) {
return "automock";
}
if (typeof factoryOrOptions === "function") {
return "manual";
}
return factoryOrOptions.spy ? "autospy" : "automock";
}
const normalizedDistDir = normalize$1(distDir);
const { readFileSync } = fs;
async function createVitestExecutor(options) {
const runner = new VitestExecutor(options);
await runner.executeId("/@vite/env");
await runner.mocker.initializeSpyModule();
return runner;
}
const externalizeMap = /* @__PURE__ */ new Map();
const bareVitestRegexp = /^@?vitest(?:\/|$)/;
const dispose = [];
function listenForErrors(state) {
dispose.forEach((fn) => fn());
dispose.length = 0;
function catchError(err, type, event) {
const worker = state();
if (worker.current) {
const listeners = process.listeners(event);
if (listeners.length > 1) {
return;
}
}
const error = processError(err);
if (!isPrimitive(error)) {
error.VITEST_TEST_NAME = worker.current?.name;
if (worker.filepath) {
error.VITEST_TEST_PATH = relative(state().config.root, worker.filepath);
}
error.VITEST_AFTER_ENV_TEARDOWN = worker.environmentTeardownRun;
}
state().rpc.onUnhandledError(error, type);
}
const uncaughtException = (e) => catchError(e, "Uncaught Exception", "uncaughtException");
const unhandledRejection = (e) => catchError(e, "Unhandled Rejection", "unhandledRejection");
process.on("uncaughtException", uncaughtException);
process.on("unhandledRejection", unhandledRejection);
dispose.push(() => {
process.off("uncaughtException", uncaughtException);
process.off("unhandledRejection", unhandledRejection);
});
}
async function startVitestExecutor(options) {
const state = () => (
// @ts-expect-error injected untyped global
globalThis.__vitest_worker__ || options.state
);
const rpc = () => state().rpc;
process.exit = (code = process.exitCode || 0) => {
throw new Error(`process.exit unexpectedly called with "${code}"`);
};
listenForErrors(state);
const getTransformMode = () => {
return state().environment.transformMode ?? "ssr";
};
return await createVitestExecutor({
async fetchModule(id) {
if (externalizeMap.has(id)) {
return { externalize: externalizeMap.get(id) };
}
if (id.includes(distDir) || id.includes(normalizedDistDir)) {
const { path } = toFilePath(id, state().config.root);
const externalize = pathToFileURL(path).toString();
externalizeMap.set(id, externalize);
return { externalize };
}
if (bareVitestRegexp.test(id)) {
externalizeMap.set(id, id);
return { externalize: id };
}
const result = await rpc().fetch(id, getTransformMode());
if (result.id && !result.externalize) {
const code = readFileSync(result.id, "utf-8");
return { code };
}
return result;
},
resolveId(id, importer) {
return rpc().resolveId(id, importer, getTransformMode());
},
get moduleCache() {
return state().moduleCache;
},
get interopDefault() {
return state().config.deps.interopDefault;
},
get moduleDirectories() {
return state().config.deps.moduleDirectories;
},
get root() {
return state().config.root;
},
get base() {
return state().config.base;
},
...options
});
}
function updateStyle(id, css) {
if (typeof document === "undefined") {
return;
}
const element = document.querySelector(`[data-vite-dev-id="${id}"]`);
if (element) {
element.textContent = css;
return;
}
const head = document.querySelector("head");
const style = document.createElement("style");
style.setAttribute("type", "text/css");
style.setAttribute("data-vite-dev-id", id);
style.textContent = css;
head?.appendChild(style);
}
function removeStyle(id) {
if (typeof document === "undefined") {
return;
}
const sheet = document.querySelector(`[data-vite-dev-id="${id}"]`);
if (sheet) {
document.head.removeChild(sheet);
}
}
function getDefaultRequestStubs(context) {
if (!context) {
const clientStub2 = {
...DEFAULT_REQUEST_STUBS["@vite/client"],
updateStyle,
removeStyle
};
return {
"/@vite/client": clientStub2,
"@vite/client": clientStub2
};
}
const clientStub = vm.runInContext(
`(defaultClient) => ({ ...defaultClient, updateStyle: ${updateStyle.toString()}, removeStyle: ${removeStyle.toString()} })`,
context
)(DEFAULT_REQUEST_STUBS["@vite/client"]);
return {
"/@vite/client": clientStub,
"@vite/client": clientStub
};
}
class VitestExecutor extends ViteNodeRunner {
constructor(options) {
super({
...options,
// interop is done inside the external executor instead
interopDefault: options.context ? false : options.interopDefault
});
this.options = options;
this.mocker = new VitestMocker(this);
if (!options.context) {
Object.defineProperty(globalThis, "__vitest_mocker__", {
value: this.mocker,
writable: true,
configurable: true
});
this.primitives = { Object, Reflect, Symbol };
} else if (options.externalModulesExecutor) {
this.primitives = vm.runInContext(
"({ Object, Reflect, Symbol })",
options.context
);
this.externalModules = options.externalModulesExecutor;
} else {
throw new Error(
"When context is provided, externalModulesExecutor must be provided as well."
);
}
}
mocker;
externalModules;
primitives;
getContextPrimitives() {
return this.primitives;
}
get state() {
return globalThis.__vitest_worker__ || this.options.state;
}
shouldResolveId(id, _importee) {
if (isInternalRequest(id) || id.startsWith("data:")) {
return false;
}
const transformMode = this.state.environment?.transformMode ?? "ssr";
return transformMode === "ssr" ? !isNodeBuiltin$1(id) : !id.startsWith("node:");
}
async originalResolveUrl(id, importer) {
return super.resolveUrl(id, importer);
}
async resolveUrl(id, importer) {
if (VitestMocker.pendingIds.length) {
await this.mocker.resolveMocks();
}
if (importer && importer.startsWith("mock:")) {
importer = importer.slice(5);
}
try {
return await super.resolveUrl(id, importer);
} catch (error) {
if (error.code === "ERR_MODULE_NOT_FOUND") {
const { id: id2 } = error[Symbol.for("vitest.error.not_found.data")];
const path = this.mocker.normalizePath(id2);
const mock = this.mocker.getDependencyMock(path);
if (mock !== void 0) {
return [id2, id2];
}
}
throw error;
}
}
async runModule(context, transformed) {
const vmContext = this.options.context;
if (!vmContext || !this.externalModules) {
return super.runModule(context, transformed);
}
const codeDefinition = `'use strict';async (${Object.keys(context).join(
","
)})=>{{`;
const code = `${codeDefinition}${transformed}
}}`;
const options = {
filename: context.__filename,
lineOffset: 0,
columnOffset: -codeDefinition.length
};
const fn = vm.runInContext(code, vmContext, {
...options,
// if we encountered an import, it's not inlined
importModuleDynamically: this.externalModules.importModuleDynamically
});
await fn(...Object.values(context));
}
async importExternalModule(path) {
if (this.externalModules) {
return this.externalModules.import(path);
}
return super.importExternalModule(path);
}
async dependencyRequest(id, fsPath, callstack) {
const mocked = await this.mocker.requestWithMock(fsPath, callstack);
if (typeof mocked === "string") {
return super.dependencyRequest(mocked, mocked, callstack);
}
if (mocked && typeof mocked === "object") {
return mocked;
}
return super.dependencyRequest(id, fsPath, callstack);
}
prepareContext(context) {
if (this.state.filepath && normalize$1(this.state.filepath) === normalize$1(context.__filename)) {
const globalNamespace = this.options.context || globalThis;
Object.defineProperty(context.__vite_ssr_import_meta__, "vitest", {
// @ts-expect-error injected untyped global
get: () => globalNamespace.__vitest_index__
});
}
if (this.options.context && this.externalModules) {
context.require = this.externalModules.createRequire(context.__filename);
}
return context;
}
}
export { VitestExecutor as V, getDefaultRequestStubs as g, startVitestExecutor as s };