@hughescr/stryker-bun-runner 1.2.1 → 1.2.2

package/dist/index.d.ts

@@ -83,7 +83,12 @@ export declare class BunTestRunner implements TestRunner {
    */
 	private loadRegistryFile;
 	/**
-   * Build test results from inspector data
+   * Build test results from inspector data.
+   *
+   * @param inspectorIdToProjectFile - Optional mapping from inspector ID to project file path.
+   *   When provided, the project file is used for TestResult.id, name, and fileName instead of
+   *   testInfo.url. This is important for tests defined via helpers (e.g. RuleTester.run()) where
+   *   Bun's inspector reports a url pointing to node_modules rather than the user's test file.
    */
 	private buildTestsFromInspector;
 	/**

package/dist/index.js

@@ -5593,6 +5593,9 @@ function normalizeTestFilePath(url) {
 function normalizeTestName(testName) {
   return testName.replaceAll(/\p{Cc}/gu, "_").trim();
 }
+function buildProjectFileTestName(filePrefix, fullName) {
+  return normalizeTestName(`${filePrefix} > ${fullName}`);
+}
 function buildUniqueTestName(fullName, url) {
   const normalizedPath = normalizeTestFilePath(url);
   if (normalizedPath) {
@@ -5604,16 +5607,16 @@ function buildUniqueTestName(fullName, url) {
 // src/coverage/coverage-mapper.ts
 function mapCoverageToInspectorIds(rawCoverage, executionOrder, testHierarchy, logger) {
   if (!rawCoverage?.perTest || Object.keys(rawCoverage.perTest).length === 0) {
-    return rawCoverage ?? undefined;
+    return { coverage: rawCoverage ?? undefined, inspectorIdToProjectFile: new Map };
   }
   const firstKey = Object.keys(rawCoverage.perTest)[0];
   if (/@@test-\d+$/.test(firstKey)) {
     return mapFilePrefixedCounterKeys(rawCoverage, executionOrder, testHierarchy, logger);
   }
   if (/^test-\d+$/.test(firstKey)) {
-    return mapLegacyCounterKeys(rawCoverage, executionOrder, testHierarchy, logger);
+    return { coverage: mapLegacyCounterKeys(rawCoverage, executionOrder, testHierarchy, logger), inspectorIdToProjectFile: new Map };
   }
-  return rawCoverage;
+  return { coverage: rawCoverage, inspectorIdToProjectFile: new Map };
 }
 function countPerTestAppearances(perTestEntries) {
   const appearances = new Map;
@@ -5671,22 +5674,23 @@ function stabilizeCoverage(coverage) {
   const newPerTest = buildFilteredPerTest(perTestEntries, promoteToStatic);
   return { static: newStatic, perTest: newPerTest };
 }
-function buildFileToInspectorIds(executionOrder, testHierarchy) {
-  const fileToInspectorIds = new Map;
-  for (const inspectorId of executionOrder) {
-    const testInfo = testHierarchy.get(inspectorId);
-    if (!testInfo) {
-      continue;
-    }
-    const relFile = normalizeTestFilePath(testInfo.url) ?? "";
-    const bucket = fileToInspectorIds.get(relFile);
-    if (bucket) {
-      bucket.push(inspectorId);
-    } else {
-      fileToInspectorIds.set(relFile, [inspectorId]);
-    }
+function pairKeysWithInspectorIds(globallyOrderedPerTestKeys, executionOrder, testHierarchy, logger) {
+  const nonSkipped = executionOrder.filter((id) => {
+    const status = testHierarchy.get(id)?.status;
+    return status !== "skip" && status !== "todo";
+  });
+  if (globallyOrderedPerTestKeys.length < nonSkipped.length) {
+    logger?.warn("Coverage/execution count mismatch: %s coverage entries vs %s non-skipped executed tests. " + "Performing partial mapping for %s tests.", globallyOrderedPerTestKeys.length, nonSkipped.length, Math.min(globallyOrderedPerTestKeys.length, nonSkipped.length));
+  }
+  const pairCount = Math.min(globallyOrderedPerTestKeys.length, nonSkipped.length);
+  const pairs = [];
+  for (let i = 0;i < pairCount; i++) {
+    const key = globallyOrderedPerTestKeys[i];
+    const sepIdx = key.indexOf("@@");
+    const filePrefix = sepIdx === -1 ? key : key.slice(0, sepIdx);
+    pairs.push({ filePrefix, inspectorId: nonSkipped[i] });
   }
-  return fileToInspectorIds;
+  return pairs;
 }
 function resolveCounterKeys(counterIds, fileToInspectorIds, testHierarchy, logger) {
   return counterIds.map((key) => {
@@ -5695,51 +5699,115 @@ function resolveCounterKeys(counterIds, fileToInspectorIds, testHierarchy, logge
     const counterStr = key.slice(sepIdx + 2 + "test-".length);
     const n = Number.parseInt(counterStr, 10);
     const fileIds = fileToInspectorIds.get(filePrefix);
-    const inspectorId = fileIds?.[n - 1];
+    const clampedIdx = fileIds ? Math.min(n - 1, fileIds.length - 1) : undefined;
+    const inspectorId = clampedIdx === undefined ? undefined : fileIds?.[clampedIdx];
     const testInfo = inspectorId === undefined ? undefined : testHierarchy.get(inspectorId);
     if (testInfo) {
-      return { name: buildUniqueTestName(testInfo.fullName, testInfo.url), testInfo };
+      const testName = buildProjectFileTestName(filePrefix, testInfo.fullName);
+      return { name: testName, testInfo, inspectorId };
     }
     logger?.warn('Coverage key %s: no inspector test found for file "%s" at position %s ' + "(file has %s tests in execution order). Skipping this test in coverage mapping.", key, filePrefix, n, fileToInspectorIds.get(filePrefix)?.length ?? 0);
-    return { name: `unknown-${key}`, testInfo: null };
+    return { name: `unknown-${key}`, testInfo: null, inspectorId: undefined };
   });
 }
-function buildRemappedPerTest(counterIds, resolved, rawPerTest) {
-  const nameCounts = new Map;
-  for (const { name } of resolved) {
-    nameCounts.set(name, (nameCounts.get(name) ?? 0) + 1);
+function buildNameInspectorIds(resolved) {
+  const nameInspectorIds = new Map;
+  for (const { name, inspectorId, testInfo } of resolved) {
+    if (!testInfo) {
+      continue;
+    }
+    let ids = nameInspectorIds.get(name);
+    if (!ids) {
+      ids = new Set;
+      nameInspectorIds.set(name, ids);
+    }
+    ids.add(inspectorId);
   }
+  return nameInspectorIds;
+}
+function resolveEachTestName(baseName, inspectorId, nameInspectorIds, nameIndexes) {
+  const distinctIds = nameInspectorIds.get(baseName);
+  if ((distinctIds?.size ?? 1) <= 1) {
+    return baseName;
+  }
+  const key_ = `${inspectorId}/${baseName}`;
+  const existingIndex = nameIndexes.get(key_);
+  if (existingIndex === undefined) {
+    const nextIndex = nameIndexes.get(baseName) ?? 0;
+    nameIndexes.set(key_, nextIndex);
+    nameIndexes.set(baseName, nextIndex + 1);
+    return `${baseName} [${nextIndex}]`;
+  }
+  return `${baseName} [${existingIndex}]`;
+}
+function buildRemappedPerTest(counterIds, resolved, rawPerTest) {
+  const nameInspectorIds = buildNameInspectorIds(resolved);
   const remappedPerTest = {};
   const nameIndexes = new Map;
   for (const [i, key] of counterIds.entries()) {
-    const { name: baseName, testInfo } = resolved[i];
+    const { name: baseName, testInfo, inspectorId } = resolved[i];
     if (!testInfo) {
       continue;
     }
-    const count = nameCounts.get(baseName) ?? 1;
-    let finalName = baseName;
-    if (count > 1) {
-      const index = nameIndexes.get(baseName) ?? 0;
-      finalName = `${baseName} [${index}]`;
-      nameIndexes.set(baseName, index + 1);
+    const finalName = resolveEachTestName(baseName, inspectorId, nameInspectorIds, nameIndexes);
+    const incoming = rawPerTest[key];
+    const existing = remappedPerTest[finalName];
+    if (existing) {
+      for (const [mutantId, count_] of Object.entries(incoming)) {
+        existing[mutantId] = (existing[mutantId] ?? 0) + count_;
+      }
+    } else {
+      remappedPerTest[finalName] = { ...incoming };
     }
-    remappedPerTest[finalName] = rawPerTest[key];
   }
   return remappedPerTest;
 }
+function warnInteriorGapIfPresent(pairs, testHierarchy, logger) {
+  const warnedFiles = new Set;
+  for (const { filePrefix, inspectorId } of pairs) {
+    const testUrl = testHierarchy.get(inspectorId)?.url;
+    if (!testUrl) {
+      continue;
+    }
+    const inspectorFile = normalizeTestFilePath(testUrl);
+    if (!inspectorFile || testUrl.includes("node_modules")) {
+      continue;
+    }
+    if (filePrefix !== inspectorFile && !warnedFiles.has(filePrefix)) {
+      warnedFiles.add(filePrefix);
+      logger?.warn('Interior coverage gap detected for "%s": coverage key paired with inspector test from "%s". ' + "Some tests may have been aborted mid-run (e.g. beforeAll failure). Coverage mapping may be inaccurate.", filePrefix, inspectorFile);
+    }
+  }
+}
 function mapFilePrefixedCounterKeys(rawCoverage, executionOrder, testHierarchy, logger) {
-  const fileToInspectorIds = buildFileToInspectorIds(executionOrder, testHierarchy);
-  const counterIds = Object.keys(rawCoverage.perTest).toSorted((a, b) => {
+  const globallyOrderedKeys = Object.keys(rawCoverage.perTest);
+  const pairs = pairKeysWithInspectorIds(globallyOrderedKeys, executionOrder, testHierarchy, logger);
+  const fileToInspectorIds = new Map;
+  const inspectorIdToProjectFile = new Map;
+  for (const { filePrefix, inspectorId } of pairs) {
+    const bucket = fileToInspectorIds.get(filePrefix);
+    if (bucket) {
+      bucket.push(inspectorId);
+    } else {
+      fileToInspectorIds.set(filePrefix, [inspectorId]);
+    }
+    inspectorIdToProjectFile.set(inspectorId, filePrefix);
+  }
+  if (globallyOrderedKeys.length === pairs.length) {
+    warnInteriorGapIfPresent(pairs, testHierarchy, logger);
+  }
+  const counterIds = globallyOrderedKeys.toSorted((a, b) => {
     const nA = Number.parseInt(a.split("@@test-")[1] ?? "0", 10);
     const nB = Number.parseInt(b.split("@@test-")[1] ?? "0", 10);
     return nA - nB;
   });
   const resolved = resolveCounterKeys(counterIds, fileToInspectorIds, testHierarchy, logger);
   const remappedPerTest = buildRemappedPerTest(counterIds, resolved, rawCoverage.perTest);
-  return stabilizeCoverage({
+  const coverage = stabilizeCoverage({
     static: rawCoverage.static,
     perTest: remappedPerTest
   });
+  return { coverage, inspectorIdToProjectFile };
 }
 function mapLegacyCounterKeys(rawCoverage, executionOrder, testHierarchy, logger) {
   const counterIds = Object.keys(rawCoverage.perTest).toSorted((a, b) => Number.parseInt(a.split("-")[1] ?? "0", 10) - Number.parseInt(b.split("-")[1] ?? "0", 10));
@@ -7870,7 +7938,7 @@ class BunTestRunner {
       }
     }
   }
-  buildTestsFromInspector(testHierarchy, executionOrder, parsed, totalElapsedMs) {
+  buildTestsFromInspector(testHierarchy, executionOrder, parsed, totalElapsedMs, inspectorIdToProjectFile) {
     if (executionOrder.length === 0) {
       return parsed.tests.map((t) => {
         const normalizedName = normalizeTestName(t.name);
@@ -7914,7 +7982,9 @@ class BunTestRunner {
           timeSpentMs: timePerTest
         };
       }
-      const uniqueName = buildUniqueTestName(testInfo.fullName, testInfo.url);
+      const projectFile = inspectorIdToProjectFile?.get(inspectorId);
+      const uniqueName = projectFile ? buildProjectFileTestName(projectFile, testInfo.fullName) : buildUniqueTestName(testInfo.fullName, testInfo.url);
+      const fileName = projectFile ?? normalizeTestFilePath(testInfo.url);
       const status = testInfo.status;
       const elapsed = testInfo.elapsed === undefined ? timePerTest : Math.round(testInfo.elapsed / 1e6);
       const startPosition = testInfo.line === undefined ? undefined : { line: testInfo.line, column: 0 };
@@ -7923,7 +7993,7 @@ class BunTestRunner {
         return {
           id: uniqueName,
           name: uniqueName,
-          fileName: normalizeTestFilePath(testInfo.url),
+          fileName,
           startPosition,
           status: TestStatus.Failed,
           failureMessage: parsedTest?.failureMessage ?? testInfo.error?.message ?? "Test failed",
@@ -7934,7 +8004,7 @@ class BunTestRunner {
         return {
           id: uniqueName,
           name: uniqueName,
-          fileName: normalizeTestFilePath(testInfo.url),
+          fileName,
           startPosition,
           status: TestStatus.Skipped,
           timeSpentMs: elapsed
@@ -7943,7 +8013,7 @@ class BunTestRunner {
       return {
         id: uniqueName,
         name: uniqueName,
-        fileName: normalizeTestFilePath(testInfo.url),
+        fileName,
         startPosition,
         status: TestStatus.Success,
         timeSpentMs: elapsed
@@ -8073,8 +8143,8 @@ exit=%s timedOut=%s
       if (earlyResult) {
         return earlyResult;
       }
-      const mutantCoverage = await this.collectAndRemapCoverage(testHierarchy, executionOrder);
-      const tests = this.buildTestsFromInspector(testHierarchy, executionOrder, parsed, totalElapsedMs);
+      const { coverage: mutantCoverage, inspectorIdToProjectFile } = await this.collectAndRemapCoverage(testHierarchy, executionOrder);
+      const tests = this.buildTestsFromInspector(testHierarchy, executionOrder, parsed, totalElapsedMs, inspectorIdToProjectFile);
       tests.sort((a, b) => a.name.localeCompare(b.name));
       await this.buildAndPersistTestRegistry(tests);
       return {
@@ -8229,16 +8299,17 @@ ${result.stderr}`
     return null;
   }
   async collectAndRemapCoverage(testHierarchy, executionOrder) {
+    const testMap = new Map(testHierarchy.map((t) => [t.id, t]));
     if (!this.coverageFilePath) {
-      return;
+      return { coverage: undefined, inspectorIdToProjectFile: new Map };
     }
     const rawCoverage = await collectCoverage(this.coverageFilePath, this.logger);
     await cleanupCoverageFile(this.coverageFilePath);
     if (!rawCoverage) {
-      return;
+      return { coverage: undefined, inspectorIdToProjectFile: new Map };
     }
-    const testMap = new Map(testHierarchy.map((t) => [t.id, t]));
-    return mapCoverageToInspectorIds(rawCoverage, executionOrder, testMap, this.logger);
+    const { coverage, inspectorIdToProjectFile } = mapCoverageToInspectorIds(rawCoverage, executionOrder, testMap, this.logger);
+    return { coverage, inspectorIdToProjectFile };
   }
   buildLocalTestFilterIndex(testFilter) {
     const localRegistry = new Set(testFilter);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hughescr/stryker-bun-runner",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "Stryker test runner plugin for Bun with perTest coverage support",
   "keywords": [
     "stryker",