@hughescr/stryker-bun-runner 1.1.3 → 1.2.0

package/README.md

@@ -96,10 +96,24 @@ bun: {
 bunx stryker run
 ```
 
+## How the sandboxed config works
+
+When the plugin initialises it reads your project's `bunfig.toml` (if present) and writes a sanitized copy that is passed to every `bun test` invocation via `--config`. The sanitizer forwards only an explicit allowlist of `[test]` keys; everything else is stripped. The forwarded keys are: `preload`, `root`, `pathIgnorePatterns`, `timeout`, `smol`, `rerunEach`, `retry`, `randomize`, `seed`. The `[install]` table is copied verbatim. Two keys are always forced: `coverage = false` and `onlyFailures = false`. This prevents `coverageThreshold` misses (which cause Bun to exit 1 even when no test actually fails) from being mistaken for mutant kills. If you need additional `[test]` settings forwarded, add their key names to the `SAFE_TEST_KEYS` set in `src/utils/bunfig-sanitizer.ts`.
+
 ## Known Limitations
 
 - **Sequential execution required** - Tests run with `--concurrency=1` to ensure accurate coverage tracking. This is slower than parallel execution but necessary for correct test-to-mutant correlation.
 
+**Eager-import and `mock.module()` compatibility**
+
+During `dryRun`, the plugin eager-imports every mutated source module at preload time in order to produce deterministic per-test coverage. Each mutated module is imported once, before any test file executes.
+
+Because of this, any `mock.module()` call that runs after a module has already been imported has no effect on the already-resolved module binding. In practice, this means that if a test file calls `mock.module('./some-source-file')` at the top level (or inside a `beforeAll`), and that file is among the mutated modules, the test will see the real module rather than the mock.
+
+Suggested workarounds: use dependency injection so the real module reference is replaceable at test time; wrap the mocked surface in a test-local helper that the test can control without replacing the module; or use `mock.fn()` on method instances rather than replacing the entire module with `mock.module()`.
+
+This limitation applies only to mutated source files — the ones listed under `mutate:` in your Stryker config. Pre-import `mock.module()` of non-mutated modules (for example `node:fs`, third-party libraries, or utility files outside the mutation scope) is unaffected.
+
 ## Concurrent Tests
 
 This plugin automatically patches `describe.concurrent()`, `test.concurrent()`, and `it.concurrent()` to run sequentially during mutation testing. Your tests will work without modification.

package/dist/coverage/preload-logic.js

@@ -41,44 +41,11 @@ function writeCoverageToFile(coverageFile, data) {
   appendFileSync(coverageFile, JSON.stringify(data) + `
 `, "utf-8");
 }
-function parseWebSocketMessage(data) {
-  if (data === "ready") {
-    return "ready";
-  }
-  try {
-    const msg = JSON.parse(data);
-    if (msg.type === "testStart" && msg.name) {
-      return { type: "testStart", name: msg.name };
-    }
-  } catch {}
-  return null;
-}
-function createTestCounter() {
-  let counter = 0;
-  const counterToName = new Map;
-  return {
-    increment() {
-      counter++;
-      return `test-${counter}`;
-    },
-    setName(counterId, name) {
-      counterToName.set(counterId, name);
-    },
-    getName(counterId) {
-      return counterToName.get(counterId);
-    },
-    getCounterToNameMap() {
-      return counterToName;
-    }
-  };
-}
 export {
   writeCoverageToFile,
   shouldCollectCoverage,
   setActiveMutant,
-  parseWebSocketMessage,
   initializeStrykerNamespace,
   getPreloadConfig,
-  formatCoverageData,
-  createTestCounter
+  formatCoverageData
 };

package/dist/index.d.ts

@@ -19,11 +19,27 @@ export declare class BunTestRunner implements TestRunner {
 	private readonly inspectorTimeout;
 	private readonly env?;
 	private readonly bunArgs?;
+	private readonly mutateGlobs;
 	private preloadScriptPath?;
 	private coverageFilePath?;
+	private sanitizedBunfigPath?;
+	private sanitizedBunfigCwd?;
+	private tempDir?;
 	private cachedTestNames?;
+	private baseNameIndex?;
+	private cachedTestFiles?;
+	private cachedEagerModules?;
+	private lastRegistryTmpPath?;
 	constructor(logger: Logger, options: StrykerOptions);
 	/**
+	 * Single source of truth for the registry file name.
+	 * Using getters that read process.cwd() at call time ensures the path
+	 * resolves to Stryker's sandbox directory — which is set by the time these
+	 * are invoked — rather than the orchestrator's cwd at module-load time.
+	 */
+	private get registryPath();
+	private get registryTmpPath();
+	/**
    * Get test runner capabilities
    */
 	capabilities(): TestRunnerCapabilities;
@@ -32,6 +48,23 @@ export declare class BunTestRunner implements TestRunner {
    */
 	init(): Promise<void>;
 	/**
+   * Regenerate the sanitized bunfig if the worker's cwd has changed (or if this
+   * is the first spawn). Bun resolves relative paths in a bunfig against the
+   * bunfig file's location, so keying on cwd ensures preload/root paths land in
+   * the right sandbox.
+   */
+	private ensureSanitizedBunfig;
+	/**
+   * Load the shared dryRun registry written by the one worker that ran dryRun.
+   * Populates this.cachedTestNames and this.baseNameIndex so that subsequent
+   * mutantRun calls on this worker can resolve killedBy names correctly, even
+   * for static-coverage mutants where testFilter is empty.
+   *
+   * Failures are non-fatal — the worker falls back to raw console names (current
+   * behaviour before this fix), and a warning is logged so the issue is visible.
+   */
+	private loadRegistryFile;
+	/**
    * Build test results from inspector data
    */
 	private buildTestsFromInspector;