@elench/testkit 0.1.32 → 0.1.34

package/lib/runner/runtime-contexts.mjs

@@ -0,0 +1,133 @@
+import fs from "fs";
+import path from "path";
+import { execaCommand } from "execa";
+import { resolveServiceCwd } from "../config/index.mjs";
+import { prepareDatabaseRuntime } from "../database/index.mjs";
+import { buildExecutionEnv, resolveWorkerRuntimeConfigs } from "./template.mjs";
+import { writeGraphMetadata } from "./state.mjs";
+import { startLocalServices, stopLocalServices } from "./services.mjs";
+
+export function createGraphContext(worker, graph) {
+  const graphDir = path.join(worker.productDir, ".testkit", "_graphs", graph.dirName);
+  const workerStateDir = path.join(graphDir, "workers", `worker-${worker.workerId}`);
+  fs.mkdirSync(workerStateDir, { recursive: true });
+  writeGraphMetadata(graphDir, graph);
+
+  const runtimeConfigs = resolveWorkerRuntimeConfigs(
+    graph.rootConfig,
+    graph.runtimeConfigs,
+    worker.workerId,
+    workerStateDir
+  );
+
+  return {
+    graphKey: graph.key,
+    graphDir,
+    workerStateDir,
+    runtimeConfigs,
+    configByName: new Map(runtimeConfigs.map((config) => [config.name, config])),
+    prepared: false,
+    started: false,
+    startedServices: [],
+  };
+}
+
+export async function ensureWorkerGraph(worker, batch, graphByKey, lifecycle) {
+  const graph = graphByKey.get(batch.graphKey);
+  if (!graph) {
+    throw new Error(`Unknown graph "${batch.graphKey}"`);
+  }
+
+  if (worker.currentGraphKey && worker.currentGraphKey !== batch.graphKey) {
+    await deactivateGraphContext(worker.graphContexts.get(worker.currentGraphKey), lifecycle);
+    worker.graphSwitches += 1;
+    worker.currentGraphKey = null;
+  }
+
+  let context = worker.graphContexts.get(batch.graphKey);
+  if (!context) {
+    context = createGraphContext(worker, graph);
+    worker.graphContexts.set(batch.graphKey, context);
+    lifecycle.trackGraphContext(context);
+  }
+
+  if (!context.prepared) {
+    await prepareDatabases(context.runtimeConfigs);
+    context.prepared = true;
+  }
+
+  if (batchNeedsLocalRuntime(batch) && !context.started) {
+    context.startedServices = await startLocalServices(context.runtimeConfigs, lifecycle);
+    context.started = true;
+  }
+
+  worker.currentGraphKey = batch.graphKey;
+  return context;
+}
+
+export async function deactivateGraphContext(context, lifecycle) {
+  if (!context?.started) return;
+  await stopLocalServices(context.startedServices, lifecycle);
+  context.started = false;
+  context.startedServices = [];
+}
+
+export async function resetCurrentGraph(worker, lifecycle) {
+  if (!worker.currentGraphKey) return;
+  await deactivateGraphContext(worker.graphContexts.get(worker.currentGraphKey), lifecycle);
+  worker.currentGraphKey = null;
+}
+
+export async function cleanupWorker(worker, lifecycle) {
+  for (const context of worker.graphContexts.values()) {
+    await deactivateGraphContext(context, lifecycle);
+  }
+  worker.currentGraphKey = null;
+}
+
+export async function prepareDatabases(runtimeConfigs) {
+  for (const config of runtimeConfigs) {
+    await prepareDatabaseRuntime(config, {
+      runMigrate: config.testkit.migrate
+        ? (databaseUrl) => runMigrate(config, databaseUrl)
+        : null,
+      runSeed: config.testkit.seed ? (databaseUrl) => runSeed(config, databaseUrl) : null,
+    });
+  }
+}
+
+async function runMigrate(config, databaseUrl) {
+  const migrate = config.testkit.migrate;
+  if (!migrate) return;
+
+  const env = buildExecutionEnv(config, {}, process.env);
+  if (databaseUrl) env.DATABASE_URL = databaseUrl;
+
+  console.log(`\n── migrate:${config.workerLabel}:${config.name} ──`);
+  await execaCommand(migrate.cmd, {
+    cwd: resolveServiceCwd(config.productDir, migrate.cwd),
+    env,
+    stdio: "inherit",
+    shell: true,
+  });
+}
+
+async function runSeed(config, databaseUrl) {
+  const seed = config.testkit.seed;
+  if (!seed) return;
+
+  const env = buildExecutionEnv(config, {}, process.env);
+  if (databaseUrl) env.DATABASE_URL = databaseUrl;
+
+  console.log(`\n── seed:${config.workerLabel}:${config.name} ──`);
+  await execaCommand(seed.cmd, {
+    cwd: resolveServiceCwd(config.productDir, seed.cwd),
+    env,
+    stdio: "inherit",
+    shell: true,
+  });
+}
+
+function batchNeedsLocalRuntime(batch) {
+  return batch.type !== "dal";
+}

package/lib/runner/selection.mjs

@@ -0,0 +1,33 @@
+export function findUnmatchedRequestedFiles(
+  configs,
+  suiteType,
+  suiteNames,
+  framework,
+  fileNames,
+  collectSuites,
+  normalizePathSeparators
+) {
+  const matchedFiles = new Set();
+  for (const config of configs) {
+    const suites = collectSuites(config, suiteType, suiteNames, framework, []);
+    for (const suite of suites) {
+      for (const file of suite.files) {
+        matchedFiles.add(normalizePathSeparators(file));
+      }
+    }
+  }
+
+  return [...new Set(fileNames.map(normalizePathSeparators))].filter(
+    (file) => !matchedFiles.has(file)
+  );
+}
+
+export function isFullRunSelection(suiteNames, fileNames, framework, shard, serviceFilter) {
+  return (
+    (suiteNames || []).length === 0 &&
+    (fileNames || []).length === 0 &&
+    (framework || "all") === "all" &&
+    (shard || null) === null &&
+    (serviceFilter || null) === null
+  );
+}

package/lib/runner/selection.test.mjs

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import { findUnmatchedRequestedFiles, isFullRunSelection } from "./selection.mjs";
+
+describe("runner selection", () => {
+  it("finds unmatched requested files", () => {
+    const unmatched = findUnmatchedRequestedFiles(
+      [{ name: "api" }],
+      "int",
+      [],
+      "all",
+      ["tests/a.int.testkit.ts", "tests/missing.int.testkit.ts"],
+      () => [{ files: ["tests/a.int.testkit.ts"] }],
+      (value) => value
+    );
+
+    expect(unmatched).toEqual(["tests/missing.int.testkit.ts"]);
+  });
+
+  it("detects a full run selection", () => {
+    expect(isFullRunSelection([], [], "all", null, null)).toBe(true);
+    expect(isFullRunSelection(["auth"], [], "all", null, null)).toBe(false);
+    expect(isFullRunSelection([], ["a"], "all", null, null)).toBe(false);
+    expect(isFullRunSelection([], [], "playwright", null, null)).toBe(false);
+  });
+});

package/lib/runner/services.mjs

@@ -0,0 +1,73 @@
+import { resolveServiceCwd } from "../config/index.mjs";
+import { buildExecutionEnv, numericPortFromUrl } from "./template.mjs";
+import { DEFAULT_READY_TIMEOUT_MS, assertLocalServicePortsAvailable, isPortInUse, waitForReady } from "./readiness.mjs";
+import { pipeOutput, startDetachedCommand, stopChildProcess, sleep } from "./processes.mjs";
+import { readDatabaseUrl } from "./state-io.mjs";
+
+export async function startLocalServices(runtimeConfigs, lifecycle) {
+  const started = [];
+
+  try {
+    for (const config of runtimeConfigs) {
+      if (!config.testkit.local) continue;
+      const proc = await startLocalService(config, lifecycle);
+      started.push(proc);
+    }
+  } catch (error) {
+    await stopLocalServices(started, lifecycle);
+    throw error;
+  }
+
+  return started;
+}
+
+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 port = config.testkit.local.port || numericPortFromUrl(config.testkit.local.baseUrl);
+  if (port) {
+    env.PORT = String(port);
+  }
+
+  const dbUrl = readDatabaseUrl(config.stateDir);
+  if (dbUrl) {
+    env.DATABASE_URL = dbUrl;
+  }
+
+  await assertLocalServicePortsAvailable(config, isPortInUse);
+
+  console.log(`Starting ${config.workerLabel}:${config.name}: ${config.testkit.local.start}`);
+  const child = startDetachedCommand(config.testkit.local.start, cwd, env);
+
+  const outputDrains = [
+    pipeOutput(child.stdout, `[${config.workerLabel}:${config.name}]`),
+    pipeOutput(child.stderr, `[${config.workerLabel}:${config.name}]`),
+  ];
+  lifecycle.registerService(config, child, cwd);
+
+  const readyTimeoutMs = config.testkit.local.readyTimeoutMs || DEFAULT_READY_TIMEOUT_MS;
+
+  try {
+    await waitForReady({
+      name: `${config.workerLabel}:${config.name}`,
+      url: config.testkit.local.readyUrl,
+      timeoutMs: readyTimeoutMs,
+      process: child,
+      signal: lifecycle.signal,
+      sleep,
+    });
+  } catch (error) {
+    await stopChildProcess(child, outputDrains);
+    lifecycle.unregisterService(child.pid);
+    throw error;
+  }
+
+  return { name: config.name, child, outputDrains };
+}
+
+export async function stopLocalServices(started, lifecycle) {
+  for (const service of [...started].reverse()) {
+    await stopChildProcess(service.child, service.outputDrains);
+    lifecycle?.unregisterService(service.child.pid);
+  }
+}

package/lib/runner/state-io.mjs

@@ -0,0 +1,25 @@
+import fs from "fs";
+import path from "path";
+
+export function readDatabaseUrl(stateDir) {
+  return readStateValue(path.join(stateDir, "database_url"));
+}
+
+export function readStateValue(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  return fs.readFileSync(filePath, "utf8").trim();
+}
+
+export function printStateDir(dir, indent) {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const filePath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      console.log(`${indent}${entry.name}/`);
+      printStateDir(filePath, `${indent}  `);
+      continue;
+    }
+    const value =
+      entry.name === "password" ? "********" : fs.readFileSync(filePath, "utf8").trim();
+    console.log(`${indent}${entry.name}: ${value}`);
+  }
+}

package/lib/runner/worker-loop.mjs

@@ -0,0 +1,95 @@
+import { formatError } from "./formatting.mjs";
+import { runDalBatch, runHttpK6Batch } from "./default-runtime-runner.mjs";
+import { runPlaywrightBatch } from "./playwright-runner.mjs";
+import {
+  cleanupWorker,
+  ensureWorkerGraph,
+  resetCurrentGraph,
+} from "./runtime-contexts.mjs";
+
+const HTTP_K6_TYPES = new Set(["integration", "e2e", "load"]);
+
+export function createWorker(workerId, productDir) {
+  return {
+    workerId,
+    productDir,
+    currentGraphKey: null,
+    graphContexts: new Map(),
+    graphSwitches: 0,
+    taskCount: 0,
+  };
+}
+
+export async function runWorker(
+  worker,
+  queue,
+  graphByKey,
+  trackers,
+  timingUpdates,
+  lifecycle,
+  claimNextBatch,
+  recordTaskOutcome,
+  recordGraphError
+) {
+  const startedAt = Date.now();
+  console.log(`\n══ global worker ${worker.workerId} ══`);
+  const errors = [];
+
+  try {
+    while (true) {
+      if (lifecycle.isStopRequested()) break;
+      const batch = claimNextBatch(queue, worker.currentGraphKey);
+      if (!batch) break;
+
+      try {
+        const context = await ensureWorkerGraph(worker, batch, graphByKey, lifecycle);
+        const outcomes = await runBatch(context, batch, lifecycle);
+        for (const outcome of outcomes) {
+          recordTaskOutcome(trackers, outcome.task, outcome);
+          timingUpdates.push({
+            key: outcome.task.timingKey,
+            durationMs: outcome.durationMs,
+          });
+          worker.taskCount += 1;
+        }
+      } catch (error) {
+        const message = formatError(error);
+        errors.push(message);
+        recordGraphError(trackers, graphByKey.get(batch.graphKey), message);
+        await resetCurrentGraph(worker, lifecycle);
+      }
+    }
+  } finally {
+    await cleanupWorker(worker, lifecycle);
+  }
+
+  return {
+    workerId: worker.workerId,
+    failed: errors.length > 0,
+    durationMs: Date.now() - startedAt,
+    taskCount: worker.taskCount,
+    graphSwitches: worker.graphSwitches,
+    errors,
+  };
+}
+
+async function runBatch(context, batch, lifecycle) {
+  const targetConfig = context.configByName.get(batch.targetName);
+  if (!targetConfig) {
+    throw new Error(`Worker graph missing target config "${batch.targetName}"`);
+  }
+
+  if (batch.framework === "playwright") {
+    return runPlaywrightBatch(targetConfig, batch, lifecycle);
+  }
+  if (batch.type === "dal") {
+    return runDalBatch(targetConfig, batch, lifecycle);
+  }
+  if (batch.framework === "k6" && HTTP_K6_TYPES.has(batch.type)) {
+    return runHttpK6Batch(targetConfig, batch, lifecycle);
+  }
+
+  throw new Error(
+    `Unsupported task combination for ${batch.targetName}: type=${batch.type} framework=${batch.framework}`
+  );
+}

package/package.json

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