@elench/testkit 0.1.48 → 0.1.50

package/lib/runner/template.mjs

@@ -113,12 +113,14 @@ export function resolveRuntimeConfig(
   urlMappings
 ) {
   const stateDir = resolveServiceStateDir(runtimeDir, config);
+  const prepareDir = resolveServicePrepareDir(runtimeDir, config);
   const context = {
     runtimeId,
     runtimeLabel,
     runtimeDir,
     serviceName: config.name,
     serviceStateDir: stateDir,
+    prepareDir,
     portMap,
     baseUrlByService,
     readyUrlByService,
@@ -135,6 +137,11 @@ export function resolveRuntimeConfig(
       }
     : undefined;
 
+  const runtime = {
+    ...config.testkit.runtime,
+    prepare: finalizeRuntimePrepare(config.testkit.runtime.prepare, context),
+  };
+
   const local = config.testkit.local
     ? {
         ...config.testkit.local,
@@ -158,7 +165,9 @@ export function resolveRuntimeConfig(
     testkit: {
       ...config.testkit,
       database,
+      prepareDir,
       templateContext: context,
+      runtime,
       local,
     },
   };
@@ -197,6 +206,10 @@ export function resolveServiceStateDir(runtimeDir, config) {
   return path.join(runtimeDir, "services", config.name);
 }
 
+export function resolveServicePrepareDir(runtimeDir, config) {
+  return path.join(resolveServiceStateDir(runtimeDir, config), "prepared");
+}
+
 export function buildExecutionEnv(config, extraEnv = {}, processEnv = process.env) {
   return buildExecutionEnvWithContext(config, null, extraEnv, processEnv);
 }
@@ -244,6 +257,7 @@ function buildTemplateContext(config, lease) {
     runtimeLabel: config.runtimeLabel || baseContext.runtimeLabel || null,
     serviceName: config.name,
     serviceStateDir: config.stateDir || baseContext.serviceStateDir || null,
+    prepareDir: config.testkit?.prepareDir || baseContext.prepareDir || null,
     leaseId: lease?.leaseId || null,
     leaseDir: lease?.leaseDir || null,
   };
@@ -280,6 +294,8 @@ export function resolveTemplateString(value, context) {
         return context.serviceName;
       case "stateDir":
         return context.serviceStateDir;
+      case "prepareDir":
+        return context.prepareDir || "";
       case "lease":
         return context.leaseId ? String(context.leaseId) : "";
       case "leaseDir":
@@ -332,6 +348,31 @@ function resolveEnvTemplates(values, templateContext) {
   );
 }
 
+function finalizeRuntimePrepare(prepare, context) {
+  if (!prepare) {
+    return {
+      inputs: [],
+      steps: [],
+    };
+  }
+
+  const finalizeStep = (step) => ({
+    ...step,
+    ...(typeof step.cmd === "string" ? { cmd: finalizeString(step.cmd, context) } : {}),
+    ...(typeof step.cwd === "string" ? { cwd: finalizeString(step.cwd, context) } : {}),
+    ...(typeof step.path === "string" ? { path: finalizeString(step.path, context) } : {}),
+    ...(typeof step.specifier === "string"
+      ? { specifier: finalizeString(step.specifier, context) }
+      : {}),
+    inputs: (step.inputs || []).map((input) => finalizeString(input, context)),
+  });
+
+  return {
+    inputs: (prepare.inputs || []).map((input) => finalizeString(input, context)),
+    steps: (prepare.steps || []).map(finalizeStep),
+  };
+}
+
 function resolveDatabaseTemplateValue(token, serviceName, context) {
   const stateDir = context.stateDirByService?.get(serviceName);
   if (!stateDir) {

package/lib/runner/template.test.mjs

@@ -22,8 +22,18 @@ function makeRuntimeConfig(name, local, extras = {}) {
     name,
     stateDir: extras.stateDir,
     runtimeId: extras.runtimeId,
+    productDir: extras.productDir || process.cwd(),
     testkit: {
       local,
+      runtime: extras.runtime || {
+        instances: 1,
+        maxConcurrentTasks: Infinity,
+        prepare: {
+          inputs: [],
+          steps: [],
+        },
+      },
+      envFiles: extras.envFiles || [],
       serviceEnv: extras.serviceEnv || {},
       databaseFrom: extras.databaseFrom,
       database: extras.database,
@@ -88,6 +98,9 @@ describe("runner-template", () => {
     expect(resolveTemplateString("{runtime}:{service}:{lease}", context)).toBe(
       "runtime-2:frontend:lease-1"
     );
+    expect(resolveTemplateString("{prepareDir}", { ...context, prepareDir: "/tmp/prepare-1" })).toBe(
+      "/tmp/prepare-1"
+    );
     expect(resolveTemplateString("{baseUrl:api}", context)).toBe("http://127.0.0.1:3100");
     expect(resolveTemplateString("{dbHost:api}:{dbPort:api}/{dbName:api}", context)).toBe(
       "127.0.0.1:55432/runtime_db"
@@ -140,6 +153,7 @@ describe("runner-template", () => {
     expect(resolved[0].testkit.local.port).toBe(3100);
     expect(resolved[0].runtimeLabel).toBe("api__frontend/runtime-2");
     expect(resolveServiceStateDir(runtimeDir, api)).toBe(`${runtimeDir}/services/api`);
+    expect(resolved[0].testkit.prepareDir).toBe(`${runtimeDir}/services/api/prepared`);
 
     fs.mkdirSync(path.join(runtimeDir, "services", "api"), { recursive: true });
     fs.writeFileSync(
@@ -197,6 +211,56 @@ describe("runner-template", () => {
     });
   });
 
+  it("finalizes runtime.prepare templates with prepareDir", () => {
+    const runtimeDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-runtime-prepare-"));
+    const api = makeRuntimeConfig(
+      "api",
+      {
+        cwd: ".",
+        start: "npm run api",
+        port: 3000,
+        baseUrl: "http://127.0.0.1:{port}",
+        readyUrl: "http://127.0.0.1:{port}/health",
+        env: {},
+      },
+      {
+        runtime: {
+          instances: 1,
+          maxConcurrentTasks: 2,
+          prepare: {
+            inputs: ["src/{service}.ts"],
+            steps: [
+              {
+                kind: "command",
+                cmd: "node scripts/prepare.mjs {prepareDir}",
+                cwd: ".",
+                inputs: ["src/{service}.ts"],
+              },
+            ],
+          },
+        },
+      }
+    );
+
+    const [resolved] = resolveRuntimeInstanceConfigs([api], "runtime-1", runtimeDir, {
+      graphDirName: "api",
+      portNamespaceIndex: 0,
+      portNamespaceStride: 1,
+    });
+
+    expect(resolved.testkit.runtime.prepare).toEqual({
+      inputs: ["src/api.ts"],
+      steps: [
+        {
+          kind: "command",
+          cmd: `node scripts/prepare.mjs ${runtimeDir}/services/api/prepared`,
+          cwd: ".",
+          inputs: ["src/api.ts"],
+        },
+      ],
+    });
+  });
+
   it("parses runtime sockets", () => {
     expect(numericPortFromUrl("http://localhost:3000")).toBe(3000);
     expect(socketFromUrl("http://localhost:3000")).toEqual({

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

@@ -58,6 +58,10 @@ export interface SkipConfig {
 export interface RuntimeConfig {
   instances?: number;
   maxConcurrentTasks?: number;
+  prepare?: {
+    inputs?: string[];
+    steps?: TemplateLifecycleStepConfig[];
+  };
 }
 
 export interface SuiteRequirementRule {

package/lib/setup/index.mjs

@@ -85,7 +85,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 +105,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 +196,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,26 @@
+import { describe, expect, it } from "vitest";
+import { goService, nextService, 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"
+    );
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit",
-  "version": "0.1.48",
+  "version": "0.1.50",
   "description": "CLI for discovering and running local HTTP, DAL, and Playwright test suites",
   "type": "module",
   "types": "./lib/index.d.ts",