@hughescr/stryker-bun-runner 1.1.2 → 1.1.3

package/dist/index.d.ts

@@ -21,6 +21,7 @@ export declare class BunTestRunner implements TestRunner {
 	private readonly bunArgs?;
 	private preloadScriptPath?;
 	private coverageFilePath?;
+	private cachedTestNames?;
 	constructor(logger: Logger, options: StrykerOptions);
 	/**
    * Get test runner capabilities

package/dist/index.js

@@ -3285,8 +3285,23 @@ function mapCoverageToInspectorIds(rawCoverage, executionOrder, testHierarchy) {
   if (counterIds.length !== executionOrder.length) {
     console.warn(`Coverage/execution count mismatch: ${counterIds.length} coverage entries vs ${executionOrder.length} executed tests. ` + `Performing partial mapping for ${Math.min(counterIds.length, executionOrder.length)} tests.`);
   }
-  const remappedPerTest = {};
   const maxIndex = Math.min(counterIds.length, executionOrder.length);
+  const testNames = [];
+  for (let i = 0;i < maxIndex; i++) {
+    const inspectorId = executionOrder[i];
+    const testInfo = testHierarchy.get(inspectorId);
+    if (testInfo) {
+      testNames.push(buildUniqueTestName(testInfo.fullName, testInfo.url));
+    } else {
+      testNames.push(`unknown-${inspectorId}`);
+    }
+  }
+  const nameCounts = new Map;
+  for (const name of testNames) {
+    nameCounts.set(name, (nameCounts.get(name) ?? 0) + 1);
+  }
+  const remappedPerTest = {};
+  const nameIndexes = new Map;
   for (let i = 0;i < maxIndex; i++) {
     const counterId = counterIds[i];
     const inspectorId = executionOrder[i];
@@ -3295,7 +3310,15 @@ function mapCoverageToInspectorIds(rawCoverage, executionOrder, testHierarchy) {
       console.warn(`Missing test info for inspector ID ${inspectorId} (counter ID: ${counterId}). Skipping this test in coverage mapping.`);
       continue;
     }
-    remappedPerTest[testInfo.fullName] = rawCoverage.perTest[counterId];
+    const baseName = buildUniqueTestName(testInfo.fullName, testInfo.url);
+    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);
+    }
+    remappedPerTest[finalName] = rawCoverage.perTest[counterId];
   }
   return {
     static: rawCoverage.static,
@@ -3666,11 +3689,16 @@ function normalizeTestFilePath(url) {
   }
   return url;
 }
-function stripFilePrefix(testName) {
-  const match = /^[^\s>]+\.(?:test|spec)\.[jt]sx? > (.+)$/.exec(testName);
-  return match ? match[1] : testName;
+function normalizeTestName(testName) {
+  return testName.replace(/[^\x20-\x7E]/g, "_").trim();
+}
+function buildUniqueTestName(fullName, url) {
+  const normalizedPath = normalizeTestFilePath(url);
+  if (normalizedPath) {
+    return normalizeTestName(`${normalizedPath} > ${fullName}`);
+  }
+  return normalizeTestName(fullName);
 }
-
 class BunTestRunner {
   logger;
   static inject = tokens(commonTokens.logger, commonTokens.options);
@@ -3681,6 +3709,7 @@ class BunTestRunner {
   bunArgs;
   preloadScriptPath;
   coverageFilePath;
+  cachedTestNames;
   constructor(logger, options) {
     this.logger = logger;
     const bunOptions = options.bun ?? {};
@@ -3716,10 +3745,11 @@ class BunTestRunner {
   buildTestsFromInspector(testHierarchy, executionOrder, parsed, totalElapsedMs) {
     if (executionOrder.length === 0) {
       return parsed.tests.map((t) => {
+        const normalizedName = normalizeTestName(t.name);
         if (t.status === "failed") {
           return {
-            id: t.name,
-            name: t.name,
+            id: normalizedName,
+            name: normalizedName,
             status: TestStatus.Failed,
             failureMessage: t.failureMessage ?? "Test failed",
             timeSpentMs: Math.round(t.duration ?? 1)
@@ -3727,15 +3757,15 @@ class BunTestRunner {
         }
         if (t.status === "skipped") {
           return {
-            id: t.name,
-            name: t.name,
+            id: normalizedName,
+            name: normalizedName,
             status: TestStatus.Skipped,
             timeSpentMs: Math.round(t.duration ?? 1)
           };
         }
         return {
-          id: t.name,
-          name: t.name,
+          id: normalizedName,
+          name: normalizedName,
           status: TestStatus.Success,
           timeSpentMs: Math.round(t.duration ?? 1)
         };
@@ -3746,7 +3776,7 @@ class BunTestRunner {
     for (const test of testHierarchy) {
       testMap.set(test.id, test);
     }
-    return executionOrder.map((inspectorId) => {
+    const tests = executionOrder.map((inspectorId) => {
       const testInfo = testMap.get(inspectorId);
       if (!testInfo) {
         return {
@@ -3756,14 +3786,14 @@ class BunTestRunner {
           timeSpentMs: timePerTest
         };
       }
-      const fullName = testInfo.fullName;
+      const uniqueName = buildUniqueTestName(testInfo.fullName, testInfo.url);
       const status = testInfo.status;
       const elapsed = testInfo.elapsed !== undefined ? Math.round(testInfo.elapsed / 1e6) : timePerTest;
       if (status === "fail") {
         const parsedTest = parsed.tests.find((t) => t.name.includes(testInfo.name));
         return {
-          id: fullName,
-          name: fullName,
+          id: uniqueName,
+          name: uniqueName,
           fileName: normalizeTestFilePath(testInfo.url),
           startPosition: testInfo.line !== undefined ? { line: testInfo.line, column: 0 } : undefined,
           status: TestStatus.Failed,
@@ -3773,8 +3803,8 @@ class BunTestRunner {
       }
       if (status === "skip" || status === "todo") {
         return {
-          id: fullName,
-          name: fullName,
+          id: uniqueName,
+          name: uniqueName,
           fileName: normalizeTestFilePath(testInfo.url),
           startPosition: testInfo.line !== undefined ? { line: testInfo.line, column: 0 } : undefined,
           status: TestStatus.Skipped,
@@ -3782,14 +3812,31 @@ class BunTestRunner {
         };
       }
       return {
-        id: fullName,
-        name: fullName,
+        id: uniqueName,
+        name: uniqueName,
         fileName: normalizeTestFilePath(testInfo.url),
         startPosition: testInfo.line !== undefined ? { line: testInfo.line, column: 0 } : undefined,
         status: TestStatus.Success,
         timeSpentMs: elapsed
       };
     });
+    const nameCounts = new Map;
+    for (const test of tests) {
+      nameCounts.set(test.name, (nameCounts.get(test.name) ?? 0) + 1);
+    }
+    const nameIndexes = new Map;
+    for (const test of tests) {
+      const originalName = test.name;
+      const count = nameCounts.get(originalName) ?? 1;
+      if (count > 1) {
+        const index = nameIndexes.get(originalName) ?? 0;
+        const uniqueName = `${originalName} [${index}]`;
+        test.id = uniqueName;
+        test.name = uniqueName;
+        nameIndexes.set(originalName, index + 1);
+      }
+    }
+    return tests;
   }
   async dryRun() {
     this.logger.debug("Running dry run with inspector-based coverage collection...");
@@ -3890,6 +3937,16 @@ ${result.stderr}`
     }
     const tests = this.buildTestsFromInspector(testHierarchy, executionOrder, parsed, totalElapsedMs);
     tests.sort((a, b) => a.name.localeCompare(b.name));
+    this.cachedTestNames = new Set(tests.map((t) => t.name));
+    if (tests.length !== this.cachedTestNames.size) {
+      const nameCount = new Map;
+      for (const test of tests) {
+        nameCount.set(test.name, (nameCount.get(test.name) ?? 0) + 1);
+      }
+      const duplicates = Array.from(nameCount.entries()).filter(([_, count]) => count > 1).map(([name, count]) => `"${name}" (${count}x)`);
+      this.logger.warn("Found %d duplicate test names (total: %d, unique: %d): %s", tests.length - this.cachedTestNames.size, tests.length, this.cachedTestNames.size, duplicates.join(", "));
+    }
+    this.logger.debug("Cached %d test names from dry run for killedBy validation", this.cachedTestNames.size);
     return {
       status: DryRunStatus.Complete,
       tests,
@@ -3922,7 +3979,34 @@ ${result.stderr}`
       exitCode: result.exitCode
     });
     if (result.exitCode !== 0) {
-      const killedBy = parsed.tests.filter((test) => test.status === "failed").map((test) => stripFilePrefix(test.name));
+      const killedBy = parsed.tests.filter((test) => test.status === "failed").map((test) => normalizeTestName(test.name));
+      if (killedBy.length === 0 && parsed.tests.length === 0) {
+        const stderr = result.stderr ?? "";
+        const isRuntimeError = stderr.includes("Unhandled error") || stderr.includes("Cannot find module") || stderr.includes("SyntaxError") || stderr.includes("TypeError") || stderr.includes("ReferenceError") || stderr.includes("is not defined") || stderr.includes("Unexpected token");
+        if (isRuntimeError) {
+          this.logger.debug("Mutant %s caused runtime error (tests could not run): %s", options.activeMutant.id, stderr.slice(0, 200));
+          return {
+            status: MutantRunStatus.Error,
+            errorMessage: stderr.slice(0, 500) || `Runtime error with exit code ${result.exitCode}`
+          };
+        }
+      }
+      if (killedBy.length === 0) {
+        this.logger.debug('CACHE WARNING: No failed tests identified for mutant %s (will use "unknown" fallback). ' + "Exit code: %d, Parser found: %d total / %d passed / %d failed. " + "Parsed tests: %o", options.activeMutant.id, result.exitCode, parsed.totalTests, parsed.passed, parsed.failed, parsed.tests.map((t) => ({ name: t.name, status: t.status })));
+        if (result.stdout || result.stderr) {
+          const stdoutPreview = result.stdout?.slice(0, 500) || "(empty)";
+          const stderrPreview = result.stderr?.slice(0, 500) || "(empty)";
+          this.logger.debug("CACHE WARNING: Raw output for mutant %s - stdout: %s%s - stderr: %s%s", options.activeMutant.id, stdoutPreview, result.stdout && result.stdout.length > 500 ? "...(truncated)" : "", stderrPreview, result.stderr && result.stderr.length > 500 ? "...(truncated)" : "");
+        }
+      }
+      if (killedBy.length > 0 && this.cachedTestNames) {
+        const unknownKillers = killedBy.filter((k) => !this.cachedTestNames.has(k));
+        if (unknownKillers.length > 0) {
+          this.logger.debug("CACHE WARNING: killedBy for mutant %s contains %d test name(s) not in registry " + "(will break incremental cache): %s", options.activeMutant.id, unknownKillers.length, unknownKillers.join(", "));
+          const sampleKnown = Array.from(this.cachedTestNames).slice(0, 5);
+          this.logger.debug("CACHE WARNING: Sample of known test names from registry (first 5 of %d): %s", this.cachedTestNames.size, sampleKnown.join(", "));
+        }
+      }
       return {
         status: MutantRunStatus.Killed,
         killedBy: killedBy.length > 0 ? killedBy : ["unknown"],

package/package.json

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