@nuxt/test-utils 3.19.2 → 3.21.0

package/dist/config.d.mts

@@ -24,7 +24,7 @@ interface NuxtEnvironmentOptions {
     rootDir?: string;
     /**
      * The starting URL for your Nuxt window environment
-     * @default {http://localhost:3000}
+     * @default 'http://localhost:3000'
      */
     url?: string;
     /**
@@ -37,14 +37,14 @@ interface NuxtEnvironmentOptions {
     overrides?: NuxtConfig;
     /**
      * The id of the root div to which the app should be mounted. You should also set `app.rootId` to the same value.
-     * @default {nuxt-test}
+     * @default 'nuxt-test'
      */
     rootId?: string;
     /**
      * The name of the DOM environment to use.
      *
      * It also needs to be installed as a dev dependency in your project.
-     * @default {happy-dom}
+     * @default 'happy-dom'
      */
     domEnvironment?: 'happy-dom' | 'jsdom';
     mock?: {

package/dist/config.mjs

@@ -1,42 +1,16 @@
-import process$1 from 'node:process';
+import process from 'node:process';
 import { defineConfig } from 'vite';
 import { setupDotenv } from 'c12';
 import { defu } from 'defu';
-import { createResolver, findPath, loadNuxt, buildNuxt } from '@nuxt/kit';
-import destr from 'destr';
-import { snakeCase } from 'scule';
+import { createResolver, findPath } from '@nuxt/kit';
+import { a as applyEnv, l as loadKit } from './shared/test-utils.G1ew4kEe.mjs';
+import 'destr';
+import 'scule';
+import 'node:url';
+import 'exsolve';
 
-function getEnv(key, opts) {
-  const env = opts.env ?? process.env;
-  const envKey = snakeCase(key).toUpperCase();
-  return destr(
-    env[opts.prefix + envKey] ?? env[opts.altPrefix + envKey]
-  );
-}
-function _isObject(input) {
-  return typeof input === "object" && !Array.isArray(input);
-}
-function applyEnv(obj, opts, parentKey = "") {
-  for (const key in obj) {
-    const subKey = parentKey ? `${parentKey}_${key}` : key;
-    const envValue = getEnv(subKey, opts);
-    if (_isObject(obj[key])) {
-      if (_isObject(envValue)) {
-        obj[key] = { ...obj[key], ...envValue };
-        applyEnv(obj[key], opts, subKey);
-      } else if (envValue === void 0) {
-        applyEnv(obj[key], opts, subKey);
-      } else {
-        obj[key] = envValue ?? obj[key];
-      }
-    } else {
-      obj[key] = envValue ?? obj[key];
-    }
-  }
-  return obj;
-}
-
-async function startNuxtAndGetViteConfig(rootDir = process$1.cwd(), options = {}) {
+async function startNuxtAndGetViteConfig(rootDir = process.cwd(), options = {}) {
+  const { buildNuxt, loadNuxt } = await loadKit(rootDir);
   const nuxt = await loadNuxt({
     cwd: rootDir,
     dev: false,
@@ -89,7 +63,7 @@ const excludedPlugins = [
   "vite-plugin-vue-tracer"
 ];
 async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
-  const { rootDir = process$1.cwd(), ..._overrides } = loadNuxtOptions.overrides || {};
+  const { rootDir = process.cwd(), ..._overrides } = loadNuxtOptions.overrides || {};
   if (!options) {
     options = await startNuxtAndGetViteConfig(rootDir, {
       dotenv: loadNuxtOptions.dotenv,
@@ -117,7 +91,7 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
         noDiscovery: true
       },
       test: {
-        dir: process$1.cwd(),
+        dir: process.cwd(),
         environmentOptions: {
           nuxtRuntimeConfig: applyEnv(structuredClone(options.nuxt.options.runtimeConfig), {
             prefix: "NUXT_",
@@ -214,14 +188,14 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
   return resolvedConfig;
 }
 async function defineVitestProject(config) {
-  if (process$1.env.__NUXT_VITEST_RESOLVED__) return config;
+  if (process.env.__NUXT_VITEST_RESOLVED__) return config;
   const resolvedConfig = await resolveConfig(config);
   resolvedConfig.test.environment = "nuxt";
   return resolvedConfig;
 }
 function defineVitestConfig(config = {}) {
   return defineConfig(async () => {
-    if (process$1.env.__NUXT_VITEST_RESOLVED__) return config;
+    if (process.env.__NUXT_VITEST_RESOLVED__) return config;
     const resolvedConfig = await resolveConfig(config);
     if (resolvedConfig.test.browser?.enabled) {
       return resolvedConfig;

package/dist/e2e.d.mts

@@ -1,5 +1,5 @@
-import { T as TestOptions, a as TestContext, b as TestHooks } from './shared/test-utils.DtJCg4f3.mjs';
-export { $ as $fetch, G as GotoOptions, N as NuxtPage, S as StartServerOptions, h as TestRunner, c as createBrowser, d as createPage, f as fetch, g as getBrowser, s as startServer, e as stopServer, u as url, w as waitForHydration } from './shared/test-utils.DtJCg4f3.mjs';
+import { T as TestOptions, a as TestContext, b as TestHooks } from './shared/test-utils.20kU0tZa.mjs';
+export { $ as $fetch, G as GotoOptions, N as NuxtPage, S as StartServerOptions, h as TestRunner, c as createBrowser, d as createPage, f as fetch, g as getBrowser, s as startServer, e as stopServer, u as url, w as waitForHydration } from './shared/test-utils.20kU0tZa.mjs';
 import { LogType } from 'consola';
 import 'playwright-core';
 import '@nuxt/schema';

package/dist/e2e.mjs

@@ -1,13 +1,17 @@
-export { b as buildFixture, c as createBrowser, a as createPage, d as createTest, g as getBrowser, l as loadFixture, e as setup, s as setupMaps, w as waitForHydration } from './shared/test-utils.CT3RJOY3.mjs';
-import { u as useTestContext } from './shared/test-utils.B8qEdk9k.mjs';
-export { $ as $fetch, c as createTestContext, e as exposeContextToEnv, f as fetch, i as isDev, r as recoverContextFromEnv, s as setTestContext, a as startServer, b as stopServer, d as url } from './shared/test-utils.B8qEdk9k.mjs';
+export { b as buildFixture, c as createBrowser, a as createPage, d as createTest, g as getBrowser, l as loadFixture, e as setup, s as setupMaps, w as waitForHydration } from './shared/test-utils.3NR-so9-.mjs';
+import { u as useTestContext } from './shared/test-utils.CtwoJP76.mjs';
+export { $ as $fetch, c as createTestContext, e as exposeContextToEnv, f as fetch, i as isDev, r as recoverContextFromEnv, s as setTestContext, a as startServer, b as stopServer, d as url } from './shared/test-utils.CtwoJP76.mjs';
 import { consola } from 'consola';
 import { resolve } from 'pathe';
 import { distDir } from '#dirs';
 import 'node:fs';
 import 'node:path';
 import 'defu';
-import '@nuxt/kit';
+import './shared/test-utils.G1ew4kEe.mjs';
+import 'destr';
+import 'scule';
+import 'node:url';
+import 'exsolve';
 import 'tinyexec';
 import 'get-port-please';
 import 'ofetch';

package/dist/experimental.mjs

@@ -1,6 +1,6 @@
 import { resolve } from 'pathe';
 import { stringifyQuery } from 'ufo';
-import { $ as $fetch, u as useTestContext } from './shared/test-utils.B8qEdk9k.mjs';
+import { $ as $fetch, u as useTestContext } from './shared/test-utils.CtwoJP76.mjs';
 import 'tinyexec';
 import 'get-port-please';
 import 'ofetch';

package/dist/module.mjs

@@ -1,21 +1,23 @@
 import { pathToFileURL } from 'node:url';
-import { useNuxt, resolveIgnorePatterns, addVitePlugin, defineNuxtModule, createResolver, resolvePath, importModule, logger } from '@nuxt/kit';
+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 { 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 { extname, join, dirname } from 'pathe';
 import 'node:process';
 import 'vite';
 import 'c12';
 import 'destr';
 import 'scule';
+import 'exsolve';
 
 const PLUGIN_NAME$1 = "nuxt:vitest:mock-transform";
 const HELPER_MOCK_IMPORT = "mockNuxtImport";
@@ -67,16 +69,16 @@ const createMockPlugin = (ctx) => createUnplugin(() => {
               startOf(node)
             );
           }
-          const importName = node.arguments[0];
-          if (!isLiteral(importName) || typeof importName.value !== "string") {
+          const importTarget = node.arguments[0];
+          const name = isLiteral(importTarget) ? importTarget.value : isIdentifier(importTarget) ? importTarget.name : void 0;
+          if (typeof name !== "string") {
             return this.error(
               new Error(
-                `The first argument of ${HELPER_MOCK_IMPORT}() must be a string literal`
+                `The first argument of ${HELPER_MOCK_IMPORT}() must be a string literal or mocked target`
               ),
-              startOf(importName)
+              startOf(importTarget)
             );
           }
-          const name = importName.value;
           const importItem = ctx.imports.find((_) => name === (_.as || _.name));
           if (!importItem) {
             console.log({ imports: ctx.imports });
@@ -262,8 +264,8 @@ function endOf(node) {
   return "range" in node && node.range ? node.range[1] : "end" in node ? node.end : void 0;
 }
 
-function setupImportMocking() {
-  const nuxt = useNuxt();
+async function setupImportMocking(nuxt) {
+  const { addVitePlugin } = await loadKit(nuxt.options.rootDir);
   const ctx = {
     components: [],
     imports: []
@@ -279,7 +281,7 @@ function setupImportMocking() {
     ctx.components = _;
   });
   nuxt.hook("imports:sources", (presets) => {
-    const idx = presets.findIndex((p) => p.imports.includes("setInterval"));
+    const idx = presets.findIndex((p) => p.imports?.includes("setInterval"));
     if (idx !== -1) {
       presets.splice(idx, 1);
     }
@@ -317,7 +319,7 @@ const NuxtRootStubPlugin = createUnplugin((options) => {
 });
 
 const vitePluginBlocklist = ["vite-plugin-vue-inspector", "vite-plugin-vue-inspector:post", "vite-plugin-inspect", "nuxt:type-check"];
-const module = defineNuxtModule({
+const module$1 = defineNuxtModule({
   meta: {
     name: "@nuxt/test-utils",
     configKey: "testUtils"
@@ -328,8 +330,9 @@ const module = defineNuxtModule({
   },
   async setup(options, nuxt) {
     if (nuxt.options.test || nuxt.options.dev) {
-      setupImportMocking();
+      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 }),
@@ -339,8 +342,15 @@ const module = defineNuxtModule({
       nuxt.options.vite.define ||= {};
       nuxt.options.vite.define["import.meta.vitest"] = "undefined";
     }
-    nuxt.hook("prepare:types", ({ references }) => {
-      references.push({ types: "vitest/import-meta" });
+    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.*")));
+        if (nuxt.options.workspaceDir !== nuxt.options.rootDir) {
+          ctx2.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;
@@ -461,4 +471,4 @@ function toArray(value) {
   return Array.isArray(value) ? value : [value];
 }
 
-export { module as default };
+export { module$1 as default };

package/dist/playwright.d.mts

@@ -1,7 +1,7 @@
 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, b as TestHooks } from './shared/test-utils.DtJCg4f3.mjs';
+import { T as TestOptions$1, G as GotoOptions, b as TestHooks } from './shared/test-utils.20kU0tZa.mjs';
 import '@nuxt/schema';
 import 'tinyexec';
 

package/dist/playwright.mjs

@@ -1,16 +1,20 @@
 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.CT3RJOY3.mjs';
+import { w as waitForHydration, d as createTest } from './shared/test-utils.3NR-so9-.mjs';
 import 'node:path';
 import 'ufo';
 import 'std-env';
 import 'consola';
 import 'node:fs';
-import '@nuxt/kit';
-import { d as url } from './shared/test-utils.B8qEdk9k.mjs';
+import 'destr';
+import 'scule';
+import 'node:url';
+import 'exsolve';
+import { d as url } from './shared/test-utils.CtwoJP76.mjs';
 import 'pathe';
 import '#dirs';
+import './shared/test-utils.G1ew4kEe.mjs';
 import 'tinyexec';
 import 'get-port-please';
 import 'ofetch';

package/dist/runtime/global-setup.mjs

@@ -1,13 +1,12 @@
-import * as _kit from "@nuxt/kit";
+import { consola } from "consola";
 import { createTest, exposeContextToEnv } from "@nuxt/test-utils/e2e";
-const kit = _kit.default || _kit;
 const options = JSON.parse(process.env.NUXT_TEST_OPTIONS || "{}");
 const hooks = createTest(options);
 export const setup = async () => {
-  kit.logger.info("Building Nuxt app...");
+  consola.info("Building Nuxt app...");
   await hooks.beforeAll();
   exposeContextToEnv();
-  kit.logger.info("Running tests...");
+  consola.info("Running tests...");
 };
 export const teardown = async () => {
   await hooks.afterAll();

package/dist/runtime/shared/environment.mjs

@@ -36,24 +36,46 @@ export async function setupWindow(win, environmentOptions) {
   app.id = rootId;
   win.document.body.appendChild(app);
   const h3App = createApp();
-  if (!win.fetch) {
+  if (!win.fetch || !("Request" in win)) {
     await import("node-fetch-native/polyfill");
     win.URLSearchParams = globalThis.URLSearchParams;
+    win.Request ??= class Request extends globalThis.Request {
+      constructor(input, init) {
+        if (typeof input === "string") {
+          super(new URL(input, win.location.origin), init);
+        } else {
+          super(input, init);
+        }
+      }
+    };
   }
   const nodeHandler = toNodeListener(h3App);
   const registry = /* @__PURE__ */ new Set();
-  win.fetch = async (url, init) => {
-    if (typeof url === "string") {
-      const base = url.split("?")[0];
-      if (registry.has(base) || registry.has(url)) {
-        url = "/_" + url;
-      }
-      if (url.startsWith("/")) {
-        const response = await fetchNodeRequestHandler(nodeHandler, url, init);
-        return normalizeFetchResponse(response);
-      }
+  const _fetch = fetch;
+  win.fetch = async (input, _init) => {
+    let url;
+    let init = _init;
+    if (typeof input === "string") {
+      url = input;
+    } else if (input instanceof URL) {
+      url = input.toString();
+    } else {
+      url = input.url;
+      init = {
+        method: init?.method ?? input.method,
+        body: init?.body ?? input.body,
+        headers: init?.headers ?? input.headers
+      };
+    }
+    const base = url.split("?")[0];
+    if (registry.has(base) || registry.has(url)) {
+      url = "/_" + url;
+    }
+    if (url.startsWith("/")) {
+      const response = await fetchNodeRequestHandler(nodeHandler, url, init);
+      return normalizeFetchResponse(response);
     }
-    return fetch(url, init);
+    return _fetch(input, _init);
   };
   win.$fetch = createFetch({ fetch: win.fetch, Headers: win.Headers });
   win.__registry = registry;

package/dist/runtime-utils/index.d.mts

@@ -2,18 +2,41 @@ import { EventHandler, HTTPMethod } from 'h3';
 import { SetupContext, RenderFunction, ComputedOptions, MethodOptions, ComponentOptionsMixin, EmitsOptions, ComponentInjectOptions, ComponentOptionsWithoutProps, ComponentOptionsWithArrayProps, ComponentPropsOptions, ComponentOptionsWithObjectProps } from 'vue';
 import { ComponentMountingOptions, mount } from '@vue/test-utils';
 import { RouteLocationRaw } from 'vue-router';
-import * as _testing_library_vue from '@testing-library/vue';
-import { RenderOptions as RenderOptions$1 } from '@testing-library/vue';
+import { RenderOptions, RenderResult } from '@testing-library/vue';
 
 type Awaitable<T> = T | Promise<T>;
 type OptionalFunction<T> = T | (() => Awaitable<T>);
+/**
+ * `registerEndpoint` allows you create Nitro endpoint that returns mocked data. It can come in handy if you want to test a component that makes requests to API to display some data.
+ * @param url - endpoint name (e.g. `/test/`).
+ * @param options - factory function that returns the mocked data or an object containing the `handler`, `method`, and `once` properties.
+ * - `handler`: the event handler function
+ * - `method`: (optional) HTTP method to match (e.g., 'GET', 'POST')
+ * - `once`: (optional) if true, the handler will only be used for the first matching request and then automatically removed
+ * @example
+ * ```ts
+ * import { registerEndpoint } from '@nuxt/test-utils/runtime'
+ *
+ * registerEndpoint("/test/", () => ({
+ *  test: "test-field"
+ * }))
+ *
+ * // With once option
+ * registerEndpoint("/api/user", {
+ *   handler: () => ({ name: "Alice" }),
+ *   once: true
+ * })
+ * ```
+ * @see https://nuxt.com/docs/getting-started/testing#registerendpoint
+ */
 declare function registerEndpoint(url: string, options: EventHandler | {
     handler: EventHandler;
-    method: HTTPMethod;
+    method?: HTTPMethod;
+    once?: boolean;
 }): () => void;
 /**
  * `mockNuxtImport` allows you to mock Nuxt's auto import functionality.
- * @param _name - name of an import to mock.
+ * @param _target - name of an import to mock or mocked target.
  * @param _factory - factory function that returns mocked import.
  * @example
  * ```ts
@@ -24,10 +47,17 @@ declare function registerEndpoint(url: string, options: EventHandler | {
  *    return { value: 'mocked storage' }
  *  }
  * })
+ *
+ * // With mocked target
+ * mockNuxtImport(useStorage, () => {
+ *  return () => {
+ *    return { value: 'mocked storage' }
+ *  }
+ * })
  * ```
  * @see https://nuxt.com/docs/getting-started/testing#mocknuxtimport
  */
-declare function mockNuxtImport<T = unknown>(_name: string, _factory: () => T | Promise<T>): void;
+declare function mockNuxtImport<T = unknown>(_target: string | T, _factory: () => T | Promise<T>): void;
 /**
  * `mockComponent` allows you to mock Nuxt's component.
  * @param path - component name in PascalCase, or the relative path of the component.
@@ -67,6 +97,10 @@ declare function mockComponent<PropsOptions extends Readonly<ComponentPropsOptio
 
 type MountSuspendedOptions<T> = ComponentMountingOptions<T> & {
     route?: RouteLocationRaw;
+    scoped?: boolean;
+};
+type MountSuspendedResult<T> = ReturnType<typeof mount<T>> & {
+    setupState: SetupState$1;
 };
 type SetupState$1 = Record<string, any>;
 /**
@@ -95,13 +129,17 @@ type SetupState$1 = Record<string, any>;
  * @param component the component to be tested
  * @param options optional options to set up your component
  */
-declare function mountSuspended<T>(component: T, options?: MountSuspendedOptions<T>): Promise<ReturnType<typeof mount<T>> & {
-    setupState: SetupState$1;
-}>;
+declare function mountSuspended<T>(component: T, options?: MountSuspendedOptions<T>): Promise<MountSuspendedResult<T>>;
+declare global {
+    var __cleanup: Array<() => void> | undefined;
+}
 
-type RenderOptions<C = unknown> = RenderOptions$1<C> & {
+type RenderSuspendeOptions<T> = RenderOptions<T> & {
     route?: RouteLocationRaw;
 };
+type RenderSuspendeResult = RenderResult & {
+    setupState: SetupState;
+};
 type SetupState = Record<string, any>;
 /**
  * `renderSuspended` allows you to mount any vue component within the Nuxt environment, allowing async setup and access to injections from your Nuxt plugins.
@@ -133,9 +171,7 @@ type SetupState = Record<string, any>;
  * @param component the component to be tested
  * @param options optional options to set up your component
  */
-declare function renderSuspended<T>(component: T, options?: RenderOptions<T>): Promise<_testing_library_vue.RenderResult & {
-    setupState: SetupState;
-}>;
+declare function renderSuspended<T>(component: T, options?: RenderSuspendeOptions<T>): Promise<RenderSuspendeResult>;
 declare global {
     interface Window {
         __cleanup?: Array<() => void>;