@elench/testkit 0.1.16 → 0.1.18

package/lib/runner/metadata.mjs

@@ -0,0 +1,55 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { execFileSync } from "child_process";
+import { fileURLToPath } from "url";
+
+export function collectGitMetadata(productDir) {
+  const read = (args) => {
+    try {
+      return execaSyncCompat("git", args, { cwd: productDir }).trim() || null;
+    } catch {
+      return null;
+    }
+  };
+
+  return {
+    branch: read(["rev-parse", "--abbrev-ref", "HEAD"]),
+    commitSha: read(["rev-parse", "HEAD"]),
+    repoRoot: read(["rev-parse", "--show-toplevel"]),
+  };
+}
+
+export function readPackageMetadata() {
+  try {
+    const thisFile = fileURLToPath(import.meta.url);
+    const packagePath = path.resolve(path.dirname(thisFile), "..", "..", "package.json");
+    return JSON.parse(fs.readFileSync(packagePath, "utf8"));
+  } catch {
+    return { version: "unknown" };
+  }
+}
+
+export function safeHostname() {
+  try {
+    return os.hostname();
+  } catch {
+    return null;
+  }
+}
+
+export function safeUsername() {
+  try {
+    return os.userInfo().username;
+  } catch {
+    return process.env.USER || process.env.USERNAME || null;
+  }
+}
+
+function execaSyncCompat(command, args, options) {
+  return execFileSync(command, args, {
+    cwd: options?.cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+}

package/lib/runner/metadata.test.mjs

@@ -0,0 +1,52 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { execFileSync } from "child_process";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  collectGitMetadata,
+  readPackageMetadata,
+  safeHostname,
+  safeUsername,
+} from "./metadata.mjs";
+
+const tempDirs = [];
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+function mkTempDir() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-runner-metadata-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+describe("runner-metadata", () => {
+  it("reads package metadata and safe host/user info", () => {
+    const pkg = readPackageMetadata();
+    const packageJson = JSON.parse(
+      fs.readFileSync(path.resolve(process.cwd(), "package.json"), "utf8")
+    );
+    expect(pkg.version).toBe(packageJson.version);
+    expect(typeof safeHostname()).toBe("string");
+    expect(typeof safeUsername()).toBe("string");
+  });
+
+  it("collects git metadata from a real repo", () => {
+    const repoDir = mkTempDir();
+    execFileSync("git", ["init", "-b", "main"], { cwd: repoDir, stdio: "ignore" });
+    execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: repoDir, stdio: "ignore" });
+    execFileSync("git", ["config", "user.name", "Test User"], { cwd: repoDir, stdio: "ignore" });
+    fs.writeFileSync(path.join(repoDir, "README.md"), "# test\n");
+    execFileSync("git", ["add", "README.md"], { cwd: repoDir, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "init"], { cwd: repoDir, stdio: "ignore" });
+
+    const metadata = collectGitMetadata(repoDir);
+    expect(metadata.branch).toBe("main");
+    expect(metadata.commitSha).toMatch(/^[a-f0-9]{40}$/);
+    expect(metadata.repoRoot).toBe(repoDir);
+  });
+});

package/lib/runner/planning.mjs

@@ -0,0 +1,270 @@
+import { buildTimingKey, estimateTaskDuration } from "../timing/index.mjs";
+
+const TYPE_ORDER = ["dal", "integration", "e2e", "load"];
+
+export function batchNeedsLocalRuntime(batch) {
+  return batch.tasks.some((task) => task.type !== "dal");
+}
+
+export function resolveRuntimeConfigs(targetConfig, configMap) {
+  const ordered = [];
+  const visiting = new Set();
+  const seen = new Set();
+
+  const visit = (config) => {
+    if (seen.has(config.name)) return;
+    if (visiting.has(config.name)) {
+      throw new Error(`Dependency cycle detected involving "${config.name}"`);
+    }
+
+    visiting.add(config.name);
+    for (const depName of config.testkit.dependsOn || []) {
+      const dep = configMap.get(depName);
+      if (!dep) {
+        throw new Error(`Service "${config.name}" depends on unknown service "${depName}"`);
+      }
+      visit(dep);
+    }
+    visiting.delete(config.name);
+    seen.add(config.name);
+    ordered.push(config);
+  };
+
+  visit(targetConfig);
+  return ordered;
+}
+
+export function collectSuites(config, suiteType, suiteNames, frameworkFilter) {
+  const types =
+    suiteType === "all"
+      ? orderedTypes(Object.keys(config.suites))
+      : [suiteType === "int" ? "integration" : suiteType];
+
+  const selectedNames = new Set(suiteNames);
+  const suites = [];
+  let orderIndex = 0;
+
+  for (const type of types) {
+    for (const suite of config.suites[type] || []) {
+      const framework = suite.framework || "k6";
+      if (selectedNames.size > 0 && !selectedNames.has(suite.name)) continue;
+      if (frameworkFilter && frameworkFilter !== "all" && framework !== frameworkFilter) continue;
+
+      suites.push({
+        ...suite,
+        framework,
+        type,
+        orderIndex,
+        sortKey: `${type}:${suite.name}`,
+        weight:
+          suite.testkit?.weight ||
+          (framework === "playwright"
+            ? Math.max(2, suite.files.length)
+            : Math.max(1, suite.files.length)),
+        maxFileConcurrency:
+          framework === "k6" ? suite.testkit?.maxFileConcurrency || 1 : 1,
+      });
+      orderIndex += 1;
+    }
+  }
+
+  return suites;
+}
+
+export function applyShard(suites, shard) {
+  if (!shard) return suites;
+  return suites.filter((unused, index) => index % shard.total === shard.index - 1);
+}
+
+export function orderedTypes(types) {
+  const ordered = [];
+  for (const known of TYPE_ORDER) {
+    if (types.includes(known)) ordered.push(known);
+  }
+  for (const type of types) {
+    if (!ordered.includes(type)) ordered.push(type);
+  }
+  return ordered;
+}
+
+export function buildRuntimeGraphs(servicePlans) {
+  const executed = servicePlans.filter((plan) => !plan.skipped);
+  const uniqueGraphs = [];
+  const graphByRuntimeKey = new Map();
+
+  for (const plan of executed) {
+    if (graphByRuntimeKey.has(plan.runtimeKey)) {
+      graphByRuntimeKey.get(plan.runtimeKey).exactTargets.push(plan.config.name);
+      continue;
+    }
+
+    const graph = {
+      key: plan.runtimeKey,
+      runtimeNames: plan.runtimeNames,
+      runtimeConfigs: plan.runtimeConfigs,
+      exactTargets: [plan.config.name],
+      assignedTargets: [],
+      dirName: null,
+      rootConfig: null,
+    };
+    uniqueGraphs.push(graph);
+    graphByRuntimeKey.set(plan.runtimeKey, graph);
+  }
+
+  const maximalGraphs = uniqueGraphs.filter(
+    (graph) =>
+      !uniqueGraphs.some(
+        (other) =>
+          other.key !== graph.key &&
+          isRuntimeSuperset(other.runtimeNames, graph.runtimeNames)
+      )
+  );
+
+  for (const plan of executed) {
+    const compatible = maximalGraphs.filter((graph) =>
+      isRuntimeSuperset(graph.runtimeNames, plan.runtimeNames)
+    );
+    if (compatible.length === 0) {
+      throw new Error(`No runtime graph found for service "${plan.config.name}"`);
+    }
+
+    const assigned = compatible.sort(compareGraphsForAssignment)[0];
+    plan.assignedGraphKey = assigned.key;
+    assigned.assignedTargets.push(plan.config.name);
+  }
+
+  for (const graph of maximalGraphs) {
+    const rootName = [...graph.exactTargets].sort()[0];
+    const rootPlan = executed.find((plan) => plan.config.name === rootName);
+    if (!rootPlan) {
+      throw new Error(`Missing root plan for graph "${graph.key}"`);
+    }
+    graph.rootConfig = rootPlan.config;
+    graph.dirName = buildGraphDirName(graph.runtimeNames);
+  }
+
+  return maximalGraphs.sort((a, b) => a.dirName.localeCompare(b.dirName));
+}
+
+export function buildTaskQueue(servicePlans, graphs, timings) {
+  const graphByKey = new Map(graphs.map((graph) => [graph.key, graph]));
+  const tasks = [];
+  let nextId = 1;
+
+  for (const plan of servicePlans) {
+    if (plan.skipped) continue;
+
+    const graph = graphByKey.get(plan.assignedGraphKey);
+    if (!graph) {
+      throw new Error(`Assigned graph "${plan.assignedGraphKey}" not found for ${plan.config.name}`);
+    }
+
+    for (const suite of plan.suites) {
+      for (const file of suite.files) {
+        const timingKey = buildTimingKey(plan.config.name, suite, file);
+        tasks.push({
+          id: nextId,
+          graphKey: graph.key,
+          targetName: plan.config.name,
+          serviceName: plan.config.name,
+          suiteKey: `${suite.type}:${suite.name}`,
+          suiteName: suite.name,
+          type: suite.type,
+          framework: suite.framework,
+          orderIndex: suite.orderIndex,
+          file,
+          timingKey,
+          estimatedDurationMs: estimateTaskDuration(timings, timingKey, suite),
+          maxBatchSize:
+            suite.framework === "playwright"
+              ? Number.POSITIVE_INFINITY
+              : suite.maxFileConcurrency || 1,
+        });
+        nextId += 1;
+      }
+    }
+  }
+
+  return tasks.sort(
+    (a, b) =>
+      b.estimatedDurationMs - a.estimatedDurationMs ||
+      a.serviceName.localeCompare(b.serviceName) ||
+      a.suiteKey.localeCompare(b.suiteKey) ||
+      a.file.localeCompare(b.file)
+  );
+}
+
+export function claimNextBatch(queue, preferredGraphKey) {
+  if (queue.length === 0) return null;
+
+  let index = -1;
+  if (preferredGraphKey) {
+    index = queue.findIndex((task) => task.graphKey === preferredGraphKey);
+  }
+  if (index === -1) index = 0;
+
+  const seed = queue.splice(index, 1)[0];
+  const tasks = [seed];
+
+  if (seed.framework === "playwright") {
+    for (let cursor = queue.length - 1; cursor >= 0; cursor -= 1) {
+      const candidate = queue[cursor];
+      if (
+        candidate.framework === "playwright" &&
+        candidate.graphKey === seed.graphKey &&
+        candidate.targetName === seed.targetName
+      ) {
+        tasks.push(candidate);
+        queue.splice(cursor, 1);
+      }
+    }
+  } else if (seed.maxBatchSize > 1) {
+    for (let cursor = queue.length - 1; cursor >= 0 && tasks.length < seed.maxBatchSize; cursor -= 1) {
+      const candidate = queue[cursor];
+      if (
+        candidate.framework === seed.framework &&
+        candidate.type === seed.type &&
+        candidate.graphKey === seed.graphKey &&
+        candidate.targetName === seed.targetName &&
+        candidate.suiteKey === seed.suiteKey
+      ) {
+        tasks.push(candidate);
+        queue.splice(cursor, 1);
+      }
+    }
+  }
+
+  tasks.sort(
+    (a, b) =>
+      a.orderIndex - b.orderIndex ||
+      a.file.localeCompare(b.file)
+  );
+
+  return {
+    graphKey: seed.graphKey,
+    targetName: seed.targetName,
+    framework: seed.framework,
+    type: seed.type,
+    tasks,
+  };
+}
+
+export function isRuntimeSuperset(candidate, target) {
+  return target.every((name) => candidate.includes(name));
+}
+
+export function compareGraphsForAssignment(left, right) {
+  if (left.runtimeNames.length !== right.runtimeNames.length) {
+    return left.runtimeNames.length - right.runtimeNames.length;
+  }
+  return left.key.localeCompare(right.key);
+}
+
+export function buildGraphDirName(runtimeNames) {
+  const slug = runtimeNames.map(slugSegment).join("__");
+  return slug.length > 0 ? slug : "graph";
+}
+
+function slugSegment(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "svc";
+}

package/lib/runner/planning.test.mjs

@@ -0,0 +1,127 @@
+import { describe, expect, it } from "vitest";
+import {
+  applyShard,
+  buildGraphDirName,
+  buildRuntimeGraphs,
+  buildTaskQueue,
+  claimNextBatch,
+  collectSuites,
+  resolveRuntimeConfigs,
+} from "./planning.mjs";
+
+function makeConfig(name, extras = {}) {
+  return {
+    name,
+    suites: extras.suites || {},
+    testkit: {
+      dependsOn: extras.dependsOn || [],
+    },
+    ...extras,
+  };
+}
+
+describe("runner-planning", () => {
+  it("orders runtime configs by dependency and detects cycles", () => {
+    const api = makeConfig("api");
+    const frontend = makeConfig("frontend", { dependsOn: ["api"] });
+    const configMap = new Map([
+      ["api", api],
+      ["frontend", frontend],
+    ]);
+
+    expect(resolveRuntimeConfigs(frontend, configMap).map((config) => config.name)).toEqual([
+      "api",
+      "frontend",
+    ]);
+
+    api.testkit.dependsOn = ["frontend"];
+    expect(() => resolveRuntimeConfigs(frontend, configMap)).toThrow("Dependency cycle");
+  });
+
+  it("collects suites with aliases, weights, and framework filters", () => {
+    const config = makeConfig("api", {
+      suites: {
+        integration: [
+          { name: "health", files: ["health.js"] },
+        ],
+        e2e: [
+          { name: "auth", framework: "playwright", files: ["auth.spec.js", "signup.spec.js"] },
+        ],
+      },
+    });
+
+    expect(collectSuites(config, "int", [], "all")[0]).toMatchObject({
+      name: "health",
+      type: "integration",
+      framework: "k6",
+      weight: 1,
+    });
+
+    expect(collectSuites(config, "all", [], "playwright")[0]).toMatchObject({
+      name: "auth",
+      framework: "playwright",
+      weight: 2,
+    });
+  });
+
+  it("applies shards, builds graphs, queues tasks, and claims batches", () => {
+    const api = makeConfig("api");
+    const frontend = makeConfig("frontend");
+    const plans = [
+      {
+        config: api,
+        skipped: false,
+        runtimeConfigs: [api],
+        runtimeNames: ["api"],
+        runtimeKey: "api",
+        suites: [
+          {
+            name: "health",
+            type: "integration",
+            framework: "k6",
+            files: ["a.js", "b.js"],
+            orderIndex: 0,
+            weight: 2,
+            maxFileConcurrency: 2,
+          },
+        ],
+      },
+      {
+        config: frontend,
+        skipped: false,
+        runtimeConfigs: [api, frontend],
+        runtimeNames: ["api", "frontend"],
+        runtimeKey: "api|frontend",
+        suites: [
+          {
+            name: "auth",
+            type: "e2e",
+            framework: "playwright",
+            files: ["auth.spec.js", "signup.spec.js"],
+            orderIndex: 0,
+            weight: 2,
+            maxFileConcurrency: 1,
+          },
+        ],
+      },
+    ];
+
+    expect(applyShard(["a", "b", "c", "d"], { index: 2, total: 2 })).toEqual(["b", "d"]);
+
+    const graphs = buildRuntimeGraphs(plans);
+    expect(graphs).toHaveLength(1);
+    expect(plans[0].assignedGraphKey).toBe("api|frontend");
+    expect(buildGraphDirName(["api", "frontend"])).toBe("api__frontend");
+
+    const queue = buildTaskQueue(plans, graphs, { files: {} });
+    expect(queue).toHaveLength(4);
+
+    const firstBatch = claimNextBatch(queue, "api|frontend");
+    expect(firstBatch.tasks).toHaveLength(2);
+    expect(firstBatch.framework).toBe("playwright");
+
+    const secondBatch = claimNextBatch(queue, "api|frontend");
+    expect(secondBatch.tasks).toHaveLength(2);
+    expect(secondBatch.framework).toBe("k6");
+  });
+});