@alchemy.run/test 2.0.0-beta.85 → 2.0.0-beta.86

package/src/PlainReporter.ts

@@ -4,8 +4,7 @@
  * Reports progress through the collection phase (importing a large suite's
  * files takes tens of seconds before any test can run), then logs one line per
  * test as it finishes, prefixed with a `[done/total]` counter (failures include
- * their error and captured output inline); if nothing finishes for 10s it
- * prints the list of currently-running tests; at the end every failure is
+ * their error and captured output inline); at the end every failure is
  * repeated consolidated.
  */
 import * as Effect from "effect/Effect";
@@ -53,25 +52,14 @@ const indent = (text: string, prefix = "  "): string =>
 interface ReporterState {
   readonly hookLogs: Map<string, ReadonlyArray<LogEntry>>;
   readonly failedFiles: Set<string>;
-  /**
-   * Currently-executing work items: tests AND file-level hooks. Hooks must
-   * be tracked too — a `beforeAll` deploy can legitimately run for many
-   * minutes with no test starting or finishing, and if the stall report
-   * only covered tests, such a run would print nothing at all and read as
-   * deadlocked.
-   */
-  /** `queued`: started, but still waiting for its `exclusive` run lock. */
-  readonly running: Map<string, { label: string; startedAt: number; queued?: boolean }>;
   /** Total tests in the run, known once RunStart arrives. */
   total: number;
   /** Tests that have reported a result so far, and how they went. */
   completed: number;
   passed: number;
   failed: number;
-  lastEnd: number;
-  /** Running-set fingerprint of the last stall report — dedupes repeats. */
-  lastStallKey: string;
-  stallTimer: ReturnType<typeof setInterval> | undefined;
+  /** Repaints the collection line while files are importing. */
+  collectTimer: ReturnType<typeof setInterval> | undefined;
   /** Files discovered for the collection phase. */
   collectTotal: number;
   collectDone: number;
@@ -128,6 +116,10 @@ const renderCollect = (state: ReporterState, force: boolean): void => {
 /** Settle the progress line on the final count so the total cost stays visible. */
 const finishCollect = (state: ReporterState): void => {
   state.collecting = false;
+  if (state.collectTimer !== undefined) {
+    clearInterval(state.collectTimer);
+    state.collectTimer = undefined;
+  }
   clearCollectLine(state);
   state.collectCurrent = "";
   renderCollect(state, true);
@@ -159,44 +151,6 @@ const progress = (state: ReporterState, status: TestResult["status"]): string =>
   ].join(" ");
 };
 
-const STALL_AFTER_MS = 10_000;
-const STALL_LIST_MAX = 25;
-
-/**
- * Print the currently-running tests when nothing has finished for a while.
- * Printed AT MOST ONCE per distinct running set: while the exact same tests
- * stay stuck, nothing is re-printed — the timestamp on the report tells the
- * reader how long ago it was taken.
- */
-const printStalled = (state: ReporterState): void => {
-  if (state.running.size === 0) return;
-  if (Date.now() - state.lastEnd < STALL_AFTER_MS) return;
-  const key = [...state.running.entries()]
-    .map(([id, item]) => `${id}${item.queued ? " (queued)" : ""}`)
-    .sort()
-    .join("\n");
-  if (key === state.lastStallKey) return;
-  state.lastStallKey = key;
-  const now = Date.now();
-  const timestamp = new Date(now).toTimeString().slice(0, 8);
-  const items = [...state.running.values()].sort((a, b) => a.startedAt - b.startedAt);
-  const queued = items.filter((item) => item.queued).length;
-  const lines = [
-    dim(
-      `⧗ [${timestamp}] no tests finished in the last 10s — ${items.length - queued} still running` +
-        (queued > 0 ? `, ${queued} queued for an exclusive lock:` : ":"),
-    ),
-  ];
-  for (const item of items.slice(0, STALL_LIST_MAX)) {
-    const elapsed = formatDuration(now - item.startedAt);
-    lines.push(dim(`    ${item.label} (${item.queued ? `queued ${elapsed}` : elapsed})`));
-  }
-  if (items.length > STALL_LIST_MAX) {
-    lines.push(dim(`    … ${items.length - STALL_LIST_MAX} more`));
-  }
-  writeDirect(`${lines.join("\n")}\n`);
-};
-
 const onEvent = (event: TestEvent, state: ReporterState): Effect.Effect<void> => {
   switch (event._tag) {
     case "PlanPreview":
@@ -209,6 +163,13 @@ const onEvent = (event: TestEvent, state: ReporterState): Effect.Effect<void> =>
       state.collectTotal = event.files.length;
       state.collectStartedAt = Date.now();
       state.collecting = true;
+      if (state.collectTimer === undefined) {
+        state.collectTimer = setInterval(() => {
+          if (state.collecting) renderCollect(state, false);
+        }, 1000);
+        // Don't hold the process open once the run's fibers finish.
+        (state.collectTimer as unknown as { unref?: () => void }).unref?.();
+      }
       return write(dim(`collecting ${event.files.length} test files...`));
     case "FileCollected":
       return Effect.sync(() => {
@@ -223,36 +184,7 @@ const onEvent = (event: TestEvent, state: ReporterState): Effect.Effect<void> =>
           write(dim(`running ${event.tests.length} tests from ${event.files} files\n`)),
         ),
       );
-    case "TestStart":
-      return Effect.sync(() => {
-        state.running.set(event.test.id, {
-          label: `${event.test.file} > ${event.test.titlePath.join(" > ")}`,
-          startedAt: Date.now(),
-          queued: true,
-        });
-      });
-    case "TestLocked":
-      return Effect.sync(() => {
-        const item = state.running.get(event.test.id);
-        if (item !== undefined) {
-          state.running.set(event.test.id, { label: item.label, startedAt: Date.now() });
-        }
-      });
-    case "HookStart":
-      return Effect.sync(() => {
-        state.running.set(`${event.file} :: ${event.hook}`, {
-          label: `${event.file} > [${event.hook} hook]`,
-          startedAt: Date.now(),
-        });
-      });
-    case "HookEnd":
-      return Effect.sync(() => {
-        state.running.delete(`${event.file} :: ${event.hook}`);
-        state.lastEnd = Date.now();
-      });
     case "TestEnd": {
-      state.running.delete(event.test.id);
-      state.lastEnd = Date.now();
       const title = `${dim(event.test.file)} ${dim(">")} ${event.test.titlePath.join(` ${dim(">")} `)}`;
       const duration = dim(`(${formatDuration(event.result.durationMs)})`);
       const retries = event.result.retries > 0 ? yellow(` [retried x${event.result.retries}]`) : "";
@@ -306,6 +238,10 @@ const onEvent = (event: TestEvent, state: ReporterState): Effect.Effect<void> =>
       return Effect.void;
     }
     case "RunEnd":
+      if (state.collectTimer !== undefined) {
+        clearInterval(state.collectTimer);
+        state.collectTimer = undefined;
+      }
       return printSummary(event.summary, state.hookLogs);
     default:
       return Effect.void;
@@ -382,14 +318,11 @@ export const PlainReporterLive: Layer.Layer<Reporter> = Layer.sync(Reporter)(()
   const state: ReporterState = {
     hookLogs: new Map(),
     failedFiles: new Set(),
-    running: new Map(),
     total: 0,
     completed: 0,
     passed: 0,
     failed: 0,
-    lastEnd: Date.now(),
-    lastStallKey: "",
-    stallTimer: undefined,
+    collectTimer: undefined,
     collectTotal: 0,
     collectDone: 0,
     collectStartedAt: Date.now(),
@@ -398,29 +331,8 @@ export const PlainReporterLive: Layer.Layer<Reporter> = Layer.sync(Reporter)(()
     collectLinePending: false,
     collecting: false,
   };
-  // Ticks through both phases: repaints the collection line while files are
-  // importing, reports stalled tests once the run is executing.
-  const tick = (): void => {
-    if (state.collecting) renderCollect(state, false);
-    else printStalled(state);
-  };
   return {
-    emit: (event) =>
-      Effect.suspend(() => {
-        if (
-          (event._tag === "CollectStart" || event._tag === "RunStart") &&
-          state.stallTimer === undefined
-        ) {
-          state.stallTimer = setInterval(tick, 1000);
-          // Don't hold the process open once the run's fibers finish.
-          (state.stallTimer as unknown as { unref?: () => void }).unref?.();
-        }
-        if (event._tag === "RunEnd" && state.stallTimer !== undefined) {
-          clearInterval(state.stallTimer);
-          state.stallTimer = undefined;
-        }
-        return onEvent(event, state);
-      }),
+    emit: (event) => Effect.suspend(() => onEvent(event, state)),
     waitForExit: () => Effect.void,
   };
 });

package/src/Runner.ts

@@ -24,7 +24,7 @@ import * as Path from "effect/Path";
 import * as Semaphore from "effect/Semaphore";
 import { makeCapture } from "./Capture.ts";
 import { makeFileLog, type FileLog } from "./FileLog.ts";
-import type { Exclusive, FileSuite, Hook, LogEntry, Suite, TestCase } from "./Model.ts";
+import type { Exclusive, FileSuite, Hook, Limit, LogEntry, Suite, TestCase } from "./Model.ts";
 import { containsOnly, forEachTest, makeFileSuite, titlePath } from "./Model.ts";
 import type { TestPlan } from "./Plan.ts";
 import * as Registry from "./Registry.ts";
@@ -309,18 +309,35 @@ const EXCLUSIVE_PERMITS = 100_000;
 
 interface LockSpec {
   readonly global: boolean;
-  /** Sorted, so holders of several labels acquire them in one order. */
-  readonly labels: ReadonlyArray<string>;
+  /** Sorted by label, so holders of several labels acquire them in one order. */
+  readonly labels: ReadonlyArray<Limit>;
 }
 
-const lockSpec = (values: ReadonlyArray<Exclusive | undefined>): LockSpec => ({
-  global: values.some((value) => value === true),
-  labels: [
-    ...new Set(
-      values.filter((value): value is string => typeof value === "string" && value !== ""),
-    ),
-  ].sort(),
-});
+const lockSpec = (values: ReadonlyArray<Exclusive | undefined>): LockSpec => {
+  const flat = values.flatMap((value) => (Array.isArray(value) ? value : [value])) as Array<
+    boolean | string | Limit | undefined
+  >;
+  // A plain label is a one-permit lock; the tightest permit count wins.
+  const labels = new Map<string, number>();
+  for (const value of flat) {
+    const limit =
+      typeof value === "string"
+        ? value === ""
+          ? undefined
+          : { label: value, permits: 1 }
+        : typeof value === "object" && value !== null
+          ? value
+          : undefined;
+    if (limit === undefined) continue;
+    labels.set(limit.label, Math.min(labels.get(limit.label) ?? Infinity, limit.permits));
+  }
+  return {
+    global: flat.some((value) => value === true),
+    labels: [...labels]
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([label, permits]) => ({ label, permits })),
+  };
+};
 
 interface RunLock {
   readonly withLock: (
@@ -342,10 +359,11 @@ interface RunLock {
 const makeRunLock = Effect.gen(function* () {
   const permits = yield* Semaphore.make(EXCLUSIVE_PERMITS);
   const labels = new Map<string, Semaphore.Semaphore>();
-  const labelLock = (label: string): Semaphore.Semaphore => {
+  // A label's permit count is fixed by its first holder.
+  const labelLock = ({ label, permits }: Limit): Semaphore.Semaphore => {
     let lock = labels.get(label);
     if (lock === undefined) {
-      lock = Semaphore.makeUnsafe(1);
+      lock = Semaphore.makeUnsafe(Math.max(1, Math.floor(permits)));
       labels.set(label, lock);
     }
     return lock;
@@ -702,40 +720,19 @@ const runTest = Effect.fn(function* (test: TestCase, ctx: ExecContext) {
   let exit = yield* runAttempt();
   while (attemptNeedsRetry(exit, test.fails) && retries < (test.retry ?? ctx.options.retry)) {
     retries++;
+    // The retry replaces this attempt's result; keep its error in the run
+    // log, or a test that passes on retry hides what failed (and leaked).
+    ctx.fileLog.appendTestLine(`${meta.file} > ${meta.titlePath.join(" > ")}`, {
+      level: "ERROR",
+      message: `attempt ${retries} failed, retrying: ${attemptOutcome(exit, test).error ?? "unknown"}`,
+      time: new Date(),
+    });
     // Clear IN PLACE — TestStart handed this array's reference out.
     ctx.capture.release(logs);
     exit = yield* runAttempt();
   }
 
-  let status: TestResult["status"];
-  let error: string | undefined;
-  if (wasInterrupted(exit)) {
-    status = "fail";
-    error = "killed (interrupted by user)";
-  } else if (Exit.isFailure(exit)) {
-    status = "fail";
-    error = prettyCause(exit.cause);
-  } else {
-    const failedHook = hookError(exit.value);
-    const bodyExit = exit.value.body;
-    if (failedHook !== undefined) {
-      status = "fail";
-      error = failedHook;
-    } else if (test.fails && bodyExit !== undefined) {
-      if (Exit.isFailure(bodyExit)) {
-        status = "pass";
-      } else {
-        status = "fail";
-        error = "expected test to fail, but it passed";
-      }
-    } else if (bodyExit !== undefined && Exit.isSuccess(bodyExit)) {
-      status = "pass";
-    } else {
-      status = "fail";
-      error = bodyExit === undefined ? "test body did not run" : prettyCause(bodyExit.cause);
-    }
-  }
-
+  const { status, error } = attemptOutcome(exit, test);
   if (ctx.interactive) ctx.completed.add(meta.id);
   const result: TestResult = { status, durationMs, error, logs, retries };
   ctx.results.set(meta.id, {
@@ -746,6 +743,29 @@ const runTest = Effect.fn(function* (test: TestCase, ctx: ExecContext) {
   if (!ctx.interactive && status !== "fail") ctx.capture.release(logs);
 });
 
+/** The status and error a finished attempt reports. */
+const attemptOutcome = (
+  exit: Exit.Exit<TestAttempt, unknown>,
+  test: TestCase,
+): { status: TestResult["status"]; error: string | undefined } => {
+  if (wasInterrupted(exit)) return { status: "fail", error: "killed (interrupted by user)" };
+  if (Exit.isFailure(exit)) return { status: "fail", error: prettyCause(exit.cause) };
+  const failedHook = hookError(exit.value);
+  const bodyExit = exit.value.body;
+  if (failedHook !== undefined) return { status: "fail", error: failedHook };
+  if (test.fails && bodyExit !== undefined) {
+    return Exit.isFailure(bodyExit)
+      ? { status: "pass", error: undefined }
+      : { status: "fail", error: "expected test to fail, but it passed" };
+  }
+  if (bodyExit !== undefined && Exit.isSuccess(bodyExit))
+    return { status: "pass", error: undefined };
+  return {
+    status: "fail",
+    error: bodyExit === undefined ? "test body did not run" : prettyCause(bodyExit.cause),
+  };
+};
+
 /** Fail every (non-skipped) test in a subtree without running it. */
 const failSubtree = Effect.fn(function* (suite: Suite, ctx: ExecContext, error: string) {
   const tests: Array<TestCase> = [];

package/src/Vitest.ts

@@ -1,4 +1,3 @@
-/** @effect-diagnostics anyUnknownInErrorContext:off */
 import { it } from "@effect/vitest";
 import type { AlchemyContext } from "alchemy/AlchemyContext";
 import type { CompiledStack, StackDefinition } from "alchemy/Stack";

package/src/index.ts

@@ -49,6 +49,7 @@ export type {
   Exclusive,
   FileSuite,
   Hook,
+  Limit,
   LogEntry,
   Mode,
   Suite,