@ultimat3/cli 22.6.2 → 22.7.0

package/src/verify-test-run.ts

@@ -2,13 +2,16 @@
 // files belong to a type and this one owns what happens to them once selected — a wrong file list
 // is never a race, and a race is never a selection bug.
 
+// why: Bun ships no path-join primitive; the timings cache lives under the run's root.
+import { join } from 'node:path';
 import type { Runner } from './exec';
 import type { Finding } from './output';
 import { runBatches, testBatches } from './test-batches';
 import { countsOf } from './test-counts';
 import { testEnvOverrides } from './test-dotenv';
 import type { TestFile } from './test-select';
-import { failureOf, testArgs } from './test-shards';
+import { failureOf, ISOLATED_TEST_ENV, TEST_TIMINGS_FILE, testArgs } from './test-shards';
+import { BATCH_FILES_PER_WORKER, SHARED_BATCH_FILES_PER_WORKER } from './test-workers';
 import type { StepOutcome } from './verify-step';
 // Type-only, so nothing here evaluates verify-tests.ts and the two files cannot form a cycle.
 import type { TestType } from './verify-tests';
@@ -23,6 +26,12 @@ export interface ParallelRunOptions {
   readonly type: TestType;
   /** This process's own environment. Optional and defaulted to `Bun.env` — see `VerifyContext.env`. */
   readonly env?: Readonly<Record<string, string | undefined>>;
+  /** A fresh global per file — `x.verify.json` `"isolate": true` or `--isolate`. Default off. */
+  readonly isolate?: boolean;
+  /** Why the width is what it is — printed on the step line. */
+  readonly widthReason?: string;
+  /** The machine-pool lease (`test-slots.ts`), for a default-width run. */
+  readonly lease?: (want: number) => Promise<{ readonly count: number; release(): void }>;
 }
 
 /**
@@ -42,14 +51,29 @@ export interface ParallelRunOptions {
 export async function runParallel(options: ParallelRunOptions): Promise<StepOutcome> {
   const files = options.files.map((file) => file.path);
   const workers = Math.max(1, Math.min(Math.trunc(options.workers), files.length || 1));
-  const envOverrides = testEnvOverrides(options.root, options.env ?? Bun.env);
+  const envOverrides = {
+    ...testEnvOverrides(options.root, options.env ?? Bun.env),
+    ...(options.isolate === true ? { [ISOLATED_TEST_ENV]: '1' } : {}),
+  };
   // Batched exactly as `x test` batches the same selection at the same width, so the gate's
   // `fix:` line — `x test <type> --workers N` — reruns the very processes that failed.
-  const batches = testBatches(files, workers);
+  const batches = testBatches(
+    files,
+    workers,
+    options.isolate === true ? BATCH_FILES_PER_WORKER : SHARED_BATCH_FILES_PER_WORKER,
+  );
   const result = await runBatches({
     runner: options.runner,
     batches,
-    argsFor: (batch) => testArgs({ files: batch, workers: Math.min(workers, batch.length) }),
+    workers,
+    ...(options.lease === undefined || workers === 1 ? {} : { lease: options.lease }),
+    argsFor: (batch, width) =>
+      testArgs({
+        files: batch,
+        workers: width,
+        isolate: options.isolate === true,
+        timings: join(options.root, TEST_TIMINGS_FILE),
+      }),
     options: {
       cwd: options.root,
       ...(Object.keys(envOverrides).length === 0 ? {} : { env: envOverrides }),
@@ -60,11 +84,28 @@ export async function runParallel(options: ParallelRunOptions): Promise<StepOutc
   // to drift — and the one that drifts is the gate's, which is the one an agent reads first.
   const findings: readonly Finding[] = result.ok
     ? []
-    : [failureOf(result.code, files.length, { workers, type: options.type })];
+    : [
+        failureOf(result.code, files.length, {
+          workers,
+          type: options.type,
+          ...(options.isolate === true ? { isolate: true } : {}),
+        }),
+      ];
+  // The width the run REACHED: a batch the machine pool narrowed ran narrower than planned, and a
+  // step line that printed the plan would name a width that never ran.
+  const reached = Math.max(1, ...result.widths);
+  const narrowed = reached < workers;
   return {
     ok: findings.length === 0,
     findings,
-    workers,
+    workers: reached,
+    ...(options.widthReason === undefined
+      ? {}
+      : {
+          widthReason: narrowed
+            ? `${String(reached)} of ${options.widthReason} — machine slots held by another run`
+            : options.widthReason,
+        }),
     // Per batch: each process printed its own summary, and one parse of the joined text would
     // read only the last one.
     tests: countsOf(result.results),

package/src/verify-tests.ts

@@ -18,8 +18,11 @@ import { countsOf } from './test-counts';
 import { testEnvOverrides } from './test-dotenv';
 import type { TestFile } from './test-select';
 import { discoverTests } from './test-select';
-import { defaultWorkers, SERIAL_TYPES } from './test-workers';
+import { machineLease } from './test-slots';
+import type { WorkerPlan } from './test-workers';
+import { availableCpus, SERIAL_TYPES, totalMemory, workerPlan } from './test-workers';
 import { withE2eApp } from './verify-e2e';
+import { shardFiles } from './verify-shard';
 import type { StepOutcome, VerifyContext, VerifyStep } from './verify-step';
 import { fromExec, fromFindings } from './verify-step';
 import { runParallel } from './verify-test-run';
@@ -212,16 +215,48 @@ const runSerial = async (ctx: VerifyContext, type: TestType): Promise<StepOutcom
 
 const runType = async (ctx: VerifyContext, type: TestType): Promise<StepOutcome> => {
   if (isSerial(type)) return runSerial(ctx, type);
-  const files = await filesFor(ctx.root, type);
+  const discoveredFiles = await filesFor(ctx.root, type);
+  // Under `--shard`, this job runs its slice and says which — `x verify merge` checks the slices.
+  // An EMPTY slice is a pass with zero tests, never the serial fallback below (which would run
+  // the whole type): the zero-tests floor is `merge`'s to apply, on the summed counts.
+  const shard =
+    ctx.shard === undefined
+      ? undefined
+      : shardFiles(
+          discoveredFiles.map((file) => file.path),
+          ctx.shard,
+          ctx.shard.timings,
+        );
+  if (shard !== undefined && shard.files.length === 0) {
+    return { ok: true, findings: [], workers: 0, tests: { ran: 0, skipped: 0 }, shard };
+  }
+  const files =
+    shard === undefined
+      ? discoveredFiles
+      : discoveredFiles.filter((file) => shard.files.includes(file.path));
   if (files.length === 0) return runSerial(ctx, type);
-  return runParallel({
+  const env = ctx.env ?? Bun.env;
+  const plan =
+    ctx.workers === undefined ? workerPlan(availableCpus(), totalMemory(), env) : undefined;
+  const workers = ctx.workers ?? (plan as WorkerPlan).workers;
+  const lease = plan === undefined ? undefined : machineLease(plan.workers, env);
+  const outcome = await runParallel({
     root: ctx.root,
     runner: ctx.runner,
     files,
-    workers: ctx.workers ?? defaultWorkers(),
+    workers,
     type,
+    isolate: ctx.isolate === true,
+    widthReason:
+      plan === undefined
+        ? `${String(Math.min(workers, files.length))} workers (--workers)`
+        : files.length < plan.workers
+          ? `${String(files.length)} of ${plan.reason}`
+          : plan.reason,
+    ...(lease === undefined ? {} : { lease }),
     ...(ctx.env === undefined ? {} : { env: ctx.env }),
   });
+  return shard === undefined ? outcome : { ...outcome, shard };
 };
 
 const isApp = (root: string): boolean => existsSync(join(root, APP_CONFIG_FILE));