@elench/testkit 0.1.40 → 0.1.41

package/lib/runner/planning.mjs

@@ -4,12 +4,11 @@ import {
   matchesSuiteSelectors,
   suiteSelectionType,
 } from "./suite-selection.mjs";
-import { resolveBatchAccessMode, resolveBatchStackMode } from "./execution-config.mjs";
 
 const TYPE_ORDER = ["dal", "integration", "e2e", "load"];
 
-export function batchNeedsLocalRuntime(batch) {
-  return batch.tasks.some((task) => task.type !== "dal");
+export function taskNeedsLocalRuntime(task) {
+  return task.type !== "dal";
 }
 
 export function resolveRuntimeConfigs(targetConfig, configMap) {
@@ -78,10 +77,6 @@ export function collectSuites(config, typeValues, suiteSelectors, fileNames = []
           (framework === "playwright"
             ? Math.max(2, Math.max(1, files.length))
             : Math.max(1, files.length)),
-        maxFileConcurrency:
-          framework === "k6" || framework === "playwright"
-            ? suite.testkit?.maxFileConcurrency || 1
-            : 1,
         totalFileCount: selectedSuiteFiles.length,
       });
       orderIndex += 1;
@@ -93,7 +88,7 @@ export function collectSuites(config, typeValues, suiteSelectors, fileNames = []
 
 export function applyShard(suites, shard) {
   if (!shard) return suites;
-  return suites.filter((unused, index) => index % shard.total === shard.index - 1);
+  return suites.filter((_unused, index) => index % shard.total === shard.index - 1);
 }
 
 export function orderedTypes(types) {
@@ -109,12 +104,15 @@ export function orderedTypes(types) {
 
 export function buildRuntimeGraphs(servicePlans) {
   const executed = servicePlans.filter((plan) => !plan.skipped);
-  const uniqueGraphs = [];
+  const graphs = [];
   const graphByRuntimeKey = new Map();
 
   for (const plan of executed) {
-    if (graphByRuntimeKey.has(plan.runtimeKey)) {
-      graphByRuntimeKey.get(plan.runtimeKey).exactTargets.push(plan.config.name);
+    plan.assignedGraphKey = plan.runtimeKey;
+    const existing = graphByRuntimeKey.get(plan.runtimeKey);
+    if (existing) {
+      existing.targetNames.push(plan.config.name);
+      existing.instanceCount = Math.max(existing.instanceCount, plan.config.testkit.runtime.instances);
       continue;
     }
 
@@ -122,48 +120,22 @@ export function buildRuntimeGraphs(servicePlans) {
       key: plan.runtimeKey,
       runtimeNames: plan.runtimeNames,
       runtimeConfigs: plan.runtimeConfigs,
-      exactTargets: [plan.config.name],
-      assignedTargets: [],
-      dirName: null,
-      rootConfig: null,
+      targetNames: [plan.config.name],
+      dirName: buildGraphDirName(plan.runtimeNames),
+      instanceCount: plan.config.testkit.runtime.instances,
     };
-    uniqueGraphs.push(graph);
+    graphs.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);
-  }
+  const sortedGraphs = graphs.sort((left, right) => left.dirName.localeCompare(right.dirName));
+  const maxInstanceCount = Math.max(1, ...sortedGraphs.map((graph) => graph.instanceCount));
 
-  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));
+  return sortedGraphs.map((graph, index) => ({
+    ...graph,
+    portNamespaceIndex: index,
+    portNamespaceStride: maxInstanceCount,
+  }));
 }
 
 export function buildTaskQueue(servicePlans, graphs, timings) {
@@ -181,7 +153,6 @@ export function buildTaskQueue(servicePlans, graphs, timings) {
 
     for (const suite of plan.suites) {
       for (const file of suite.files) {
-        const stackMode = resolveTaskStackMode(plan.config, plan.execution, suite, file);
         const timingKey = buildTimingKey(plan.config.name, suite, file);
         tasks.push({
           id: nextId,
@@ -192,18 +163,11 @@ export function buildTaskQueue(servicePlans, graphs, timings) {
           suiteName: suite.name,
           type: suite.type,
           framework: suite.framework,
-          stackMode,
-          accessMode: resolveBatchAccessMode({
-            framework: suite.framework,
-            type: suite.type,
-            stackMode,
-          }),
           orderIndex: suite.orderIndex,
           file,
+          locks: resolveTaskLocks(plan.config, suite, file),
           timingKey,
           estimatedDurationMs: estimateTaskDuration(timings, timingKey, suite),
-          maxBatchSize:
-            suite.maxFileConcurrency || 1,
         });
         nextId += 1;
       }
@@ -219,7 +183,7 @@ export function buildTaskQueue(servicePlans, graphs, timings) {
   );
 }
 
-export function claimNextBatch(queue, preferredGraphKey) {
+export function claimNextTask(queue, preferredGraphKey) {
   if (queue.length === 0) return null;
 
   let index = -1;
@@ -228,59 +192,12 @@ export function claimNextBatch(queue, preferredGraphKey) {
   }
   if (index === -1) index = 0;
 
-  const seed = queue.splice(index, 1)[0];
-  const tasks = [seed];
-
-  if (seed.maxBatchSize > 1) {
-    for (let cursor = 0; cursor < queue.length; cursor += 1) {
-      if (tasks.length >= seed.maxBatchSize) break;
-      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 &&
-        candidate.stackMode === seed.stackMode &&
-        candidate.accessMode === seed.accessMode
-      ) {
-        tasks.push(candidate);
-        queue.splice(cursor, 1);
-        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,
-    stackMode: seed.stackMode,
-    accessMode: seed.accessMode,
-    tasks,
-  };
-}
-
-export function isRuntimeSuperset(candidate, target) {
-  return target.every((name) => candidate.includes(name));
+  return queue.splice(index, 1)[0];
 }
 
-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);
-}
-
-function normalizePathSeparators(filePath) {
-  return String(filePath).split("\\").join("/");
+export function buildGraphDirName(runtimeNames) {
+  const slug = runtimeNames.map(slugSegment).join("__");
+  return slug.length > 0 ? slug : "graph";
 }
 
 function applySkipRules(config, displayType, suiteName, files, opts = {}) {
@@ -324,38 +241,27 @@ function applySkipRules(config, displayType, suiteName, files, opts = {}) {
   };
 }
 
-function resolveSuiteStackMode(config, displayType, suiteName) {
-  const defaultStackMode = config.testkit.execution.stackMode;
-  const rules = config.testkit.serviceExecution?.suites || [];
-  const matchedRule = rules.find((rule) =>
-    matchesSuiteSelectors(displayType, suiteName, [rule.selector])
-  );
-  return resolveBatchStackMode(defaultStackMode, matchedRule?.stackMode || null);
-}
+function resolveTaskLocks(config, suite, file) {
+  const locks = new Set();
+  const matchedSuiteRules = config.testkit.requirements?.suites || [];
+  for (const rule of matchedSuiteRules) {
+    if (matchesSuiteSelectors(suite.displayType, suite.name, [rule.selector])) {
+      for (const lockName of rule.locks || []) {
+        locks.add(lockName);
+      }
+    }
+  }
 
-function resolveTaskStackMode(config, execution, suite, file) {
-  const effectiveExecution = execution || config.testkit.execution;
   const normalizedFile = normalizePathSeparators(file);
-  const fileOverride = config.testkit.serviceExecution?.fileStackModeByPath?.get(normalizedFile);
-  if (fileOverride) {
-    return resolveBatchStackMode(effectiveExecution.stackMode, fileOverride);
+  for (const lockName of config.testkit.requirements?.fileLocksByPath?.get(normalizedFile) || []) {
+    locks.add(lockName);
   }
-  return resolveSuiteStackMode(
-    {
-      ...config,
-      testkit: {
-        ...config.testkit,
-        execution: effectiveExecution,
-      },
-    },
-    suite.displayType,
-    suite.name
-  );
+
+  return [...locks].sort();
 }
 
-export function buildGraphDirName(runtimeNames) {
-  const slug = runtimeNames.map(slugSegment).join("__");
-  return slug.length > 0 ? slug : "graph";
+function normalizePathSeparators(filePath) {
+  return String(filePath).split("\\").join("/");
 }
 
 function slugSegment(value) {

package/lib/runner/planning.test.mjs

@@ -4,7 +4,7 @@ import {
   buildGraphDirName,
   buildRuntimeGraphs,
   buildTaskQueue,
-  claimNextBatch,
+  claimNextTask,
   collectSuites,
   resolveRuntimeConfigs,
 } from "./planning.mjs";
@@ -14,20 +14,22 @@ function makeConfig(name, extras = {}) {
   return {
     name,
     suites: extras.suites || {},
-      testkit: {
-        dependsOn: extras.dependsOn || providedTestkit.dependsOn || [],
-        execution: providedTestkit.execution || {
-          workers: 1,
-          stackMode: "isolated",
-          stackCount: 1,
-        },
-        serviceExecution: providedTestkit.serviceExecution || {
-          suites: [],
-          files: [],
-          fileStackModeByPath: new Map(),
-        },
-        ...providedTestkit,
+    testkit: {
+      dependsOn: extras.dependsOn || providedTestkit.dependsOn || [],
+      execution: providedTestkit.execution || {
+        workers: 1,
+        fileTimeoutSeconds: 60,
       },
+      runtime: providedTestkit.runtime || {
+        instances: 1,
+      },
+      requirements: providedTestkit.requirements || {
+        suites: [],
+        files: [],
+        fileLocksByPath: new Map(),
+      },
+      ...providedTestkit,
+    },
     ...extras,
   };
 }
@@ -67,17 +69,6 @@ describe("runner-planning", () => {
           },
         ],
       },
-      testkit: {
-        dependsOn: [],
-        execution: {
-          workers: 1,
-          stackMode: "shared",
-          stackCount: 1,
-        },
-        serviceExecution: {
-          suites: [],
-        },
-      },
     });
 
     expect(collectSuites(config, ["int"], [], [])[0]).toMatchObject({
@@ -122,15 +113,6 @@ describe("runner-planning", () => {
         ],
       },
       testkit: {
-        dependsOn: [],
-        execution: {
-          workers: 1,
-          stackMode: "shared",
-          stackCount: 1,
-        },
-        serviceExecution: {
-          suites: [],
-        },
         skip: {
           fileReasonByPath: new Map([
             ["__testkit__/billing/a.int.testkit.ts", "Billing is stubbed"],
@@ -153,21 +135,9 @@ describe("runner-planning", () => {
         totalFileCount: 2,
       }),
     ]);
-
-    expect(collectSuites(config, ["int"], [], [], { ignoreSkipRules: true })).toEqual([
-      expect.objectContaining({
-        name: "billing",
-        files: [
-          "__testkit__/billing/a.int.testkit.ts",
-          "__testkit__/billing/b.int.testkit.ts",
-        ],
-        skippedFiles: [],
-        totalFileCount: 2,
-      }),
-    ]);
   });
 
-  it("applies file-level stack isolation overrides within the same suite", () => {
+  it("applies lock requirements to matching suites and files", () => {
     const api = makeConfig("api", {
       suites: {
         integration: [
@@ -180,28 +150,30 @@ describe("runner-planning", () => {
             ],
             orderIndex: 0,
             weight: 2,
-            maxFileConcurrency: 1,
           },
         ],
       },
       testkit: {
-        execution: {
-          workers: 8,
-          stackMode: "shared",
-          stackCount: 1,
+        runtime: {
+          instances: 3,
         },
-        serviceExecution: {
-          suites: [],
+        requirements: {
+          suites: [
+            {
+              selector: { kind: "typed", type: "int", name: "routes", raw: "int:routes" },
+              locks: ["suite-lock"],
+            },
+          ],
           files: [
             {
               path: "src/api/routes/__testkit__/crawls-worker-concurrency.int.testkit.ts",
-              stackMode: "isolated",
+              locks: ["worker-loop"],
             },
           ],
-          fileStackModeByPath: new Map([
+          fileLocksByPath: new Map([
             [
               "src/api/routes/__testkit__/crawls-worker-concurrency.int.testkit.ts",
-              "isolated",
+              ["worker-loop"],
             ],
           ]),
         },
@@ -239,21 +211,33 @@ describe("runner-planning", () => {
       expect.arrayContaining([
         expect.objectContaining({
           file: "src/api/routes/__testkit__/health.int.testkit.ts",
-          stackMode: "shared",
-          accessMode: "shared",
+          locks: ["suite-lock"],
         }),
         expect.objectContaining({
           file: "src/api/routes/__testkit__/crawls-worker-concurrency.int.testkit.ts",
-          stackMode: "isolated",
-          accessMode: "exclusive",
+          locks: ["suite-lock", "worker-loop"],
         }),
       ])
     );
   });
 
-  it("applies shards, builds graphs, queues tasks, and claims batches", () => {
-    const api = makeConfig("api");
-    const frontend = makeConfig("frontend");
+  it("builds exact runtime graphs and claims single file tasks", () => {
+    const api = makeConfig("api", {
+      testkit: {
+        runtime: {
+          instances: 2,
+        },
+      },
+    });
+    const frontend = makeConfig("frontend", {
+      dependsOn: ["api"],
+      testkit: {
+        runtime: {
+          instances: 1,
+        },
+      },
+    });
+
     const plans = [
       {
         config: api,
@@ -269,9 +253,6 @@ describe("runner-planning", () => {
             files: ["a.js", "b.js"],
             orderIndex: 0,
             weight: 2,
-            maxFileConcurrency: 2,
-            stackMode: "isolated",
-            accessMode: "exclusive",
           },
         ],
       },
@@ -286,12 +267,9 @@ describe("runner-planning", () => {
             name: "auth",
             type: "e2e",
             framework: "playwright",
-            files: ["auth.spec.js", "signup.spec.js"],
+            files: ["auth.spec.js"],
             orderIndex: 0,
-            weight: 2,
-            maxFileConcurrency: 1,
-            stackMode: "isolated",
-            accessMode: "exclusive",
+            weight: 1,
           },
         ],
       },
@@ -300,112 +278,30 @@ describe("runner-planning", () => {
     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(graphs).toEqual([
+      expect.objectContaining({
+        key: "api",
+        instanceCount: 2,
+        targetNames: ["api"],
+      }),
+      expect.objectContaining({
+        key: "api|frontend",
+        instanceCount: 1,
+        targetNames: ["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(1);
-    expect(firstBatch.framework).toBe("playwright");
-    expect(firstBatch.accessMode).toBe("exclusive");
-
-    const secondBatch = claimNextBatch(queue, "api|frontend");
-    expect(secondBatch.tasks).toHaveLength(1);
-    expect(secondBatch.framework).toBe("playwright");
-
-    const thirdBatch = claimNextBatch(queue, "api|frontend");
-    expect(thirdBatch.tasks).toHaveLength(2);
-    expect(thirdBatch.framework).toBe("k6");
-  });
-
-  it("allows Playwright suites to opt into bounded multi-file batches", () => {
-    const frontend = makeConfig("frontend");
-    const plans = [
-      {
-        config: frontend,
-        skipped: false,
-        runtimeConfigs: [frontend],
-        runtimeNames: ["frontend"],
-        runtimeKey: "frontend",
-        suites: [
-          {
-            name: "auth",
-            type: "e2e",
-            framework: "playwright",
-            files: ["a.spec.js", "b.spec.js", "c.spec.js"],
-            orderIndex: 0,
-            weight: 3,
-            maxFileConcurrency: 2,
-            stackMode: "isolated",
-            accessMode: "exclusive",
-          },
-        ],
-      },
-    ];
-
-    const graphs = buildRuntimeGraphs(plans);
-    const queue = buildTaskQueue(plans, graphs, { files: {} });
-
-    const firstBatch = claimNextBatch(queue, "frontend");
-    expect(firstBatch.tasks.map((task) => task.file)).toEqual(["a.spec.js", "b.spec.js"]);
-    expect(firstBatch.tasks).toHaveLength(2);
-    expect(firstBatch.framework).toBe("playwright");
-
-    const secondBatch = claimNextBatch(queue, "frontend");
-    expect(secondBatch.tasks).toHaveLength(1);
-    expect(secondBatch.framework).toBe("playwright");
-  });
-
-  it("applies typed suite execution rules from config", () => {
-    const config = makeConfig("api", {
-      suites: {
-        integration: [{ name: "health", files: ["__testkit__/health/health.int.testkit.ts"] }],
-      },
-      testkit: {
-        dependsOn: [],
-        execution: {
-          workers: 8,
-          stackMode: "shared",
-          stackCount: 1,
-        },
-        serviceExecution: {
-          suites: [{ selector: { kind: "typed", type: "int", name: "health", raw: "int:health" }, stackMode: "isolated" }],
-        },
-      },
+    expect(queue).toHaveLength(3);
+    expect(claimNextTask(queue, "api|frontend")).toMatchObject({
+      framework: "playwright",
+      graphKey: "api|frontend",
+      file: "auth.spec.js",
     });
-
-    const graphs = buildRuntimeGraphs([
-      {
-        config,
-        skipped: false,
-        runtimeConfigs: [config],
-        runtimeNames: ["api"],
-        runtimeKey: "api",
-        suites: collectSuites(config, ["int"], [], []),
-      },
-    ]);
-    const queue = buildTaskQueue(
-      [
-        {
-          config,
-          skipped: false,
-          runtimeConfigs: [config],
-          runtimeNames: ["api"],
-          runtimeKey: "api",
-          assignedGraphKey: "api",
-          suites: collectSuites(config, ["int"], [], []),
-        },
-      ],
-      graphs,
-      { files: {} }
-    );
-
-    expect(queue[0]).toMatchObject({
-      stackMode: "isolated",
-      accessMode: "exclusive",
+    expect(claimNextTask(queue, "api")).toMatchObject({
+      framework: "k6",
+      graphKey: "api",
     });
   });
 });

package/lib/runner/playwright-config.mjs

@@ -3,8 +3,14 @@ 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");
+export function ensurePlaywrightTestConfig(targetConfig, cwd, requestedFiles, lease) {
+  if (!lease?.leaseDir) {
+    throw new Error(
+      `Playwright task for service "${targetConfig.name}" requires a lease-scoped directory`
+    );
+  }
+
+  const stateDir = lease.leaseDir;
   const outputDir = resolvePlaywrightOutputDir(stateDir);
   fs.mkdirSync(stateDir, { recursive: true });
   fs.mkdirSync(outputDir, { recursive: true });

package/lib/runner/playwright-config.test.mjs

@@ -24,9 +24,9 @@ function makeTempDir(prefix) {
 }
 
 describe("runner-playwright-config", () => {
-  it("uses a shard-local output directory under the state dir", async () => {
+  it("uses a lease-local output directory under the lease dir", async () => {
     const productDir = makeTempDir("testkit-playwright-product-");
-    const stateDir = path.join(productDir, ".testkit", "stack-3");
+    const leaseDir = path.join(productDir, ".testkit", "leases", "lease-12");
     const cwd = path.join(productDir, "frontend");
     fs.mkdirSync(cwd, { recursive: true });
     fs.writeFileSync(
@@ -35,13 +35,14 @@ describe("runner-playwright-config", () => {
     );
 
     const configPath = ensurePlaywrightTestConfig(
-      { productDir, stateDir },
+      { name: "frontend", productDir, stateDir: path.join(productDir, ".testkit", "frontend") },
       cwd,
-      ["frontend/__testkit__/homepage/homepage.pw.testkit.ts"]
+      ["frontend/__testkit__/homepage/homepage.pw.testkit.ts"],
+      { leaseDir }
     );
     const generated = await import(pathToFileURL(configPath).href + `?t=${Date.now()}`);
 
-    const expectedOutputDir = resolvePlaywrightOutputDir(stateDir);
+    const expectedOutputDir = resolvePlaywrightOutputDir(leaseDir);
     expect(generated.default.outputDir).toBe(expectedOutputDir);
     expect(fs.existsSync(expectedOutputDir)).toBe(true);
     expect(fs.readFileSync(configPath, "utf8")).toContain(
@@ -49,6 +50,20 @@ describe("runner-playwright-config", () => {
     );
   });
 
+  it("requires a lease-scoped directory", () => {
+    const productDir = makeTempDir("testkit-playwright-product-");
+    const cwd = path.join(productDir, "frontend");
+    fs.mkdirSync(cwd, { recursive: true });
+
+    expect(() =>
+      ensurePlaywrightTestConfig(
+        { name: "frontend", productDir, stateDir: path.join(productDir, ".testkit", "frontend") },
+        cwd,
+        ["frontend/__testkit__/homepage/homepage.pw.testkit.ts"]
+      )
+    ).toThrow('Playwright task for service "frontend" requires a lease-scoped directory');
+  });
+
   it("finds a supported playwright config file", () => {
     const cwd = makeTempDir("testkit-playwright-cwd-");
     fs.writeFileSync(path.join(cwd, "playwright.config.ts"), "export default {};\n");