bin/mutation-report.mjs

Functions

Imports

It imports no other module of this repo. No module of this repo imports it.

Source

1#!/usr/bin/env node
2// Summarises a StrykerJS run. Measurement only: it merges every mutation JSON in the report directory (one per chunk, or
3// mutation.json for a single run), prints the score and the pruning candidates, and deletes and decides nothing.
4//
5//   npx devkit-mutation-report --protected <regex> [--dir reports/mutation] [--table] [--json <file>]
6//
7// Candidates: zero-kill (kills no mutant) and covered (every mutant it kills is also killed by another test). Per test,
8// not joint: two tests that only cover each other both show up, so a pruning step must re-check. `--protected` is the
9// repository's keep rule, matched against each test's file and name (case-insensitive); a protected test is never a
10// candidate. `--table` prints a per-file markdown table; `--json` writes the kill matrix (per test: file, name, kills,
11// unique kills, candidate kind, protected).
12import { mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
13import { dirname, resolve } from "node:path";
14
15const argv = process.argv.slice(2);
16const option = (/** @type {string} */ name) => (argv.includes(name) ? argv[argv.indexOf(name) + 1] : undefined);
17const keep = option("--protected");
18if (!keep) {
19  console.error("devkit-mutation-report: --protected <regex> is required (the repository's keep rule).");
20  process.exit(1);
21}
22const PROTECTED = new RegExp(keep, "i");
23const DIR = resolve(option("--dir") ?? "reports/mutation");
24const reports = readdirSync(DIR)
25  .filter((n) => n.endsWith(".json") && n !== "kill-matrix.json" && !n.startsWith("incremental"))
26  .map((n) => JSON.parse(readFileSync(resolve(DIR, n), "utf8")));
27if (reports.length === 0) {
28  console.error(`devkit-mutation-report: no mutation JSON in ${DIR}. Run Stryker first.`);
29  process.exit(1);
30}
31
32// Test ids are per run, so across chunks a test is keyed by file and name.
33const tests = new Map();
34/** @type {Record<string, number>} */
35const counts = {};
36const perFile = new Map();
37const killers = new Map();
38for (const report of reports) {
39  const keyOf = new Map();
40  for (const [file, entry] of Object.entries(report.testFiles ?? {})) {
41    for (const test of entry.tests ?? []) {
42      const key = `${file}::${test.name}`;
43      keyOf.set(test.id, key);
44      if (!tests.has(key)) tests.set(key, { file, name: test.name, kills: new Set() });
45    }
46  }
47  for (const [file, entry] of Object.entries(report.files ?? {})) {
48    const f = perFile.get(file) ?? {};
49    perFile.set(file, f);
50    for (const mutant of entry.mutants ?? []) {
51      counts[mutant.status] = (counts[mutant.status] ?? 0) + 1;
52      f[mutant.status] = (f[mutant.status] ?? 0) + 1;
53      const key = `${file}#${mutant.id}`;
54      const by = mutant.killedBy ?? [];
55      killers.set(key, by.length);
56      for (const id of by) tests.get(keyOf.get(id))?.kills.add(key);
57    }
58  }
59}
60
61const killed = (/** @type {Record<string, number>} */ c) => (c.Killed ?? 0) + (c.Timeout ?? 0);
62const valid = (/** @type {Record<string, number>} */ c) => killed(c) + (c.Survived ?? 0) + (c.NoCoverage ?? 0);
63const pct = (/** @type {number} */ n, /** @type {number} */ d) => (d ? `${((100 * n) / d).toFixed(2)}%` : "n/a");
64
65const rows = [];
66for (const t of tests.values()) {
67  let unique = 0;
68  for (const key of t.kills) if (killers.get(key) === 1) unique += 1;
69  const isProtected = PROTECTED.test(t.file) || PROTECTED.test(t.name);
70  const kind = t.kills.size === 0 ? "zero-kill" : unique === 0 ? "covered" : "";
71  rows.push({ file: t.file, name: t.name, kills: t.kills.size, unique, kind, protected: isProtected });
72}
73const zero = rows.filter((r) => r.kind === "zero-kill");
74const covered = rows.filter((r) => r.kind === "covered");
75console.log(`Reports merged: ${reports.length}`);
76console.log("Mutant status counts:", counts);
77console.log(`Mutation score: ${pct(killed(counts), valid(counts))} (${killed(counts)} of ${valid(counts)})`);
78console.log(`Score over covered code: ${pct(killed(counts), killed(counts) + (counts.Survived ?? 0))}`);
79console.log(`Tests in the kill matrix: ${rows.length}`);
80console.log(`Zero-kill: ${zero.length} (${zero.filter((r) => r.protected).length} protected)`);
81console.log(`Covered by others: ${covered.length} (${covered.filter((r) => r.protected).length} protected)`);
82console.log(`Unprotected candidates: ${zero.filter((r) => !r.protected).length} zero-kill, ${covered.filter((r) => !r.protected).length} covered`);
83
84if (argv.includes("--table")) {
85  console.log("\n| File | Mutants | Killed | Survived | No coverage | Score |\n|---|---|---|---|---|---|");
86  for (const [file, c] of [...perFile].sort((a, b) => a[0].localeCompare(b[0]))) {
87    console.log(`| ${file} | ${valid(c)} | ${killed(c)} | ${c.Survived ?? 0} | ${c.NoCoverage ?? 0} | ${pct(killed(c), valid(c))} |`);
88  }
89}
90const out = option("--json");
91if (out) {
92  mkdirSync(dirname(resolve(out)), { recursive: true });
93  writeFileSync(resolve(out), JSON.stringify(rows, null, 2));
94  console.log(`Wrote ${out}`);
95}