@nuxt/test-utils 3.22.0 → 4.0.0

package/dist/module.mjs

@@ -1,16 +1,20 @@
-import { resolveIgnorePatterns, useNuxt, addDevServerHandler, defineNuxtModule, createResolver, resolvePath, logger } from '@nuxt/kit';
-import { extname, join, dirname, resolve, relative } from 'pathe';
-import { provider, isCI } from 'std-env';
+import { resolveIgnorePatterns, logger, addDevServerHandler, useNuxt, defineNuxtModule, createResolver, resolvePath } from '@nuxt/kit';
+import { refreshCustomTabs, addCustomTab, onDevToolsInitialized } from '@nuxt/devtools-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.BIY9XRkB.mjs';
-import { readFileSync } from 'node:fs';
+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 { defineEventHandler } from 'h3';
 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 { l as listenCliMessages, s as sendMessageToCli, c as createVitestTestSummary } from './shared/test-utils.DDUpsMYL.mjs';
 import { distDir } from '#dirs';
 import 'destr';
 import 'scule';
@@ -21,6 +25,7 @@ const PLUGIN_NAME$1 = "nuxt:vitest:mock-transform";
 const HELPER_MOCK_IMPORT = "mockNuxtImport";
 const HELPER_MOCK_COMPONENT = "mockComponent";
 const HELPER_MOCK_HOIST = "__NUXT_VITEST_MOCKS";
+const HELPER_MOCK_HOIST_ORIGINAL = "__NUXT_VITEST_MOCKS_ORIGINAL";
 const HELPERS_NAME = [HELPER_MOCK_IMPORT, HELPER_MOCK_COMPONENT];
 const createMockPlugin = (ctx) => createUnplugin(() => {
   function transform(code, id) {
@@ -79,7 +84,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(
@@ -148,25 +152,23 @@ const createMockPlugin = (ctx) => createUnplugin(() => {
         ...Array.from(mockImportMap.entries()).flatMap(
           ([from, mocks]) => {
             importPathsList.add(from);
+            const quotedFrom = JSON.stringify(from);
+            const mockModuleEntry = `globalThis.${HELPER_MOCK_HOIST}[${quotedFrom}]`;
             const lines = [
-              `vi.mock(${JSON.stringify(from)}, async (importOriginal) => {`,
-              `  const mocks = globalThis.${HELPER_MOCK_HOIST}`,
-              `  if (!mocks[${JSON.stringify(from)}]) {`,
-              `    mocks[${JSON.stringify(from)}] = { ...await importOriginal(${JSON.stringify(from)}) }`,
+              `vi.mock(${quotedFrom}, async (importOriginal) => {`,
+              `  if (!${mockModuleEntry}) {`,
+              `    const original = await importOriginal(${quotedFrom})`,
+              `    ${mockModuleEntry} = { ...original }`,
+              `    ${mockModuleEntry}.${HELPER_MOCK_HOIST_ORIGINAL} = { ...original }`,
               `  }`
             ];
             for (const mock of mocks) {
-              if (mock.import.name === "default") {
-                lines.push(
-                  `  mocks[${JSON.stringify(from)}]["default"] = await (${mock.factory})();`
-                );
-              } else {
-                lines.push(
-                  `  mocks[${JSON.stringify(from)}][${JSON.stringify(mock.name)}] = await (${mock.factory})();`
-                );
-              }
+              const quotedName = JSON.stringify(mock.import.name === "default" ? "default" : mock.name);
+              lines.push(
+                `  ${mockModuleEntry}[${quotedName}] = await (${mock.factory})(${mockModuleEntry}.${HELPER_MOCK_HOIST_ORIGINAL}[${quotedName}]);`
+              );
             }
-            lines.push(`  return mocks[${JSON.stringify(from)}] `);
+            lines.push(`  return ${mockModuleEntry} `);
             lines.push(`});`);
             return lines;
           }
@@ -323,25 +325,455 @@ const NuxtRootStubPlugin = (options) => {
   };
 };
 
+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!')
+      },
+    })
+    
+    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");
+    refreshCustomTabs(nuxt);
   }, 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);
-    }
-  });
+  addCustomTab(() => createVitestCustomTab(vitestWrapper, { iframeSrc }), nuxt);
   addDevServerHandler({
     route: iframeSrc,
-    handler: defineEventHandler(
-      () => iframeContentHtml(vitestWrapper.uiUrl)
-    )
+    handler: Object.assign(() => iframeContentHtml(vitestWrapper.uiUrl), { __is_handler__: true })
   });
   vitestWrapper.ons({
     started() {
@@ -521,15 +953,23 @@ function vitestWrapper(options) {
   };
 }
 
+const version = "4.0.0";
+const pkg = {
+	version: version};
+
 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);
@@ -559,9 +999,9 @@ const module$1 = defineNuxtModule({
     if (!nuxt.options.dev) return;
     if (process.env.TEST || process.env.VITE_TEST) return;
     const vitestWrapper2 = createVitestWrapper(options, nuxt);
-    nuxt.hook("devtools:before", async () => {
+    onDevToolsInitialized(async () => {
       await setupDevTools(vitestWrapper2, nuxt);
-    });
+    }, nuxt);
     if (options.startOnBoot) {
       vitestWrapper2.start();
     }

package/dist/playwright.d.mts

@@ -1,9 +1,10 @@
 import * as _playwright_test from '@playwright/test';
 export { expect } from '@playwright/test';
 import { Response } from 'playwright-core';
-import { T as TestOptions$1, G as GotoOptions, a as TestHooks } from './shared/test-utils.ZByFDqps.mjs';
+import { T as TestOptions$1, G as GotoOptions, a as TestHooks } from './shared/test-utils.BLyxqr96.mjs';
 import '@nuxt/schema';
 import 'tinyexec';
+import 'ofetch';
 
 type ConfigOptions = {
     nuxt: Partial<TestOptions$1> | undefined;

package/dist/playwright.mjs

@@ -1,17 +1,17 @@
 import defu from 'defu';
 import { test as test$1 } from '@playwright/test';
 export { expect } from '@playwright/test';
-import { w as waitForHydration, d as createTest } from './shared/test-utils.D2ZzXztg.mjs';
+import { isWindows } from 'std-env';
+import { w as waitForHydration, d as createTest } from './shared/test-utils.E_cAGA8l.mjs';
 import 'node:path';
 import 'ufo';
-import 'std-env';
 import 'consola';
 import 'node:fs';
 import 'destr';
 import 'scule';
 import 'node:url';
 import 'exsolve';
-import { d as url } from './shared/test-utils.C_clWQBc.mjs';
+import { d as url } from './shared/test-utils.BsmyE2FA.mjs';
 import 'pathe';
 import '#dirs';
 import './shared/test-utils.BIY9XRkB.mjs';
@@ -19,6 +19,7 @@ import 'tinyexec';
 import 'get-port-please';
 import 'ofetch';
 
+const FIXTURE_TIMEOUT = isWindows ? 12e4 : 6e4;
 const test = test$1.extend({
   nuxt: [void 0, { option: true, scope: "worker" }],
   defaults: [{ nuxt: void 0 }, { option: true, scope: "worker" }],
@@ -29,7 +30,7 @@ const test = test$1.extend({
       await use(hooks);
       await hooks.afterAll();
     },
-    { scope: "worker" }
+    { scope: "worker", timeout: FIXTURE_TIMEOUT }
   ],
   baseURL: async ({ _nuxtHooks }, use) => {
     _nuxtHooks.beforeEach();

package/dist/runtime/browser-entry.mjs

@@ -1,8 +1,5 @@
 import environmentOptions from "nuxt-vitest-environment-options";
 import { setupNuxt } from "./shared/nuxt.mjs";
 import { setupWindow } from "./shared/environment.mjs";
-const el = document.querySelector(environmentOptions.nuxt.rootId || "nuxt-test");
-if (!el) {
-  await setupWindow(window, environmentOptions);
-  await setupNuxt();
-}
+await setupWindow(window, environmentOptions);
+await setupNuxt();

package/dist/runtime/entry.mjs

@@ -1,7 +1,8 @@
-import { vi } from "vitest";
+import { beforeAll } from "vitest";
 import { setupNuxt } from "./shared/nuxt.mjs";
 if (typeof window !== "undefined" && window.__NUXT_VITEST_ENVIRONMENT__) {
-  await setupNuxt();
-  vi.resetModules();
+  beforeAll(async () => {
+    await setupNuxt();
+  });
 }
 export {};