nrwl · Copilot · Jan 7, 2026 · Jan 7, 2026 · Jan 7, 2026 · Jan 7, 2026
@@ -1,6 +1,7 @@
 import { ProjectConfiguration } from '@nx/devkit';
 import {
   checkFilesExist,
+  checkFilesMatchingPatternExist,
   cleanupProject,
   createFile,
   expectTestsPass,
@@ -54,6 +55,31 @@ describe('Nx Plugin', () => {
     runCLI(`e2e ${plugin}-e2e`);
   }, 90000);
 
+  it('should be able to generate a Nx Plugin with vitest e2e tests', async () => {
+    const plugin = uniq('plugin');
+
+    runCLI(
+      `generate @nx/plugin:plugin ${plugin} --linter=eslint --e2eTestRunner=vitest --publishable`
+    );
+    const lintResults = runCLI(`lint ${plugin}`);
+    expect(lintResults).toContain('All files pass linting');
+
+    const buildResults = runCLI(`build ${plugin}`);
+    expect(buildResults).toContain('Done compiling TypeScript files');
+    checkFilesExist(
+      `dist/${plugin}/package.json`,
+      `dist/${plugin}/src/index.js`
+    );
+
+    // Verify vitest config was created
+    checkFilesMatchingPatternExist(`${plugin}-e2e/vitest.config.(ts|mts)`);
+
+    // Run the e2e tests with vitest
+    expect(() => {
+      runCLI(`e2e ${plugin}-e2e`);
+    }).not.toThrow();
+  }, 120000);
+
   it('should be able to generate a migration', async () => {
     const plugin = uniq('plugin');
     const version = '1.0.0';

@@ -1,9 +1,17 @@
 ## Examples
 
-##### E2E Project
+##### E2E Project with Jest (default)
 
-Scaffolds an E2E project for the plugin `my-plugin`.
+Scaffolds an E2E project for the plugin `my-plugin` using Jest.
 
 ```bash
 nx g @nx/plugin:e2e-project --pluginName my-plugin --npmPackageName my-plugin --pluginOutputPath dist/my-plugin
 ```
+
+##### E2E Project with Vitest
+
+Scaffolds an E2E project for the plugin `my-plugin` using Vitest.
+
+```bash
+nx g @nx/plugin:e2e-project --pluginName my-plugin --npmPackageName my-plugin --pluginOutputPath dist/my-plugin --testRunner vitest
+```
@@ -37,6 +37,14 @@
   "devDependencies": {
     "nx": "workspace:*"
   },
+  "peerDependencies": {
+    "@nx/vitest": "workspace:*"
+  },
+  "peerDependenciesMeta": {
+    "@nx/vitest": {
+      "optional": true
+    }
+  },
   "publishConfig": {
     "access": "public"
   }

@@ -3,11 +3,11 @@ import 'nx/src/internal-testing-utils/mock-project-graph';
 import {
   Tree,
   addProjectConfiguration,
-  readProjectConfiguration,
-  readJson,
   getProjects,
-  writeJson,
+  readJson,
+  readProjectConfiguration,
   updateJson,
+  writeJson,
 } from '@nx/devkit';
 import { createTreeWithEmptyWorkspace } from '@nx/devkit/testing';
 import { e2eProjectGenerator } from './e2e';
@@ -211,6 +211,44 @@ describe('NxPlugin e2e-project Generator', () => {
     expect(tree.exists('my-plugin-e2e/.spec.swcrc')).toBeFalsy();
   });
 
+  it('should add vitest support', async () => {
+    await e2eProjectGenerator(tree, {
+      pluginName: 'my-plugin',
+      pluginOutputPath: `dist/libs/my-plugin`,
+      npmPackageName: '@proj/my-plugin',
+      testRunner: 'vitest',
+      addPlugin: false,
+    });
+
+    const project = readProjectConfiguration(tree, 'my-plugin-e2e');
+
+    expect(project.targets.e2e.executor).toBe('@nx/vitest:test');
+    expect(project.targets.e2e).toMatchObject({
+      dependsOn: ['^build'],
+      options: expect.objectContaining({
+        pool: 'forks',
+        poolOptions: {
+          forks: {
+            singleFork: true,
+          },
+        },
+      }),
+    });
+
+    expect(tree.exists('my-plugin-e2e/tsconfig.spec.json')).toBeTruthy();
+    const vitestConfigExists =
+      tree.exists('my-plugin-e2e/vitest.config.ts') ||
+      tree.exists('my-plugin-e2e/vitest.config.mts');
+    expect(vitestConfigExists).toBeTruthy();
+
+    const vitestConfigPath = tree.exists('my-plugin-e2e/vitest.config.ts')
+      ? 'my-plugin-e2e/vitest.config.ts'
+      : 'my-plugin-e2e/vitest.config.mts';
+    const vitestConfig = tree.read(vitestConfigPath, 'utf-8');
+    expect(vitestConfig).toContain('globalSetup');
+    expect(vitestConfig).toContain('globalTeardown');
+  });
+
   it('should setup the eslint builder', async () => {
     await e2eProjectGenerator(tree, {
       pluginName: 'my-plugin',

@@ -1,5 +1,6 @@
 import {
   addProjectConfiguration,
+  ensurePackage,
   formatFiles,
   generateFiles,
   getPackageManagerCommand,
@@ -10,12 +11,12 @@ import {
   readNxJson,
   readProjectConfiguration,
   runTasksInSerial,
+  Tree,
   updateJson,
   updateProjectConfiguration,
   writeJson,
   type GeneratorCallback,
   type ProjectConfiguration,
-  type Tree,
 } from '@nx/devkit';
 import { determineProjectNameAndRootOptions } from '@nx/devkit/src/generators/project-name-and-root-utils';
 import { LinterType, lintProjectGenerator } from '@nx/eslint';
@@ -32,10 +33,13 @@ import {
   addProjectToTsSolutionWorkspace,
   isUsingTsSolutionSetup,
 } from '@nx/js/src/utils/typescript/ts-solution-setup';
+import type { VitestGeneratorSchema } from '@nx/vitest/generators';
 import type { PackageJson } from 'nx/src/utils/package-json';
 import { join } from 'path';
 import type { Schema } from './schema';
 
+const nxVersion = require('../../../package.json').version;
+
 interface NormalizedSchema extends Schema {
   projectRoot: string;
   projectName: string;
@@ -197,6 +201,130 @@ async function addJest(host: Tree, options: NormalizedSchema) {
   return jestTask;
 }
 
+async function addVitest(host: Tree, options: NormalizedSchema) {
+  const projectConfiguration: ProjectConfiguration = {
+    name: options.projectName,
+    root: options.projectRoot,
+    projectType: 'application',
+    sourceRoot: `${options.projectRoot}/src`,
+    implicitDependencies: [options.pluginName],
+  };
+
+  if (options.isTsSolutionSetup) {
+    writeJson<PackageJson>(
+      host,
+      joinPathFragments(options.projectRoot, 'package.json'),
+      {
+        name: options.projectName,
+        version: '0.0.1',
+        private: true,
+      }
+    );
+    updateProjectConfiguration(host, options.projectName, projectConfiguration);
+  } else {
+    projectConfiguration.targets = {};
+    addProjectConfiguration(host, options.projectName, projectConfiguration);
+  }
+
+  // Ensure @nx/vitest is installed before using it
+  ensurePackage('@nx/vitest', nxVersion);
+  const { configurationGenerator: vitestConfigurationGenerator } = await import(
+    '@nx/vitest/generators'
+  );
+
+  const vitestTask = await vitestConfigurationGenerator(host, {
+    project: options.projectName,
+    testTarget: 'e2e',
+    skipFormat: true,
+    addPlugin: options.addPlugin,
+    testEnvironment: 'node',
+    coverageProvider: 'none',
+  } satisfies Partial<VitestGeneratorSchema>);
+
+  const { startLocalRegistryPath, stopLocalRegistryPath } =
+    addLocalRegistryScripts(host);
+
+  // Add globalSetup and globalTeardown to vitest config
+  // Check for both .mts and .ts extensions (mts is checked first as it's the default created by @nx/vitest)
+  const vitestConfigExtensions = ['mts', 'ts'];
+  let vitestConfigPath: string | undefined;
+
+  for (const ext of vitestConfigExtensions) {
+    const configPath = joinPathFragments(
+      options.projectRoot,
+      `vitest.config.${ext}`
+    );
+    if (host.exists(configPath)) {
+      vitestConfigPath = configPath;
+      break;
+    }
+  }
+
+  if (vitestConfigPath) {
+    let vitestConfig = host.read(vitestConfigPath, 'utf-8');
+    const globalSetupPath = join(
+      offsetFromRoot(options.projectRoot),
+      startLocalRegistryPath
+    );
+    const globalTeardownPath = join(
+      offsetFromRoot(options.projectRoot),
+      stopLocalRegistryPath
+    );
+
+    // Insert globalSetup and globalTeardown in the test config
+    // Look for 'test: {' and insert our properties right after the opening brace
+    const testConfigRegex = /(test:\s*\{\s*)/;
+    const match = testConfigRegex.exec(vitestConfig);
+
+    if (match) {
+      // Extract the indentation from the next line to maintain consistent formatting
+      const afterMatch = vitestConfig.slice(match.index + match[0].length);
+      const nextLineMatch = afterMatch.match(/\n(\s*)/);
+      const indent = nextLineMatch ? nextLineMatch[1] : '    ';
+
+      vitestConfig = vitestConfig.replace(
+        testConfigRegex,
+        `$1\n${indent}globalSetup: '${globalSetupPath}',\n${indent}globalTeardown: '${globalTeardownPath}',`
+      );
+      host.write(vitestConfigPath, vitestConfig);
+    } else {
+      // If we can't find the test config block, log a warning
+      throw new Error(
+        `Could not find test configuration block in ${vitestConfigPath}. Please manually add globalSetup and globalTeardown properties.`
+      );
+    }
+  } else {
+    // This should not happen as the vitest configuration generator should create the config file
+    throw new Error(
+      `Could not find Vitest config for project ${options.projectName} at ${options.projectRoot}`
+    );
+  }
+
+  const project = readProjectConfiguration(host, options.projectName);
+  project.targets ??= {};
+  if (project.targets.e2e) {
+    const e2eTarget = project.targets.e2e;
+
+    project.targets.e2e = {
+      ...e2eTarget,
+      dependsOn: [`^build`],
+      options: {
+        ...e2eTarget.options,
+        pool: 'forks',
+        poolOptions: {
+          forks: {
+            singleFork: true,
+          },
+        },
+      },
+    };
+
+    updateProjectConfiguration(host, options.projectName, project);
+  }
+
+  return vitestTask;
+}
+
 async function addLintingToApplication(
   tree: Tree,
   options: NormalizedSchema
@@ -207,7 +335,7 @@ async function addLintingToApplication(
     tsConfigPaths: [
       joinPathFragments(options.projectRoot, 'tsconfig.app.json'),
     ],
-    unitTestRunner: 'jest',
+    unitTestRunner: options.testRunner ?? 'jest',
     skipFormat: true,
     setParserOptionsProject: false,
     addPlugin: options.addPlugin,
@@ -238,13 +366,24 @@ export async function e2eProjectGeneratorInternal(host: Tree, schema: Schema) {
 
   validatePlugin(host, schema.pluginName);
   const options = await normalizeOptions(host, schema);
+
+  // Default to jest if no testRunner is specified
+  options.testRunner = options.testRunner ?? 'jest';
+
   addFiles(host, options);
   tasks.push(
     await setupVerdaccio(host, {
       skipFormat: true,
     })
   );
-  tasks.push(await addJest(host, options));
+
+  // Add test runner based on the testRunner option
+  if (options.testRunner === 'vitest') {
+    tasks.push(await addVitest(host, options));
+  } else {
+    tasks.push(await addJest(host, options));
+  }
+
   updatePluginPackageJson(host, options);
 
   if (options.linter !== 'none') {

@@ -8,14 +8,14 @@ describe('<%= pluginName %>', () => {
   beforeAll(() => {
     projectDirectory = createTestProject();
 
-    // The plugin has been built and published to a local registry in the jest globalSetup
+    // The plugin has been built and published to a local registry in the globalSetup
     // Install the plugin built with the latest source code into the test repo
     execSync(`<%= packageManagerCommands.addDev %> <%= pluginPackageName %>@e2e`, {
       cwd: projectDirectory,
       stdio: 'inherit',
       env: process.env,
     });
-  });
+  }, 30_000);
 
   afterAll(() => {
     if (projectDirectory) {

@@ -6,6 +6,7 @@ export interface Schema {
   projectDirectory?: string;
   pluginOutputPath?: string;
   jestConfig?: string;
+  testRunner?: 'jest' | 'vitest';
   linter?: Linter | LinterType;
   skipFormat?: boolean;
   rootProject?: boolean;

@@ -30,6 +30,12 @@
       "type": "string",
       "description": "Jest config file."
     },
+    "testRunner": {
+      "type": "string",
+      "enum": ["jest", "vitest"],
+      "description": "Test runner to use for the e2e tests.",
+      "default": "jest"
+    },
     "linter": {
       "description": "The tool to use for running lint checks.",
       "type": "string",

@@ -341,6 +341,22 @@ describe('NxPlugin Plugin Generator', () => {
       const projects = getProjects(tree);
       expect(projects.has('my-plugin-e2e')).toBe(false);
     });
+
+    it('should generate e2e project with jest', async () => {
+      await pluginGenerator(tree, getSchema({ e2eTestRunner: 'jest' }));
+      const projects = getProjects(tree);
+      expect(projects.has('my-plugin-e2e')).toBe(true);
+      const e2eProject = projects.get('my-plugin-e2e');
+      expect(e2eProject.targets.e2e.executor).toBe('@nx/jest:jest');
+    });
+
+    it('should generate e2e project with vitest', async () => {
+      await pluginGenerator(tree, getSchema({ e2eTestRunner: 'vitest' }));
+      const projects = getProjects(tree);
+      expect(projects.has('my-plugin-e2e')).toBe(true);
+      const e2eProject = projects.get('my-plugin-e2e');
+      expect(e2eProject.targets.e2e.executor).toBe('@nx/vitest:test');
+    });
   });
 
   describe('TS solution setup', () => {