@elench/testkit 0.1.37 → 0.1.39

package/lib/runner/template.test.mjs

@@ -1,15 +1,18 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
 import { describe, expect, it } from "vitest";
 import {
   buildExecutionEnv,
   buildPlaywrightEnv,
   buildPortMap,
   finalizeString,
-  getWorkerServiceStateDir,
+  getStackServiceStateDir,
   normalizeSocketHost,
   numericPortFromUrl,
   resolveServiceStateDir,
+  resolveStackRuntimeConfigs,
   resolveTemplateString,
-  resolveWorkerRuntimeConfigs,
   rewriteUrlPort,
   socketFromUrl,
 } from "./template.mjs";
@@ -34,7 +37,7 @@ describe("runner-template", () => {
       makeRuntimeConfig("frontend", { port: 3001, baseUrl: "http://127.0.0.1:{port}" }),
     ];
 
-    expect([...buildPortMap(configs, 2).entries()]).toEqual([
+    expect([...buildPortMap(configs, "stack-2").entries()]).toEqual([
       ["api", 3100],
       ["frontend", 3101],
     ]);
@@ -45,14 +48,22 @@ describe("runner-template", () => {
           makeRuntimeConfig("api", { port: 3000, baseUrl: "http://127.0.0.1:{port}" }),
           makeRuntimeConfig("other", { port: 3000, baseUrl: "http://127.0.0.1:{port}" }),
         ],
-        1
+        "shared"
       )
-    ).toThrow("Worker port collision");
+    ).toThrow("Stack port collision");
   });
 
   it("resolves template strings and URL rewrites", () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-template-"));
+    const apiStateDir = path.join(tmpDir, "api");
+    fs.mkdirSync(apiStateDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(apiStateDir, "database_url"),
+      "postgres://testkit:testkit@127.0.0.1:55432/onix_db"
+    );
+
     const context = {
-      workerId: 2,
+      stackId: "stack-2",
       targetName: "frontend",
       serviceName: "frontend",
       serviceStateDir: "/tmp/state",
@@ -62,11 +73,17 @@ describe("runner-template", () => {
       ]),
       baseUrlByService: new Map([["api", "http://127.0.0.1:3100"]]),
       readyUrlByService: new Map([["api", "http://127.0.0.1:3100/health"]]),
+      stateDirByService: new Map([["api", apiStateDir]]),
       urlMappings: [["http://api:3000", "http://127.0.0.1:3100"]],
     };
 
-    expect(resolveTemplateString("{worker}:{target}:{service}", context)).toBe("2:frontend:frontend");
+    expect(resolveTemplateString("{stack}:{target}:{service}", context)).toBe(
+      "stack-2:frontend:frontend"
+    );
     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/onix_db"
+    );
     expect(finalizeString("API={baseUrl:api} OLD=http://api:3000", context)).toBe(
       "API=http://127.0.0.1:3100 OLD=http://127.0.0.1:3100"
     );
@@ -75,21 +92,26 @@ describe("runner-template", () => {
     );
   });
 
-  it("builds worker runtime configs and execution env", () => {
-    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: {
-        PORT: "{port}",
-      },
-    }, {
-      serviceEnv: {
-        API_KEY: "secret",
+  it("builds stack runtime configs and execution env", () => {
+    const stackStateDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-stack-"));
+    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: {
+          PORT: "{port}",
+        },
       },
-    });
+      {
+        serviceEnv: {
+          API_KEY: "secret",
+        },
+      }
+    );
     const frontend = makeRuntimeConfig("frontend", {
       cwd: "frontend",
       start: "npm run web",
@@ -98,26 +120,29 @@ describe("runner-template", () => {
       readyUrl: "http://127.0.0.1:{port}",
       env: {
         NEXT_PUBLIC_API_URL: "{baseUrl:api}",
+        ONIX_DB_HOST: "{dbHost:api}",
       },
     });
 
-    const resolved = resolveWorkerRuntimeConfigs(frontend, [api, frontend], 2, "/tmp/w2");
+    const resolved = resolveStackRuntimeConfigs(frontend, [api, frontend], "stack-2", stackStateDir);
     expect(resolved[0].testkit.local.port).toBe(3100);
-    expect(resolved[1].testkit.local.env.NEXT_PUBLIC_API_URL).toBe("http://127.0.0.1:3100");
-    expect(resolveServiceStateDir("/tmp/w2", "frontend", api)).toBe("/tmp/w2/deps/api");
-    expect(getWorkerServiceStateDir("/tmp/w2", "frontend", "frontend")).toBe("/tmp/w2");
+    expect(resolved[1].testkit.local.env.NEXT_PUBLIC_API_URL).toBe("{baseUrl:api}");
+    expect(resolveServiceStateDir(stackStateDir, "frontend", api)).toBe(
+      `${stackStateDir}/deps/api`
+    );
+    expect(getStackServiceStateDir(stackStateDir, "frontend", "frontend")).toBe(stackStateDir);
+
+    fs.mkdirSync(path.join(stackStateDir, "deps", "api"), { recursive: true });
+    fs.writeFileSync(
+      path.join(stackStateDir, "deps", "api", "database_url"),
+      "postgres://testkit:testkit@127.0.0.1:55432/onix_db"
+    );
 
     expect(
       buildExecutionEnv(
+        resolved[1],
         {
-          workerId: 2,
-          testkit: {
-            serviceEnv: {
-              API_KEY: "secret",
-            },
-          },
-        },
-        {
+          ...resolved[1].testkit.local.env,
           DATABASE_URL: "gone",
         },
         {
@@ -126,17 +151,19 @@ describe("runner-template", () => {
       )
     ).toEqual({
       PATH: "/usr/bin",
-      API_KEY: "secret",
+      NEXT_PUBLIC_API_URL: "http://127.0.0.1:3100",
+      ONIX_DB_HOST: "127.0.0.1",
       TESTKIT_ACTIVE: "1",
-      TESTKIT_WORKER_ID: "2",
+      TESTKIT_STACK_ID: "stack-2",
     });
 
-    expect(buildPlaywrightEnv({ workerId: 3, testkit: { serviceEnv: {} } }, "http://localhost:3000", {}))
-      .toMatchObject({
-        BASE_URL: "http://localhost:3000",
-        TESTKIT_WORKER_ID: "3",
-        PLAYWRIGHT_HTML_OPEN: "never",
-      });
+    expect(
+      buildPlaywrightEnv({ stackId: "shared", testkit: { serviceEnv: {} } }, "http://localhost:3000", {})
+    ).toMatchObject({
+      BASE_URL: "http://localhost:3000",
+      TESTKIT_STACK_ID: "shared",
+      PLAYWRIGHT_HTML_OPEN: "never",
+    });
   });
 
   it("parses runtime sockets", () => {

package/lib/runner/worker-loop.mjs

@@ -1,11 +1,6 @@
 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"]);
 
@@ -14,7 +9,6 @@ export function createWorker(workerId, productDir) {
     workerId,
     productDir,
     currentGraphKey: null,
-    graphContexts: new Map(),
     graphSwitches: 0,
     taskCount: 0,
   };
@@ -23,7 +17,7 @@ export function createWorker(workerId, productDir) {
 export async function runWorker(
   worker,
   queue,
-  graphByKey,
+  stackManager,
   trackers,
   timingUpdates,
   lifecycle,
@@ -32,7 +26,7 @@ export async function runWorker(
   recordGraphError
 ) {
   const startedAt = Date.now();
-  console.log(`\n══ global worker ${worker.workerId} ══`);
+  console.log(`\n══ worker ${worker.workerId} ══`);
   const errors = [];
 
   try {
@@ -41,9 +35,14 @@ export async function runWorker(
       const batch = claimNextBatch(queue, worker.currentGraphKey);
       if (!batch) break;
 
+      let lease = null;
       try {
-        const context = await ensureWorkerGraph(worker, batch, graphByKey, lifecycle);
-        const outcomes = await runBatch(context, batch, lifecycle);
+        if (worker.currentGraphKey && worker.currentGraphKey !== batch.graphKey) {
+          worker.graphSwitches += 1;
+        }
+        worker.currentGraphKey = batch.graphKey;
+        lease = await stackManager.acquire(batch);
+        const outcomes = await runBatch(lease.context, batch, lifecycle);
         for (const outcome of outcomes) {
           recordTaskOutcome(trackers, outcome.task, outcome);
           timingUpdates.push({
@@ -52,15 +51,19 @@ export async function runWorker(
           });
           worker.taskCount += 1;
         }
+        await stackManager.release(lease, { accessMode: batch.accessMode });
       } catch (error) {
         const message = formatError(error);
         errors.push(message);
-        recordGraphError(trackers, graphByKey.get(batch.graphKey), message);
-        await resetCurrentGraph(worker, lifecycle);
+        recordGraphError(trackers, { assignedTargets: lease?.context?.assignedTargets || [batch.targetName] }, message);
+        await stackManager.release(lease, {
+          accessMode: batch.accessMode,
+          invalidate: lease !== null,
+        });
       }
     }
   } finally {
-    await cleanupWorker(worker, lifecycle);
+    worker.currentGraphKey = null;
   }
 
   return {
@@ -76,7 +79,7 @@ export async function runWorker(
 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}"`);
+    throw new Error(`Stack is missing target config "${batch.targetName}"`);
   }
 
   if (batch.framework === "playwright") {

package/lib/setup/index.d.ts

@@ -33,6 +33,27 @@ export interface SkipConfig {
   suites?: SkipSuiteRule[];
 }
 
+export interface SuiteExecutionRule {
+  selector: string;
+  stackMode: "shared" | "pooled" | "isolated";
+}
+
+export interface FileExecutionRule {
+  path: string;
+  stackMode: "shared" | "pooled" | "isolated";
+}
+
+export interface ServiceExecutionConfig {
+  suites?: SuiteExecutionRule[];
+  files?: FileExecutionRule[];
+}
+
+export interface TestkitExecutionConfig {
+  workers?: number;
+  stackMode?: "shared" | "pooled" | "isolated";
+  stackCount?: number;
+}
+
 export interface ServiceConfig {
   database?: LocalDatabaseConfig;
   databaseFrom?: string;
@@ -40,9 +61,10 @@ export interface ServiceConfig {
   discovery?: {
     roots?: string[];
   };
+  env?: Record<string, string>;
   envFile?: string;
   envFiles?: string[];
-  local?: {
+  local?: false | {
     baseUrl: string;
     cwd?: string;
     env?: Record<string, string>;
@@ -54,9 +76,11 @@ export interface ServiceConfig {
   migrate?: LifecycleConfig;
   seed?: LifecycleConfig;
   skip?: SkipConfig;
+  execution?: ServiceExecutionConfig;
 }
 
 export interface TestkitSetup {
+  execution?: TestkitExecutionConfig;
   profiles?: {
     http?: Record<string, HttpSuiteConfig>;
   };

package/package.json

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