@nuxt/test-utils-nightly 4.0.0-1699284628.89ffa77 → 4.0.0-1701501480.7490334

package/dist/module.mjs

@@ -0,0 +1,459 @@
+import { pathToFileURL } from 'node:url';
+import { resolvePath, useNuxt, resolveIgnorePatterns, addVitePlugin, defineNuxtModule, createResolver, logger } from '@nuxt/kit';
+import { mergeConfig } from 'vite';
+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 { getVitestConfigFromNuxt } from './config.mjs';
+import { walk } from 'estree-walker';
+import MagicString from 'magic-string';
+import { normalize, resolve } from 'node:path';
+import { createUnplugin } from 'unplugin';
+import { readFileSync } from 'node:fs';
+
+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 HELPERS_NAME = [HELPER_MOCK_IMPORT, HELPER_MOCK_COMPONENT];
+const createMockPlugin = (ctx) => createUnplugin(() => {
+  let resolvedFirstSetupFile = null;
+  function transform(code, id) {
+    const isFirstSetupFile = normalize(id) === resolvedFirstSetupFile;
+    const shouldPrependMockHoist = resolvedFirstSetupFile ? isFirstSetupFile : true;
+    if (!HELPERS_NAME.some((n) => code.includes(n)))
+      return;
+    if (id.includes("/node_modules/"))
+      return;
+    let ast;
+    try {
+      ast = this.parse(code, {
+        // @ts-expect-error compatibility with rollup v3
+        sourceType: "module",
+        ecmaVersion: "latest",
+        ranges: true
+      });
+    } catch (e) {
+      return;
+    }
+    let insertionPoint = 0;
+    let hasViImport = false;
+    const s = new MagicString(code);
+    const mocksImport = [];
+    const mocksComponent = [];
+    const importPathsList = /* @__PURE__ */ new Set();
+    walk(ast, {
+      enter: (node, parent) => {
+        if (isImportDeclaration(node)) {
+          if (node.source.value === "vitest" && !hasViImport) {
+            const viImport = node.specifiers.find(
+              (i) => isImportSpecifier(i) && i.imported.name === "vi"
+            );
+            if (viImport) {
+              insertionPoint = endOf(node);
+              hasViImport = true;
+            }
+            return;
+          }
+        }
+        if (!isCallExpression(node))
+          return;
+        if (isIdentifier(node.callee) && node.callee.name === HELPER_MOCK_IMPORT) {
+          if (node.arguments.length !== 2) {
+            return this.error(
+              new Error(
+                `${HELPER_MOCK_IMPORT}() should have exactly 2 arguments`
+              ),
+              startOf(node)
+            );
+          }
+          const importName = node.arguments[0];
+          if (!isLiteral(importName) || typeof importName.value !== "string") {
+            return this.error(
+              new Error(
+                `The first argument of ${HELPER_MOCK_IMPORT}() must be a string literal`
+              ),
+              startOf(importName)
+            );
+          }
+          const name = importName.value;
+          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(
+            isExpressionStatement(parent) ? startOf(parent) : startOf(node.arguments[0]),
+            isExpressionStatement(parent) ? endOf(parent) : endOf(node.arguments[1]),
+            ""
+          );
+          mocksImport.push({
+            name,
+            import: importItem,
+            factory: code.slice(
+              startOf(node.arguments[1]),
+              endOf(node.arguments[1])
+            )
+          });
+        }
+        if (isIdentifier(node.callee) && node.callee.name === HELPER_MOCK_COMPONENT) {
+          if (node.arguments.length !== 2) {
+            return this.error(
+              new Error(
+                `${HELPER_MOCK_COMPONENT}() should have exactly 2 arguments`
+              ),
+              startOf(node)
+            );
+          }
+          const componentName = node.arguments[0];
+          if (!isLiteral(componentName) || typeof componentName.value !== "string") {
+            return this.error(
+              new Error(
+                `The first argument of ${HELPER_MOCK_COMPONENT}() must be a string literal`
+              ),
+              startOf(componentName)
+            );
+          }
+          const pathOrName = componentName.value;
+          const component = ctx.components.find(
+            (_) => _.pascalName === pathOrName || _.kebabName === pathOrName
+          );
+          const path = component?.filePath || pathOrName;
+          s.overwrite(
+            isExpressionStatement(parent) ? startOf(parent) : startOf(node.arguments[1]),
+            isExpressionStatement(parent) ? endOf(parent) : endOf(node.arguments[1]),
+            ""
+          );
+          mocksComponent.push({
+            path,
+            factory: code.slice(
+              startOf(node.arguments[1]),
+              endOf(node.arguments[1])
+            )
+          });
+        }
+      }
+    });
+    if (mocksImport.length === 0 && mocksComponent.length === 0)
+      return;
+    const mockLines = [];
+    if (mocksImport.length) {
+      const mockImportMap = /* @__PURE__ */ new Map();
+      for (const mock of mocksImport) {
+        if (!mockImportMap.has(mock.import.from)) {
+          mockImportMap.set(mock.import.from, []);
+        }
+        mockImportMap.get(mock.import.from).push(mock);
+      }
+      mockLines.push(
+        ...Array.from(mockImportMap.entries()).flatMap(
+          ([from, mocks]) => {
+            importPathsList.add(from);
+            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)}) }`,
+              `  }`
+            ];
+            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})();`
+                );
+              }
+            }
+            lines.push(`  return mocks[${JSON.stringify(from)}] `);
+            lines.push(`});`);
+            return lines;
+          }
+        )
+      );
+    }
+    if (mocksComponent.length) {
+      mockLines.push(
+        ...mocksComponent.flatMap((mock) => {
+          return [
+            `vi.mock(${JSON.stringify(mock.path)}, async () => {`,
+            `  const factory = (${mock.factory});`,
+            `  const result = typeof factory === 'function' ? await factory() : await factory`,
+            `  return 'default' in result ? result : { default: result }`,
+            "});"
+          ];
+        })
+      );
+    }
+    if (!mockLines.length)
+      return;
+    s.prepend(`vi.hoisted(() => { 
+        if(!globalThis.${HELPER_MOCK_HOIST}){
+          vi.stubGlobal(${JSON.stringify(HELPER_MOCK_HOIST)}, {})
+        }
+      });
+`);
+    if (!hasViImport)
+      s.prepend(`import {vi} from "vitest";
+`);
+    s.appendLeft(insertionPoint, mockLines.join("\n") + "\n");
+    if (shouldPrependMockHoist) {
+      importPathsList.forEach((p) => {
+        s.append(`
+ import ${JSON.stringify(p)};`);
+      });
+    }
+    return {
+      code: s.toString(),
+      map: s.generateMap()
+    };
+  }
+  return {
+    name: PLUGIN_NAME$1,
+    enforce: "post",
+    vite: {
+      transform,
+      // Place Vitest's mock plugin after all Nuxt plugins
+      async configResolved(config) {
+        const firstSetupFile = Array.isArray(config.test?.setupFiles) ? config.test.setupFiles.find((p) => !p.includes("runtime/entry")) : config.test?.setupFiles;
+        if (firstSetupFile) {
+          resolvedFirstSetupFile = await resolvePath(normalize(resolve(firstSetupFile)));
+        }
+        const plugins = config.plugins || [];
+        const vitestPlugins = plugins.filter((p) => p.name === "vite:mocks" || p.name.startsWith("vitest:"));
+        const lastNuxt = findLastIndex(
+          plugins,
+          (i) => i.name?.startsWith("nuxt:")
+        );
+        if (lastNuxt === -1)
+          return;
+        for (const plugin of vitestPlugins) {
+          const index = plugins.indexOf(plugin);
+          if (index < lastNuxt) {
+            plugins.splice(index, 1);
+            plugins.splice(lastNuxt, 0, plugin);
+          }
+        }
+      }
+    }
+  };
+});
+function findLastIndex(arr, predicate) {
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (predicate(arr[i]))
+      return i;
+  }
+  return -1;
+}
+function isImportDeclaration(node) {
+  return node.type === "ImportDeclaration";
+}
+function isImportSpecifier(node) {
+  return node.type === "ImportSpecifier";
+}
+function isCallExpression(node) {
+  return node.type === "CallExpression";
+}
+function isIdentifier(node) {
+  return node.type === "Identifier";
+}
+function isLiteral(node) {
+  return node.type === "Literal";
+}
+function isExpressionStatement(node) {
+  return node?.type === "ExpressionStatement";
+}
+function startOf(node) {
+  return "range" in node && node.range ? node.range[0] : node.start;
+}
+function endOf(node) {
+  return "range" in node && node.range ? node.range[1] : node.end;
+}
+
+function setupImportMocking() {
+  const nuxt = useNuxt();
+  const ctx = {
+    components: [],
+    imports: []
+  };
+  let importsCtx;
+  nuxt.hook("imports:context", async (ctx2) => {
+    importsCtx = ctx2;
+  });
+  nuxt.hook("ready", async () => {
+    ctx.imports = await importsCtx.getImports();
+  });
+  nuxt.hook("components:extend", (_) => {
+    ctx.components = _;
+  });
+  nuxt.options.ignore = nuxt.options.ignore.filter((i) => i !== "**/*.{spec,test}.{js,cts,mts,ts,jsx,tsx}");
+  if (nuxt._ignore) {
+    for (const pattern of resolveIgnorePatterns("**/*.{spec,test}.{js,cts,mts,ts,jsx,tsx}")) {
+      nuxt._ignore.add(`!${pattern}`);
+    }
+  }
+  addVitePlugin(createMockPlugin(ctx).vite());
+}
+
+const PLUGIN_NAME = "nuxt:vitest:nuxt-root-stub";
+const NuxtRootStubPlugin = createUnplugin((options) => {
+  return {
+    name: PLUGIN_NAME,
+    enforce: "pre",
+    vite: {
+      async resolveId(id) {
+        if (id.endsWith("nuxt-vitest-app-entry")) {
+          return id;
+        }
+      },
+      async load(id) {
+        if (id.endsWith("nuxt-vitest-app-entry")) {
+          const entryContents = readFileSync(options.entry, "utf-8");
+          return entryContents.replace("#build/root-component.mjs", options.rootStubPath);
+        }
+      }
+    }
+  };
+});
+
+const vitePluginBlocklist = ["vite-plugin-vue-inspector", "vite-plugin-inspect"];
+const module = defineNuxtModule({
+  meta: {
+    name: "@nuxt/test-utils",
+    configKey: "vitest"
+  },
+  defaults: {
+    startOnBoot: false,
+    logToConsole: false
+  },
+  async setup(options, nuxt) {
+    if (nuxt.options.test || nuxt.options.dev) {
+      setupImportMocking();
+    }
+    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.dev)
+      return;
+    if (nuxt.options.test && nuxt.options.app.rootId === "__nuxt") {
+      nuxt.options.app.rootId = "nuxt-test";
+    }
+    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);
+        });
+      });
+    });
+    const PORT = await getPort({ port: 15555 });
+    const URL = `http://localhost:${PORT}/__vitest__/`;
+    let loaded = false;
+    let promise;
+    let ctx = void 0;
+    let testFiles = null;
+    const updateTabs = debounce(() => {
+      nuxt.callHook("devtools:customTabs:refresh");
+    }, 100);
+    async function start() {
+      const rawViteConfig = mergeConfig({}, await rawViteConfigPromise);
+      const viteConfig = await getVitestConfigFromNuxt({ nuxt, viteConfig: defu({ test: options.vitestConfig }, rawViteConfig) });
+      viteConfig.plugins = (viteConfig.plugins || []).filter((p) => {
+        return !vitePluginBlocklist.includes(p?.name);
+      });
+      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 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}`);
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+      } else {
+        promise2.then((v) => v?.close()).then(() => process.exit());
+        promise2.catch(() => process.exit(1));
+      }
+      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
+      });
+    });
+    if (options.startOnBoot) {
+      promise = promise || start();
+      promise.then(updateTabs);
+    }
+  }
+});
+function toArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
+export { module as default };

package/dist/runtime/entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/entry.mjs

@@ -0,0 +1,8 @@
+if (typeof window !== "undefined" && // @ts-expect-error undefined property
+window.__NUXT_VITEST_ENVIRONMENT__) {
+  await import("#app/nuxt-vitest-app-entry").then((r) => r.default());
+  const nuxtApp = useNuxtApp();
+  await nuxtApp.callHook("page:finish");
+  useRouter().afterEach(() => nuxtApp.callHook("page:finish"));
+}
+export {};

package/dist/runtime/nuxt-root.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+export default _default;

package/dist/runtime/nuxt-root.mjs

@@ -0,0 +1,21 @@
+import { Suspense, defineComponent, h, onErrorCaptured, provide } from "vue";
+import { isNuxtError, useNuxtApp, useRoute } from "#imports";
+import { PageRouteSymbol } from "#app/components/injections";
+export default defineComponent({
+  setup(_options, { slots }) {
+    const nuxtApp = useNuxtApp();
+    provide(PageRouteSymbol, useRoute());
+    const done = nuxtApp.deferHydration();
+    const results = nuxtApp.hooks.callHookWith((hooks) => hooks.map((hook) => hook()), "vue:setup");
+    if (import.meta.dev && results && results.some((i) => i && "then" in i)) {
+      console.error("[nuxt] Error in `vue:setup`. Callbacks must be synchronous.");
+    }
+    onErrorCaptured((err, target, info) => {
+      nuxtApp.hooks.callHook("vue:error", err, target, info).catch((hookError) => console.error("[nuxt] Error in `vue:error` hook", hookError));
+      if (isNuxtError(err) && (err.fatal || err.unhandled)) {
+        return false;
+      }
+    });
+    return () => h(Suspense, { onResolve: done }, slots.default?.());
+  }
+});

package/dist/runtime-utils.d.mts

@@ -0,0 +1,150 @@
+import { EventHandler, HTTPMethod } from 'h3';
+import { SetupContext, RenderFunction, ComputedOptions, MethodOptions, ComponentOptionsMixin, EmitsOptions, ComponentInjectOptions, ComponentOptionsWithoutProps, ComponentOptionsWithArrayProps, ComponentPropsOptions, ComponentOptionsWithObjectProps } from 'vue';
+import { mount, ComponentMountingOptions } 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';
+
+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 both the `handler` and the `method` properties.
+ * @example
+ * ```ts
+ * import { registerEndpoint } from '@nuxt/test-utils/runtime-utils'
+ *
+ * registerEndpoint("/test/", () => {
+ *  test: "test-field"
+ * })
+ * ```
+ * @see https://github.com/danielroe/nuxt-vitest#registerendpoint
+ */
+declare function registerEndpoint(url: string, options: EventHandler | {
+    handler: EventHandler;
+    method: HTTPMethod;
+}): void;
+/**
+ * `mockNuxtImport` allows you to mock Nuxt's auto import functionality.
+ * @param _name - name of an import to mock.
+ * @param _factory - factory function that returns mocked import.
+ * @example
+ * ```ts
+ * import { mockNuxtImport } from '@nuxt/test-utils/runtime-utils'
+ *
+ * mockNuxtImport('useStorage', () => {
+ *  return () => {
+ *    return { value: 'mocked storage' }
+ *  }
+ * })
+ * ```
+ * @see https://github.com/danielroe/nuxt-vitest#mocknuxtimport
+ */
+declare function mockNuxtImport<T = any>(_name: string, _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.
+ * @param setup - factory function that returns the mocked component.
+ * @example
+ * ```ts
+ * import { mockComponent } from '@nuxt/test-utils/runtime-utils'
+ *
+ * mockComponent('MyComponent', {
+ *  props: {
+ *    value: String
+ *  },
+ *  setup(props) {
+ *    // ...
+ *  }
+ * })
+ *
+ * // relative path or alias also works
+ * mockComponent('~/components/my-component.vue', async () => {
+ *  // or a factory function
+ *  return {
+ *    setup(props) {
+ *      // ...
+ *    }
+ *  }
+ * })
+ *
+ * // or you can use SFC for redirecting to a mock component
+ * mockComponent('MyComponent', () => import('./MockComponent.vue'))
+ * ```
+ * @see https://github.com/danielroe/nuxt-vitest#mockcomponent
+ */
+declare function mockComponent<Props, RawBindings = object>(path: string, setup: OptionalFunction<(props: Readonly<Props>, ctx: SetupContext) => RawBindings | RenderFunction>): void;
+declare function mockComponent<Props = {}, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(path: string, options: OptionalFunction<ComponentOptionsWithoutProps<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>>): void;
+declare function mockComponent<PropNames extends string, RawBindings, D, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(path: string, options: OptionalFunction<ComponentOptionsWithArrayProps<PropNames, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>>): void;
+declare function mockComponent<PropsOptions extends Readonly<ComponentPropsOptions>, RawBindings, D, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(path: string, options: OptionalFunction<ComponentOptionsWithObjectProps<PropsOptions, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>>): void;
+
+type MountSuspendedOptions<T> = ComponentMountingOptions<T> & {
+    route?: RouteLocationRaw;
+};
+/**
+ * `mountSuspended` allows you to mount any vue component within the Nuxt environment, allowing async setup and access to injections from your Nuxt plugins. For example:
+ *
+ * ```ts
+ * // tests/components/SomeComponents.nuxt.spec.ts
+ * it('can mount some component', async () => {
+ * const component = await mountSuspended(SomeComponent)
+ * expect(component.text()).toMatchInlineSnapshot(
+ * 'This is an auto-imported component'
+ * )
+ * })
+ *
+ * // tests/App.nuxt.spec.ts
+ * it('can also mount an app', async () => {
+ * const component = await mountSuspended(App, { route: '/test' })
+ * expect(component.html()).toMatchInlineSnapshot(`
+ * "<div>This is an auto-imported component</div>
+ * <div> I am a global component </div>
+ * <div>/</div>
+ * <a href=\\"/test\\"> Test link </a>"
+ * `)
+ * })
+ * ```
+ * @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: any;
+}>;
+
+type RenderOptions = RenderOptions$1 & {
+    route?: RouteLocationRaw;
+};
+/**
+ * `renderSuspended` allows you to mount any vue component within the Nuxt environment, allowing async setup and access to injections from your Nuxt plugins.
+ *
+ * This is a wrapper around the `render` function from @testing-libary/vue, and should be used together with
+ * utilities from that package.
+ *
+ * ```ts
+ * // tests/components/SomeComponents.nuxt.spec.ts
+ * import { renderSuspended } from '@nuxt/test-utils/runtime-utils'
+ *
+ * it('can render some component', async () => {
+ * const { html } = await renderSuspended(SomeComponent)
+ * expect(html()).toMatchInlineSnapshot(
+ * 'This is an auto-imported component'
+ * )
+ *
+ * })
+ *
+ * // tests/App.nuxt.spec.ts
+ * import { renderSuspended } from '@nuxt/test-utils/runtime-utils'
+ * import { screen } from '@testing-library/vue'
+ *
+ * it('can also mount an app', async () => {
+ * const { html } = await renderSuspended(App, { route: '/test' })
+ * expect(screen.getByRole('link', { name: 'Test Link' })).toBeVisible()
+ * })
+ * ```
+ * @param component the component to be tested
+ * @param options optional options to set up your component
+ */
+declare function renderSuspended<T>(component: T, options?: RenderOptions): Promise<_testing_library_vue.RenderResult>;
+
+export { mockComponent, mockNuxtImport, mountSuspended, registerEndpoint, renderSuspended };