@avi2dg/checks 0.42.0 → 0.44.0

package/src/testing/test-layout.ts

@@ -1,9 +1,10 @@
 #!/usr/bin/env bun
 import { Console, Effect, FileSystem, Path, Schema } from "effect";
-import { git } from "../core/git.ts";
+import { workingTreeFiles } from "../core/git.ts";
 import { runMain } from "../core/main.ts";
 import { ENTRY_POINT, TEST_ENTRY_POINT } from "../core/gates.ts";
 import { identifierName, isRecord, lineOf, parseTypeScript, spanStart, stringValue } from "../core/swc.ts";
+import { scriptOptions } from "./test.ts";
 
 export type Violation = {
   readonly file: string;
@@ -60,7 +61,7 @@ const ACCEPTED_IGNORES: readonly (readonly string[])[] = [
 export const LAYOUT_CHECK_MARK = "src/testing/test-layout.ts";
 export const LAYOUT_CHECK_BIN = "checks-test-layout";
 const OWN_ENTRY_POINT = `src/${ENTRY_POINT.script}`;
-const TEST_SCRIPTS: readonly string[] = [TEST_ENTRY_POINT.bin, `bun src/${TEST_ENTRY_POINT.script}`];
+const PARALLEL_OPTION = "optionally with --parallel=<workers>";
 
 export class LayoutError extends Schema.TaggedError<LayoutError>()("LayoutError", {
   message: Schema.String,
@@ -236,11 +237,11 @@ function tierScriptViolation(scripts: unknown, files: readonly string[], tier: (
   const expected = `${TEST_ENTRY_POINT.bin} --tier=${tier}`;
   const hasTests = files.some((candidate) => candidate.startsWith(`tests/${tier}/`) && TEST_FILE.test(candidate));
   if (!hasTests && found === undefined) return undefined;
-  if (found === expected) return undefined;
+  if (scriptOptions(found)?.tier === tier) return undefined;
   return {
     file,
     line: undefined,
-    message: `${key} must be "${expected}"${hasTests ? " when its test tier has files" : " when declared"}, found ${JSON.stringify(found ?? null)}`,
+    message: `${key} must be "${expected}", ${PARALLEL_OPTION},${hasTests ? " when its test tier has files" : " when declared"}, found ${JSON.stringify(found ?? null)}`,
   };
 }
 
@@ -250,11 +251,12 @@ export function scriptViolations(manifest: unknown, files: readonly string[] = [
   const test = isRecord(scripts) ? scripts["test"] : undefined;
   const lint = isRecord(scripts) ? scripts["lint"] : undefined;
   const violations: Violation[] = [];
-  if (typeof test !== "string" || !TEST_SCRIPTS.includes(test)) {
+  const options = scriptOptions(test);
+  if (options === undefined || options.tier !== undefined) {
     violations.push({
       file,
       line: undefined,
-      message: `scripts.test must be exactly "${TEST_ENTRY_POINT.bin}", which runs bun test --randomize and judges its skips, found ${JSON.stringify(test ?? null)}`,
+      message: `scripts.test must be "${TEST_ENTRY_POINT.bin}", ${PARALLEL_OPTION}, which runs bun test --randomize and judges its skips, found ${JSON.stringify(test ?? null)}`,
     });
   }
   if (typeof lint !== "string" || !runsLayoutCheck(lint)) {
@@ -299,15 +301,6 @@ export function bunfigViolations(consumer: unknown, preset: unknown): readonly V
   return violations;
 }
 
-const workingTreeFiles = Effect.fn("workingTreeFiles")(function* (root: string) {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const listed = yield* git(["ls-files", "-z", "--cached", "--others", "--exclude-standard"], root);
-  return yield* Effect.filter(listed.split("\0").filter(Boolean), (file) => fs.exists(path.join(root, file)), {
-    concurrency: "unbounded",
-  });
-});
-
 const parsedToml = Effect.fn("parsedToml")(function* (file: string) {
   const text = yield* (yield* FileSystem.FileSystem).readFileString(file);
   return yield* Effect.try({

package/src/testing/test-report.ts

@@ -9,6 +9,11 @@ export type TestResult = {
   readonly outcome: Outcome;
 };
 
+type Report = {
+  readonly results: readonly TestResult[];
+  readonly crashedFiles: readonly string[];
+};
+
 export class ReportError extends Schema.TaggedError<ReportError>()("ReportError", {
   message: Schema.String,
 }) {}
@@ -36,6 +41,7 @@ const decodeSuite = Schema.decodeUnknownEffect(Schema.Struct({ name: Schema.Stri
 const decodeCase = Schema.decodeUnknownEffect(
   Schema.Struct({ name: Schema.String, file: Schema.String, line: Schema.NumberFromString.check(Schema.isInt()) }),
 );
+const decodeCrash = Schema.decodeUnknownEffect(Schema.Struct({ file: Schema.String }));
 
 function unescape(text: string): string {
   return text.replace(ENTITY, (_, named: string | undefined, decimal: string | undefined, hex: string | undefined) => {
@@ -91,20 +97,28 @@ function outcomeOf(testcase: Element): Outcome {
   return testcase.children.some((child) => child.tag === "failure" || child.tag === "error") ? "failed" : "passed";
 }
 
+// bun's parallel coordinator replaces every result of a file whose worker crashed with one failure that has no line.
+function crashed(testcase: Element): boolean {
+  return testcase.attributes["line"] === undefined && outcomeOf(testcase) === "failed";
+}
+
 const collect = Effect.fnUntraced(function* (
   suite: Element,
   describes: readonly string[],
-  results: TestResult[],
+  report: { readonly results: TestResult[]; readonly crashedFiles: string[] },
 ): Effect.fn.Return<void, ReportError> {
   const unreadable = (tag: string) => (cause: { readonly message: string }) =>
     new ReportError({ message: `the junit report holds a <${tag}> bun never writes: ${cause.message}` });
   for (const child of suite.children) {
     if (child.tag === "testsuite") {
       const { name } = yield* decodeSuite(child.attributes).pipe(Effect.mapError(unreadable(child.tag)));
-      yield* collect(child, [...describes, name], results);
+      yield* collect(child, [...describes, name], report);
+    } else if (child.tag === "testcase" && crashed(child)) {
+      const { file } = yield* decodeCrash(child.attributes).pipe(Effect.mapError(unreadable(child.tag)));
+      report.crashedFiles.push(file);
     } else if (child.tag === "testcase") {
       const { name, file, line } = yield* decodeCase(child.attributes).pipe(Effect.mapError(unreadable(child.tag)));
-      results.push({ file, name: [...describes, name].join(NAME_SEPARATOR), line, outcome: outcomeOf(child) });
+      report.results.push({ file, name: [...describes, name].join(NAME_SEPARATOR), line, outcome: outcomeOf(child) });
     }
   }
 });
@@ -113,8 +127,9 @@ const collect = Effect.fnUntraced(function* (
 export const parseReport = Effect.fn("parseReport")(function* (xml: string) {
   const root = yield* parseElements(xml);
   const results: TestResult[] = [];
+  const crashedFiles: string[] = [];
   for (const fileSuite of root.children) {
-    if (fileSuite.tag === "testsuite") yield* collect(fileSuite, [], results);
+    if (fileSuite.tag === "testsuite") yield* collect(fileSuite, [], { results, crashedFiles });
   }
-  return results;
+  return { results, crashedFiles } satisfies Report;
 });

package/src/testing/test-skips.ts

@@ -2,7 +2,7 @@ import { Effect, FileSystem, Path, Schema } from "effect";
 import { identifierName, isRecord, lineOf, parseTypeScript, spanStart, stringValue } from "../core/swc.ts";
 
 export type Environment = "ci" | "local";
-export type TestTier = "live" | "pixel";
+export type TestTier = "live" | "pixel" | "unit" | "e2e";
 export type SkipDeclaration = {
   readonly file: string;
   readonly line: number;

package/src/testing/test.ts

@@ -20,12 +20,45 @@ export class SkipGateError extends Schema.TaggedError<SkipGateError>()("SkipGate
   message: Schema.String,
 }) {}
 
+export type TestOptions = {
+  readonly tier?: TestTier;
+  readonly workers?: number;
+};
+
 const NAME = TEST_ENTRY_POINT.bin;
-const USAGE = `usage: ${NAME} takes no arguments except --tier=live or --tier=pixel`;
+const USAGE = `usage: ${NAME} [--tier=live | --tier=pixel | --tier=unit | --tier=e2e] [--parallel=<workers>], and it refuses test filters`;
 const TIERS = new Map<string, TestTier>([
   ["--tier=live", "live"],
   ["--tier=pixel", "pixel"],
+  ["--tier=unit", "unit"],
+  ["--tier=e2e", "e2e"],
 ]);
+const PARALLEL = /^--parallel=([1-9][0-9]*)$/;
+
+function optionOf(arg: string): TestOptions | undefined {
+  const tier = TIERS.get(arg);
+  if (tier !== undefined) return { tier };
+  const workers = PARALLEL.exec(arg)?.[1];
+  return workers === undefined ? undefined : { workers: Number(workers) };
+}
+
+export function testOptions(args: readonly string[]): TestOptions | undefined {
+  let options: TestOptions = {};
+  for (const arg of args) {
+    const option = optionOf(arg);
+    if (option === undefined || Object.keys(option).some((key) => key in options)) return undefined;
+    options = { ...options, ...option };
+  }
+  return options;
+}
+
+const TEST_SCRIPTS: readonly string[] = [NAME, `bun src/${TEST_ENTRY_POINT.script}`];
+
+export function scriptOptions(script: unknown): TestOptions | undefined {
+  if (typeof script !== "string") return undefined;
+  const entry = TEST_SCRIPTS.find((candidate) => script === candidate || script.startsWith(`${candidate} `));
+  return entry === undefined ? undefined : testOptions(script.slice(entry.length).split(" ").filter((arg) => arg !== ""));
+}
 
 function matches(declaration: SkipDeclaration, result: TestResult): boolean {
   const { name } = declaration;
@@ -113,10 +146,17 @@ const environmentOf = Config.Boolean("CI").pipe(
   Effect.mapError((cause) => new SkipGateError({ message: `cannot tell a ci run from a local one: ${cause.message}` })),
 );
 
-const runSuite = Effect.fn("runSuite")(function* (outfile: string, tier: TestTier | undefined) {
+function tierArgs(tier: TestTier | undefined): readonly string[] {
+  if (tier === undefined) return [];
+  // The preset ignores tests/live and tests/pixel, so only those tiers clear the ignore list.
+  if (tier === "live" || tier === "pixel") return ["--path-ignore-patterns", "", `./tests/${tier}`];
+  return [`./tests/${tier}`];
+}
+
+const runSuite = Effect.fn("runSuite")(function* (outfile: string, { tier, workers }: TestOptions) {
   const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
-  const tierArgs = tier === undefined ? [] : ["--path-ignore-patterns", "", `./tests/${tier}`];
-  const args = ["test", "--randomize", ...tierArgs, ...reporterArgs(outfile)];
+  const parallelArgs = workers === undefined ? [] : [`--parallel=${workers}`];
+  const args = ["test", "--randomize", ...parallelArgs, ...tierArgs(tier), ...reporterArgs(outfile)];
   return yield* spawner.exitCode(
     ChildProcess.make(process.execPath, args, {
       stdin: "ignore",
@@ -129,15 +169,14 @@ const runSuite = Effect.fn("runSuite")(function* (outfile: string, tier: TestTie
 });
 
 const testEntry = Effect.gen(function* () {
-  const args = process.argv.slice(2);
-  const tier = args.length === 0 ? undefined : args.length === 1 ? TIERS.get(args[0] ?? "") : undefined;
-  if (args.length > 0 && tier === undefined) return yield* new Usage({ message: USAGE });
+  const options = testOptions(process.argv.slice(2));
+  if (options === undefined) return yield* new Usage({ message: USAGE });
   const fs = yield* FileSystem.FileSystem;
-  const declarations = yield* readSkipDeclarations(process.cwd(), tier);
+  const declarations = yield* readSkipDeclarations(process.cwd(), options.tier);
   const environment = yield* environmentOf;
 
   const outfile = (yield* Path.Path).join(yield* fs.makeTempDirectoryScoped({ prefix: "checks-test-" }), "junit.xml");
-  const suitePassed = (yield* runSuite(outfile, tier)) === ChildProcessSpawner.ExitCode(0);
+  const suitePassed = (yield* runSuite(outfile, options)) === ChildProcessSpawner.ExitCode(0);
   if (!(yield* fs.exists(outfile))) {
     if (!suitePassed) {
       yield* Console.error(`${NAME}: bun test failed before it wrote a report, so no skip was judged`);
@@ -146,9 +185,12 @@ const testEntry = Effect.gen(function* () {
     return yield* new ReportError({ message: `bun test passed but wrote no report to ${outfile}` });
   }
 
-  const verdict = judgeSkips(yield* parseReport(yield* fs.readFileString(outfile)), declarations, environment);
+  const { results, crashedFiles } = yield* parseReport(yield* fs.readFileString(outfile));
+  for (const file of crashedFiles) yield* Console.error(`${NAME}: the worker running ${file} crashed, so its skips were not judged`);
+  const judged = declarations.filter((declaration) => !crashedFiles.includes(declaration.file));
+  const verdict = judgeSkips(results, judged, environment);
   yield* passes(verdict) ? Console.log(report(verdict)) : Console.error(report(verdict));
-  return suitePassed && passes(verdict);
+  return suitePassed && crashedFiles.length === 0 && passes(verdict);
 }).pipe(Effect.scoped);
 
 if (import.meta.main) runMain(NAME, testEntry);

package/stryker.preset.js

@@ -1,8 +1,8 @@
 import { readdirSync } from "node:fs";
 import { availableParallelism } from "node:os";
 import { fileURLToPath } from "node:url";
-import { GUARD_IGNORER } from "./src/testing/mutation-guard-plugin.js";
-import { fullRunRefusal } from "./src/testing/mutation-scope.js";
+import { GUARD_IGNORER } from "./dist/mutation/mutation-guard-plugin.js";
+import { fullRunRefusal } from "./dist/mutation/mutation-refusal.js";
 
 const [, , command, ...args] = process.argv;
 const refusal = command === "run" ? fullRunRefusal(args, process.env.CI ?? "") : undefined;
@@ -22,7 +22,7 @@ export default {
   plugins: [
     "@stryker-mutator/*",
     "@hughescr/stryker-bun-runner",
-    fileURLToPath(new URL("./src/testing/mutation-guard-plugin.js", import.meta.url)),
+    fileURLToPath(new URL("./dist/mutation/mutation-guard-plugin.js", import.meta.url)),
   ],
   ignorers: [GUARD_IGNORER],
   testRunner: "bun",

package/src/testing/mutation-guard-plugin.js

@@ -1,13 +0,0 @@
-import { missingReportRefusal } from "./mutation-scope.js";
-
-export const GUARD_IGNORER = "checks-incremental-report-guard";
-
-// An ignorer is built before instrumentation from the resolved options, so a throw here stops the run before any mutant.
-function incrementalReportGuard(options) {
-  const refusal = missingReportRefusal(process.argv.slice(3), process.env.CI ?? "", options.incrementalFile);
-  if (refusal !== undefined) throw new Error(refusal);
-  return { shouldIgnore: () => undefined };
-}
-incrementalReportGuard.inject = ["options"];
-
-export const strykerPlugins = [{ kind: "Ignore", name: GUARD_IGNORER, factory: incrementalReportGuard }];