feat(vitest-plugin): retrieve vitest major version to know which config to apply

Author: adriencaccia

packages/vitest-plugin/src/__tests__/index.test.ts

@@ -10,6 +10,21 @@ const coreMocks = vi.hoisted(() => {
   };
 });
 
+const fsMocks = vi.hoisted(() => {
+  let mockVersion = "4.0.18"; // default to v4
+  return {
+    readFileSync: vi.fn((path: string) => {
+      if (path.includes("vitest/package.json")) {
+        return JSON.stringify({ version: mockVersion });
+      }
+      throw new Error(`File not found: ${path}`);
+    }),
+    setMockVersion: (version: string) => {
+      mockVersion = version;
+    },
+  };
+});
+
 const resolvedCodSpeedPlugin = codspeedPlugin();
 const applyPluginFunction = resolvedCodSpeedPlugin.apply;
 if (typeof applyPluginFunction !== "function")
@@ -20,6 +35,12 @@ vi.mock("@codspeed/core", async (importOriginal) => {
   return { ...mod, ...coreMocks };
 });
 
+vi.mock("fs", () => {
+  return {
+    readFileSync: fsMocks.readFileSync,
+  };
+});
+
 console.warn = vi.fn();
 
 describe("codSpeedPlugin", () => {
@@ -79,12 +100,51 @@ describe("codSpeedPlugin", () => {
     });
   });
 
-  it("should apply the codspeed config", async () => {
+  it("should apply the codspeed config for v4", () => {
     const config = resolvedCodSpeedPlugin.config;
     if (typeof config !== "function")
       throw new Error("config is not a function");
 
-    expect(config.call({} as never, {}, fromPartial({}))).toStrictEqual({
+    const result = config.call({} as never, {}, fromPartial({}));
+
+    expect(result).toStrictEqual({
+      test: {
+        globalSetup: [
+          expect.stringContaining("packages/vitest-plugin/src/globalSetup.ts"),
+        ],
+        pool: "forks",
+        execArgv: [
+          "--interpreted-frames-native-stack",
+          "--allow-natives-syntax",
+          "--hash-seed=1",
+          "--random-seed=1",
+          "--no-opt",
+          "--predictable",
+          "--predictable-gc-schedule",
+          "--expose-gc",
+          "--no-concurrent-sweeping",
+          "--max-old-space-size=4096",
+        ],
+        runner: expect.stringContaining(
+          "packages/vitest-plugin/src/simulation.ts"
+        ),
+      },
+    });
+  });
+
+  it("should apply the codspeed config for v3 with poolOptions", () => {
+    // Set mock version to v3
+    fsMocks.setMockVersion("3.2.0");
+
+    // Create a new plugin instance to pick up the mocked version
+    const v3Plugin = codspeedPlugin();
+    const config = v3Plugin.config;
+    if (typeof config !== "function")
+      throw new Error("config is not a function");
+
+    const result = config.call({} as never, {}, fromPartial({}));
+
+    expect(result).toStrictEqual({
       test: {
         globalSetup: [
           expect.stringContaining("packages/vitest-plugin/src/globalSetup.ts"),
@@ -111,5 +171,8 @@ describe("codSpeedPlugin", () => {
         ),
       },
     });
+
+    // Reset mock version back to v4
+    fsMocks.setMockVersion("4.0.18");
   });
 });

packages/vitest-plugin/src/index.ts

@@ -6,6 +6,8 @@ import {
   SetupInstrumentsRequestBody,
   SetupInstrumentsResponse,
 } from "@codspeed/core";
+import { readFileSync } from "fs";
+import { createRequire } from "module";
 import { join } from "path";
 import { Plugin } from "vite";
 import { type ViteUserConfig } from "vitest/config";
@@ -20,6 +22,19 @@ function getCodSpeedFileFromName(name: string) {
   return join(__dirname, `${name}.${fileExtension}`);
 }
 
+function getVitestMajorVersion(): number | null {
+  try {
+    // Resolve vitest from the project's perspective (cwd), not from the plugin's location
+    // This ensures we detect the vitest version the user has installed
+    const require = createRequire(join(process.cwd(), "package.json"));
+    const vitestPkgPath = require.resolve("vitest/package.json");
+    const vitestPkg = JSON.parse(readFileSync(vitestPkgPath, "utf-8"));
+    return parseInt(vitestPkg.version.split(".")[0], 10);
+  } catch {
+    return null;
+  }
+}
+
 function getRunnerFile(): string | undefined {
   const codspeedRunnerMode = getCodspeedRunnerMode();
   if (codspeedRunnerMode === "disabled") {
@@ -49,18 +64,25 @@ export default function codspeedPlugin(): Plugin {
       const runnerFile = getRunnerFile();
       const runnerMode = getCodspeedRunnerMode();
       const v8Flags = getV8Flags();
+      const vitestMajorVersion = getVitestMajorVersion();
+      // by default, assume Vitest v4 or higher
+      const isVitestV4OrHigher = (vitestMajorVersion ?? 4) >= 4;
 
       const config: ViteUserConfig = {
         test: {
           pool: "forks",
-          execArgv: v8Flags,
-          // @ts-expect-error Compat with Vitest v3
-          // See: https://vitest.dev/guide/migration.html#pool-rework
-          poolOptions: {
-            forks: {
-              execArgv: v8Flags,
-            },
-          },
+          ...(isVitestV4OrHigher
+            ? { execArgv: v8Flags }
+            : {
+                // Compat with Vitest v3
+                // See: https://vitest.dev/guide/migration.html#pool-rework
+                // poolOptions only exists in Vitest v3
+                poolOptions: {
+                  forks: {
+                    execArgv: v8Flags,
+                  },
+                },
+              }),
           globalSetup: [getCodSpeedFileFromName("globalSetup")],
           ...(runnerFile && {
             runner: runnerFile,