module-spec 0.2.0 → 0.2.2

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.2.2
+
+- `mutate` names every live mutant. When two shared a file and a change, such as two
+  `StringLiteral: ""`, it named only the first, so a module showed 20 of its 70.
+
+## 0.2.1
+
+- Under vitest, a live mutant of a module-level constant or regex runs again in a fresh vitest
+  process. Stryker's vitest runner, given the module's test files, ran its tests without the
+  mutant switched on, so it read as live whatever the tests checked.
+
 ## 0.2.0
 
 - `mutate` counts only the module's core, shell and door tests. An adapter's test and a

package/lib/languages/typescript/mutate.js

@@ -11,10 +11,18 @@ const OUTPUT_LIMIT = 512 * 1024 * 1024;
 const CAUGHT = new Set(["Killed", "Timeout"]);
 const LIVE = new Set(["Survived", "NoCoverage"]);
 
+/** The project's own vitest, as Stryker's vitest runner loads it, or else the kit's. */
+function vitestBin(root) {
+  const local = path.join(root, "node_modules", "vitest");
+  const dir = fs.existsSync(path.join(local, "package.json")) ? local : kitPackageDir("vitest");
+  return path.join(dir, JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8")).bin.vitest);
+}
+
 /** The shell command that runs only `tests`, with the project's own runner. Stryker runs it once per mutant. */
 function testCommand(root, tests) {
   const files = tests.map((file) => JSON.stringify(file)).join(" ");
-  return testRunnerOf(root) === "vitest" ? `node_modules/.bin/vitest run ${files}` : `${JSON.stringify(process.execPath)} --test ${files}`;
+  if (testRunnerOf(root) !== "vitest") return `${JSON.stringify(process.execPath)} --test ${files}`;
+  return `${JSON.stringify(process.execPath)} ${JSON.stringify(vitestBin(root))} run ${files}`;
 }
 
 const oneLine = (text) => {
@@ -51,38 +59,59 @@ function incrementalConfig(root, module) {
   return { incremental: true, incrementalFile: path.join(root, "node_modules", ".cache", "module-spec", "mutate", file) };
 }
 
+/** One Stryker run with `config`, in its own folder under `work`, and the mutants it reported. */
+function strykerRun(root, work, name, config) {
+  const report = path.join(work, `${name}.json`);
+  const configFile = path.join(work, `${name}.config.json`);
+  fs.writeFileSync(configFile, JSON.stringify({
+    ...config,
+    reporters: ["json"],
+    jsonReporter: { fileName: report },
+    tempDirName: path.join(work, `${name}-sandbox`),
+    cleanTempDir: "always",
+    checkers: [],
+    // Stryker rewrites tsconfig.json with the project's own TypeScript, which from version 7 has no JS API. The kit's
+    // runners read TypeScript without it, so the rewrite is skipped by naming a file that does not exist.
+    tsconfigFile: "module-spec-skips-the-tsconfig-rewrite.json",
+    logLevel: "error",
+  }));
+  const dir = kitPackageDir("@stryker-mutator/core");
+  const bin = path.join(dir, JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8")).bin.stryker);
+  const run = spawnSync(process.execPath, [bin, "run", configFile], { cwd: root, env: environmentForTests(), encoding: "utf8", maxBuffer: OUTPUT_LIMIT });
+  if (run.status !== 0 || !fs.existsSync(report)) throw new Error(`Stryker failed:\n${run.stderr || run.stdout}`);
+  return Object.entries(JSON.parse(fs.readFileSync(report, "utf8")).files).flatMap(([file, { mutants }]) => mutants.map((mutant) => ({ ...mutant, file })));
+}
+
+const mutantKey = (mutant) => `${mutant.file}:${mutant.location.start.line}:${mutant.location.start.column} ${mutant.mutatorName} ${mutant.replacement ?? ""}`;
+/** Stryker reads a range's columns from another origin than its report writes them, so a range names whole lines. */
+const linesOf = ({ file, location: { start, end } }) => `${file}:${start.line}-${end.line}`;
+
+/**
+ * Stryker's vitest runner, given the module's test files, runs a static mutant's tests without the mutant switched
+ * on, so a module-level constant or regex reads as live whatever its tests check. A command run starts vitest anew
+ * for each mutant, so the module loads with the mutant on. Only the live static mutants run again that way.
+ */
+function withStaticMutantsRetested(root, work, tests, mutants) {
+  const doubtful = mutants.filter((mutant) => mutant.static && LIVE.has(mutant.status));
+  if (doubtful.length === 0) return mutants;
+  const retested = new Map(
+    strykerRun(root, work, "static", {
+      testRunner: "command",
+      commandRunner: { command: testCommand(root, tests) },
+      coverageAnalysis: "off",
+      plugins: [],
+      mutate: [...new Set(doubtful.map(linesOf))],
+    }).map((mutant) => [mutantKey(mutant), mutant.status]),
+  );
+  return mutants.map((mutant) => (retested.has(mutantKey(mutant)) ? { ...mutant, status: retested.get(mutantKey(mutant)) } : mutant));
+}
+
 /** Mutation testing by the kit's own StrykerJS, in a sandbox under the system temp folder. */
 export async function mutate({ root, module, files, tests }) {
   const work = fs.mkdtempSync(path.join(os.tmpdir(), "module-spec-stryker-"));
   try {
-    const report = path.join(work, "report.json");
-    const configFile = path.join(work, "stryker.config.json");
-    fs.writeFileSync(configFile, JSON.stringify({
-      ...runnerConfig(root, tests),
-      mutate: files,
-      reporters: ["json"],
-      jsonReporter: { fileName: report },
-      tempDirName: path.join(work, "sandbox"),
-      cleanTempDir: "always",
-      checkers: [],
-      // Stryker rewrites tsconfig.json with the project's own TypeScript, which from version 7 has no JS API. The kit's
-      // runners read TypeScript without it, so the rewrite is skipped by naming a file that does not exist.
-      tsconfigFile: "module-spec-skips-the-tsconfig-rewrite.json",
-      logLevel: "error",
-      ...incrementalConfig(root, module),
-    }));
-    const dir = kitPackageDir("@stryker-mutator/core");
-    const bin = path.join(dir, JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8")).bin.stryker);
-    const run = spawnSync(process.execPath, [bin, "run", configFile], {
-      cwd: root,
-      env: environmentForTests(),
-      encoding: "utf8",
-      maxBuffer: OUTPUT_LIMIT,
-    });
-    if (run.status !== 0 || !fs.existsSync(report)) throw new Error(`Stryker failed:\n${run.stderr || run.stdout}`);
-    const mutants = Object.entries(JSON.parse(fs.readFileSync(report, "utf8")).files).flatMap(([file, { mutants }]) =>
-      mutants.map((mutant) => ({ ...mutant, file })),
-    );
+    const first = strykerRun(root, work, "run", { ...runnerConfig(root, tests), mutate: files, ...incrementalConfig(root, module) });
+    const mutants = testRunnerOf(root) === "vitest" ? withStaticMutantsRetested(root, work, tests, first) : first;
     return {
       killed: mutants.filter((mutant) => CAUGHT.has(mutant.status)).length,
       survivors: mutants

package/lib/mutation.js

@@ -68,8 +68,9 @@ export function judge(accepted, survivors, accept) {
   for (const entry of accepted) left.set(keyOf(entry), (left.get(keyOf(entry)) ?? 0) + 1);
   const fresh = survivors.filter((survivor) => {
     const count = left.get(keyOf(survivor)) ?? 0;
+    if (count === 0) return true;
     left.set(keyOf(survivor), count - 1);
-    return count === 0;
+    return false;
   });
   return { failed: fresh.length > 0, fresh };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "module-spec",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "How every project splits its code into modules, with the checks that enforce it. The why behind each rule: spec/.",
   "type": "module",
   "packageManager": "pnpm@12.10.1",