Rewrite vitest-runner to no longer rely on file communcation.

See vitest-dev/vitest#7957

Author: nicojs

e2e/test/coverage-analysis/vitest.browser.config.js

@@ -2,7 +2,7 @@ import config from './vitest.config.js';
 
 config.test.browser = {
   enabled: true,
-  name: 'chromium',
+  instances: [{ browser: 'chromium' }],
   provider: 'playwright',
   headless: true,
 };

packages/vitest-runner/src/file-communicator.ts

@@ -0,0 +1,57 @@
+import { MutantCoverage } from '@stryker-mutator/api/core';
+import { MutantActivation } from '@stryker-mutator/api/test-runner';
+import { beforeEach, afterAll, beforeAll, afterEach, inject } from 'vitest';
+import { toRawTestId } from './test-helpers.js';
+
+const globalNamespace = inject('globalNamespace');
+const mutantActivation = inject('mutantActivation');
+const mode = inject('mode');
+
+const ns = globalThis[globalNamespace] || (globalThis[globalNamespace] = {});
+ns.hitLimit = inject('hitLimit');
+debugger;
+
+if (mode === 'mutant') {
+  beforeAll(() => {
+    ns.hitCount = 0;
+  });
+
+  if (mutantActivation === 'static') {
+    ns.activeMutant = inject('activeMutant');
+  } else {
+    beforeAll(() => {
+      ns.activeMutant = inject('activeMutant');
+    });
+  }
+  afterAll((suite) => {
+    suite.meta.hitCount = ns.hitCount;
+  });
+} else {
+  ns.activeMutant = undefined;
+
+  beforeEach((test) => {
+    ns.currentTestId = toRawTestId(test.task);
+  });
+
+  afterEach(() => {
+    ns.currentTestId = undefined;
+  });
+
+  afterAll((suite) => {
+    suite.meta.mutantCoverage = ns.mutantCoverage;
+  });
+}
+
+declare module 'vitest' {
+  interface ProvidedContext {
+    globalNamespace: '__stryker__' | '__stryker2__';
+    hitLimit: number | undefined;
+    mutantActivation: MutantActivation;
+    activeMutant: string | undefined;
+    mode: 'mutant' | 'dry-run';
+  }
+  interface TaskMeta {
+    hitCount: number | undefined;
+    mutantCoverage: MutantCoverage | undefined;
+  }
+}

packages/vitest-runner/src/stryker-setup.ts

@@ -0,0 +1,19 @@
+import type { RunnerTestCase, RunnerTestSuite } from 'vitest';
+
+// Don't merge this file into 'vitest-helpers.ts'!
+// This file is used from the testing environment (via stryker-setup.js) and thus could be loaded into the browser (when using vitest with browser mode).
+// Thus we should avoid unnecessary dependencies in this file.
+
+export function collectTestName({ name, suite }: { name: string; suite?: RunnerTestSuite }): string {
+  const nameParts = [name];
+  let currentSuite = suite;
+  while (currentSuite) {
+    nameParts.unshift(currentSuite.name);
+    currentSuite = currentSuite.suite;
+  }
+  return nameParts.join(' ').trim();
+}
+
+export function toRawTestId(test: RunnerTestCase): string {
+  return `${test.file?.filepath ?? 'unknown.js'}#${collectTestName(test)}`;
+}

packages/vitest-runner/src/test-helpers.ts

@@ -1,8 +1,9 @@
 import path from 'path';
 
 import { BaseTestResult, TestResult, TestStatus } from '@stryker-mutator/api/test-runner';
-import type { RunMode, Suite, TaskState, Test, ResolvedConfig } from 'vitest';
+import type { RunMode, RunnerTestSuite, TaskState, RunnerTestCase } from 'vitest';
 import { MutantCoverage } from '@stryker-mutator/api/core';
+import { collectTestName, toRawTestId } from './test-helpers.js';
 
 function convertTaskStateToTestStatus(taskState: TaskState | undefined, testMode: RunMode): TestStatus {
   if (testMode === 'skip') {
@@ -21,7 +22,7 @@ function convertTaskStateToTestStatus(taskState: TaskState | undefined, testMode
   return TestStatus.Failed;
 }
 
-export function convertTestToTestResult(test: Test): TestResult {
+export function convertTestToTestResult(test: RunnerTestCase): TestResult {
   const status = convertTaskStateToTestStatus(test.result?.state, test.mode);
   const baseTestResult: BaseTestResult = {
     id: normalizeTestId(toRawTestId(test)),
@@ -62,7 +63,7 @@ export function normalizeCoverage(rawCoverage: MutantCoverage): MutantCoverage {
   };
 }
 
-export function collectTestsFromSuite(suite: Suite): Test[] {
+export function collectTestsFromSuite(suite: RunnerTestSuite): RunnerTestCase[] {
   return suite.tasks.flatMap((task) => {
     if (task.type === 'suite') {
       return collectTestsFromSuite(task);
@@ -73,40 +74,3 @@ export function collectTestsFromSuite(suite: Suite): Test[] {
     }
   });
 }
-
-export function addToInlineDeps(config: ResolvedConfig, matcher: RegExp): void {
-  switch (typeof config.deps?.inline) {
-    case 'undefined':
-      config.deps = { inline: [matcher] };
-      break;
-    case 'object':
-      config.deps.inline.push(matcher);
-      break;
-    case 'boolean':
-      if (!config.deps.inline) {
-        config.deps.inline = [matcher];
-      }
-      break;
-    default:
-      config.deps.inline satisfies never;
-  }
-}
-
-// Stryker disable all: the function toTestId will be stringified at runtime which will cause problems when mutated.
-
-// Note: this function is used in code and copied to the mutated environment so the naming convention will always be the same.
-// It can not use external resource because those will not be available in the mutated environment.
-export function collectTestName({ name, suite }: { name: string; suite?: Suite }): string {
-  const nameParts = [name];
-  let currentSuite = suite;
-  while (currentSuite) {
-    nameParts.unshift(currentSuite.name);
-    currentSuite = currentSuite.suite;
-  }
-  return nameParts.join(' ').trim();
-}
-
-export function toRawTestId(test: Test): string {
-  return `${test.file?.filepath ?? 'unknown.js'}#${collectTestName(test)}`;
-}
-// Stryker restore all

packages/vitest-runner/src/vitest-helpers.ts

@@ -15,25 +15,26 @@ import {
 import { escapeRegExp, notEmpty } from '@stryker-mutator/util';
 
 import { vitestWrapper, Vitest } from './vitest-wrapper.js';
-import { convertTestToTestResult, fromTestId, collectTestsFromSuite, addToInlineDeps, normalizeCoverage } from './vitest-helpers.js';
-import { FileCommunicator } from './file-communicator.js';
+import { convertTestToTestResult, fromTestId, collectTestsFromSuite, normalizeCoverage } from './vitest-helpers.js';
 import { VitestRunnerOptionsWithStrykerOptions } from './vitest-runner-options-with-stryker-options.js';
+import { fileURLToPath } from 'url';
 
 type StrykerNamespace = '__stryker__' | '__stryker2__';
+const STRYKER_SETUP = fileURLToPath(new URL('./stryker-setup.js', import.meta.url));
 
 export class VitestTestRunner implements TestRunner {
   public static inject = [commonTokens.options, commonTokens.logger, 'globalNamespace'] as const;
   private ctx?: Vitest;
-  private readonly fileCommunicator: FileCommunicator;
+  // private readonly fileCommunicator: FileCommunicator;
   private readonly options: VitestRunnerOptionsWithStrykerOptions;
 
   constructor(
     options: StrykerOptions,
     private readonly log: Logger,
-    globalNamespace: StrykerNamespace,
+    private globalNamespace: StrykerNamespace,
   ) {
     this.options = options as VitestRunnerOptionsWithStrykerOptions;
-    this.fileCommunicator = new FileCommunicator(globalNamespace);
+    // this.fileCommunicator = new FileCommunicator(globalNamespace);
   }
 
   public capabilities(): TestRunnerCapabilities {
@@ -62,26 +63,22 @@ export class VitestTestRunner implements TestRunner {
       bail: this.options.disableBail ? 0 : 1,
       onConsoleLog: () => false,
     });
-
-    // The vitest setup file needs to be inlined
-    // See https://github.com/vitest-dev/vitest/issues/3403#issuecomment-1554057966
-    const vitestSetupMatcher = new RegExp(escapeRegExp(this.fileCommunicator.vitestSetup));
-    addToInlineDeps(this.ctx.config, vitestSetupMatcher);
+    this.ctx.provide('globalNamespace', this.globalNamespace);
     this.ctx.config.browser.screenshotFailures = false;
     this.ctx.projects.forEach((project) => {
-      project.config.setupFiles = [this.fileCommunicator.vitestSetup, ...project.config.setupFiles];
+      project.config.setupFiles = [STRYKER_SETUP, ...project.config.setupFiles];
       project.config.browser.screenshotFailures = false;
-      addToInlineDeps(project.config, vitestSetupMatcher);
     });
     if (this.log.isDebugEnabled()) {
       this.log.debug(`vitest final config: ${JSON.stringify(this.ctx.config, null, 2)}`);
     }
   }
 
   public async dryRun(): Promise<DryRunResult> {
-    await this.fileCommunicator.setDryRun();
+    this.ctx!.provide('mode', 'dry-run');
+
     const testResult = await this.run();
-    const mutantCoverage: MutantCoverage = this.readMutantCoverage();
+    const mutantCoverage = this.readMutantCoverage();
     if (testResult.status === DryRunStatus.Complete) {
       return {
         status: testResult.status,
@@ -93,7 +90,10 @@ export class VitestTestRunner implements TestRunner {
   }
 
   public async mutantRun(options: MutantRunOptions): Promise<MutantRunResult> {
-    await this.fileCommunicator.setMutantRun(options);
+    this.ctx!.provide('mode', 'mutant');
+    this.ctx!.provide('hitLimit', options.hitLimit);
+    this.ctx!.provide('mutantActivation', options.mutantActivation);
+    this.ctx!.provide('activeMutant', options.activeMutant.id);
     const dryRunResult = await this.run(options.testFilter);
     const hitCount = this.readHitCount();
     const timeOut = determineHitLimitReached(hitCount, options.hitLimit);
@@ -150,21 +150,6 @@ export class VitestTestRunner implements TestRunner {
     // Clear the state from the previous run
     // Note that this is kind of a hack, see https://github.com/vitest-dev/vitest/discussions/3017#discussioncomment-5901751
     this.ctx!.state.filesMap.clear();
-
-    // Since we:
-    // 1. are reusing the same vitest instance
-    // 2. have changed the vitest setup file contents (see FileCommunicator.setMutantRun)
-    // 3. the vitest setup file is inlined (see VitestTestRunner.init)
-    // 4. we're not using the vitest watch mode
-    // We need to invalidate the module cache for the vitest setup file
-    // See https://github.com/vitest-dev/vitest/issues/3409#issuecomment-1555884513
-    this.ctx!.projects.forEach((project) => {
-      const { moduleGraph } = project.server;
-      const module = moduleGraph.getModuleById(this.fileCommunicator.vitestSetup);
-      if (module) {
-        moduleGraph.invalidateModule(module);
-      }
-    });
   }
 
   private readHitCount() {
@@ -213,7 +198,7 @@ export class VitestTestRunner implements TestRunner {
   }
 
   public async dispose(): Promise<void> {
-    await this.fileCommunicator.dispose();
+    // await this.fileCommunicator.dispose();
     await this.ctx?.close();
   }
 }

packages/vitest-runner/src/vitest-test-runner.ts

@@ -25,7 +25,7 @@ describe('VitestRunner in browser mode', () => {
 
     sandbox = new TempTestDirectorySandbox('browser-project', { soft: true });
     await sandbox.init();
-    sandboxFileName = path.resolve(sandbox.tmpDir, 'src/heading.component.ts');
+    sandboxFileName = path.resolve(sandbox.tmpDir, 'src/math.component.ts');
     await sut.init();
   });
   afterEach(async () => {
@@ -137,9 +137,10 @@ describe('VitestRunner in browser mode', () => {
 
     it('should be able to survive after killing mutant', async () => {
       // Arrange
-      await sut.mutantRun(
+      const initResult = await sut.mutantRun(
         factory.mutantRunOptions({ activeMutant: factory.mutant({ id: '50' }), mutantActivation: 'runtime', testFilter: [test3], sandboxFileName }),
       );
+      assertions.expectKilled(initResult);
 
       // Act
       const runResult = await sut.mutantRun(
@@ -156,6 +157,28 @@ describe('VitestRunner in browser mode', () => {
       expect(runResult.nrOfTests).eq(1);
     });
 
+    it('should be able to kill after survive mutant', async () => {
+      // Arrange
+      const initResult = await sut.mutantRun(
+        factory.mutantRunOptions({
+          activeMutant: factory.mutant({ id: '48' }), // Should survive
+          sandboxFileName,
+          mutantActivation: 'runtime',
+          testFilter: [test2],
+        }),
+      );
+      assertions.expectSurvived(initResult);
+
+      // Act
+      const runResult = await sut.mutantRun(
+        factory.mutantRunOptions({ activeMutant: factory.mutant({ id: '50' }), mutantActivation: 'runtime', testFilter: [test3], sandboxFileName }),
+      );
+
+      // Assert
+      assertions.expectKilled(runResult);
+      expect(runResult.nrOfTests).eq(1);
+    });
+
     it('should be able to kill a static mutant', async () => {
       // Act
       const runResult = await sut.mutantRun(