@elench/testkit 0.1.49 → 0.1.51

package/lib/runner/runtime-preparation.mjs

@@ -3,6 +3,7 @@ import fs from "fs";
 import path from "path";
 import { resolveServiceCwd } from "../config/index.mjs";
 import { appendFileToHash, appendInputToHash } from "../database/fingerprint.mjs";
+import { announceResolvedToolchain, resolveConfiguredToolchain } from "../toolchains/index.mjs";
 import { readDatabaseUrl } from "./state-io.mjs";
 import { buildExecutionEnv } from "./template.mjs";
 import {
@@ -42,6 +43,7 @@ export async function prepareRuntimeService(config) {
   }
 
   try {
+    await announceResolvedToolchain(config, await resolveConfiguredToolchain(config));
     await runConfiguredSteps({
       config,
       steps: prepare.steps,
@@ -61,10 +63,22 @@ export async function prepareRuntimeService(config) {
 }
 
 export async function computeRuntimePrepareFingerprint(config) {
+  const resolvedToolchain = await resolveConfiguredToolchain(config);
   const hash = crypto.createHash("sha256");
   hash.update(
     JSON.stringify({
       prepare: config.testkit.runtime.prepare || null,
+      toolchain: resolvedToolchain
+        ? {
+            kind: resolvedToolchain.kind,
+            install: resolvedToolchain.install,
+            nodeVersion: resolvedToolchain.nodeVersion,
+            npmVersion: resolvedToolchain.npmVersion,
+            nodeSource: resolvedToolchain.nodeSource,
+            npmSource: resolvedToolchain.npmSource,
+            fingerprint: resolvedToolchain.fingerprint,
+          }
+        : null,
       serviceEnv: config.testkit.serviceEnv || {},
       local: config.testkit.local
         ? {

package/lib/runner/services.mjs

@@ -1,4 +1,9 @@
 import { resolveServiceCwd } from "../config/index.mjs";
+import {
+  announceResolvedToolchain,
+  applyToolchainEnv,
+  resolveConfiguredToolchain,
+} from "../toolchains/index.mjs";
 import { buildExecutionEnv, numericPortFromUrl } from "./template.mjs";
 import { DEFAULT_READY_TIMEOUT_MS, assertLocalServicePortsAvailable, isPortInUse, waitForReady } from "./readiness.mjs";
 import { killChildProcess, pipeOutput, startDetachedCommand, stopChildProcess, sleep } from "./processes.mjs";
@@ -23,7 +28,12 @@ export async function startLocalServices(runtimeConfigs, lifecycle) {
 
 export async function startLocalService(config, lifecycle) {
   const cwd = resolveServiceCwd(config.productDir, config.testkit.local.cwd);
-  const env = buildExecutionEnv(config, config.testkit.local.env, process.env);
+  const resolvedToolchain = await resolveConfiguredToolchain(config);
+  await announceResolvedToolchain(config, resolvedToolchain);
+  const env = applyToolchainEnv(
+    buildExecutionEnv(config, config.testkit.local.env, process.env),
+    resolvedToolchain
+  );
   const port = config.testkit.local.port || numericPortFromUrl(config.testkit.local.baseUrl);
   if (port) {
     env.PORT = String(port);

package/lib/runner/template-step-module-runner.mjs

@@ -0,0 +1,25 @@
+import fs from "fs";
+import { pathToFileURL } from "url";
+
+const [, , moduleFile, exportName, contextFile] = process.argv;
+
+if (!moduleFile || !exportName || !contextFile) {
+  console.error("Usage: node template-step-module-runner.mjs <module-file> <export-name> <context-file>");
+  process.exit(1);
+}
+
+try {
+  const context = JSON.parse(fs.readFileSync(contextFile, "utf8"));
+  const moduleRef = await import(pathToFileURL(moduleFile).href);
+  const fn = moduleRef[exportName];
+  if (typeof fn !== "function") {
+    throw new Error(
+      `Template module step "${moduleFile}#${exportName}" did not export a function named "${exportName}"`
+    );
+  }
+
+  await fn(context);
+} catch (error) {
+  console.error(error?.stack || error?.message || String(error));
+  process.exit(1);
+}

package/lib/runner/template-steps.mjs

@@ -3,22 +3,35 @@ import fs from "fs";
 import path from "path";
 import { build } from "esbuild";
 import { execa, execaCommand } from "execa";
-import { fileURLToPath, pathToFileURL } from "url";
+import { fileURLToPath } from "url";
 import { resolveServiceCwd } from "../config/index.mjs";
+import {
+  announceResolvedToolchain,
+  applyToolchainEnv,
+  resolveConfiguredToolchain,
+} from "../toolchains/index.mjs";
 
 const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
 const ROOT_ENTRY = path.join(PACKAGE_ROOT, "lib", "index.mjs");
 const SETUP_ENTRY = path.join(PACKAGE_ROOT, "lib", "setup", "index.mjs");
 const RUNTIME_ENTRY = path.join(PACKAGE_ROOT, "lib", "runtime", "index.mjs");
 const KNOWN_FAILURES_ENTRY = path.join(PACKAGE_ROOT, "lib", "known-failures", "index.mjs");
+const MODULE_RUNNER_ENTRY = path.join(
+  PACKAGE_ROOT,
+  "lib",
+  "runner",
+  "template-step-module-runner.mjs"
+);
 
 export async function runConfiguredSteps({ config, steps = [], env, labelPrefix }) {
   if (steps.length === 0) return;
+  const resolvedToolchain = await resolveConfiguredToolchain(config);
+  await announceResolvedToolchain(config, resolvedToolchain);
 
   for (const [index, step] of steps.entries()) {
     const label = `${labelPrefix}:${config.name}:${index + 1}`;
     console.log(`\n── ${label} ──`);
-    await runConfiguredStep(config, step, env);
+    await runConfiguredStep(config, step, env, resolvedToolchain);
   }
 }
 
@@ -51,11 +64,14 @@ export function resolveConfiguredPath(productDir, stepCwd, targetPath) {
   return path.resolve(resolveConfiguredCwd(productDir, stepCwd), targetPath);
 }
 
-async function runConfiguredStep(config, step, env) {
+async function runConfiguredStep(config, step, env, resolvedToolchain) {
+  const runtimeEnv = applyToolchainEnv(env, resolvedToolchain);
+  const cwd = resolveConfiguredCwd(config.productDir, step.cwd);
+
   if (step.kind === "command") {
     await execaCommand(step.cmd, {
-      cwd: resolveConfiguredCwd(config.productDir, step.cwd),
-      env,
+      cwd,
+      env: runtimeEnv,
       stdio: "inherit",
       shell: true,
     });
@@ -66,7 +82,7 @@ async function runConfiguredStep(config, step, env) {
     await execa(
       "psql",
       [
-        env.DATABASE_URL,
+        runtimeEnv.DATABASE_URL,
         "-v",
         "ON_ERROR_STOP=1",
         "-X",
@@ -74,8 +90,8 @@ async function runConfiguredStep(config, step, env) {
         resolveConfiguredPath(config.productDir, step.cwd, step.path),
       ],
       {
-        cwd: resolveConfiguredCwd(config.productDir, step.cwd),
-        env,
+        cwd,
+        env: runtimeEnv,
         stdio: "inherit",
       }
     );
@@ -83,34 +99,41 @@ async function runConfiguredStep(config, step, env) {
   }
 
   if (step.kind === "module") {
-    const moduleRef = await loadConfiguredModule(config.productDir, step);
+    const bundledModule = await bundleConfiguredModule(config.productDir, step);
     const { exportName } = parseModuleSpecifier(step.specifier);
-    const fn = moduleRef[exportName];
-    if (typeof fn !== "function") {
-      throw new Error(
-        `Template module step "${step.specifier}" did not export a function named "${exportName}"`
+    const context = {
+      databaseUrl: runtimeEnv.DATABASE_URL || null,
+      productDir: config.productDir,
+      cwd,
+      serviceName: config.name,
+      env: { ...runtimeEnv },
+      runtimeId: config.runtimeId || null,
+      stateDir: config.stateDir,
+      prepareDir: config.testkit.prepareDir || null,
+    };
+    const contextPath = `${bundledModule.outputFile}.context.json`;
+    fs.writeFileSync(contextPath, JSON.stringify(context));
+
+    try {
+      await execa(
+        resolvedToolchain?.nodeExecutable || process.execPath,
+        [MODULE_RUNNER_ENTRY, bundledModule.outputFile, exportName, contextPath],
+        {
+          cwd,
+          env: runtimeEnv,
+          stdio: "inherit",
+        }
       );
+    } finally {
+      fs.rmSync(contextPath, { force: true });
     }
-
-    await withProcessContext(resolveConfiguredCwd(config.productDir, step.cwd), env, async () => {
-      await fn({
-        databaseUrl: env.DATABASE_URL || null,
-        productDir: config.productDir,
-        cwd: resolveConfiguredCwd(config.productDir, step.cwd),
-        serviceName: config.name,
-        env: { ...env },
-        runtimeId: config.runtimeId || null,
-        stateDir: config.stateDir,
-        prepareDir: config.testkit.prepareDir || null,
-      });
-    });
     return;
   }
 
   throw new Error(`Unsupported template step kind "${step.kind}"`);
 }
 
-async function loadConfiguredModule(productDir, step) {
+async function bundleConfiguredModule(productDir, step) {
   const { modulePath } = parseModuleSpecifier(step.specifier);
   const absoluteModulePath = resolveConfiguredPath(productDir, step.cwd, modulePath);
   const bundleDir = path.join(productDir, ".testkit", "_template-steps");
@@ -135,7 +158,10 @@ async function loadConfiguredModule(productDir, step) {
     plugins: [testkitAliasPlugin()],
   });
 
-  return import(`${pathToFileURL(outputFile).href}?v=${cacheKey}`);
+  return {
+    outputFile,
+    cacheKey,
+  };
 }
 
 function buildModuleCacheKey(modulePath) {
@@ -172,20 +198,3 @@ function parseModuleSpecifier(specifier) {
     exportName: exportName || "default",
   };
 }
-
-async function withProcessContext(cwd, env, fn) {
-  const previousCwd = process.cwd();
-  const previousEnv = process.env;
-  process.chdir(cwd);
-  process.env = {
-    ...previousEnv,
-    ...env,
-  };
-
-  try {
-    return await fn();
-  } finally {
-    process.chdir(previousCwd);
-    process.env = previousEnv;
-  }
-}

package/lib/runner/worker-loop.mjs

@@ -36,6 +36,27 @@ export async function runWorker(
         runtimeManager.canAcquire(candidate)
       );
       if (!task) {
+        const blockedTasks = runtimeManager.drainFailedTasks(queue);
+        if (blockedTasks.length > 0) {
+          const now = Date.now();
+          const recordedGraphs = new Set();
+          for (const blocked of blockedTasks) {
+            recordTaskOutcome(trackers, blocked.task, {
+              failed: false,
+              status: "not_run",
+              reason: blocked.reason,
+              durationMs: 0,
+              startedAt: now,
+              finishedAt: now,
+              error: null,
+            });
+            if (!recordedGraphs.has(blocked.graph.key)) {
+              recordGraphError(trackers, blocked.graph, blocked.message, now);
+              recordedGraphs.add(blocked.graph.key);
+            }
+          }
+          continue;
+        }
         if (queue.length === 0) break;
         await new Promise((resolve) => setTimeout(resolve, 10));
         continue;

package/lib/setup/index.d.ts

@@ -62,8 +62,20 @@ export interface RuntimeConfig {
     inputs?: string[];
     steps?: TemplateLifecycleStepConfig[];
   };
+  toolchain?: string | NodeToolchainConfig;
 }
 
+export interface NodeToolchainConfig {
+  kind?: "node";
+  cwd?: string;
+  detect?: "auto" | "off";
+  install?: "require-host" | "download";
+  node?: string;
+  npm?: string;
+}
+
+export type ToolchainConfig = NodeToolchainConfig;
+
 export interface SuiteRequirementRule {
   selector: string;
   locks?: string[];
@@ -124,6 +136,7 @@ export interface TestkitSetup {
     issueValidation?: KnownFailureIssueValidationConfig;
   };
   services?: Record<string, ServiceConfig>;
+  toolchains?: Record<string, ToolchainConfig>;
   telemetry?: {
     enabled?: boolean;
     endpoint?: string;
@@ -148,6 +161,7 @@ export declare function moduleStep(
   specifier: string,
   options?: Omit<TemplateModuleStepConfig, "kind" | "specifier">
 ): TemplateModuleStepConfig;
+export declare function nodeToolchain(options?: NodeToolchainConfig): NodeToolchainConfig;
 export declare function goService(options: ServiceConfig["local"] & {
   command?: string;
   entrypoint?: string;

package/lib/setup/index.mjs

@@ -56,6 +56,13 @@ export function moduleStep(specifier, options = {}) {
   };
 }
 
+export function nodeToolchain(options = {}) {
+  return {
+    kind: "node",
+    ...options,
+  };
+}
+
 export function goService(options = {}) {
   const cwd = options.cwd || ".";
   const port = requiredNumber(options.port, "goService port");
@@ -85,7 +92,7 @@ export function nextService(options = {}) {
     ...service(options),
     local: {
       cwd,
-      start: options.start || "exec ./node_modules/.bin/next dev -p {port}",
+      start: options.start || "./node_modules/.bin/next dev -p {port}",
       port,
       baseUrl,
       readyUrl: options.readyUrl || baseUrl,
@@ -105,7 +112,7 @@ export function tsxService(options = {}) {
     ...service(options),
     local: {
       cwd,
-      start: options.start || `exec ./node_modules/.bin/tsx watch ${entry}`,
+      start: options.start || `./node_modules/.bin/tsx watch ${entry}`,
       port,
       baseUrl,
       readyUrl: options.readyUrl || `${baseUrl}${options.readyPath || "/health"}`,
@@ -196,12 +203,12 @@ export {
 
 function defaultGoStartCommand(options) {
   if (options.command) {
-    return `exec go run ${options.command}`;
+    return `go run ${options.command}`;
   }
   if (options.entrypoint) {
-    return `exec go run ${options.entrypoint}`;
+    return `go run ${options.entrypoint}`;
   }
-  return "exec go run ./cmd/server";
+  return "go run ./cmd/server";
 }
 
 function requiredNumber(value, label) {

package/lib/setup/index.test.mjs

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import { goService, nextService, nodeToolchain, tsxService } from "./index.mjs";
+
+describe("setup helpers", () => {
+  it("emits plain next start commands without an exec prefix", () => {
+    const config = nextService({ port: 3000 });
+
+    expect(config.local.start).toBe("./node_modules/.bin/next dev -p {port}");
+  });
+
+  it("emits plain tsx start commands without an exec prefix", () => {
+    const config = tsxService({ port: 3000, entry: "src/server.ts" });
+
+    expect(config.local.start).toBe("./node_modules/.bin/tsx watch src/server.ts");
+  });
+
+  it("emits plain go start commands without an exec prefix", () => {
+    expect(goService({ port: 3000 }).local.start).toBe("go run ./cmd/server");
+    expect(goService({ port: 3000, entrypoint: "./cmd/api" }).local.start).toBe(
+      "go run ./cmd/api"
+    );
+    expect(goService({ port: 3000, command: "./cmd/worker" }).local.start).toBe(
+      "go run ./cmd/worker"
+    );
+  });
+
+  it("builds node toolchain profiles with a node kind", () => {
+    expect(nodeToolchain({ node: "20.19.5", install: "download" })).toEqual({
+      kind: "node",
+      node: "20.19.5",
+      install: "download",
+    });
+  });
+});