@t09tanaka/test-gates 0.0.0-stage → 0.1.0

package/dist/chunk-LMD3ANJ2.js

@@ -0,0 +1,564 @@
+// src/core/manifest.ts
+var MANIFEST_FILE = "test-gates.json";
+var ManifestError = class extends Error {
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFilled(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function allowanceProblems(entry) {
+  if (!isRecord(entry)) {
+    return [" must be an object"];
+  }
+  const problems = [];
+  if (!isFilled(entry.mutator)) {
+    problems.push(': "mutator" is missing');
+  }
+  if (!isFilled(entry.original)) {
+    problems.push(': "original" is missing');
+  }
+  if (typeof entry.replacement !== "string") {
+    problems.push(': "replacement" is missing');
+  }
+  if (!isFilled(entry.reason)) {
+    problems.push(': "reason" is missing (say why the mutant cannot be observed)');
+  }
+  if (entry.occurrence !== void 0 && !(Number.isInteger(entry.occurrence) && entry.occurrence >= 1)) {
+    problems.push(': "occurrence" must be an integer >= 1');
+  }
+  return problems;
+}
+function validateEquivalentMutants(gatePath, value) {
+  if (value === void 0) {
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    return [{ file: MANIFEST_FILE, message: `${gatePath}: equivalentMutants must be an array` }];
+  }
+  return value.flatMap(
+    (entry, index) => allowanceProblems(entry).map((problem) => ({
+      file: MANIFEST_FILE,
+      message: `${gatePath}: equivalentMutants[${index}]${problem}`
+    }))
+  );
+}
+function isUsableEquivalentMutant(entry) {
+  return allowanceProblems(entry).length === 0;
+}
+function parseEntries(kind, entries, fields, violations) {
+  const usable = [];
+  const seen = /* @__PURE__ */ new Set();
+  entries.forEach((entry, index) => {
+    const at = `${kind}[${index}]`;
+    if (!isRecord(entry)) {
+      violations.push({ file: MANIFEST_FILE, message: `${at} must be an object` });
+      return;
+    }
+    if (!isFilled(entry.path)) {
+      violations.push({ file: MANIFEST_FILE, message: `${at}: "path" is missing` });
+      return;
+    }
+    for (const field of fields) {
+      if (!isFilled(entry[field])) {
+        violations.push({
+          file: MANIFEST_FILE,
+          message: `${entry.path}: "${field}" is missing in ${kind}`
+        });
+      }
+    }
+    if (seen.has(entry.path)) {
+      violations.push({ file: MANIFEST_FILE, message: `${entry.path}: listed twice in ${kind}` });
+      return;
+    }
+    seen.add(entry.path);
+    usable.push(entry);
+  });
+  return usable;
+}
+function parseManifest(text) {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (error) {
+    throw new ManifestError(`${MANIFEST_FILE} is not valid JSON: ${error.message}`);
+  }
+  if (!isRecord(raw)) {
+    throw new ManifestError(`${MANIFEST_FILE} must be a JSON object`);
+  }
+  if (!Array.isArray(raw.gates)) {
+    throw new ManifestError(`${MANIFEST_FILE}: "gates" must be an array`);
+  }
+  if (raw.candidates !== void 0 && !Array.isArray(raw.candidates)) {
+    throw new ManifestError(`${MANIFEST_FILE}: "candidates" must be an array`);
+  }
+  for (const key of Object.keys(raw)) {
+    if (!["$schema", "gates", "candidates", "settings"].includes(key)) {
+      throw new ManifestError(`${MANIFEST_FILE}: unknown top-level key ${JSON.stringify(key)}`);
+    }
+  }
+  const violations = [];
+  if (raw.gates.length === 0) {
+    violations.push({
+      file: MANIFEST_FILE,
+      message: "gates is empty. A project with nothing to gate should not have this file"
+    });
+  }
+  const gates = parseEntries("gates", raw.gates, ["decides", "impact"], violations);
+  const candidates = parseEntries(
+    "candidates",
+    raw.candidates ?? [],
+    ["decides", "blocker"],
+    violations
+  );
+  const gatePaths = new Set(gates.map((gate) => gate.path));
+  for (const candidate of candidates) {
+    if (gatePaths.has(candidate.path)) {
+      violations.push({
+        file: MANIFEST_FILE,
+        message: `${candidate.path}: listed in both gates and candidates`
+      });
+    }
+  }
+  for (const gate of gates) {
+    violations.push(...validateEquivalentMutants(gate.path, gate.equivalentMutants));
+  }
+  return { gates, candidates, settings: raw.settings, violations };
+}
+
+// src/core/settings.ts
+var DEFAULT_REPORT_FILE = "reports/mutation/mutation.json";
+var DEFAULT_GATE_EXTENSIONS = [".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"];
+var DEFAULT_IMPURE_IMPORTS = [
+  { pattern: "^@nestjs/", reason: "NestJS runtime (DI, decorators)" },
+  { pattern: "^class-(validator|transformer)$", reason: "decorator-based DTO library" },
+  {
+    pattern: "^(typeorm|sequelize|mongoose|knex|pg|mysql|mysql2|ioredis|redis)(/|$)",
+    reason: "database client"
+  },
+  { pattern: "^@prisma/adapter-", reason: "database client" },
+  { pattern: "^(react|react-dom)(/|$)", reason: "React runtime" },
+  { pattern: "^next(/|$)", reason: "Next.js runtime" },
+  { pattern: "^(server-only|client-only)$", reason: "Next.js execution environment" },
+  { pattern: "^(vue|vue-router|vue-i18n|pinia)(/|$)", reason: "Vue runtime" },
+  { pattern: "^nuxt(/|$)", reason: "Nuxt runtime" },
+  { pattern: "^#(app|imports)(/|$)", reason: "Nuxt runtime" },
+  { pattern: "\\.vue$", reason: "component" },
+  {
+    pattern: "^(express|express-jwt|fastify|koa|rxjs|passport)(/|$)",
+    reason: "HTTP framework runtime"
+  },
+  { pattern: "^passport-", reason: "HTTP framework runtime" },
+  {
+    pattern: "^(axios|openapi-fetch|stripe|nodemailer|firebase-admin)(/|$)",
+    reason: "HTTP client / external service SDK"
+  },
+  { pattern: "^@(aws-sdk|sentry|slack|stripe)/", reason: "external service SDK" },
+  {
+    pattern: "^(node:)?(fs|http|https|http2|net|tls|dgram|dns|child_process|worker_threads)(/|$)",
+    reason: "file system / network / process access"
+  }
+];
+var DEFAULT_IMPURE_NAMED_IMPORTS = [
+  { module: "@prisma/client", names: ["PrismaClient"], reason: "connects to the database" }
+];
+var DEFAULT_IMPURE_PATHS = [
+  { pattern: "\\.(vue|jsx|tsx)$", reason: "component file" },
+  { pattern: "\\.d\\.[cm]?ts$", reason: "type declaration file" }
+];
+var DEFAULT_FORBIDDEN_SOURCE = [
+  {
+    pattern: `^\\s*(['"])use (client|server)\\1`,
+    reason: "'use client' / 'use server' directive (not a pure module)"
+  }
+];
+var SettingsError = class extends Error {
+};
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function compile(pattern, flags, where) {
+  try {
+    return new RegExp(pattern, flags);
+  } catch (error) {
+    throw new SettingsError(
+      `${where}: invalid regular expression ${JSON.stringify(pattern)} (${error.message})`
+    );
+  }
+}
+function stringArray(value, where) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item === "")) {
+    throw new SettingsError(`${where}: must be an array of non-empty strings`);
+  }
+  return value;
+}
+function optionalString(value, where) {
+  if (value === void 0) {
+    return null;
+  }
+  if (typeof value !== "string" || value === "") {
+    throw new SettingsError(`${where}: must be a non-empty string`);
+  }
+  return value;
+}
+function rejectUnknownKeys(value, known, where) {
+  for (const key of Object.keys(value)) {
+    if (!known.includes(key)) {
+      throw new SettingsError(`${where}: unknown key ${JSON.stringify(key)}`);
+    }
+  }
+}
+function section(value, known, where) {
+  if (value === void 0) {
+    return {};
+  }
+  if (!isRecord2(value)) {
+    throw new SettingsError(`${where}: must be an object`);
+  }
+  rejectUnknownKeys(value, known, where);
+  return value;
+}
+function compileRules(defaults, raw, where, extraKeys = []) {
+  const config = section(raw, ["defaults", "add", ...extraKeys], where);
+  if (config.defaults !== void 0 && typeof config.defaults !== "boolean") {
+    throw new SettingsError(`${where}.defaults: must be a boolean`);
+  }
+  const added = config.add ?? [];
+  if (!Array.isArray(added)) {
+    throw new SettingsError(`${where}.add: must be an array`);
+  }
+  const all = [];
+  if (config.defaults !== false) {
+    defaults.forEach((rule) => all.push({ rule, where: `${where} (default)` }));
+  }
+  added.forEach((item, index) => {
+    const at = `${where}.add[${index}]`;
+    if (typeof item === "string" && item !== "") {
+      all.push({ rule: { pattern: item }, where: at });
+      return;
+    }
+    if (!isRecord2(item) || typeof item.pattern !== "string" || item.pattern === "") {
+      throw new SettingsError(`${at}: must be a pattern string or { pattern, flags?, reason? }`);
+    }
+    rejectUnknownKeys(item, ["pattern", "flags", "reason"], at);
+    if (item.flags !== void 0 && typeof item.flags !== "string") {
+      throw new SettingsError(`${at}.flags: must be a string`);
+    }
+    if (item.reason !== void 0 && typeof item.reason !== "string") {
+      throw new SettingsError(`${at}.reason: must be a string`);
+    }
+    all.push({ rule: item, where: at });
+  });
+  return {
+    rules: all.map(({ rule, where: at }) => ({
+      regex: compile(rule.pattern, rule.flags, at),
+      reason: rule.reason ?? `matches ${rule.pattern}`
+    })),
+    section: config
+  };
+}
+function resolveSettings(raw) {
+  const settings = section(
+    raw,
+    [
+      "gateExtensions",
+      "spec",
+      "impureImports",
+      "impureNamedImports",
+      "impurePaths",
+      "forbiddenSource",
+      "importAliases",
+      "gateCommand",
+      "selfcheck",
+      "stryker",
+      "lcov"
+    ],
+    "settings"
+  );
+  const gateExtensions = settings.gateExtensions === void 0 ? DEFAULT_GATE_EXTENSIONS : stringArray(settings.gateExtensions, "settings.gateExtensions");
+  if (gateExtensions.length === 0 || gateExtensions.some((ext) => !ext.startsWith("."))) {
+    throw new SettingsError(
+      'settings.gateExtensions: must list at least one extension starting with "."'
+    );
+  }
+  const spec = section(settings.spec, ["suffixes", "rewrite"], "settings.spec");
+  const specSuffixes = spec.suffixes === void 0 ? null : stringArray(spec.suffixes, "settings.spec.suffixes");
+  const rewriteRaw = spec.rewrite ?? [];
+  if (!Array.isArray(rewriteRaw)) {
+    throw new SettingsError("settings.spec.rewrite: must be an array");
+  }
+  const specRewrite = rewriteRaw.map((item, index) => {
+    const at = `settings.spec.rewrite[${index}]`;
+    if (!isRecord2(item) || typeof item.from !== "string" || typeof item.to !== "string") {
+      throw new SettingsError(`${at}: must be { from, to }`);
+    }
+    rejectUnknownKeys(item, ["from", "to"], at);
+    return { regex: compile(item.from, void 0, at), to: item.to };
+  });
+  const imports = compileRules(
+    DEFAULT_IMPURE_IMPORTS,
+    settings.impureImports,
+    "settings.impureImports",
+    ["allow"]
+  );
+  const allowedImports = imports.section.allow === void 0 ? [] : stringArray(imports.section.allow, "settings.impureImports.allow").map(
+    (pattern, index) => compile(pattern, void 0, `settings.impureImports.allow[${index}]`)
+  );
+  const named = section(
+    settings.impureNamedImports,
+    ["defaults", "add"],
+    "settings.impureNamedImports"
+  );
+  if (named.defaults !== void 0 && typeof named.defaults !== "boolean") {
+    throw new SettingsError("settings.impureNamedImports.defaults: must be a boolean");
+  }
+  const namedAdd = named.add ?? [];
+  if (!Array.isArray(namedAdd)) {
+    throw new SettingsError("settings.impureNamedImports.add: must be an array");
+  }
+  const impureNamedImports = [
+    ...named.defaults === false ? [] : DEFAULT_IMPURE_NAMED_IMPORTS,
+    ...namedAdd.map((item, index) => {
+      const at = `settings.impureNamedImports.add[${index}]`;
+      if (!isRecord2(item) || typeof item.module !== "string" || item.module === "") {
+        throw new SettingsError(`${at}: must be { module, names, reason? }`);
+      }
+      rejectUnknownKeys(item, ["module", "names", "reason"], at);
+      const names = stringArray(item.names, `${at}.names`);
+      if (names.length === 0) {
+        throw new SettingsError(`${at}.names: must list at least one name`);
+      }
+      if (item.reason !== void 0 && typeof item.reason !== "string") {
+        throw new SettingsError(`${at}.reason: must be a string`);
+      }
+      return {
+        module: item.module,
+        names,
+        reason: item.reason ?? "not allowed in a pure module"
+      };
+    })
+  ];
+  const aliasesRaw = settings.importAliases ?? [];
+  if (!Array.isArray(aliasesRaw)) {
+    throw new SettingsError("settings.importAliases: must be an array");
+  }
+  const importAliases = aliasesRaw.map((item, index) => {
+    const at = `settings.importAliases[${index}]`;
+    if (!isRecord2(item) || typeof item.prefix !== "string" || item.prefix === "" || typeof item.target !== "string") {
+      throw new SettingsError(`${at}: must be { prefix, target }`);
+    }
+    rejectUnknownKeys(item, ["prefix", "target"], at);
+    return { prefix: item.prefix, target: item.target };
+  });
+  let gateCommand = null;
+  if (settings.gateCommand !== void 0) {
+    gateCommand = stringArray(settings.gateCommand, "settings.gateCommand");
+    if (gateCommand.length === 0) {
+      throw new SettingsError("settings.gateCommand: must not be empty");
+    }
+  }
+  const selfcheck = section(settings.selfcheck, ["mode", "failurePattern"], "settings.selfcheck");
+  if (selfcheck.mode !== void 0 && selfcheck.mode !== "all" && selfcheck.mode !== "first") {
+    throw new SettingsError('settings.selfcheck.mode: must be "all" or "first"');
+  }
+  const selfcheckFailurePattern = optionalString(
+    selfcheck.failurePattern,
+    "settings.selfcheck.failurePattern"
+  );
+  if (selfcheckFailurePattern !== null) {
+    compile(
+      selfcheckFailurePattern.split("{gate}").join("x"),
+      void 0,
+      "settings.selfcheck.failurePattern"
+    );
+  }
+  const stryker = section(settings.stryker, ["configFile", "reportFile"], "settings.stryker");
+  const lcov = section(settings.lcov, ["file", "summaryExclude"], "settings.lcov");
+  return {
+    gateExtensions,
+    specSuffixes,
+    specRewrite,
+    impureImports: imports.rules,
+    allowedImports,
+    impureNamedImports,
+    impurePaths: compileRules(DEFAULT_IMPURE_PATHS, settings.impurePaths, "settings.impurePaths").rules,
+    forbiddenSource: compileRules(
+      DEFAULT_FORBIDDEN_SOURCE,
+      settings.forbiddenSource,
+      "settings.forbiddenSource"
+    ).rules,
+    importAliases,
+    gateCommand,
+    selfcheckMode: selfcheck.mode ?? "all",
+    selfcheckFailurePattern,
+    strykerConfigFile: optionalString(stryker.configFile, "settings.stryker.configFile"),
+    strykerReportFile: optionalString(stryker.reportFile, "settings.stryker.reportFile") ?? DEFAULT_REPORT_FILE,
+    lcovFile: optionalString(lcov.file, "settings.lcov.file"),
+    lcovSummaryExclude: lcov.summaryExclude === void 0 ? [] : stringArray(lcov.summaryExclude, "settings.lcov.summaryExclude").map(
+      (pattern, index) => compile(pattern, void 0, `settings.lcov.summaryExclude[${index}]`)
+    )
+  };
+}
+
+// src/core/selfcheck.ts
+var EXCLUDE_ENV = "TEST_GATES_EXCLUDE_SPEC";
+var THRESHOLD_MESSAGE = /threshold|coverage data for/i;
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function judgeSelfcheck(input) {
+  const { status, output, gatePath } = input;
+  if (status === null) {
+    return "the gate command did not run to completion";
+  }
+  if (status === 0) {
+    return `the gate passed although the spec of ${gatePath} was left out. The gate does not measure this file (does the gate config honor ${EXCLUDE_ENV}?)`;
+  }
+  if (input.failurePattern) {
+    const pattern = input.failurePattern.split("{gate}").join(escapeRegExp(gatePath));
+    return new RegExp(pattern).test(output) ? null : `the gate failed (exit ${status}) but the output does not match settings.selfcheck.failurePattern`;
+  }
+  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`;
+}
+
+// src/load.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/core/spec-path.ts
+function gateExtensionOf(gatePath, gateExtensions) {
+  const matching = gateExtensions.filter((extension) => gatePath.endsWith(extension)).sort((a, b) => b.length - a.length);
+  return matching[0] ?? null;
+}
+function suffixesFor(extension, settings) {
+  return settings.specSuffixes ?? [`.spec${extension}`, `.test${extension}`];
+}
+function specCandidatesFor(gatePath, settings) {
+  const extension = gateExtensionOf(gatePath, settings.gateExtensions);
+  if (extension === null) {
+    return [];
+  }
+  let base = gatePath.slice(0, -extension.length);
+  for (const { regex, to } of settings.specRewrite) {
+    base = base.replace(regex, to);
+  }
+  return suffixesFor(extension, settings).map((suffix) => base + suffix);
+}
+function looksLikeSpec(gatePath, settings) {
+  const extension = gateExtensionOf(gatePath, settings.gateExtensions);
+  return extension !== null && suffixesFor(extension, settings).some((suffix) => gatePath.endsWith(suffix));
+}
+
+// src/fs.ts
+import fs from "fs";
+import path from "path";
+function existsExact(rootDir, relativePath, kind = "file") {
+  let current = rootDir;
+  for (const segment of relativePath.split("/")) {
+    if (segment === "" || segment === ".") {
+      continue;
+    }
+    let entries;
+    try {
+      entries = fs.readdirSync(current);
+    } catch {
+      return false;
+    }
+    if (!entries.includes(segment)) {
+      return false;
+    }
+    current = path.join(current, segment);
+  }
+  try {
+    return kind === "any" || fs.statSync(current).isFile();
+  } catch {
+    return false;
+  }
+}
+function readText(rootDir, relativePath) {
+  return fs.readFileSync(path.join(rootDir, relativePath), "utf8");
+}
+
+// src/load.ts
+function readManifest(dir) {
+  const absoluteDir = path2.resolve(dir);
+  const manifestPath = path2.join(absoluteDir, MANIFEST_FILE);
+  let text;
+  try {
+    text = fs2.readFileSync(manifestPath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new ManifestError(`${MANIFEST_FILE} not found in ${absoluteDir}`);
+    }
+    throw new ManifestError(`cannot read ${manifestPath}: ${error.message}`);
+  }
+  const parsed = parseManifest(text);
+  let settings;
+  try {
+    settings = resolveSettings(parsed.settings);
+  } catch (error) {
+    if (error instanceof SettingsError) {
+      throw new ManifestError(`${MANIFEST_FILE}: ${error.message}`);
+    }
+    throw error;
+  }
+  const gates = parsed.gates.map((gate) => {
+    const specCandidates = specCandidatesFor(gate.path, settings);
+    const existingSpecs = specCandidates.filter((candidate) => existsExact(absoluteDir, candidate));
+    return {
+      ...gate,
+      specCandidates,
+      existingSpecs,
+      spec: existingSpecs[0] ?? specCandidates[0] ?? null
+    };
+  });
+  return {
+    dir: absoluteDir,
+    gates,
+    candidates: parsed.candidates,
+    settings,
+    violations: parsed.violations
+  };
+}
+function loadGates(dir = process.cwd()) {
+  const manifest = readManifest(dir);
+  if (manifest.violations.length > 0) {
+    throw new ManifestError(
+      `${MANIFEST_FILE} has problems (run "test-gates check"):
+` + manifest.violations.map((violation) => `  - ${violation.message}`).join("\n")
+    );
+  }
+  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);
+}
+var NO_SPEC_PATTERN = "__test_gates_no_spec_left__";
+
+export {
+  MANIFEST_FILE,
+  ManifestError,
+  validateEquivalentMutants,
+  isUsableEquivalentMutant,
+  parseManifest,
+  DEFAULT_REPORT_FILE,
+  DEFAULT_GATE_EXTENSIONS,
+  DEFAULT_IMPURE_IMPORTS,
+  DEFAULT_IMPURE_NAMED_IMPORTS,
+  DEFAULT_IMPURE_PATHS,
+  DEFAULT_FORBIDDEN_SOURCE,
+  resolveSettings,
+  EXCLUDE_ENV,
+  judgeSelfcheck,
+  gateExtensionOf,
+  looksLikeSpec,
+  existsExact,
+  readText,
+  readManifest,
+  loadGates,
+  gateSpecs,
+  NO_SPEC_PATTERN
+};