@t09tanaka/test-gates 0.3.3 → 0.4.0

package/dist/{chunk-F7WBEFIL.js → chunk-AK2NTFQO.js}

@@ -452,6 +452,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];
+}
 var THRESHOLD_MESSAGE = /threshold|coverage data for/i;
 function escapeRegExp(text) {
   return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -471,6 +489,10 @@ function judgeSelfcheck(input) {
   const reported = output.split("\n").some((line) => line.includes(gatePath) && THRESHOLD_MESSAGE.test(line));
   return reported ? null : `the gate failed (exit ${status}) but not on the coverage threshold of ${gatePath}. It may be failing for another reason`;
 }
+function inCi(env) {
+  const ci = (env.CI ?? "").trim().toLowerCase();
+  return ci !== "" && ci !== "false" && ci !== "0";
+}
 
 // src/load.ts
 import fs2 from "fs";
@@ -503,19 +525,22 @@ function looksLikeSpec(gatePath, settings) {
 // src/fs.ts
 import fs from "fs";
 import path from "path";
-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 = fs.readdirSync(current);
-    } catch {
-      return false;
+    let entries = listing.get(current);
+    if (entries === void 0) {
+      try {
+        entries = fs.readdirSync(current);
+      } catch {
+        entries = null;
+      }
+      listing.set(current, entries);
     }
-    if (!entries.includes(segment)) {
+    if (entries === null || !entries.includes(segment)) {
       return false;
     }
     current = path.join(current, segment);
@@ -553,9 +578,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,
@@ -582,8 +610,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__";
 
@@ -602,6 +630,7 @@ export {
   resolveSettings,
   EXCLUDE_ENV,
   judgeSelfcheck,
+  inCi,
   gateExtensionOf,
   looksLikeSpec,
   existsExact,

package/dist/chunk-TOKHAUFX.js

@@ -0,0 +1,163 @@
+// src/touch.ts
+import { createHash } from "crypto";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+var TOUCH_ENV = "TEST_GATES_TOUCH_DIR";
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function countersOf(coverage) {
+  return {
+    s: Object.values(coverage.s ?? {}),
+    f: Object.values(coverage.f ?? {}),
+    b: Object.values(coverage.b ?? {}).flat()
+  };
+}
+function countersOfAll(coverage) {
+  if (!isObject(coverage)) {
+    return null;
+  }
+  const files = {};
+  for (const [file, counters] of Object.entries(coverage)) {
+    if (!isObject(counters)) {
+      return null;
+    }
+    files[file] = countersOf(counters);
+  }
+  return files;
+}
+function add(before, now) {
+  return before.length === now.length ? before.map((count, index) => count + (now[index] ?? 0)) : [-1];
+}
+function writeSpecNote(directory, spec, coverage) {
+  const files = countersOfAll(coverage) ?? {};
+  const specs = path.join(directory, "specs");
+  fs.mkdirSync(specs, { recursive: true });
+  const file = path.join(specs, `${createHash("sha256").update(spec).digest("hex")}.json`);
+  let before = {};
+  try {
+    before = JSON.parse(fs.readFileSync(file, "utf8")).files;
+  } catch {
+  }
+  for (const [name, counters] of Object.entries(before)) {
+    const now = files[name];
+    files[name] = now === void 0 ? counters : { s: add(counters.s, now.s), f: add(counters.f, now.f), b: add(counters.b, now.b) };
+  }
+  const note = { spec, files };
+  fs.writeFileSync(file, JSON.stringify(note));
+}
+function writeRunInfo(directory, run) {
+  fs.mkdirSync(directory, { recursive: true });
+  fs.writeFileSync(path.join(directory, "run.json"), JSON.stringify(run));
+}
+function jestReporterFile(moduleUrl) {
+  const directory = path.dirname(fileURLToPath(moduleUrl));
+  const found = [".cjs", ".ts"].map((extension) => path.join(directory, `jest-touch-reporter${extension}`)).find((file) => fs.existsSync(file));
+  if (found === void 0) {
+    throw new Error(`test-gates: jest-touch-reporter is missing in ${directory}`);
+  }
+  return found;
+}
+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 = path.join(directory, "vitest-provider.mjs");
+  fs.mkdirSync(directory, { recursive: true });
+  fs.writeFileSync(file, VITEST_PROVIDER.replace('"__DIRECTORY__"', JSON.stringify(directory)));
+  return file;
+}
+
+export {
+  TOUCH_ENV,
+  writeSpecNote,
+  writeRunInfo,
+  jestReporterFile,
+  vitestProviderFile
+};