@nx/vitest 23.2.0-rc.0 → 23.2.0-rc.2

package/dist/src/plugins/plugin.js

@@ -157,14 +157,70 @@ async function buildVitestTargets(configFilePath, projectRoot, options, context,
             // Resolve under `mode: 'test'` to match Vitest, which defaults the Vite
             // mode to 'test'; a config that branches on `command`/`mode` would
             // otherwise enumerate a different spec set here than at test time.
+            // Capture the raw root after user hooks: graph construction and the
+            // atom run resolve it against different cwds.
+            let configuredViteRoot;
             const viteServeConfig = await resolveConfig({
                 configFile: absoluteConfigFilePath,
                 mode: 'test',
+                plugins: [
+                    {
+                        // Promotes test.root before user hooks as Vitest does, so a
+                        // later hook can override it. No options.root: atoms pass no --root.
+                        name: 'nx-promote-vitest-root',
+                        enforce: 'pre',
+                        config(config) {
+                            if (config.test?.root) {
+                                return { root: config.test.root };
+                            }
+                        },
+                    },
+                    {
+                        name: 'nx-capture-vitest-root',
+                        enforce: 'post',
+                        config: {
+                            order: 'post',
+                            handler(config) {
+                                configuredViteRoot = config.root;
+                            },
+                        },
+                    },
+                ],
             }, 'serve');
             const projectRootRelativeTestPaths = await getTestPathsRelativeToProjectRoot(projectRoot, context.workspaceRoot, 
             // Only the glob path reads this config; the opt-out path forces the
             // runtime by receiving no config, and takes `test.dir` separately.
             useGlobDiscovery ? viteServeConfig : undefined, viteServeConfig.test?.dir);
+            // Each atom writes coverage to its own directory or the reports would
+            // overwrite one another. The nested flag never enables coverage.
+            const coverageReportsDirectory = viteServeConfig.test?.coverage?.reportsDirectory || 'coverage';
+            // Atom directories mirror spec paths. A shared base outside the project
+            // gets a project-root prefix unless it already ends with it, as the
+            // generated `<offset>/coverage/<projectRoot>` configs do.
+            const fullProjectRoot = (0, node_path_1.resolve)(context.workspaceRoot, projectRoot);
+            // A relative reportsDirectory resolves against the Vitest root, mapped
+            // here as the atom run would (cwd is the project root). A root computed
+            // from runtime state such as `process.cwd()` cannot be mapped and is
+            // not supported.
+            const effectiveVitestRoot = !configuredViteRoot
+                ? fullProjectRoot
+                : (0, node_path_1.isAbsolute)(configuredViteRoot)
+                    ? configuredViteRoot
+                    : (0, node_path_1.resolve)(fullProjectRoot, configuredViteRoot);
+            const resolvedReportsDirectory = (0, node_path_1.resolve)(effectiveVitestRoot, coverageReportsDirectory);
+            // Vitest refuses a reports directory equal to its root or cwd, and redirecting
+            // under it would point each atom at its own spec path for coverage to delete.
+            const vitestRejectsReportsDirectory = (0, node_path_1.relative)(effectiveVitestRoot, resolvedReportsDirectory) === '' ||
+                (0, node_path_1.relative)(fullProjectRoot, resolvedReportsDirectory) === '';
+            const atomSubfolderPrefix = isPathOutside((0, node_path_1.relative)(fullProjectRoot, resolvedReportsDirectory)) &&
+                !endsWithProjectRoot(resolvedReportsDirectory, projectRoot)
+                ? projectRoot
+                : '';
+            // The cache only accepts outputs inside the workspace. A base outside it
+            // cannot be declared, and a cache hit would then replay without writing
+            // coverage, so the atoms and their parent are not cached either.
+            const isCoverageCacheable = !isPathOutside((0, node_path_1.relative)(context.workspaceRoot, resolvedReportsDirectory));
+            const atomOutputs = [];
             for (const relativePath of projectRootRelativeTestPaths) {
                 if (relativePath.includes('../')) {
                     throw new Error('@nx/vitest attempted to run tests outside of the project root. This is not supported and should not happen. Please open an issue at https://github.com/nrwl/nx/issues/new/choose with the following information:\n\n' +
@@ -175,14 +231,28 @@ async function buildVitestTargets(configFilePath, projectRoot, options, context,
                             context,
                         }, null, 2)}`);
                 }
+                const outputSubfolder = atomSubfolderPrefix
+                    ? (0, devkit_1.joinPathFragments)(atomSubfolderPrefix, relativePath)
+                    : relativePath;
+                // joinPathFragments strips Windows drive letters, so an absolute
+                // reports directory must be joined with the OS path helper.
+                const atomCoverageDirectory = (0, node_path_1.isAbsolute)(coverageReportsDirectory)
+                    ? (0, node_path_1.join)(coverageReportsDirectory, outputSubfolder)
+                    : (0, devkit_1.joinPathFragments)(coverageReportsDirectory, outputSubfolder);
                 const targetName = `${options.ciTargetName}--${relativePath}`;
                 dependsOn.push(targetName);
                 targets[targetName] = {
                     // It does not make sense to run atomized tests in watch mode as they are intended to be run in CI
-                    command: `vitest run ${relativePath}`,
-                    cache: targets[options.testTargetName].cache,
+                    command: `vitest run ${(0, internal_1.quoteShellArg)(relativePath)}${vitestRejectsReportsDirectory
+                        ? ''
+                        : ` --coverage.reportsDirectory=${(0, internal_1.quoteShellArg)(atomCoverageDirectory)}`}`,
+                    cache: isCoverageCacheable && targets[options.testTargetName].cache,
                     inputs: targets[options.testTargetName].inputs,
-                    outputs: targets[options.testTargetName].outputs,
+                    outputs: isCoverageCacheable && !vitestRejectsReportsDirectory
+                        ? [
+                            normalizeAtomOutputPath((0, node_path_1.join)(resolvedReportsDirectory, outputSubfolder), fullProjectRoot, context.workspaceRoot),
+                        ]
+                        : [],
                     options: {
                         cwd: projectRoot,
                         env: targets[options.testTargetName].options.env,
@@ -200,14 +270,17 @@ async function buildVitestTargets(configFilePath, projectRoot, options, context,
                         },
                     },
                 };
+                atomOutputs.push(...targets[targetName].outputs);
                 targetGroup.push(targetName);
             }
             if (targetGroup.length > 0) {
                 targets[options.ciTargetName] = {
                     executor: 'nx:noop',
-                    cache: true,
+                    cache: isCoverageCacheable,
                     inputs: targets[options.testTargetName].inputs,
-                    outputs: targets[options.testTargetName].outputs,
+                    // Exactly the atom directories: a cache restore replaces each declared
+                    // directory, and any wider one can hold other projects' coverage.
+                    outputs: atomOutputs,
                     dependsOn,
                     metadata: {
                         technologies: ['vitest'],
@@ -292,6 +365,38 @@ function getOutputs(viteBuildConfig, projectRoot, workspaceRoot) {
         hasTest: !!test,
     };
 }
+/**
+ * Whether a `relative()` result leaves the base directory. A directory named
+ * `..coverage` is a child, not traversal.
+ */
+function isPathOutside(relativePath) {
+    return (relativePath === '..' ||
+        relativePath.startsWith(`..${node_path_1.sep}`) ||
+        (0, node_path_1.isAbsolute)(relativePath));
+}
+/**
+ * Maps an atom's absolute coverage directory, which must be inside the
+ * workspace, to the narrowest Nx root token.
+ */
+function normalizeAtomOutputPath(absoluteOutputPath, fullProjectRoot, workspaceRoot) {
+    const relativeToProject = (0, node_path_1.relative)(fullProjectRoot, absoluteOutputPath);
+    if (!isPathOutside(relativeToProject)) {
+        return (0, devkit_1.joinPathFragments)('{projectRoot}', relativeToProject);
+    }
+    return (0, devkit_1.joinPathFragments)('{workspaceRoot}', (0, node_path_1.relative)(workspaceRoot, absoluteOutputPath));
+}
+/**
+ * Whether the reports directory ends with the project root's segments. The
+ * root project has none, so it always holds.
+ */
+function endsWithProjectRoot(resolvedPath, projectRoot) {
+    const pathSegments = resolvedPath.split(/[\\/]/).filter(Boolean);
+    const rootSegments = projectRoot
+        .split('/')
+        .filter((segment) => segment && segment !== '.');
+    return (pathSegments.length >= rootSegments.length &&
+        rootSegments.every((segment, i) => pathSegments[pathSegments.length - rootSegments.length + i] === segment));
+}
 function normalizeOutputPath(outputPath, projectRoot, workspaceRoot, path) {
     if (!outputPath) {
         if (projectRoot === '.') {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nx/vitest",
   "description": "The Nx Plugin for Vitest to enable fast unit testing with Vitest.",
-  "version": "23.2.0-rc.0",
+  "version": "23.2.0-rc.2",
   "type": "commonjs",
   "files": [
     "dist",
@@ -81,13 +81,13 @@
     "tslib": "^2.3.0",
     "semver": "^7.6.3",
     "@phenomnomnominal/tsquery": "~6.2.0",
-    "@nx/devkit": "23.2.0-rc.0",
-    "@nx/js": "23.2.0-rc.0"
+    "@nx/devkit": "23.2.0-rc.2",
+    "@nx/js": "23.2.0-rc.2"
   },
   "peerDependencies": {
     "vitest": "^3.0.0 || ^4.0.0",
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0",
-    "@nx/eslint": "23.2.0-rc.0"
+    "@nx/eslint": "23.2.0-rc.2"
   },
   "peerDependenciesMeta": {
     "@nx/eslint": {
@@ -101,6 +101,6 @@
     }
   },
   "devDependencies": {
-    "nx": "23.2.0-rc.0"
+    "nx": "23.2.0-rc.2"
   }
 }