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,13 +2,9 @@ import config from './vitest.config.js';
 
 config.test.browser = {
   enabled: true,
+  instances: [{ browser: 'chromium' }],
   provider: 'playwright',
   headless: true,
-  instances: [
-    {
-      browser: 'chromium',
-    }
-  ]
 };
 
 export default config;

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

@@ -4,6 +4,7 @@ import { BaseTestResult, TestResult, TestStatus } from '@stryker-mutator/api/tes
 import type { RunMode, TaskState } from 'vitest';
 import { RunnerTestCase, RunnerTestSuite } from 'vitest/node';
 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') {
@@ -74,22 +75,3 @@ export function collectTestsFromSuite(suite: RunnerTestSuite): RunnerTestCase[]
     }
   });
 }
-
-// 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?: 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)}`;
-}
-// Stryker restore all

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

@@ -16,24 +16,25 @@ import { escapeRegExp, notEmpty } from '@stryker-mutator/util';
 
 import { vitestWrapper, Vitest } from './vitest-wrapper.js';
 import { convertTestToTestResult, fromTestId, collectTestsFromSuite, normalizeCoverage } from './vitest-helpers.js';
-import { FileCommunicator } from './file-communicator.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,20 +63,22 @@ export class VitestTestRunner implements TestRunner {
       bail: this.options.disableBail ? 0 : 1,
       onConsoleLog: () => false,
     });
-
+    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;
     });
     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,
@@ -87,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);
@@ -141,21 +147,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.vite;
-      const module = moduleGraph.getModuleById(this.fileCommunicator.vitestSetup);
-      if (module) {
-        moduleGraph.invalidateModule(module);
-      }
-    });
   }
 
   private readHitCount() {
@@ -204,7 +195,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(