@t09tanaka/test-gates 0.3.3 → 0.4.0

package/dist/stryker.d.cts

@@ -12,13 +12,27 @@ interface StrykerGatesOptions {
  * mutants the speed stayed the same to the end.
  */
 declare const DEFAULT_MAX_TEST_RUNNER_REUSE = 50;
+/**
+ * How many test runners Stryker starts when neither the config nor the command line says
+ * (`concurrency`). Stryker's own default is one fewer than the cores (on more than four), but
+ * each of its runners is a Jest or Vitest that does work besides the tests (transforms, coverage),
+ * and the machine is rarely free for the run alone: half of the cores, at most 8. Measured on
+ * two projects on a machine with 12 cores, 6 runners took about half the time of 2, with the
+ * same numbers of killed, survived and timed-out mutants. In CI (`CI` set) 2, the cores of the
+ * usual hosted runner: more runners than cores only make the mutants run out of time.
+ *
+ * @param parallelism What `os.availableParallelism()` says.
+ */
+declare function defaultConcurrency(parallelism: number, ci: boolean): number;
 /**
  * Stryker config for the gates: mutate exactly the gates, never fail on the score
  * (`thresholds.break: null`), and write the JSON report that `test-gates mutation` judges.
  *
  * `mutate`, `thresholds.break` and `jsonReporter.fileName` are always set here, and `json` is
  * always among the reporters. Options that take mutants out of the evaluation are rejected.
+ * `concurrency` is defaultConcurrency unless the options set it; `--concurrency` on Stryker's
+ * command line wins over both.
  */
 declare function createStrykerGatesConfig(options?: StrykerGatesOptions): Record<string, unknown>;
 
-export { DEFAULT_MAX_TEST_RUNNER_REUSE, type StrykerGatesOptions, createStrykerGatesConfig };
+export { DEFAULT_MAX_TEST_RUNNER_REUSE, type StrykerGatesOptions, createStrykerGatesConfig, defaultConcurrency };

package/dist/stryker.d.ts

@@ -12,13 +12,27 @@ interface StrykerGatesOptions {
  * mutants the speed stayed the same to the end.
  */
 declare const DEFAULT_MAX_TEST_RUNNER_REUSE = 50;
+/**
+ * How many test runners Stryker starts when neither the config nor the command line says
+ * (`concurrency`). Stryker's own default is one fewer than the cores (on more than four), but
+ * each of its runners is a Jest or Vitest that does work besides the tests (transforms, coverage),
+ * and the machine is rarely free for the run alone: half of the cores, at most 8. Measured on
+ * two projects on a machine with 12 cores, 6 runners took about half the time of 2, with the
+ * same numbers of killed, survived and timed-out mutants. In CI (`CI` set) 2, the cores of the
+ * usual hosted runner: more runners than cores only make the mutants run out of time.
+ *
+ * @param parallelism What `os.availableParallelism()` says.
+ */
+declare function defaultConcurrency(parallelism: number, ci: boolean): number;
 /**
  * Stryker config for the gates: mutate exactly the gates, never fail on the score
  * (`thresholds.break: null`), and write the JSON report that `test-gates mutation` judges.
  *
  * `mutate`, `thresholds.break` and `jsonReporter.fileName` are always set here, and `json` is
  * always among the reporters. Options that take mutants out of the evaluation are rejected.
+ * `concurrency` is defaultConcurrency unless the options set it; `--concurrency` on Stryker's
+ * command line wins over both.
  */
 declare function createStrykerGatesConfig(options?: StrykerGatesOptions): Record<string, unknown>;
 
-export { DEFAULT_MAX_TEST_RUNNER_REUSE, type StrykerGatesOptions, createStrykerGatesConfig };
+export { DEFAULT_MAX_TEST_RUNNER_REUSE, type StrykerGatesOptions, createStrykerGatesConfig, defaultConcurrency };

package/dist/stryker.js

@@ -1,13 +1,18 @@
 import {
   resolveRootDir
-} from "./chunk-4HAJIKDZ.js";
+} from "./chunk-C4R3RDHF.js";
 import {
+  inCi,
   loadGates
-} from "./chunk-F7WBEFIL.js";
+} from "./chunk-AK2NTFQO.js";
 
 // src/stryker.ts
+import os from "os";
 var WEAKENING_OPTIONS = ["ignoreStatic", "ignorers"];
 var DEFAULT_MAX_TEST_RUNNER_REUSE = 50;
+function defaultConcurrency(parallelism, ci) {
+  return ci ? 2 : Math.min(8, Math.max(1, Math.floor(parallelism / 2)));
+}
 function createStrykerGatesConfig(options = {}) {
   const { rootDir: rootDirOption, ...overrides } = options;
   for (const option of WEAKENING_OPTIONS) {
@@ -33,6 +38,7 @@ function createStrykerGatesConfig(options = {}) {
     incrementalFile: "reports/stryker-incremental.json",
     tempDirName: ".stryker-tmp",
     maxTestRunnerReuse: DEFAULT_MAX_TEST_RUNNER_REUSE,
+    concurrency: defaultConcurrency(os.availableParallelism(), inCi(process.env)),
     clearTextReporter: { logTests: false, reportTests: false },
     ...overrides,
     mutate: manifest.gates.map((gate) => gate.path),
@@ -43,5 +49,6 @@ function createStrykerGatesConfig(options = {}) {
 }
 export {
   DEFAULT_MAX_TEST_RUNNER_REUSE,
-  createStrykerGatesConfig
+  createStrykerGatesConfig,
+  defaultConcurrency
 };

package/dist/vitest.cjs

@@ -33,6 +33,7 @@ __export(vitest_exports, {
   createVitestGatesConfig: () => createVitestGatesConfig
 });
 module.exports = __toCommonJS(vitest_exports);
+var import_node_path5 = __toESM(require("path"), 1);
 
 // src/load.ts
 var import_node_fs2 = __toESM(require("fs"), 1);
@@ -489,6 +490,24 @@ function resolveSettings(raw) {
 
 // src/core/selfcheck.ts
 var EXCLUDE_ENV = "TEST_GATES_EXCLUDE_SPEC";
+var EXCLUDE_ALL_ENV = "TEST_GATES_EXCLUDE_SPECS";
+function excludedSpecs(env) {
+  const one = env[EXCLUDE_ENV];
+  const several = env[EXCLUDE_ALL_ENV];
+  const excluded = one === void 0 || one === "" ? [] : [one];
+  if (several === void 0 || several === "") {
+    return excluded;
+  }
+  let listed = null;
+  try {
+    listed = JSON.parse(several);
+  } catch {
+  }
+  if (!Array.isArray(listed) || !listed.every((spec) => typeof spec === "string")) {
+    throw new Error(`test-gates: ${EXCLUDE_ALL_ENV} must be a JSON list of spec paths`);
+  }
+  return [...excluded, ...listed];
+}
 
 // src/core/spec-path.ts
 function gateExtensionOf(gatePath, gateExtensions) {
@@ -513,19 +532,22 @@ function specCandidatesFor(gatePath, settings) {
 // src/fs.ts
 var import_node_fs = __toESM(require("fs"), 1);
 var import_node_path = __toESM(require("path"), 1);
-function existsExact(rootDir, relativePath, kind = "file") {
+function existsExact(rootDir, relativePath, kind = "file", listing = /* @__PURE__ */ new Map()) {
   let current = rootDir;
   for (const segment of relativePath.split("/")) {
     if (segment === "" || segment === ".") {
       continue;
     }
-    let entries;
-    try {
-      entries = import_node_fs.default.readdirSync(current);
-    } catch {
-      return false;
+    let entries = listing.get(current);
+    if (entries === void 0) {
+      try {
+        entries = import_node_fs.default.readdirSync(current);
+      } catch {
+        entries = null;
+      }
+      listing.set(current, entries);
     }
-    if (!entries.includes(segment)) {
+    if (entries === null || !entries.includes(segment)) {
       return false;
     }
     current = import_node_path.default.join(current, segment);
@@ -560,9 +582,12 @@ function readManifest(dir) {
     }
     throw error;
   }
+  const listing = /* @__PURE__ */ new Map();
   const gates = parsed.gates.map((gate) => {
     const specCandidates = specCandidatesFor(gate.path, settings);
-    const existingSpecs = specCandidates.filter((candidate) => existsExact(absoluteDir, candidate));
+    const existingSpecs = specCandidates.filter(
+      (candidate) => existsExact(absoluteDir, candidate, "file", listing)
+    );
     return {
       ...gate,
       specCandidates,
@@ -589,8 +614,8 @@ function loadGates(dir = process.cwd()) {
   return manifest;
 }
 function gateSpecs(manifest, env = process.env) {
-  const excluded = env[EXCLUDE_ENV];
-  return manifest.gates.map((gate) => gate.spec).filter((spec) => spec !== null && spec !== excluded);
+  const excluded = excludedSpecs(env);
+  return manifest.gates.map((gate) => gate.spec).filter((spec) => spec !== null && !excluded.includes(spec));
 }
 var NO_SPEC_PATTERN = "__test_gates_no_spec_left__";
 
@@ -608,6 +633,107 @@ function resolveRootDir(rootDir) {
   return import_node_path3.default.resolve(rootDir);
 }
 
+// src/touch.ts
+var import_node_crypto = require("crypto");
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var import_node_url2 = require("url");
+var TOUCH_ENV = "TEST_GATES_TOUCH_DIR";
+var VITEST_PROVIDER = `import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import istanbul from '@vitest/coverage-istanbul';
+
+const directory = "__DIRECTORY__";
+const run = { runner: 'vitest', version: 'unknown', provider: 'istanbul', pool: 'unknown', isolate: false, projects: 0, problem: null };
+const save = () => fs.writeFileSync(path.join(directory, 'run.json'), JSON.stringify(run));
+const problem = (text) => {
+  run.problem ??= text;
+  save();
+};
+
+const counts = (coverage) =>
+  Object.fromEntries(
+    Object.entries(coverage).map(([file, counters]) => [
+      file,
+      {
+        s: Object.values(counters.s ?? {}),
+        f: Object.values(counters.f ?? {}),
+        b: Object.values(counters.b ?? {}).flat(),
+      },
+    ])
+  );
+const add = (before, now) =>
+  before.length === now.length ? before.map((count, index) => count + now[index]) : [-1];
+
+function note(spec, files) {
+  const file = path.join(directory, 'specs', createHash('sha256').update(spec).digest('hex') + '.json');
+  let before = {};
+  try {
+    before = JSON.parse(fs.readFileSync(file, 'utf8')).files;
+  } catch {
+    // the first note of this spec
+  }
+  const merged = { ...files };
+  for (const [name, counters] of Object.entries(before)) {
+    const now = files[name];
+    merged[name] =
+      now === undefined
+        ? counters
+        : { s: add(counters.s, now.s), f: add(counters.f, now.f), b: add(counters.b, now.b) };
+  }
+  fs.writeFileSync(file, JSON.stringify({ spec, files: merged }));
+}
+
+export default {
+  ...istanbul,
+  async getProvider() {
+    const provider = await istanbul.getProvider();
+    fs.mkdirSync(path.join(directory, 'specs'), { recursive: true });
+    save();
+    if (typeof provider.onAfterSuiteRun !== 'function' || typeof provider.initialize !== 'function') {
+      problem('the coverage provider of this Vitest has no onAfterSuiteRun or no initialize');
+      return provider;
+    }
+    const initialize = provider.initialize.bind(provider);
+    provider.initialize = (ctx) => {
+      // A project can set its own pool and isolation: all of them have to say the same.
+      const projects = Array.isArray(ctx?.projects) ? ctx.projects : [];
+      const configs = [ctx?.config ?? {}, ...projects.map((project) => project?.config ?? {})];
+      const pools = [...new Set(configs.map((config) => (typeof config.pool === 'string' ? config.pool : 'unknown')))];
+      run.version = typeof ctx?.version === 'string' ? ctx.version : 'unknown';
+      run.pool = pools.length === 1 ? pools[0] : 'mixed';
+      run.isolate = configs.every(
+        (config) => (config.poolOptions?.[config.pool]?.isolate ?? config.isolate) === true
+      );
+      run.projects = projects.length;
+      save();
+      return initialize(ctx);
+    };
+    const handOver = provider.onAfterSuiteRun.bind(provider);
+    provider.onAfterSuiteRun = (meta) => {
+      const coverage = meta?.coverage;
+      if (coverage !== undefined && coverage !== null) {
+        const specs = meta.testFiles;
+        if (typeof coverage !== 'object' || !Array.isArray(specs) || specs.length !== 1 || typeof specs[0] !== 'string') {
+          problem('Vitest handed over coverage that is not that of exactly one spec file');
+        } else {
+          note(specs[0], counts(coverage));
+        }
+      }
+      return handOver(meta);
+    };
+    return provider;
+  },
+};
+`;
+function vitestProviderFile(directory) {
+  const file = import_node_path4.default.join(directory, "vitest-provider.mjs");
+  import_node_fs3.default.mkdirSync(directory, { recursive: true });
+  import_node_fs3.default.writeFileSync(file, VITEST_PROVIDER.replace('"__DIRECTORY__"', JSON.stringify(directory)));
+  return file;
+}
+
 // src/vitest.ts
 function createVitestGatesConfig(options = {}) {
   const { rootDir: rootDirOption, coverageProvider, test = {}, ...overrides } = options;
@@ -615,6 +741,8 @@ function createVitestGatesConfig(options = {}) {
   const manifest = loadGates(rootDir);
   const { coverage = {}, ...testOverrides } = test;
   const specs = gateSpecs(manifest);
+  const provider = coverageProvider ?? coverage.provider ?? "v8";
+  const touchDir = process.env[TOUCH_ENV];
   return {
     ...overrides,
     root: rootDir,
@@ -626,11 +754,22 @@ function createVitestGatesConfig(options = {}) {
       // then fail on the coverage threshold, not on "no test files found".
       passWithNoTests: true,
       coverage: {
-        provider: "v8",
         reporter: ["text"],
         reportsDirectory: "coverage/gates",
         ...coverage,
-        ...coverageProvider === void 0 ? {} : { provider: coverageProvider },
+        provider,
+        // While `test-gates selfcheck` asks for it: write down what each spec executed. Only
+        // the istanbul provider can be wrapped for that (see src/touch.ts).
+        ...touchDir && provider === "istanbul" ? {
+          provider: "custom",
+          customProviderModule: vitestProviderFile(touchDir),
+          // The runner's own total, to check the notes against.
+          reporter: [
+            ...Array.isArray(coverage.reporter) ? coverage.reporter : [coverage.reporter ?? "text"],
+            "json"
+          ],
+          reportsDirectory: import_node_path5.default.join(touchDir, "coverage")
+        } : {},
         enabled: true,
         include: manifest.gates.map((gate) => gate.path),
         thresholds: { perFile: true, ...FULL_COVERAGE }

package/dist/vitest.js

@@ -1,20 +1,27 @@
+import {
+  TOUCH_ENV,
+  vitestProviderFile
+} from "./chunk-TOKHAUFX.js";
 import {
   FULL_COVERAGE,
   resolveRootDir
-} from "./chunk-4HAJIKDZ.js";
+} from "./chunk-C4R3RDHF.js";
 import {
   NO_SPEC_PATTERN,
   gateSpecs,
   loadGates
-} from "./chunk-F7WBEFIL.js";
+} from "./chunk-AK2NTFQO.js";
 
 // src/vitest.ts
+import path from "path";
 function createVitestGatesConfig(options = {}) {
   const { rootDir: rootDirOption, coverageProvider, test = {}, ...overrides } = options;
   const rootDir = resolveRootDir(rootDirOption);
   const manifest = loadGates(rootDir);
   const { coverage = {}, ...testOverrides } = test;
   const specs = gateSpecs(manifest);
+  const provider = coverageProvider ?? coverage.provider ?? "v8";
+  const touchDir = process.env[TOUCH_ENV];
   return {
     ...overrides,
     root: rootDir,
@@ -26,11 +33,22 @@ function createVitestGatesConfig(options = {}) {
       // then fail on the coverage threshold, not on "no test files found".
       passWithNoTests: true,
       coverage: {
-        provider: "v8",
         reporter: ["text"],
         reportsDirectory: "coverage/gates",
         ...coverage,
-        ...coverageProvider === void 0 ? {} : { provider: coverageProvider },
+        provider,
+        // While `test-gates selfcheck` asks for it: write down what each spec executed. Only
+        // the istanbul provider can be wrapped for that (see src/touch.ts).
+        ...touchDir && provider === "istanbul" ? {
+          provider: "custom",
+          customProviderModule: vitestProviderFile(touchDir),
+          // The runner's own total, to check the notes against.
+          reporter: [
+            ...Array.isArray(coverage.reporter) ? coverage.reporter : [coverage.reporter ?? "text"],
+            "json"
+          ],
+          reportsDirectory: path.join(touchDir, "coverage")
+        } : {},
         enabled: true,
         include: manifest.gates.map((gate) => gate.path),
         thresholds: { perFile: true, ...FULL_COVERAGE }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@t09tanaka/test-gates",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "description": "Test gates for the code that must not be wrong: per-file 100% coverage as the floor, mutation testing with a per-mutant allow list as the real check.",
   "author": "t09tanaka",
   "license": "MIT",
@@ -94,12 +94,15 @@
     "format:check": "prettier --check .",
     "pretest": "npm run build",
     "test": "vitest run",
+    "pretest:heavy": "npm run build",
+    "test:heavy": "vitest run --config vitest.heavy.config.ts",
+    "check:quick": "npm run lint && npm run typecheck && npm run format:check && npm test",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
     "test:gates": "node dist/cli.js check && vitest run --config vitest.gates.config.ts",
     "test:gates:selfcheck": "node dist/cli.js selfcheck",
     "test:gates:mutation": "node dist/cli.js mutation",
-    "prepublishOnly": "npm run lint && npm run format:check && npm run typecheck && npm test && npm run test:gates && npm run test:gates:selfcheck"
+    "prepublishOnly": "npm run lint && npm run format:check && npm run typecheck && npm test && npm run test:heavy && npm run test:gates && npm run test:gates:selfcheck"
   },
   "peerDependencies": {
     "@stryker-mutator/core": ">=9",
@@ -124,6 +127,7 @@
   "devDependencies": {
     "@eslint/js": "^9.39.5",
     "@stryker-mutator/core": "^10.0.0",
+    "@stryker-mutator/jest-runner": "^10.0.0",
     "@stryker-mutator/vitest-runner": "^10.0.0",
     "@types/node": "^22.20.5",
     "@vitest/coverage-istanbul": "^3.2.7",
@@ -131,6 +135,7 @@
     "eslint": "^9.39.5",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.6",
+    "jest": "^30.5.2",
     "prettier": "^3.9.9",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",