@elench/testkit 0.1.49 → 0.1.51

package/README.md

@@ -67,6 +67,7 @@ import {
   localDatabase,
   moduleStep,
   nextService,
+  nodeToolchain,
   service,
   sqlFileStep,
   tsxService,
@@ -85,6 +86,13 @@ export default defineTestkitSetup({
       cacheTtlSeconds: 900,
     },
   },
+  toolchains: {
+    frontendNode: nodeToolchain({
+      cwd: "frontend",
+      detect: "auto",
+      install: "download",
+    }),
+  },
   services: {
     api: service({
       ...tsxService({
@@ -119,7 +127,7 @@ export default defineTestkitSetup({
       ...nextService({
         cwd: "frontend",
         port: 3000,
-        start: "exec ./node_modules/.bin/next start --port {port}",
+        start: "./node_modules/.bin/next start --port {port}",
         env: {
           NEXT_DIST_DIR: "{prepareDir}/dist",
           NEXT_PUBLIC_API_URL: "{baseUrl:api}",
@@ -130,6 +138,7 @@ export default defineTestkitSetup({
       runtime: {
         instances: 1,
         maxConcurrentTasks: 2,
+        toolchain: "frontendNode",
         prepare: {
           inputs: ["frontend/src", "frontend/public", "frontend/package.json"],
           steps: [commandStep("npm run build", { cwd: "frontend" })],
@@ -164,6 +173,7 @@ for:
 - multi-service graphs
 - local runtime instance counts
 - per-runtime concurrent task caps
+- repo-managed Node toolchains for prepare/start commands
 - one-time runtime preparation steps for stable shared servers
 - local DB binding configuration
 - template database migrate / seed / verify stages
@@ -181,6 +191,41 @@ inputs, and writes cache state under the service runtime directory. This is the
 right way to move expensive browser targets from `next dev` / watch mode to
 stable build-and-start flows.
 
+`runtime.toolchain` is the first-class way to make those prepare/start commands
+run under the correct Node toolchain instead of whatever `node`/`npm` happened
+to launch `testkit`. Node toolchains support:
+
+- host verification mode: `install: "require-host"`
+- cached repo-local provisioning mode: `install: "download"`
+- auto-detection from:
+  - `package.json#volta.node`
+  - `.nvmrc`
+  - `.node-version`
+  - `.tool-versions` (`nodejs`)
+  - `package.json#engines.node`
+  - `package.json#volta.npm`
+  - `package.json#packageManager`
+  - `package.json#engines.npm`
+
+Example:
+
+```ts
+toolchains: {
+  frontendNode: nodeToolchain({
+    cwd: "frontend",
+    detect: "auto",
+    install: "download",
+  }),
+},
+services: {
+  frontend: service({
+    runtime: {
+      toolchain: "frontendNode",
+    },
+  }),
+}
+```
+
 If `reporting.knownFailuresFile` is configured, `testkit` enriches
 `.testkit/results/latest.json` and `testkit.status.json` with:
 

package/lib/config/index.mjs

@@ -16,6 +16,10 @@ import {
   normalizeRuntimeInstances,
 } from "../runner/execution-config.mjs";
 import { normalizeKnownFailureIssueValidationConfig } from "../known-failures/github.mjs";
+import {
+  normalizeRuntimeToolchain,
+  normalizeToolchainRegistry,
+} from "../toolchains/index.mjs";
 
 const TESTKIT_K6_BIN = "TESTKIT_K6_BIN";
 const DEFAULT_LOCAL_IMAGE = "pgvector/pgvector:pg16";
@@ -32,6 +36,7 @@ export async function loadConfigs(opts = {}) {
   const { setup, setupFile } = await loadTestkitSetup(productDir);
   const execution = normalizeRepoExecution(setup.execution);
   const reporting = normalizeReportingConfig(setup.reporting);
+  const toolchains = normalizeToolchainRegistry(setup.toolchains);
   const explicitServices = setup.services || {};
   const discovery = discoverProject(productDir, explicitServices);
   const serviceNames = new Set([
@@ -49,6 +54,7 @@ export async function loadConfigs(opts = {}) {
         setupFile,
         execution,
         reporting,
+        toolchains,
         explicitService: explicitServices[name] || {},
         discoveredService: discovery.services[name] || null,
         suites: discovery.suitesByService[name] || {},
@@ -109,6 +115,7 @@ function normalizeServiceConfig({
   setupFile,
   execution,
   reporting,
+  toolchains,
   explicitService,
   discoveredService,
   suites,
@@ -125,7 +132,7 @@ function normalizeServiceConfig({
     );
   }
   const database = normalizeDatabaseConfig(explicitService, name);
-  const runtime = normalizeRuntimeConfig(explicitService.runtime, name);
+  const runtime = normalizeRuntimeConfig(explicitService.runtime, name, toolchains);
   const skip = normalizeSkipConfig(explicitService.skip, {
     name,
     productDir,
@@ -212,7 +219,7 @@ function inferLocalRuntime(productDir, cwd) {
   if (detectNextApp(absoluteCwd)) {
     return {
       cwd,
-      start: "exec ./node_modules/.bin/next dev -p {port}",
+      start: "./node_modules/.bin/next dev -p {port}",
       port: 3000,
       baseUrl: "http://127.0.0.1:{port}",
       readyUrl: "http://127.0.0.1:{port}",
@@ -223,7 +230,7 @@ function inferLocalRuntime(productDir, cwd) {
   if (fs.existsSync(path.join(absoluteCwd, "cmd", "server"))) {
     return {
       cwd,
-      start: "exec go run ./cmd/server",
+      start: "go run ./cmd/server",
       port: 3000,
       baseUrl: "http://127.0.0.1:{port}",
       readyUrl: "http://127.0.0.1:{port}/health",
@@ -234,7 +241,7 @@ function inferLocalRuntime(productDir, cwd) {
   if (fs.existsSync(path.join(absoluteCwd, "package.json")) && fs.existsSync(path.join(absoluteCwd, "src"))) {
     return {
       cwd,
-      start: "exec ./node_modules/.bin/tsx watch src/index.ts",
+      start: "./node_modules/.bin/tsx watch src/index.ts",
       port: 3000,
       baseUrl: "http://127.0.0.1:{port}",
       readyUrl: "http://127.0.0.1:{port}/health",
@@ -274,7 +281,7 @@ function normalizeDatabaseConfig(explicitService, serviceName) {
   };
 }
 
-function normalizeRuntimeConfig(value, serviceName) {
+function normalizeRuntimeConfig(value, serviceName, toolchains) {
   if (!value) {
     return {
       instances: 1,
@@ -283,6 +290,7 @@ function normalizeRuntimeConfig(value, serviceName) {
         inputs: [],
         steps: [],
       },
+      toolchain: null,
     };
   }
 
@@ -296,6 +304,11 @@ function normalizeRuntimeConfig(value, serviceName) {
       `Service "${serviceName}" runtime.maxConcurrentTasks`
     ),
     prepare: normalizeRuntimePrepareConfig(value.prepare, serviceName),
+    toolchain: normalizeRuntimeToolchain(
+      value.toolchain,
+      `Service "${serviceName}" runtime.toolchain`,
+      toolchains || {}
+    ),
   };
 }
 
@@ -739,6 +752,9 @@ function validateServiceConfig({
   if (local?.cwd) {
     ensureExistingPath(productDir, local.cwd, `Service "${name}" local.cwd`);
   }
+  if (runtime.toolchain?.cwd) {
+    ensureExistingPath(productDir, runtime.toolchain.cwd, `Service "${name}" runtime.toolchain.cwd`);
+  }
   for (const [stageName, steps] of Object.entries(database?.template || {})) {
     if (stageName === "inputs") continue;
     for (const step of steps || []) {

package/lib/database/index.mjs

@@ -33,6 +33,8 @@ const LOCAL_PASSWORD = "testkit";
 const LOCAL_ADMIN_DB = "postgres";
 const LOCAL_READY_TIMEOUT_MS = 60_000;
 const LOCAL_POLL_INTERVAL_MS = 1_000;
+const LOCAL_DROP_DATABASE_TIMEOUT_MS = 15_000;
+const LOCAL_DROP_DATABASE_POLL_INTERVAL_MS = 250;
 
 export async function prepareDatabaseRuntime(config) {
   const db = config.testkit.database;
@@ -398,18 +400,78 @@ async function cloneDatabaseFromTemplate(infra, dbName, templateDbName) {
 }
 
 async function dropDatabaseIfExists(infra, dbName) {
-  await runAdminQuery(infra, [
-    "-c",
-    [
-      `SELECT pg_terminate_backend(pid)`,
-      `FROM pg_stat_activity`,
-      `WHERE datname = '${escapeSqlLiteral(dbName)}' AND pid <> pg_backend_pid();`,
-    ].join(" "),
-  ]);
-  await runAdminQuery(infra, [
-    "-c",
-    `DROP DATABASE IF EXISTS "${escapeIdentifier(dbName)}"`,
-  ]);
+  await dropDatabaseWithForceOrDrain(infra, dbName);
+}
+
+export async function dropDatabaseWithForceOrDrain(infra, dbName, hooks = {}) {
+  const runAdminQueryFn = hooks.runAdminQuery || runAdminQuery;
+  const databaseExistsFn = hooks.databaseExists || databaseExists;
+  const sleepFn = hooks.sleep || sleep;
+
+  try {
+    await runAdminQueryFn(infra, [
+      "-c",
+      `DROP DATABASE IF EXISTS "${escapeIdentifier(dbName)}" WITH (FORCE)`,
+    ]);
+    return;
+  } catch (error) {
+    if (!isUnsupportedForceDropError(error)) {
+      throw error;
+    }
+  }
+
+  if (!(await databaseExistsFn(infra, dbName))) {
+    return;
+  }
+
+  let restoreConnections = false;
+  try {
+    await runAdminQueryFn(infra, [
+      "-c",
+      `ALTER DATABASE "${escapeIdentifier(dbName)}" WITH ALLOW_CONNECTIONS false`,
+    ]);
+    restoreConnections = true;
+    await waitForDatabaseConnectionsToDrain(infra, dbName, {
+      runAdminQuery: runAdminQueryFn,
+      sleep: sleepFn,
+    });
+    await runAdminQueryFn(infra, [
+      "-c",
+      `DROP DATABASE IF EXISTS "${escapeIdentifier(dbName)}"`,
+    ]);
+    restoreConnections = false;
+  } finally {
+    if (restoreConnections && (await databaseExistsFn(infra, dbName))) {
+      await runAdminQueryFn(infra, [
+        "-c",
+        `ALTER DATABASE "${escapeIdentifier(dbName)}" WITH ALLOW_CONNECTIONS true`,
+      ]).catch(() => {
+        // Best-effort restoration for failed fallback drops.
+      });
+    }
+  }
+}
+
+export async function waitForDatabaseConnectionsToDrain(infra, dbName, hooks = {}) {
+  const runAdminQueryFn = hooks.runAdminQuery || runAdminQuery;
+  const sleepFn = hooks.sleep || sleep;
+  const now = hooks.now || Date.now;
+  const timeoutMs = hooks.timeoutMs ?? LOCAL_DROP_DATABASE_TIMEOUT_MS;
+  const deadline = now() + timeoutMs;
+
+  while (true) {
+    await terminateDatabaseConnections(infra, dbName, runAdminQueryFn);
+    const remainingConnections = await countDatabaseConnections(infra, dbName, runAdminQueryFn);
+    if (remainingConnections === 0) {
+      return;
+    }
+    if (now() >= deadline) {
+      throw new Error(
+        `Timed out waiting for database "${dbName}" connections to close (${remainingConnections} remaining)`
+      );
+    }
+    await sleepFn(LOCAL_DROP_DATABASE_POLL_INTERVAL_MS);
+  }
 }
 
 async function runAdminQuery(infra, args) {
@@ -431,6 +493,37 @@ async function runAdminQuery(infra, args) {
   return stdout;
 }
 
+async function terminateDatabaseConnections(infra, dbName, runAdminQueryFn) {
+  await runAdminQueryFn(infra, [
+    "-c",
+    [
+      "SELECT pg_terminate_backend(pid)",
+      "FROM pg_stat_activity",
+      `WHERE datname = '${escapeSqlLiteral(dbName)}' AND pid <> pg_backend_pid();`,
+    ].join(" "),
+  ]);
+}
+
+async function countDatabaseConnections(infra, dbName, runAdminQueryFn) {
+  const result = await runAdminQueryFn(infra, [
+    "-tAc",
+    [
+      "SELECT COUNT(*)",
+      "FROM pg_stat_activity",
+      `WHERE datname = '${escapeSqlLiteral(dbName)}' AND pid <> pg_backend_pid();`,
+    ].join(" "),
+  ]);
+  return Number.parseInt(result.trim(), 10) || 0;
+}
+
+function isUnsupportedForceDropError(error) {
+  const text = `${error?.shortMessage || ""}\n${error?.stderr || ""}\n${error?.stdout || ""}\n${error?.message || ""}`;
+  return (
+    text.includes('syntax error at or near "WITH"') ||
+    text.includes('option "force"')
+  );
+}
+
 async function computeTemplateFingerprint(config) {
   return computeTemplateFingerprintModel(config);
 }

package/lib/database/index.test.mjs

@@ -0,0 +1,95 @@
+import { describe, expect, it } from "vitest";
+import {
+  dropDatabaseWithForceOrDrain,
+  waitForDatabaseConnectionsToDrain,
+} from "./index.mjs";
+
+describe("database lifecycle helpers", () => {
+  it("uses DROP DATABASE ... WITH (FORCE) when supported", async () => {
+    const calls = [];
+
+    await dropDatabaseWithForceOrDrain(
+      { containerName: "pg", password: "pw", user: "user" },
+      "demo",
+      {
+        async runAdminQuery(_infra, args) {
+          calls.push(args);
+          return "";
+        },
+      }
+    );
+
+    expect(calls).toEqual([["-c", 'DROP DATABASE IF EXISTS "demo" WITH (FORCE)']]);
+  });
+
+  it("falls back to draining connections when forced drop is unsupported", async () => {
+    const calls = [];
+    const counts = ["2", "0"];
+
+    await dropDatabaseWithForceOrDrain(
+      { containerName: "pg", password: "pw", user: "user" },
+      "demo",
+      {
+        async runAdminQuery(_infra, args) {
+          calls.push(args);
+          if (args[1] === 'DROP DATABASE IF EXISTS "demo" WITH (FORCE)') {
+            const error = new Error('syntax error at or near "WITH"');
+            error.stderr = 'ERROR: syntax error at or near "WITH"';
+            throw error;
+          }
+          if (args[0] === "-tAc") {
+            return counts.shift() || "0";
+          }
+          return "";
+        },
+        async databaseExists() {
+          return true;
+        },
+        async sleep() {},
+      }
+    );
+
+    expect(calls).toEqual([
+      ["-c", 'DROP DATABASE IF EXISTS "demo" WITH (FORCE)'],
+      ["-c", 'ALTER DATABASE "demo" WITH ALLOW_CONNECTIONS false'],
+      [
+        "-c",
+        "SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = 'demo' AND pid <> pg_backend_pid();",
+      ],
+      [
+        "-tAc",
+        "SELECT COUNT(*) FROM pg_stat_activity WHERE datname = 'demo' AND pid <> pg_backend_pid();",
+      ],
+      [
+        "-c",
+        "SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = 'demo' AND pid <> pg_backend_pid();",
+      ],
+      [
+        "-tAc",
+        "SELECT COUNT(*) FROM pg_stat_activity WHERE datname = 'demo' AND pid <> pg_backend_pid();",
+      ],
+      ["-c", 'DROP DATABASE IF EXISTS "demo"'],
+    ]);
+  });
+
+  it("times out clearly while waiting for lingering connections to drain", async () => {
+    let now = 0;
+    await expect(() =>
+      waitForDatabaseConnectionsToDrain(
+        { containerName: "pg", password: "pw", user: "user" },
+        "demo",
+        {
+          async runAdminQuery(_infra, args) {
+            if (args[0] === "-tAc") return "1";
+            return "";
+          },
+          async sleep() {
+            now += 10;
+          },
+          now: () => now,
+          timeoutMs: 20,
+        }
+      )
+    ).rejects.toThrow(/Timed out waiting for database "demo" connections to close/);
+  });
+});

package/lib/runner/processes.mjs

@@ -1,8 +1,22 @@
 import { spawn } from "child_process";
 
+export function normalizeServiceStartCommand(command) {
+  if (typeof command !== "string") {
+    throw new Error("Service start command must be a string");
+  }
+
+  const trimmed = command.trim();
+  if (trimmed.length === 0) {
+    throw new Error("Service start command must not be empty");
+  }
+
+  return trimmed.replace(/^exec\s+/u, "");
+}
+
 export function startDetachedCommand(command, cwd, env) {
+  const normalizedCommand = normalizeServiceStartCommand(command);
   if (process.platform === "win32") {
-    return spawn(command, {
+    return spawn(normalizedCommand, {
       cwd,
       env,
       detached: true,
@@ -12,7 +26,7 @@ export function startDetachedCommand(command, cwd, env) {
   }
 
   const shell = process.env.SHELL || "/bin/sh";
-  return spawn(shell, ["-lc", `exec ${command}`], {
+  return spawn(shell, ["-lc", `exec ${normalizedCommand}`], {
     cwd,
     env,
     detached: true,

package/lib/runner/processes.test.mjs

@@ -0,0 +1,21 @@
+import { describe, expect, it } from "vitest";
+import { normalizeServiceStartCommand } from "./processes.mjs";
+
+describe("runner processes", () => {
+  it("strips a single leading exec prefix for backward compatibility", () => {
+    expect(normalizeServiceStartCommand("exec node server.mjs")).toBe("node server.mjs");
+    expect(normalizeServiceStartCommand("  exec ./node_modules/.bin/next dev -p {port}  ")).toBe(
+      "./node_modules/.bin/next dev -p {port}"
+    );
+  });
+
+  it("leaves plain commands unchanged", () => {
+    expect(normalizeServiceStartCommand("node server.mjs")).toBe("node server.mjs");
+  });
+
+  it("rejects empty commands", () => {
+    expect(() => normalizeServiceStartCommand("   ")).toThrow(
+      /Service start command must not be empty/
+    );
+  });
+});

package/lib/runner/results.mjs

@@ -114,7 +114,7 @@ export function recordTaskOutcome(trackers, task, outcome, finishedAt = Date.now
   const normalizedPath = normalizePathSeparators(task.file);
   const existingFileResult = suite.fileResultsByPath.get(normalizedPath);
   const status = normalizeOutcomeStatus(outcome);
-  if (status !== "skipped") {
+  if (status !== "skipped" && status !== "not_run") {
     suite.completedFileCount += 1;
   }
   if (existingFileResult) {
@@ -291,6 +291,7 @@ function formatFrameworkForArtifact(framework) {
 }
 
 function normalizeOutcomeStatus(outcome) {
+  if (outcome?.status === "not_run") return "not_run";
   if (outcome?.status === "skipped") return "skipped";
   return outcome?.failed ? "failed" : "passed";
 }

package/lib/runner/results.test.mjs

@@ -307,6 +307,67 @@ describe("runner results", () => {
     ]);
   });
 
+  it("preserves not-run task outcomes in suite and service summaries", () => {
+    const trackers = buildServiceTrackers(
+      [
+        {
+          skipped: false,
+          config: {
+            name: "api",
+            testkit: {
+              database: {
+                selectedBackend: null,
+              },
+            },
+          },
+          suites: [
+            {
+              name: "health",
+              type: "integration",
+              framework: "k6",
+              files: ["tests/a.int.testkit.ts", "tests/b.int.testkit.ts"],
+              orderIndex: 0,
+            },
+          ],
+        },
+      ],
+      1000
+    );
+
+    recordTaskOutcome(
+      trackers,
+      {
+        serviceName: "api",
+        suiteKey: "integration:health",
+        file: "tests/a.int.testkit.ts",
+      },
+      {
+        failed: false,
+        status: "not_run",
+        reason: "Graph initialization failed",
+        durationMs: 0,
+        error: null,
+      },
+      1000
+    );
+
+    const result = finalizeServiceResult(trackers.get("api"), 1000, 1200);
+
+    expect(result.completedFileCount).toBe(0);
+    expect(result.passedFileCount).toBe(0);
+    expect(result.failedFileCount).toBe(0);
+    expect(result.skippedFileCount).toBe(0);
+    expect(result.notRunFileCount).toBe(2);
+    expect(result.suites[0].files).toContainEqual({
+      path: "tests/a.int.testkit.ts",
+      failed: false,
+      status: "not_run",
+      durationMs: 0,
+      error: null,
+      reason: "Graph initialization failed",
+    });
+  });
+
   it("summarizes mixed db backends", () => {
     expect(
       summarizeDbBackend([{ dbBackend: "local" }, { dbBackend: "neon" }])

package/lib/runner/runtime-manager.mjs

@@ -1,6 +1,7 @@
 import fs from "fs";
 import path from "path";
 import { buildRuntimeIds } from "./execution-config.mjs";
+import { formatError } from "./formatting.mjs";
 import {
   cleanupRuntimeInstanceContext,
   createRuntimeInstanceContext,
@@ -11,6 +12,7 @@ export function createRuntimeManager({ productDir, graphs, lifecycle, hooks = {}
   const graphByKey = new Map(graphs.map((graph) => [graph.key, graph]));
   const pools = new Map();
   const locks = new Map();
+  const failedGraphs = new Map();
   let nextLeaseCounter = 1;
   const runtimeHooks = {
     cleanupRuntimeInstanceContext,
@@ -22,6 +24,9 @@ export function createRuntimeManager({ productDir, graphs, lifecycle, hooks = {}
 
   return {
     canAcquire(task) {
+      if (failedGraphs.has(task.graphKey)) {
+        return false;
+      }
       const pool = getPool(pools, graphByKey, task, productDir, lifecycle);
       if (!locksAvailable(locks, task.locks || [])) {
         return false;
@@ -64,6 +69,9 @@ export function createRuntimeManager({ productDir, graphs, lifecycle, hooks = {}
         releaseLocks(locks, task.locks || [], leaseId);
         cleanupLeaseDir({ leaseDir: path.join(slot.context?.runtimeDir || productDir, "leases", leaseId) });
         await drainRuntimeSlot(slot, lifecycle, runtimeHooks);
+        if (!lifecycle.isStopRequested()) {
+          markGraphFailed(failedGraphs, task.graphKey, formatError(error));
+        }
         throw error;
       }
     },
@@ -104,6 +112,27 @@ export function createRuntimeManager({ productDir, graphs, lifecycle, hooks = {}
         }))
         .sort((left, right) => String(left.graphKey).localeCompare(String(right.graphKey)));
     },
+    drainFailedTasks(queue) {
+      const drained = [];
+      for (let index = queue.length - 1; index >= 0; index -= 1) {
+        const task = queue[index];
+        const message = failedGraphs.get(task.graphKey);
+        if (!message) continue;
+
+        queue.splice(index, 1);
+        drained.push({
+          task,
+          reason: `Not run because runtime graph failed to initialize: ${message}`,
+          message,
+          graph: graphByKey.get(task.graphKey) || {
+            key: task.graphKey,
+            targetNames: [task.targetName],
+          },
+        });
+      }
+
+      return drained.reverse();
+    },
   };
 }
 
@@ -218,6 +247,11 @@ function releaseLocks(lockMap, lockNames, leaseId) {
   }
 }
 
+function markGraphFailed(failedGraphs, graphKey, message) {
+  if (!graphKey || failedGraphs.has(graphKey)) return;
+  failedGraphs.set(graphKey, message);
+}
+
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/lib/runner/runtime-manager.test.mjs

@@ -203,4 +203,50 @@ describe("runtime-manager", () => {
     await manager.release(leaseTwo);
     await manager.cleanupAll();
   });
+
+  it("blocks a graph after fatal runtime initialization failure and drains remaining tasks", async () => {
+    const productDir = makeTempDir("testkit-runtime-manager-");
+    const manager = createRuntimeManager({
+      productDir,
+      lifecycle: makeLifecycle(),
+      graphs: [
+        {
+          key: "api",
+          dirName: "api",
+          targetNames: ["api"],
+          instanceCount: 1,
+          maxConcurrentTasks: 1,
+        },
+      ],
+      hooks: {
+        ...makeHooks({ created: [], ready: [], cleaned: [] }),
+        async ensureRuntimeInstanceReady() {
+          throw new Error("prepare failed");
+        },
+      },
+    });
+
+    const firstTask = makeTask(1, { file: "tests/a.int.testkit.ts", targetName: "api" });
+    const secondTask = makeTask(2, { file: "tests/b.int.testkit.ts", targetName: "api" });
+
+    await expect(manager.acquire(firstTask)).rejects.toThrow(/prepare failed/);
+    expect(manager.canAcquire(secondTask)).toBe(false);
+
+    const queue = [secondTask];
+    expect(manager.drainFailedTasks(queue)).toEqual([
+      {
+        task: secondTask,
+        reason: "Not run because runtime graph failed to initialize: prepare failed",
+        message: "prepare failed",
+        graph: {
+          key: "api",
+          dirName: "api",
+          targetNames: ["api"],
+          instanceCount: 1,
+          maxConcurrentTasks: 1,
+        },
+      },
+    ]);
+    expect(queue).toEqual([]);
+  });
 });