@nuxt/test-utils 3.21.0 → 3.23.0

package/dist/module.mjs

@@ -1,22 +1,23 @@
-import { pathToFileURL } from 'node:url';
-import { resolveIgnorePatterns, defineNuxtModule, createResolver, resolvePath, importModule, logger } from '@nuxt/kit';
-import { getPort } from 'get-port-please';
-import { h } from 'vue';
-import { debounce } from 'perfect-debounce';
-import { isCI } from 'std-env';
-import { defu } from 'defu';
-import { extname, join, dirname, relative } from 'pathe';
-import { getVitestConfigFromNuxt } from './config.mjs';
+import { resolveIgnorePatterns, logger, useNuxt, addDevServerHandler, defineNuxtModule, createResolver, resolvePath } from '@nuxt/kit';
+import { extname, join, dirname, relative, resolve } from 'pathe';
+import { isCI, hasTTY, provider } from 'std-env';
 import { walk } from 'estree-walker';
 import MagicString from 'magic-string';
 import { createUnplugin } from 'unplugin';
-import { l as loadKit } from './shared/test-utils.G1ew4kEe.mjs';
-import { readFileSync } from 'node:fs';
-import 'node:process';
-import 'vite';
-import 'c12';
+import { l as loadKit } from './shared/test-utils.BIY9XRkB.mjs';
+import { readFileSync, existsSync, promises } from 'node:fs';
+import process$1 from 'node:process';
+import { intro, multiselect, isCancel, cancel, select, confirm, outro } from '@clack/prompts';
+import { colors } from 'consola/utils';
+import { detectPackageManager, addDependency } from 'nypm';
+import { h } from 'vue';
+import { debounce } from 'perfect-debounce';
+import { fork } from 'node:child_process';
+import { c as createVitestTestSummary, l as listenCliMessages, s as sendMessageToCli } from './shared/test-utils.DDUpsMYL.mjs';
+import { distDir } from '#dirs';
 import 'destr';
 import 'scule';
+import 'node:url';
 import 'exsolve';
 
 const PLUGIN_NAME$1 = "nuxt:vitest:mock-transform";
@@ -81,7 +82,6 @@ const createMockPlugin = (ctx) => createUnplugin(() => {
           }
           const importItem = ctx.imports.find((_) => name === (_.as || _.name));
           if (!importItem) {
-            console.log({ imports: ctx.imports });
             return this.error(`Cannot find import "${name}" to mock`);
           }
           s.overwrite(
@@ -297,178 +297,751 @@ async function setupImportMocking(nuxt) {
 
 const PLUGIN_NAME = "nuxt:vitest:nuxt-root-stub";
 const STUB_ID = "nuxt-vitest-app-entry";
-const NuxtRootStubPlugin = createUnplugin((options) => {
-  const STUB_ID_WITH_EXT = STUB_ID + extname(options.entry);
+const NuxtRootStubPlugin = (options) => {
+  const extension = extname(options.entry);
+  const escapedExt = extension.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const entryPath = join(dirname(options.entry), STUB_ID + extension);
+  const idFilter = new RegExp(`${STUB_ID}(?:${escapedExt})?$`);
   return {
     name: PLUGIN_NAME,
     enforce: "pre",
-    vite: {
-      async resolveId(id, importer) {
-        if (id.endsWith(STUB_ID) || id.endsWith(STUB_ID_WITH_EXT)) {
-          return importer?.endsWith("index.html") ? id : join(dirname(options.entry), STUB_ID_WITH_EXT);
+    resolveId: {
+      filter: {
+        id: idFilter
+      },
+      async handler(id, importer) {
+        return importer?.endsWith("index.html") ? id : entryPath;
+      }
+    },
+    load: {
+      filter: {
+        id: idFilter
+      },
+      async handler() {
+        const entryContents = readFileSync(options.entry, "utf-8");
+        return entryContents.replace("#build/root-component.mjs", options.rootStubPath);
+      }
+    }
+  };
+};
+
+function generateVitestConfig(answers) {
+  let config = `import { fileURLToPath } from 'node:url'
+import { defineConfig } from 'vitest/config'
+import { defineVitestProject } from '@nuxt/test-utils/config'`;
+  if (answers.browserMode) {
+    config += `
+import { playwright } from '@vitest/browser-playwright'`;
+  }
+  config += `
+
+export default defineConfig({
+`;
+  config += `  test: {
+    projects: [
+`;
+  if (answers.testingScope.includes("unit")) {
+    config += `      {
+        test: {
+          name: 'unit',
+          include: ['test/unit/*.{test,spec}.ts'],
+          environment: 'node',
+        },
+      },
+`;
+  }
+  config += `      await defineVitestProject({
+        test: {
+          name: 'nuxt',
+          include: ['test/nuxt/*.{test,spec}.ts'],
+          environment: 'nuxt',
+          environmentOptions: {
+            nuxt: {
+              rootDir: fileURLToPath(new URL('.', import.meta.url)),${answers.browserMode ? "" : `
+              domEnvironment: '${answers.domEnvironment || "happy-dom"}',`}
+            },
+          },${answers.browserMode ? `
+          browser: {
+            enabled: true,
+            provider: playwright(),
+            instances: [
+              { browser: 'chromium' },
+            ],
+          },` : ""}
+        },
+      }),
+`;
+  if (answers.testingScope.includes("e2e") && answers.e2eRunner === "vitest") {
+    config += `      {
+        test: {
+          name: 'e2e',
+          include: ['test/e2e/*.{test,spec}.ts'],
+          environment: 'node',
+        },
+      },
+`;
+  }
+  config += `    ],
+`;
+  if (answers.coverage) {
+    config += `    coverage: {
+      enabled: true,
+      provider: 'v8',
+    },
+`;
+  }
+  config += `  },
+`;
+  config += `})
+`;
+  return config;
+}
+function generatePlaywrightConfig() {
+  return `import { fileURLToPath } from 'node:url'
+import { defineConfig, devices } from '@playwright/test'
+import type { ConfigOptions } from '@nuxt/test-utils/playwright'
+
+export default defineConfig<ConfigOptions>({
+  testDir: './tests',
+  fullyParallel: true,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: process.env.CI ? 1 : undefined,
+  reporter: 'html',
+  use: {
+    trace: 'on-first-retry',
+    nuxt: {
+      rootDir: fileURLToPath(new URL('.', import.meta.url)),
+    },
+  },
+  projects: [
+    {
+      name: 'chromium',
+      use: { ...devices['Desktop Chrome'] },
+    },
+  ],
+})
+`;
+}
+function getDependencies(answers) {
+  const dependencies = [];
+  if (answers.testingScope.includes("unit") || answers.testingScope.includes("runtime")) {
+    dependencies.push("vitest", "@vue/test-utils");
+    if (answers.domEnvironment) {
+      dependencies.push(answers.domEnvironment);
+    }
+    if (answers.browserMode) {
+      dependencies.push("@vitest/browser-playwright");
+    }
+  }
+  if (answers.e2eRunner === "playwright") {
+    dependencies.push("@playwright/test", "playwright-core");
+  } else if (answers.e2eRunner === "cucumber") {
+    dependencies.push("@cucumber/cucumber");
+  } else if (answers.e2eRunner === "jest") {
+    dependencies.push("@jest/globals");
+  }
+  if (answers.coverage) {
+    dependencies.push("@vitest/coverage-v8");
+  }
+  return dependencies;
+}
+function getPackageScripts(answers) {
+  const scripts = {};
+  if (answers.testingScope.includes("unit") || answers.testingScope.includes("runtime")) {
+    scripts.test = "vitest";
+    scripts["test:watch"] = "vitest --watch";
+    if (answers.coverage) {
+      scripts["test:coverage"] = "vitest --coverage";
+    }
+    if (answers.testingScope.includes("unit")) {
+      scripts["test:unit"] = "vitest --project unit";
+    }
+    scripts["test:nuxt"] = "vitest --project nuxt";
+    if (answers.testingScope.includes("e2e") && answers.e2eRunner === "vitest") {
+      scripts["test:e2e"] = "vitest --project e2e";
+    }
+  }
+  if (answers.e2eRunner === "playwright") {
+    scripts["test:e2e"] = "playwright test";
+    scripts["test:e2e:ui"] = "playwright test --ui";
+  }
+  return scripts;
+}
+async function runInstallWizard(nuxt) {
+  if (isCI || !hasTTY || nuxt.options.test) {
+    return;
+  }
+  if (nuxt.options.workspaceDir && nuxt.options.workspaceDir !== nuxt.options.rootDir) {
+    logger.info("Monorepo detected. Skipping setup wizard.");
+    return;
+  }
+  const rootDir = nuxt.options.rootDir;
+  const hasVitestConfig = existsSync(join(rootDir, "vitest.config.ts")) || existsSync(join(rootDir, "vitest.config.js")) || existsSync(join(rootDir, "vitest.config.mts")) || existsSync(join(rootDir, "vitest.config.mjs"));
+  const hasPlaywrightConfig = existsSync(join(rootDir, "playwright.config.ts")) || existsSync(join(rootDir, "playwright.config.js"));
+  if (hasVitestConfig || hasPlaywrightConfig) {
+    logger.info("Test configuration already exists. Skipping setup wizard.");
+    return;
+  }
+  intro(colors.bold(colors.cyan("\u{1F9EA} Nuxt Test Utils Setup")));
+  const answers = {};
+  const testingScope = await multiselect({
+    message: "What kind of tests will you need?",
+    options: [
+      {
+        value: "runtime",
+        label: "Runtime",
+        hint: "components or composables running in a Nuxt runtime environment"
+      },
+      {
+        value: "unit",
+        label: "Unit tests",
+        hint: "pure functions or build-time/Node tests"
+      },
+      {
+        value: "e2e",
+        label: "End-to-end",
+        hint: "full application flows in browser"
+      }
+    ],
+    required: true
+  });
+  if (isCancel(testingScope)) {
+    cancel("Setup cancelled.");
+    process$1.exit(0);
+  }
+  answers.testingScope = testingScope;
+  const needsVitest = answers.testingScope.includes("unit") || answers.testingScope.includes("runtime");
+  const needsE2E = answers.testingScope.includes("e2e");
+  if (answers.testingScope.includes("runtime")) {
+    const domEnvironment = await select({
+      message: "Which Vitest environment would you like to use for runtime tests?",
+      options: [
+        {
+          value: "happy-dom",
+          label: "happy-dom",
+          hint: "recommended - faster, lighter"
+        },
+        {
+          value: "jsdom",
+          label: "jsdom",
+          hint: "more complete browser simulation"
+        },
+        {
+          value: "browser",
+          label: "browser mode",
+          hint: "real browser with Playwright"
+        }
+      ],
+      initialValue: "happy-dom"
+    });
+    if (isCancel(domEnvironment)) {
+      cancel("Setup cancelled.");
+      process$1.exit(0);
+    }
+    if (domEnvironment === "browser") {
+      answers.browserMode = true;
+    } else {
+      answers.domEnvironment = domEnvironment;
+    }
+  }
+  if (needsE2E) {
+    const e2eRunner = await select({
+      message: "Which end-to-end test runner would you like to use?",
+      options: [
+        {
+          value: "playwright",
+          label: "Playwright",
+          hint: "recommended - modern, multi-browser"
+        },
+        {
+          value: "vitest",
+          label: "Vitest",
+          hint: "same runner as unit tests"
+        },
+        {
+          value: "cucumber",
+          label: "Cucumber",
+          hint: "behavior-driven development"
+        },
+        {
+          value: "jest",
+          label: "Jest",
+          hint: "legacy test runner"
         }
+      ],
+      initialValue: "playwright"
+    });
+    if (isCancel(e2eRunner)) {
+      cancel("Setup cancelled.");
+      process$1.exit(0);
+    }
+    answers.e2eRunner = e2eRunner;
+  }
+  if (needsVitest) {
+    const coverage = await confirm({
+      message: "Would you like to set up test coverage?",
+      initialValue: false
+    });
+    if (isCancel(coverage)) {
+      cancel("Setup cancelled.");
+      process$1.exit(0);
+    }
+    answers.coverage = coverage;
+  }
+  const exampleTests = await confirm({
+    message: "Create example test files?",
+    initialValue: true
+  });
+  if (isCancel(exampleTests)) {
+    cancel("Setup cancelled.");
+    process$1.exit(0);
+  }
+  answers.exampleTests = exampleTests;
+  await performSetup(nuxt, answers);
+  outro(colors.green("\u2728 Test setup complete!"));
+}
+async function performSetup(nuxt, answers) {
+  const rootDir = nuxt.options.rootDir;
+  const packageManager = await detectPackageManager(rootDir);
+  logger.info("Installing dependencies...");
+  const dependencies = getDependencies(answers);
+  if (dependencies.length > 0) {
+    try {
+      await addDependency(dependencies, {
+        cwd: rootDir,
+        dev: true,
+        packageManager
+      });
+    } catch (error) {
+      logger.error("Failed to install dependencies:", error);
+      return;
+    }
+  }
+  if (answers.testingScope.includes("unit") || answers.testingScope.includes("runtime")) {
+    await createVitestConfig(nuxt, answers);
+  }
+  if (answers.e2eRunner === "playwright") {
+    await createPlaywrightConfig(nuxt);
+  }
+  await createTestDirectories(nuxt, answers);
+  if (answers.exampleTests) {
+    await createExampleTests(nuxt, answers);
+  }
+  await updatePackageScripts(nuxt, answers);
+  await updateGitignore(nuxt, answers);
+}
+async function createVitestConfig(nuxt, answers) {
+  const rootDir = nuxt.options.rootDir;
+  const configPath = join(rootDir, "vitest.config.ts");
+  const config = generateVitestConfig(answers);
+  await promises.writeFile(configPath, config, "utf-8");
+  logger.success(`Created ${colors.cyan(relative(process$1.cwd(), configPath))}`);
+}
+async function createPlaywrightConfig(nuxt) {
+  const rootDir = nuxt.options.rootDir;
+  const configPath = join(rootDir, "playwright.config.ts");
+  const config = generatePlaywrightConfig();
+  await promises.writeFile(configPath, config, "utf-8");
+  logger.success(`Created ${colors.cyan(relative(process$1.cwd(), configPath))}`);
+}
+async function createTestDirectories(nuxt, answers) {
+  const rootDir = nuxt.options.rootDir;
+  if (answers.testingScope.includes("unit")) {
+    const unitDir = join(rootDir, "test/unit");
+    await promises.mkdir(unitDir, { recursive: true });
+    logger.success(`Created ${colors.cyan(relative(process$1.cwd(), unitDir))}`);
+  }
+  if (answers.testingScope.includes("runtime")) {
+    const nuxtDir = join(rootDir, "test/nuxt");
+    await promises.mkdir(nuxtDir, { recursive: true });
+    logger.success(`Created ${colors.cyan(relative(process$1.cwd(), nuxtDir))}`);
+  }
+  if (answers.testingScope.includes("e2e")) {
+    const e2eDir = answers.e2eRunner === "playwright" ? join(rootDir, "tests") : join(rootDir, "test/e2e");
+    await promises.mkdir(e2eDir, { recursive: true });
+    logger.success(`Created ${colors.cyan(relative(process$1.cwd(), e2eDir))}`);
+  }
+}
+async function createExampleTests(nuxt, answers) {
+  const rootDir = nuxt.options.rootDir;
+  if (answers.testingScope.includes("unit")) {
+    const unitTestPath = join(rootDir, "test/unit/example.test.ts");
+    const unitTest = `import { describe, expect, it } from 'vitest'
+
+describe('example unit test', () => {
+  it('should pass', () => {
+    expect(1 + 1).toBe(2)
+  })
+})
+`;
+    await promises.writeFile(unitTestPath, unitTest, "utf-8");
+    logger.success(`Created ${colors.cyan(relative(process$1.cwd(), unitTestPath))}`);
+  }
+  if (answers.testingScope.includes("runtime")) {
+    const componentTestPath = join(rootDir, "test/nuxt/component.test.ts");
+    const componentTest = `import { describe, expect, it } from 'vitest'
+import { mountSuspended } from '@nuxt/test-utils/runtime'
+import { defineComponent, h } from 'vue'
+
+describe('component test example', () => {
+  it('can mount components', async () => {
+    const TestComponent = defineComponent({
+      setup() {
+        return () => h('div', 'Hello Nuxt!')
       },
-      async load(id) {
-        if (id.endsWith(STUB_ID) || id.endsWith(STUB_ID_WITH_EXT)) {
-          const entryContents = readFileSync(options.entry, "utf-8");
-          return entryContents.replace("#build/root-component.mjs", options.rootStubPath);
+    })
+    
+    const component = await mountSuspended(TestComponent)
+    
+    expect(component.text()).toBe('Hello Nuxt!')
+  })
+})
+`;
+    await promises.writeFile(componentTestPath, componentTest, "utf-8");
+    logger.success(`Created ${colors.cyan(relative(process$1.cwd(), componentTestPath))}`);
+  }
+  if (answers.testingScope.includes("e2e")) {
+    if (answers.e2eRunner === "playwright") {
+      const e2eTestPath = join(rootDir, "tests/example.spec.ts");
+      const e2eTest = `import { expect, test } from '@nuxt/test-utils/playwright'
+
+test('example e2e test', async ({ page, goto }) => {
+  await goto('/', { waitUntil: 'hydration' })
+  await expect(page).toHaveTitle(/Nuxt/)
+})
+`;
+      await promises.writeFile(e2eTestPath, e2eTest, "utf-8");
+      logger.success(`Created ${colors.cyan(relative(process$1.cwd(), e2eTestPath))}`);
+    } else {
+      const e2eTestPath = join(rootDir, "test/e2e/example.test.ts");
+      const e2eTest = `import { describe, expect, it } from 'vitest'
+import { $fetch, setup } from '@nuxt/test-utils/e2e'
+
+describe('example e2e test', async () => {
+  await setup()
+
+  it('renders the index page', async () => {
+    const html = await $fetch('/')
+    expect(html).toContain('Nuxt')
+  })
+})
+`;
+      await promises.writeFile(e2eTestPath, e2eTest, "utf-8");
+      logger.success(`Created ${colors.cyan(relative(process$1.cwd(), e2eTestPath))}`);
+    }
+  }
+}
+async function updatePackageScripts(nuxt, answers) {
+  const rootDir = nuxt.options.rootDir;
+  const packageJsonPath = join(rootDir, "package.json");
+  const packageJson = JSON.parse(await promises.readFile(packageJsonPath, "utf-8"));
+  packageJson.scripts = packageJson.scripts || {};
+  const newScripts = getPackageScripts(answers);
+  Object.assign(packageJson.scripts, newScripts);
+  await promises.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
+  logger.success("Updated package.json scripts");
+}
+async function updateGitignore(nuxt, answers) {
+  const rootDir = nuxt.options.rootDir;
+  const gitignorePath = join(rootDir, ".gitignore");
+  let gitignore = "";
+  if (existsSync(gitignorePath)) {
+    gitignore = await promises.readFile(gitignorePath, "utf-8");
+  }
+  const lines = [];
+  if (answers.coverage && !gitignore.includes("coverage")) {
+    lines.push("# Test coverage", "coverage/", "");
+  }
+  if (answers.e2eRunner === "playwright") {
+    if (!gitignore.includes("playwright-report")) {
+      lines.push("# Playwright", "playwright-report/", "test-results/", "");
+    }
+  }
+  if (lines.length > 0) {
+    gitignore += "\n" + lines.join("\n");
+    await promises.writeFile(gitignorePath, gitignore, "utf-8");
+    logger.success("Updated .gitignore");
+  }
+}
+
+async function setupDevTools(vitestWrapper, nuxt = useNuxt()) {
+  const iframeSrc = "/__test_utils_vitest__/";
+  const updateTabs = debounce(() => {
+    nuxt.callHook("devtools:customTabs:refresh");
+  }, 100);
+  nuxt.hook("devtools:customTabs", (tabs) => {
+    const tab = createVitestCustomTab(vitestWrapper, { iframeSrc });
+    const index = tabs.findIndex(({ name }) => tab.name === name);
+    if (index === -1) {
+      tabs.push(tab);
+    } else {
+      tabs.splice(index, 1, tab);
+    }
+  });
+  addDevServerHandler({
+    route: iframeSrc,
+    handler: Object.assign(() => iframeContentHtml(vitestWrapper.uiUrl), { __is_handler__: true })
+  });
+  vitestWrapper.ons({
+    started() {
+      updateTabs();
+    },
+    updated() {
+      updateTabs();
+    },
+    finished() {
+      updateTabs();
+    },
+    exited() {
+      updateTabs();
+    }
+  });
+}
+function createVitestCustomTab(vitest, { iframeSrc }) {
+  const launchView = {
+    type: "launch",
+    description: "Start tests along with Nuxt",
+    actions: [
+      {
+        get label() {
+          switch (vitest.status) {
+            case "starting":
+              return "Starting...";
+            case "running":
+              return "Running Vitest";
+            case "stopped":
+              return "Start Vitest";
+            case "finished":
+              return "Start Vitest";
+          }
+        },
+        get pending() {
+          return vitest.status === "starting" || vitest.status === "running";
+        },
+        handle: () => {
+          vitest.start();
         }
       }
+    ]
+  };
+  const uiView = {
+    type: "iframe",
+    persistent: false,
+    src: iframeSrc
+  };
+  const tab = {
+    title: "Vitest",
+    name: "vitest",
+    icon: "logos-vitest",
+    get view() {
+      if (vitest.status === "stopped" || vitest.status === "starting" || !vitest.uiUrl) {
+        return launchView;
+      } else {
+        return uiView;
+      }
+    },
+    extraTabVNode: vitest.testSummary.totalCount ? h("div", { style: { color: vitest.testSummary.failedCount ? "orange" : "green" } }, [
+      h("span", {}, vitest.testSummary.passedCount),
+      h("span", { style: { opacity: "0.5", fontSize: "0.9em" } }, "/"),
+      h(
+        "span",
+        { style: { opacity: "0.8", fontSize: "0.9em" } },
+        vitest.testSummary.totalCount
+      )
+    ]) : void 0
+  };
+  return tab;
+}
+function iframeContentHtml(uiUrl) {
+  return [
+    "<html><head><script>",
+    `(${function redirect(uiUrl2, provider2) {
+      if (typeof window === "undefined") return;
+      if (!uiUrl2) return;
+      if (provider2 === "stackblitz") {
+        const url = new URL(window.location.href);
+        const newUrl = new URL(uiUrl2);
+        newUrl.host = url.host.replace(/--\d+--/, `--${newUrl.port}--`);
+        newUrl.protocol = url.protocol;
+        newUrl.port = url.port;
+        uiUrl2 = newUrl.toString();
+      }
+      window.location.replace(uiUrl2);
+    }})(${JSON.stringify(uiUrl)}, ${JSON.stringify(provider)})`,
+    "<\/script></head></html>"
+  ].join("\n");
+}
+
+function vitestWrapper(options) {
+  const { cwd, ...startOptions } = options;
+  let _status = "stopped";
+  let _uiUrl;
+  let _process;
+  let _testSummary = createVitestTestSummary();
+  const _handlers = {
+    started: [({ uiUrl }) => {
+      _uiUrl = uiUrl;
+      _status = "running";
+      _testSummary = createVitestTestSummary();
+    }],
+    updated: [(summary) => {
+      _testSummary = summary;
+    }],
+    finished: [(summary) => {
+      _status = "finished";
+      _testSummary = summary;
+    }],
+    exited: [clear]
+  };
+  function clear() {
+    _status = "stopped";
+    _uiUrl = void 0;
+    _process = void 0;
+    _testSummary = createVitestTestSummary();
+  }
+  function on(name, handler) {
+    _handlers[name] ??= [];
+    _handlers[name]?.push(handler);
+  }
+  function ons(handlers) {
+    for (const [name, handler] of Object.entries(handlers)) {
+      if (typeof handler === "function") {
+        on(name, handler);
+      }
+    }
+  }
+  async function stop() {
+    const vitest = _process;
+    if (!vitest || vitest.exitCode !== null) return;
+    return new Promise((resolve2) => {
+      vitest.once("exit", () => resolve2());
+      sendMessageToCli(vitest, "stop", { force: true });
+    });
+  }
+  async function start() {
+    if (_process) return false;
+    const vitest = fork(resolve(distDir, "./vitest-wrapper/cli.mjs"), {
+      cwd,
+      env: {
+        ...process.env,
+        NODE_ENV: "test",
+        MODE: "test"
+      },
+      stdio: startOptions.logToConsole ? void 0 : ["ignore", "ignore", "inherit", "ipc"]
+    });
+    _status = "starting";
+    _process = vitest;
+    vitest.once("exit", () => {
+      _handlers.exited.forEach((fn) => fn({ exitCode: vitest.exitCode ?? 0 }));
+    });
+    listenCliMessages(vitest, ({ type, payload }) => {
+      _handlers[type].forEach((fn) => fn(payload));
+    });
+    sendMessageToCli(vitest, "start", startOptions);
+    return true;
+  }
+  return {
+    on,
+    ons,
+    stop,
+    start,
+    get uiUrl() {
+      return _uiUrl;
+    },
+    get options() {
+      return options;
+    },
+    get status() {
+      return _status;
+    },
+    get testSummary() {
+      return { ..._testSummary };
     }
   };
-});
+}
+
+const version = "3.23.0";
+const pkg = {
+	version: version};
 
-const vitePluginBlocklist = ["vite-plugin-vue-inspector", "vite-plugin-vue-inspector:post", "vite-plugin-inspect", "nuxt:type-check"];
 const module$1 = defineNuxtModule({
   meta: {
     name: "@nuxt/test-utils",
-    configKey: "testUtils"
+    configKey: "testUtils",
+    version: pkg.version
   },
   defaults: {
     startOnBoot: false,
     logToConsole: false
   },
+  async onInstall(nuxt) {
+    await runInstallWizard(nuxt);
+  },
   async setup(options, nuxt) {
     if (nuxt.options.test || nuxt.options.dev) {
       await setupImportMocking(nuxt);
     }
     const { addVitePlugin } = await loadKit(nuxt.options.rootDir);
     const resolver = createResolver(import.meta.url);
-    addVitePlugin(NuxtRootStubPlugin.vite({
-      entry: await resolvePath("#app/entry", { alias: nuxt.options.alias }),
-      rootStubPath: await resolvePath(resolver.resolve("./runtime/nuxt-root"))
-    }));
+    if (nuxt.options.test || nuxt.options.dev) {
+      addVitePlugin(NuxtRootStubPlugin({
+        entry: await resolvePath("#app/entry", { alias: nuxt.options.alias }),
+        rootStubPath: await resolvePath(resolver.resolve("./runtime/nuxt-root"))
+      }));
+    }
     if (!nuxt.options.test && !nuxt.options.dev) {
       nuxt.options.vite.define ||= {};
       nuxt.options.vite.define["import.meta.vitest"] = "undefined";
     }
-    nuxt.hook("prepare:types", (ctx2) => {
-      ctx2.references.push({ types: "vitest/import-meta" });
-      if (ctx2.nodeTsConfig) {
-        ctx2.nodeTsConfig.include ||= [];
-        ctx2.nodeTsConfig.include.push(relative(nuxt.options.buildDir, join(nuxt.options.rootDir, "vitest.config.*")));
+    nuxt.hook("prepare:types", (ctx) => {
+      ctx.references.push({ types: "vitest/import-meta" });
+      if (ctx.nodeTsConfig) {
+        ctx.nodeTsConfig.include ||= [];
+        ctx.nodeTsConfig.include.push(relative(nuxt.options.buildDir, join(nuxt.options.rootDir, "vitest.config.*")));
         if (nuxt.options.workspaceDir !== nuxt.options.rootDir) {
-          ctx2.nodeTsConfig.include.push(relative(nuxt.options.buildDir, join(nuxt.options.workspaceDir, "vitest.config.*")));
+          ctx.nodeTsConfig.include.push(relative(nuxt.options.buildDir, join(nuxt.options.workspaceDir, "vitest.config.*")));
         }
       }
     });
     if (!nuxt.options.dev) return;
     if (process.env.TEST || process.env.VITE_TEST) return;
-    const rawViteConfigPromise = new Promise((resolve) => {
-      nuxt.hook("app:resolve", () => {
-        nuxt.hook("vite:configResolved", (config, { isClient }) => {
-          if (isClient) resolve(config);
-        });
-      });
-    });
-    let loaded = false;
-    let promise;
-    let ctx = void 0;
-    let testFiles = null;
-    const updateTabs = debounce(() => {
-      nuxt.callHook("devtools:customTabs:refresh");
-    }, 100);
-    let URL;
-    async function start() {
-      const { mergeConfig } = await importModule("vite", { paths: nuxt.options.modulesDir });
-      const rawViteConfig = mergeConfig({}, await rawViteConfigPromise);
-      const viteConfig = await getVitestConfigFromNuxt({ nuxt, viteConfig: defu({ test: options.vitestConfig }, rawViteConfig) });
-      viteConfig.plugins = (viteConfig.plugins || []).filter((p) => {
-        return !p || !("name" in p) || !vitePluginBlocklist.includes(p.name);
-      });
-      viteConfig.test.environmentMatchGlobs ||= [];
-      viteConfig.test.environmentMatchGlobs.push(
-        ["**/*.nuxt.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}", "nuxt"],
-        ["{test,tests}/nuxt/**.*", "nuxt"]
-      );
-      process.env.__NUXT_VITEST_RESOLVED__ = "true";
-      const { startVitest } = await import(pathToFileURL(await resolvePath("vitest/node")).href);
-      const customReporter = {
-        onInit(_ctx) {
-          ctx = _ctx;
-        },
-        onTaskUpdate() {
-          testFiles = ctx.state.getFiles();
-          updateTabs();
-        },
-        onFinished() {
-          testFiles = ctx.state.getFiles();
-          updateTabs();
-        }
-      };
-      const watchMode = !process.env.NUXT_VITEST_DEV_TEST && !isCI;
-      const PORT = await getPort({ port: 15555 });
-      const PROTOCOL = nuxt.options.devServer.https ? "https" : "http";
-      URL = `${PROTOCOL}://localhost:${PORT}/__vitest__/`;
-      const overrides = watchMode ? {
-        passWithNoTests: true,
-        reporters: options.logToConsole ? [
-          ...toArray(options.vitestConfig?.reporters ?? ["default"]),
-          customReporter
-        ] : [customReporter],
-        // do not report to console
-        watch: true,
-        ui: true,
-        open: false,
-        api: {
-          port: PORT
-        }
-      } : { watch: false };
-      const promise2 = startVitest("test", [], defu(overrides, viteConfig.test), viteConfig);
-      promise2.catch(() => process.exit(1));
-      if (watchMode) {
-        logger.info(`Vitest UI starting on ${URL}`);
-        nuxt.hook("close", () => promise2.then((v) => v?.close()));
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
-      } else {
-        promise2.then((v) => nuxt.close().then(() => v?.close()).then(() => process.exit()));
-      }
-      loaded = true;
-    }
-    nuxt.hook("devtools:customTabs", (tabs) => {
-      const failedCount = testFiles?.filter((f) => f.result?.state === "fail").length ?? 0;
-      const passedCount = testFiles?.filter((f) => f.result?.state === "pass").length ?? 0;
-      const totalCount = testFiles?.length ?? 0;
-      tabs.push({
-        title: "Vitest",
-        name: "vitest",
-        icon: "logos-vitest",
-        view: loaded ? {
-          type: "iframe",
-          src: URL
-        } : {
-          type: "launch",
-          description: "Start tests along with Nuxt",
-          actions: [
-            {
-              label: promise ? "Starting..." : "Start Vitest",
-              pending: !!promise,
-              handle: () => {
-                promise = promise || start();
-                return promise;
-              }
-            }
-          ]
-        },
-        extraTabVNode: totalCount ? h("div", { style: { color: failedCount ? "orange" : "green" } }, [
-          h("span", {}, passedCount),
-          h("span", { style: { opacity: "0.5", fontSize: "0.9em" } }, "/"),
-          h(
-            "span",
-            { style: { opacity: "0.8", fontSize: "0.9em" } },
-            totalCount
-          )
-        ]) : void 0
-      });
+    const vitestWrapper2 = createVitestWrapper(options, nuxt);
+    nuxt.hook("devtools:before", async () => {
+      await setupDevTools(vitestWrapper2, nuxt);
     });
     if (options.startOnBoot) {
-      promise = promise || start();
-      promise.then(updateTabs);
+      vitestWrapper2.start();
     }
   }
 });
-function toArray(value) {
-  return Array.isArray(value) ? value : [value];
+function createVitestWrapper(options, nuxt = useNuxt()) {
+  const watchMode = !isCI;
+  const wrapper = vitestWrapper({
+    cwd: nuxt.options.rootDir,
+    apiPorts: [15555],
+    logToConsole: options.logToConsole ?? false,
+    watchMode
+  });
+  wrapper.ons({
+    started({ uiUrl }) {
+      if (watchMode) {
+        logger.info(`Vitest UI starting on ${uiUrl}`);
+      }
+    },
+    exited({ exitCode }) {
+      if (watchMode) {
+        logger.info(`Vitest exited with code ${exitCode}`);
+      } else {
+        nuxt.close().finally(() => process.exit(exitCode));
+      }
+    }
+  });
+  nuxt.hooks.addHooks({
+    close: () => wrapper.stop(),
+    restart: () => wrapper.stop()
+  });
+  return wrapper;
 }
 
 export { module$1 as default };