@t09tanaka/test-gates 0.1.0 → 0.3.0

package/dist/vitest.cjs

@@ -70,17 +70,17 @@ function allowanceProblems(entry) {
   }
   return problems;
 }
-function validateEquivalentMutants(gatePath, value) {
+function validateEquivalentMutants(gatePath, value, field = "equivalentMutants") {
   if (value === void 0) {
     return [];
   }
   if (!Array.isArray(value)) {
-    return [{ file: MANIFEST_FILE, message: `${gatePath}: equivalentMutants must be an array` }];
+    return [{ file: MANIFEST_FILE, message: `${gatePath}: ${field} must be an array` }];
   }
   return value.flatMap(
     (entry, index) => allowanceProblems(entry).map((problem) => ({
       file: MANIFEST_FILE,
-      message: `${gatePath}: equivalentMutants[${index}]${problem}`
+      message: `${gatePath}: ${field}[${index}]${problem}`
     }))
   );
 }
@@ -160,6 +160,9 @@ function parseManifest(text) {
   }
   for (const gate of gates) {
     violations.push(...validateEquivalentMutants(gate.path, gate.equivalentMutants));
+    violations.push(
+      ...validateEquivalentMutants(gate.path, gate.expectedTimeouts, "expectedTimeouts")
+    );
   }
   return { gates, candidates, settings: raw.settings, violations };
 }
@@ -208,8 +211,13 @@ var DEFAULT_FORBIDDEN_SOURCE = [
   {
     pattern: `^\\s*(['"])use (client|server)\\1`,
     reason: "'use client' / 'use server' directive (not a pure module)"
+  },
+  {
+    pattern: "\\bprocess\\??\\.env\\b",
+    reason: "reads process.env (not a pure module). Take the value as an argument"
   }
 ];
+var DEFAULT_MAX_TIMEOUTS = 0;
 var SettingsError = class extends Error {
 };
 function isRecord2(value) {
@@ -309,7 +317,9 @@ function resolveSettings(raw) {
       "gateCommand",
       "selfcheck",
       "stryker",
-      "lcov"
+      "lcov",
+      "imports",
+      "mutation"
     ],
     "settings"
   );
@@ -410,6 +420,42 @@ function resolveSettings(raw) {
       "settings.selfcheck.failurePattern"
     );
   }
+  const importsSection = section(settings.imports, ["mode", "allow"], "settings.imports");
+  if (importsSection.mode !== void 0 && importsSection.mode !== "blocklist" && importsSection.mode !== "allowlist") {
+    throw new SettingsError('settings.imports.mode: must be "blocklist" or "allowlist"');
+  }
+  const importAllowRaw = importsSection.allow ?? [];
+  if (!Array.isArray(importAllowRaw)) {
+    throw new SettingsError("settings.imports.allow: must be an array");
+  }
+  const importAllow = importAllowRaw.map((item, index) => {
+    const at = `settings.imports.allow[${index}]`;
+    if (typeof item === "string" && item !== "") {
+      return { module: item };
+    }
+    if (isRecord2(item) && typeof item.pattern === "string" && item.pattern !== "") {
+      rejectUnknownKeys(item, ["pattern", "flags"], at);
+      if (item.flags !== void 0 && typeof item.flags !== "string") {
+        throw new SettingsError(`${at}.flags: must be a string`);
+      }
+      return { regex: compile(item.pattern, item.flags, at) };
+    }
+    if (isRecord2(item) && typeof item.module === "string" && item.module !== "") {
+      rejectUnknownKeys(item, ["module", "names"], at);
+      const names = stringArray(item.names, `${at}.names`);
+      if (names.length === 0) {
+        throw new SettingsError(`${at}.names: must list at least one name`);
+      }
+      return { module: item.module, names };
+    }
+    throw new SettingsError(
+      `${at}: must be a package name, { pattern, flags? } or { module, names }`
+    );
+  });
+  const mutation = section(settings.mutation, ["maxTimeouts"], "settings.mutation");
+  if (mutation.maxTimeouts !== void 0 && !(Number.isInteger(mutation.maxTimeouts) && mutation.maxTimeouts >= 0)) {
+    throw new SettingsError("settings.mutation.maxTimeouts: must be an integer >= 0");
+  }
   const stryker = section(settings.stryker, ["configFile", "reportFile"], "settings.stryker");
   const lcov = section(settings.lcov, ["file", "summaryExclude"], "settings.lcov");
   return {
@@ -431,6 +477,9 @@ function resolveSettings(raw) {
     selfcheckFailurePattern,
     strykerConfigFile: optionalString(stryker.configFile, "settings.stryker.configFile"),
     strykerReportFile: optionalString(stryker.reportFile, "settings.stryker.reportFile") ?? DEFAULT_REPORT_FILE,
+    importMode: importsSection.mode ?? "blocklist",
+    importAllow,
+    maxTimeouts: mutation.maxTimeouts ?? DEFAULT_MAX_TIMEOUTS,
     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}]`)
@@ -561,7 +610,7 @@ function resolveRootDir(rootDir) {
 
 // src/vitest.ts
 function createVitestGatesConfig(options = {}) {
-  const { rootDir: rootDirOption, test = {}, ...overrides } = options;
+  const { rootDir: rootDirOption, coverageProvider, test = {}, ...overrides } = options;
   const rootDir = resolveRootDir(rootDirOption);
   const manifest = loadGates(rootDir);
   const { coverage = {}, ...testOverrides } = test;
@@ -581,6 +630,7 @@ function createVitestGatesConfig(options = {}) {
         reporter: ["text"],
         reportsDirectory: "coverage/gates",
         ...coverage,
+        ...coverageProvider === void 0 ? {} : { provider: coverageProvider },
         enabled: true,
         include: manifest.gates.map((gate) => gate.path),
         thresholds: { perFile: true, ...FULL_COVERAGE }

package/dist/vitest.d.cts

@@ -5,6 +5,12 @@ interface VitestGatesOptions {
     test?: Record<string, unknown> & {
         coverage?: Record<string, unknown>;
     };
+    /**
+     * Coverage provider. Default `v8`. `istanbul` (needs `@vitest/coverage-istanbul`) also counts
+     * the skipped side of an `if` without `else` on Vitest 3, and an unused default parameter on
+     * every version; see the README for the measurements. Same as `test.coverage.provider`.
+     */
+    coverageProvider?: 'v8' | 'istanbul';
     /** Any other Vite option: resolve.alias, esbuild, plugins, … */
     [option: string]: unknown;
 }

package/dist/vitest.d.ts

@@ -5,6 +5,12 @@ interface VitestGatesOptions {
     test?: Record<string, unknown> & {
         coverage?: Record<string, unknown>;
     };
+    /**
+     * Coverage provider. Default `v8`. `istanbul` (needs `@vitest/coverage-istanbul`) also counts
+     * the skipped side of an `if` without `else` on Vitest 3, and an unused default parameter on
+     * every version; see the README for the measurements. Same as `test.coverage.provider`.
+     */
+    coverageProvider?: 'v8' | 'istanbul';
     /** Any other Vite option: resolve.alias, esbuild, plugins, … */
     [option: string]: unknown;
 }

package/dist/vitest.js

@@ -6,11 +6,11 @@ import {
   NO_SPEC_PATTERN,
   gateSpecs,
   loadGates
-} from "./chunk-LMD3ANJ2.js";
+} from "./chunk-F7WBEFIL.js";
 
 // src/vitest.ts
 function createVitestGatesConfig(options = {}) {
-  const { rootDir: rootDirOption, test = {}, ...overrides } = options;
+  const { rootDir: rootDirOption, coverageProvider, test = {}, ...overrides } = options;
   const rootDir = resolveRootDir(rootDirOption);
   const manifest = loadGates(rootDir);
   const { coverage = {}, ...testOverrides } = test;
@@ -30,6 +30,7 @@ function createVitestGatesConfig(options = {}) {
         reporter: ["text"],
         reportsDirectory: "coverage/gates",
         ...coverage,
+        ...coverageProvider === void 0 ? {} : { provider: coverageProvider },
         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.1.0",
+  "version": "0.3.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",
@@ -76,7 +76,8 @@
   },
   "files": [
     "dist",
-    "schema"
+    "schema",
+    "CHANGELOG.md"
   ],
   "engines": {
     "node": ">=20"
@@ -103,7 +104,8 @@
   "peerDependencies": {
     "@stryker-mutator/core": ">=9",
     "jest": ">=29",
-    "vitest": ">=3"
+    "vitest": ">=3",
+    "@vitest/coverage-istanbul": ">=3"
   },
   "peerDependenciesMeta": {
     "@stryker-mutator/core": {
@@ -114,6 +116,9 @@
     },
     "vitest": {
       "optional": true
+    },
+    "@vitest/coverage-istanbul": {
+      "optional": true
     }
   },
   "devDependencies": {
@@ -121,6 +126,7 @@
     "@stryker-mutator/core": "^10.0.0",
     "@stryker-mutator/vitest-runner": "^10.0.0",
     "@types/node": "^22.20.5",
+    "@vitest/coverage-istanbul": "^3.2.7",
     "@vitest/coverage-v8": "^3.2.7",
     "eslint": "^9.39.5",
     "eslint-config-prettier": "^10.1.8",

package/schema/test-gates.schema.json

@@ -7,22 +7,34 @@
   "required": ["gates"],
   "additionalProperties": false,
   "properties": {
-    "$schema": { "type": "string" },
+    "$schema": {
+      "type": "string"
+    },
     "gates": {
       "description": "Pure modules that hold an important decision. Each must reach 100% on all four coverage metrics and leave no surviving mutant outside its allow list.",
       "type": "array",
       "minItems": 1,
-      "items": { "$ref": "#/definitions/gate" }
+      "items": {
+        "$ref": "#/definitions/gate"
+      }
     },
     "candidates": {
       "description": "Important logic that cannot be a gate yet. Nothing is enforced for these beyond their existence.",
       "type": "array",
-      "items": { "$ref": "#/definitions/candidate" }
+      "items": {
+        "$ref": "#/definitions/candidate"
+      }
     },
-    "settings": { "$ref": "#/definitions/settings" }
+    "settings": {
+      "$ref": "#/definitions/settings"
+    }
   },
   "definitions": {
-    "nonEmptyString": { "type": "string", "minLength": 1, "pattern": "\\S" },
+    "nonEmptyString": {
+      "type": "string",
+      "minLength": 1,
+      "pattern": "\\S"
+    },
     "gate": {
       "type": "object",
       "required": ["path", "decides", "impact"],
@@ -43,7 +55,16 @@
         "equivalentMutants": {
           "description": "Surviving mutants that are allowed because they cannot be observed from outside. One entry allows exactly one mutant.",
           "type": "array",
-          "items": { "$ref": "#/definitions/equivalentMutant" }
+          "items": {
+            "$ref": "#/definitions/equivalentMutant"
+          }
+        },
+        "expectedTimeouts": {
+          "description": "Since 0.2.0. Mutants that can never finish (a loop that no longer ends) and therefore always time out. Same key as equivalentMutants. They are not counted against settings.mutation.maxTimeouts. An entry whose mutant survives, or does not exist, fails the run; one that is killed is accepted.",
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/equivalentMutant"
+          }
         }
       }
     },
@@ -84,7 +105,9 @@
           "description": "File or directory, relative to the subproject.",
           "$ref": "#/definitions/nonEmptyString"
         },
-        "decides": { "$ref": "#/definitions/nonEmptyString" },
+        "decides": {
+          "$ref": "#/definitions/nonEmptyString"
+        },
         "blocker": {
           "description": "What has to happen before this can become a gate.",
           "$ref": "#/definitions/nonEmptyString"
@@ -94,15 +117,23 @@
     "patternRule": {
       "description": "A regular expression, either as a string or with flags and a reason.",
       "oneOf": [
-        { "$ref": "#/definitions/nonEmptyString" },
+        {
+          "$ref": "#/definitions/nonEmptyString"
+        },
         {
           "type": "object",
           "required": ["pattern"],
           "additionalProperties": false,
           "properties": {
-            "pattern": { "$ref": "#/definitions/nonEmptyString" },
-            "flags": { "type": "string" },
-            "reason": { "type": "string" }
+            "pattern": {
+              "$ref": "#/definitions/nonEmptyString"
+            },
+            "flags": {
+              "type": "string"
+            },
+            "reason": {
+              "type": "string"
+            }
           }
         }
       ]
@@ -116,7 +147,12 @@
           "type": "boolean",
           "default": true
         },
-        "add": { "type": "array", "items": { "$ref": "#/definitions/patternRule" } }
+        "add": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/patternRule"
+          }
+        }
       }
     },
     "settings": {
@@ -128,7 +164,10 @@
           "description": "File extensions a gate may have.",
           "type": "array",
           "minItems": 1,
-          "items": { "type": "string", "pattern": "^\\." },
+          "items": {
+            "type": "string",
+            "pattern": "^\\."
+          },
           "default": [".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"]
         },
         "spec": {
@@ -138,7 +177,9 @@
             "suffixes": {
               "description": "Replaces the gate's extension to form the spec path. Default: \".spec<ext>\" and \".test<ext>\". An empty array means the project has no spec convention.",
               "type": "array",
-              "items": { "$ref": "#/definitions/nonEmptyString" }
+              "items": {
+                "$ref": "#/definitions/nonEmptyString"
+              }
             },
             "rewrite": {
               "description": "Regular expression replacements applied to the gate path before the suffix, for specs that live in another directory.",
@@ -148,8 +189,12 @@
                 "required": ["from", "to"],
                 "additionalProperties": false,
                 "properties": {
-                  "from": { "$ref": "#/definitions/nonEmptyString" },
-                  "to": { "type": "string" }
+                  "from": {
+                    "$ref": "#/definitions/nonEmptyString"
+                  },
+                  "to": {
+                    "type": "string"
+                  }
                 }
               }
             }
@@ -160,12 +205,22 @@
           "type": "object",
           "additionalProperties": false,
           "properties": {
-            "defaults": { "type": "boolean", "default": true },
-            "add": { "type": "array", "items": { "$ref": "#/definitions/patternRule" } },
+            "defaults": {
+              "type": "boolean",
+              "default": true
+            },
+            "add": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/patternRule"
+              }
+            },
             "allow": {
               "description": "Module specifiers exempt from every rule (regular expressions).",
               "type": "array",
-              "items": { "$ref": "#/definitions/nonEmptyString" }
+              "items": {
+                "$ref": "#/definitions/nonEmptyString"
+              }
             }
           }
         },
@@ -174,7 +229,10 @@
           "type": "object",
           "additionalProperties": false,
           "properties": {
-            "defaults": { "type": "boolean", "default": true },
+            "defaults": {
+              "type": "boolean",
+              "default": true
+            },
             "add": {
               "type": "array",
               "items": {
@@ -182,13 +240,19 @@
                 "required": ["module", "names"],
                 "additionalProperties": false,
                 "properties": {
-                  "module": { "$ref": "#/definitions/nonEmptyString" },
+                  "module": {
+                    "$ref": "#/definitions/nonEmptyString"
+                  },
                   "names": {
                     "type": "array",
                     "minItems": 1,
-                    "items": { "$ref": "#/definitions/nonEmptyString" }
+                    "items": {
+                      "$ref": "#/definitions/nonEmptyString"
+                    }
                   },
-                  "reason": { "type": "string" }
+                  "reason": {
+                    "type": "string"
+                  }
                 }
               }
             }
@@ -199,7 +263,7 @@
           "$ref": "#/definitions/ruleList"
         },
         "forbiddenSource": {
-          "description": "Lines that must not appear in a gate (regular expressions, tested one line at a time). Default: 'use client' / 'use server'.",
+          "description": "Lines that must not appear in a gate (regular expressions, tested one line at a time). Default: 'use client' / 'use server', and process.env (since 0.3.0).",
           "$ref": "#/definitions/ruleList"
         },
         "importAliases": {
@@ -210,8 +274,12 @@
             "required": ["prefix", "target"],
             "additionalProperties": false,
             "properties": {
-              "prefix": { "$ref": "#/definitions/nonEmptyString" },
-              "target": { "type": "string" }
+              "prefix": {
+                "$ref": "#/definitions/nonEmptyString"
+              },
+              "target": {
+                "type": "string"
+              }
             }
           }
         },
@@ -219,7 +287,9 @@
           "description": "The command `test-gates selfcheck` runs. Default: `jest --config jest.gates.config.*` or `vitest run --config vitest.gates.config.*`, whichever config exists.",
           "type": "array",
           "minItems": 1,
-          "items": { "$ref": "#/definitions/nonEmptyString" }
+          "items": {
+            "$ref": "#/definitions/nonEmptyString"
+          }
         },
         "selfcheck": {
           "type": "object",
@@ -262,7 +332,74 @@
             "summaryExclude": {
               "description": "Paths left out of the reference total (regular expressions).",
               "type": "array",
-              "items": { "$ref": "#/definitions/nonEmptyString" }
+              "items": {
+                "$ref": "#/definitions/nonEmptyString"
+              }
+            }
+          }
+        },
+        "imports": {
+          "description": "Since 0.2.0. How runtime imports of a gate are judged.",
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "mode": {
+              "description": "blocklist (default): only the impureImports rules apply. allowlist: in addition, a runtime import must be relative, go through an import alias, or be listed in allow; a project import must not point at a file matched by impurePaths; a computed require() / import() is rejected.",
+              "enum": ["blocklist", "allowlist"],
+              "default": "blocklist"
+            },
+            "allow": {
+              "description": "Packages a gate may import in allowlist mode. A string is a package name (its subpaths included). { pattern } is a regular expression tested against the specifier. { module, names } allows only those named imports.",
+              "type": "array",
+              "items": {
+                "oneOf": [
+                  {
+                    "$ref": "#/definitions/nonEmptyString"
+                  },
+                  {
+                    "type": "object",
+                    "required": ["pattern"],
+                    "additionalProperties": false,
+                    "properties": {
+                      "pattern": {
+                        "$ref": "#/definitions/nonEmptyString"
+                      },
+                      "flags": {
+                        "type": "string"
+                      }
+                    }
+                  },
+                  {
+                    "type": "object",
+                    "required": ["module", "names"],
+                    "additionalProperties": false,
+                    "properties": {
+                      "module": {
+                        "$ref": "#/definitions/nonEmptyString"
+                      },
+                      "names": {
+                        "type": "array",
+                        "minItems": 1,
+                        "items": {
+                          "$ref": "#/definitions/nonEmptyString"
+                        }
+                      }
+                    }
+                  }
+                ]
+              }
+            }
+          }
+        },
+        "mutation": {
+          "description": "Since 0.2.0.",
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "maxTimeouts": {
+              "description": "How many timed-out mutants outside expectedTimeouts are tolerated. Above it the run fails. Default: 0 (since 0.3.0; before that, not set meant no limit).",
+              "type": "integer",
+              "minimum": 0
             }
           }
         }