@elench/testkit 0.1.31 → 0.1.33

package/lib/runner/playwright-config.mjs

@@ -0,0 +1,53 @@
+import fs from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+import { normalizePathSeparators } from "./state.mjs";
+
+export function ensurePlaywrightTestConfig(targetConfig, cwd, requestedFiles) {
+  const stateDir = targetConfig.stateDir || path.join(targetConfig.productDir, ".testkit");
+  fs.mkdirSync(stateDir, { recursive: true });
+  const configPath = path.join(stateDir, "playwright.testkit.config.mjs");
+  const baseConfigPath = findPlaywrightConfig(cwd);
+  const normalizedFiles = requestedFiles.map(normalizePathSeparators);
+
+  let source = "";
+  if (baseConfigPath) {
+    source =
+      `import baseConfig from ${JSON.stringify(pathToFileURL(baseConfigPath).href)};\n` +
+      `const resolvedBase = typeof baseConfig === "function" ? await baseConfig() : baseConfig;\n` +
+      `export default {\n` +
+      `  ...(resolvedBase || {}),\n` +
+      `  testDir: ${JSON.stringify(cwd)},\n` +
+      `  testMatch: ${JSON.stringify(normalizedFiles)},\n` +
+      `};\n`;
+  } else {
+    source =
+      `export default {\n` +
+      `  testDir: ${JSON.stringify(cwd)},\n` +
+      `  testMatch: ${JSON.stringify(normalizedFiles)},\n` +
+      `};\n`;
+  }
+
+  fs.writeFileSync(configPath, source);
+  return configPath;
+}
+
+export function findPlaywrightConfig(cwd) {
+  const candidates = [
+    "playwright.config.ts",
+    "playwright.config.mts",
+    "playwright.config.js",
+    "playwright.config.mjs",
+    "playwright.config.cjs",
+    "playwright.config.cts",
+  ];
+
+  for (const candidate of candidates) {
+    const candidatePath = path.join(cwd, candidate);
+    if (fs.existsSync(candidatePath)) {
+      return candidatePath;
+    }
+  }
+
+  return null;
+}

package/lib/runner/playwright-runner.mjs

@@ -0,0 +1,85 @@
+import path from "path";
+import { execa } from "execa";
+import {
+  parsePlaywrightJsonResults,
+} from "../reporters/playwright.mjs";
+import { resolveServiceCwd, } from "../config/index.mjs";
+import { formatPlaywrightBatchFiles } from "./formatting.mjs";
+import { printBufferedOutput } from "./processes.mjs";
+import { ensurePlaywrightTestConfig } from "./playwright-config.mjs";
+import { buildPlaywrightEnv } from "./template.mjs";
+import { normalizePathSeparators } from "./state.mjs";
+
+export async function runPlaywrightBatch(targetConfig, batch, lifecycle) {
+  const local = targetConfig.testkit.local;
+  if (!local?.baseUrl) {
+    throw new Error(
+      `Service "${targetConfig.name}" requires local.baseUrl for Playwright suites`
+    );
+  }
+
+  console.log(
+    `\n── ${targetConfig.workerLabel} playwright:${targetConfig.name} (${batch.tasks.length} file${batch.tasks.length === 1 ? "" : "s"})${formatPlaywrightBatchFiles(batch)} ──`
+  );
+
+  const cwd = resolveServiceCwd(targetConfig.productDir, local.cwd);
+  const requestedFiles = batch.tasks.map((task) =>
+    path.relative(cwd, path.join(targetConfig.productDir, task.file))
+  );
+  const playwrightConfigPath = ensurePlaywrightTestConfig(targetConfig, cwd, requestedFiles);
+  const startedAt = Date.now();
+  const result = await execa(
+    "npx",
+    ["playwright", "test", "--config", playwrightConfigPath, "--reporter=json"],
+    {
+      cwd,
+      env: buildPlaywrightEnv(targetConfig, local.baseUrl, process.env),
+      reject: false,
+      cancelSignal: lifecycle.signal,
+      forceKillAfterDelay: 5_000,
+    }
+  );
+
+  if (result.stderr) {
+    printBufferedOutput(result.stderr, `[${targetConfig.workerLabel}:${targetConfig.name}:playwright]`);
+  }
+
+  const parsed = parsePlaywrightJsonResults(result.stdout, cwd);
+  const finishedAt = Date.now();
+  const batchDurationMs = finishedAt - startedAt;
+  const genericError =
+    result.exitCode === 0
+      ? parsed.errors[0] || null
+      : parsed.errors[0] ||
+        result.stderr.trim() ||
+        `Playwright exited with code ${result.exitCode}`;
+
+  return batch.tasks.map((task) => {
+    const relativeFile = normalizePathSeparators(
+      path.relative(cwd, path.join(targetConfig.productDir, task.file))
+    );
+    const fileResult = parsed.fileResults.get(relativeFile);
+    if (fileResult) {
+      return {
+        task,
+        failed: fileResult.failed,
+        error: fileResult.error,
+        durationMs:
+          fileResult.durationMs > 0
+            ? fileResult.durationMs
+            : Math.round(batchDurationMs / Math.max(1, batch.tasks.length)),
+        startedAt,
+        finishedAt,
+      };
+    }
+
+    return {
+      task,
+      failed: result.exitCode !== 0,
+      error: result.exitCode !== 0 ? genericError : null,
+      durationMs: Math.round(batchDurationMs / Math.max(1, batch.tasks.length)),
+      startedAt,
+      finishedAt,
+    };
+  });
+}

package/lib/runner/processes.mjs

@@ -0,0 +1,106 @@
+import { spawn } from "child_process";
+
+export function startDetachedCommand(command, cwd, env) {
+  if (process.platform === "win32") {
+    return spawn(command, {
+      cwd,
+      env,
+      detached: true,
+      shell: true,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+  }
+
+  const shell = process.env.SHELL || "/bin/sh";
+  return spawn(shell, ["-lc", `exec ${command}`], {
+    cwd,
+    env,
+    detached: true,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+}
+
+export function killChildProcess(child, signal) {
+  if (!child?.pid) return;
+
+  try {
+    process.kill(-child.pid, signal);
+    return;
+  } catch (error) {
+    if (error?.code !== "ESRCH") {
+      // Fall back to the direct child if process-group signalling is unavailable.
+    } else {
+      return;
+    }
+  }
+
+  try {
+    child.kill(signal);
+  } catch (error) {
+    if (error?.code !== "ESRCH") throw error;
+  }
+}
+
+export function pipeOutput(stream, prefix) {
+  if (!stream) return Promise.resolve();
+
+  let pending = "";
+  return new Promise((resolve) => {
+    let settled = false;
+    const settle = () => {
+      if (settled) return;
+      settled = true;
+      resolve();
+    };
+
+    stream.on("data", (chunk) => {
+      pending += chunk.toString();
+      const lines = pending.split(/\r?\n/);
+      pending = lines.pop() || "";
+      for (const line of lines) {
+        if (line.length > 0) console.log(`${prefix} ${line}`);
+      }
+    });
+    stream.on("end", () => {
+      if (pending.length > 0) {
+        console.log(`${prefix} ${pending}`);
+      }
+      settle();
+    });
+    stream.on("close", settle);
+    stream.on("error", settle);
+  });
+}
+
+export function printBufferedOutput(output, prefix) {
+  for (const line of output.split(/\r?\n/)) {
+    if (line.trim().length > 0) {
+      console.log(`${prefix} ${line}`);
+    }
+  }
+}
+
+export async function stopChildProcess(child, outputDrains = []) {
+  if (!child) return;
+  if (child.exitCode !== null) {
+    await Promise.all(outputDrains);
+    return;
+  }
+
+  killChildProcess(child, "SIGTERM");
+  const exited = await Promise.race([
+    new Promise((resolve) => child.once("exit", () => resolve(true))),
+    sleep(5_000).then(() => false),
+  ]);
+
+  if (!exited && child.exitCode === null) {
+    killChildProcess(child, "SIGKILL");
+    await new Promise((resolve) => child.once("exit", resolve));
+  }
+
+  await Promise.all(outputDrains);
+}
+
+export function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/lib/runner/readiness.mjs

@@ -0,0 +1,117 @@
+import net from "net";
+import {
+  cleanupStaleRuns,
+  findPortOwner,
+  formatRunSummary,
+  isPidRunning,
+  listRunManifests,
+} from "./lifecycle.mjs";
+import { socketFromUrl } from "./template.mjs";
+
+export const DEFAULT_READY_TIMEOUT_MS = 120_000;
+
+export async function waitForReady({ name, url, timeoutMs, process, signal, sleep }) {
+  const start = Date.now();
+
+  while (Date.now() - start < timeoutMs) {
+    if (signal?.aborted) {
+      throw signal.reason || new Error(`Service "${name}" startup aborted`);
+    }
+    if (process.exitCode !== null) {
+      throw new Error(`Service "${name}" exited before becoming ready`);
+    }
+
+    try {
+      const response = await fetch(url);
+      if (response.ok) return;
+    } catch {
+      // Service still warming up.
+    }
+
+    await sleep(1_000);
+  }
+
+  throw new Error(`Timed out waiting for "${name}" to become ready at ${url}`);
+}
+
+export async function assertLocalServicePortsAvailable(config, isPortInUse) {
+  const endpoints = [config.testkit.local.baseUrl, config.testkit.local.readyUrl];
+  const seen = new Set();
+
+  for (const endpoint of endpoints) {
+    const socket = socketFromUrl(endpoint);
+    if (!socket) continue;
+
+    const key = `${socket.host}:${socket.port}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+
+    if (await isPortInUse(socket)) {
+      await cleanupStaleRuns(config.productDir);
+    }
+
+    if (await isPortInUse(socket)) {
+      const owner = findPortOwner(config.productDir, socket);
+      const ownerDetail = owner
+        ? owner.active
+          ? ` Active testkit run ${formatRunSummary(owner.manifest)} owns ${key} via ${owner.service.workerLabel}:${owner.service.serviceName}.`
+          : ` Stale testkit run ${formatRunSummary(owner.manifest)} owns ${key}.`
+        : "";
+      throw new Error(
+        `Cannot start "${config.workerLabel}:${config.name}" because ${key} is already in use. ` +
+          `Stop the existing process and rerun testkit.${ownerDetail}`
+      );
+    }
+  }
+}
+
+export async function isPortInUse({ host, port }) {
+  return new Promise((resolve, reject) => {
+    const socket = new net.Socket();
+    let settled = false;
+
+    const finish = (value, error = null) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve(value);
+    };
+
+    socket.setTimeout(1_000);
+    socket.once("connect", () => finish(true));
+    socket.once("timeout", () => finish(false));
+    socket.once("error", (error) => {
+      if (["ECONNREFUSED", "EHOSTUNREACH", "ENOTFOUND"].includes(error.code)) {
+        finish(false);
+        return;
+      }
+      finish(false, error);
+    });
+
+    socket.connect(port, host);
+  });
+}
+
+export function printRunStatus(productDir) {
+  const manifests = listRunManifests(productDir);
+  if (manifests.length === 0) return;
+
+  console.log("  runs/");
+  for (const manifest of manifests) {
+    const state = isPidRunning(manifest.pid) ? "active" : "stale";
+    const ports = [
+      ...new Set(
+        (manifest.services || []).flatMap((service) =>
+          (service.ports || []).map((socket) => `${socket.host}:${socket.port}`)
+        )
+      ),
+    ];
+    console.log(
+      `    ${manifest.runId}: ${state} pid=${manifest.pid}${ports.length > 0 ? ` ports=${ports.join(",")}` : ""}`
+    );
+  }
+}

package/lib/runner/reporting.mjs

@@ -0,0 +1,180 @@
+import path from "path";
+
+export function buildStatusArtifact({
+  productDir,
+  results,
+  suiteType,
+  suiteNames,
+  fileNames,
+  framework,
+  shard,
+  serviceFilter,
+  metadata,
+}) {
+  const executedResults = results.filter((result) => !result.skipped);
+  const tests = [];
+
+  for (const result of executedResults) {
+    for (const suite of result.suites) {
+      for (const file of suite.files) {
+        tests.push({
+          service: result.name,
+          type: suite.type,
+          path: file.path,
+          status: file.status,
+        });
+      }
+    }
+  }
+
+  tests.sort(
+    (left, right) =>
+      left.service.localeCompare(right.service) ||
+      left.type.localeCompare(right.type) ||
+      left.path.localeCompare(right.path)
+  );
+
+  const summary = {
+    services: {
+      total: executedResults.length,
+      passed: executedResults.filter((result) => !result.failed).length,
+      failed: executedResults.filter((result) => result.failed).length,
+    },
+    tests: {
+      total: tests.length,
+      passed: tests.filter((test) => test.status === "passed").length,
+      failed: tests.filter((test) => test.status === "failed").length,
+      notRun: tests.filter((test) => test.status === "not_run").length,
+    },
+  };
+
+  const scope = {
+    suiteType,
+    suiteNames: [...(suiteNames || [])].sort(),
+    fileNames: [...(fileNames || [])].sort(),
+    framework: formatFrameworkForArtifact(framework || "all"),
+    shard: shard || null,
+    serviceFilter: serviceFilter || null,
+  };
+  scope.isFullRun =
+    scope.suiteNames.length === 0 &&
+    scope.fileNames.length === 0 &&
+    scope.framework === "all" &&
+    scope.shard === null &&
+    scope.serviceFilter === null;
+
+  return {
+    schemaVersion: 1,
+    source: "testkit",
+    notice: "Generated file. Do not edit manually.",
+    product: {
+      name: path.basename(productDir),
+    },
+    git: {
+      branch: metadata.git?.branch || null,
+      commitSha: metadata.git?.commitSha || null,
+    },
+    testkitVersion: metadata.testkitVersion,
+    scope,
+    summary,
+    tests,
+  };
+}
+
+export function buildRunArtifact({
+  productDir,
+  results,
+  startedAt,
+  finishedAt,
+  requestedJobs,
+  workerCount,
+  suiteType,
+  suiteNames,
+  fileNames,
+  framework,
+  shard,
+  serviceFilter,
+  metadata,
+  summarizeDbBackend,
+}) {
+  const executed = results.filter((result) => !result.skipped);
+  const failedServices = executed.filter((result) => result.failed);
+  const totalSuites = executed.reduce((sum, result) => sum + result.suiteCount, 0);
+  const completedSuites = executed.reduce((sum, result) => sum + result.completedSuiteCount, 0);
+  const failedSuites = executed.reduce((sum, result) => sum + result.failedSuiteCount, 0);
+  const totalFiles = executed.reduce((sum, result) => sum + (result.totalFileCount || 0), 0);
+  const passedFiles = executed.reduce((sum, result) => sum + (result.passedFileCount || 0), 0);
+  const failedFiles = executed.reduce((sum, result) => sum + (result.failedFileCount || 0), 0);
+  const notRunFiles = executed.reduce((sum, result) => sum + (result.notRunFileCount || 0), 0);
+  const dbBackend = summarizeDbBackend(results);
+
+  return {
+    schemaVersion: 1,
+    source: "testkit",
+    generatedAt: new Date(finishedAt).toISOString(),
+    product: {
+      name: path.basename(productDir),
+      directory: productDir,
+    },
+    git: metadata.git,
+    host: metadata.host,
+    run: {
+      status: failedServices.length > 0 ? "failed" : "passed",
+      startedAt: new Date(startedAt).toISOString(),
+      finishedAt: new Date(finishedAt).toISOString(),
+      durationMs: finishedAt - startedAt,
+      requestedJobs,
+      workerCount,
+      dbBackend,
+      suiteType,
+      suiteNames,
+      fileNames,
+      framework: formatFrameworkForArtifact(framework),
+      shard,
+      serviceFilter,
+      testkitVersion: metadata.testkitVersion,
+    },
+    summary: {
+      services: {
+        total: executed.length,
+        passed: executed.length - failedServices.length,
+        failed: failedServices.length,
+      },
+      suites: {
+        total: totalSuites,
+        completed: completedSuites,
+        passed: completedSuites - failedSuites,
+        failed: failedSuites,
+      },
+      files: {
+        total: totalFiles,
+        passed: passedFiles,
+        failed: failedFiles,
+        notRun: notRunFiles,
+      },
+    },
+    services: results.map((result) => ({
+      name: result.name,
+      failed: result.failed,
+      skipped: result.skipped,
+      suiteCount: result.suiteCount,
+      completedSuiteCount: result.completedSuiteCount,
+      failedSuiteCount: result.failedSuiteCount,
+      totalFileCount: result.totalFileCount,
+      completedFileCount: result.completedFileCount,
+      passedFileCount: result.passedFileCount,
+      failedFileCount: result.failedFileCount,
+      notRunFileCount: result.notRunFileCount,
+      durationMs: result.durationMs,
+      totalTaskDurationMs: result.totalTaskDurationMs,
+      dbBackend: result.dbBackend,
+      suites: result.suites,
+      errors: result.errors,
+    })),
+  };
+}
+
+function formatFrameworkForArtifact(framework) {
+  if (framework === "k6") return "default";
+  return framework;
+}