@elench/testkit 0.1.40 → 0.1.41

package/lib/setup/index.d.ts

@@ -2,6 +2,7 @@ import type { AuthAdapter, HeaderBuilder, HttpSuiteConfig } from "../index";
 
 export interface LocalDatabaseConfig {
   provider: "local";
+  binding?: "shared" | "per-runtime";
   image?: string;
   password?: string;
   reset?: boolean;
@@ -33,26 +34,28 @@ export interface SkipConfig {
   suites?: SkipSuiteRule[];
 }
 
-export interface SuiteExecutionRule {
+export interface RuntimeConfig {
+  instances?: number;
+}
+
+export interface SuiteRequirementRule {
   selector: string;
-  stackMode: "shared" | "pooled" | "isolated";
+  locks?: string[];
 }
 
-export interface FileExecutionRule {
+export interface FileRequirementRule {
   path: string;
-  stackMode: "shared" | "pooled" | "isolated";
+  locks?: string[];
 }
 
-export interface ServiceExecutionConfig {
-  suites?: SuiteExecutionRule[];
-  files?: FileExecutionRule[];
+export interface ServiceRequirementConfig {
+  suites?: SuiteRequirementRule[];
+  files?: FileRequirementRule[];
 }
 
 export interface TestkitExecutionConfig {
   workers?: number;
   fileTimeoutSeconds?: number;
-  stackMode?: "shared" | "pooled" | "isolated";
-  stackCount?: number;
 }
 
 export interface ServiceConfig {
@@ -76,8 +79,9 @@ export interface ServiceConfig {
   };
   migrate?: LifecycleConfig;
   seed?: LifecycleConfig;
+  runtime?: RuntimeConfig;
+  requirements?: ServiceRequirementConfig;
   skip?: SkipConfig;
-  execution?: ServiceExecutionConfig;
 }
 
 export interface TestkitSetup {

package/package.json

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

package/lib/runner/stack-manager.mjs

@@ -1,146 +0,0 @@
-import { buildStackIds } from "./execution-config.mjs";
-import {
-  cleanupStackContext,
-  createStackContext,
-  ensureStackContextReady,
-} from "./runtime-contexts.mjs";
-
-export function createStackManager({ productDir, graphs, execution, lifecycle }) {
-  const graphByKey = new Map(graphs.map((graph) => [graph.key, graph]));
-  const pools = new Map();
-
-  return {
-    async acquire(batch) {
-      const pool = getPool(pools, graphByKey, batch, execution, productDir, lifecycle);
-      while (true) {
-        if (lifecycle.isStopRequested()) {
-          throw lifecycle.signal.reason || new Error("testkit run interrupted");
-        }
-
-        const slot = claimSlot(pool, batch.accessMode);
-        if (!slot) {
-          await sleep(25);
-          continue;
-        }
-
-        try {
-          const context = await getReadyContext(slot, graphByKey, productDir, batch, lifecycle);
-          return {
-            slot,
-            context,
-          };
-        } catch (error) {
-          releaseSlot(slot, batch.accessMode);
-          await invalidateSlot(slot, lifecycle);
-          throw error;
-        }
-      }
-    },
-    async release(lease, options = {}) {
-      if (!lease?.slot) return;
-      releaseSlot(lease.slot, options.accessMode || lease.slot.lastAccessMode);
-      if (options.invalidate) {
-        await invalidateSlot(lease.slot, lifecycle);
-      }
-    },
-    async cleanupAll() {
-      for (const pool of pools.values()) {
-        for (const slot of pool.slots) {
-          await invalidateSlot(slot, lifecycle);
-        }
-      }
-    },
-  };
-}
-
-function getPool(pools, graphByKey, batch, execution, productDir, lifecycle) {
-  const key = `${batch.graphKey}:${batch.stackMode}`;
-  const existing = pools.get(key);
-  if (existing) return existing;
-
-  const graph = graphByKey.get(batch.graphKey);
-  if (!graph) {
-    throw new Error(`Unknown graph "${batch.graphKey}"`);
-  }
-
-  const slots = buildPoolStackIds(batch.stackMode, execution).map((stackId) => ({
-    graph,
-    stackId,
-    context: null,
-    activeSharedCount: 0,
-    exclusiveActive: false,
-    lastAccessMode: null,
-    contextPromise: null,
-  }));
-  const pool = {
-    productDir,
-    lifecycle,
-    slots,
-  };
-  pools.set(key, pool);
-  return pool;
-}
-
-function buildPoolStackIds(stackMode, execution) {
-  if (stackMode === "isolated") {
-    return Array.from({ length: execution.workers }, (_unused, index) => `isolated-${index + 1}`);
-  }
-  if (stackMode === "shared") {
-    return ["shared"];
-  }
-  return buildStackIds({
-    stackMode: "pooled",
-    stackCount: execution.stackCount,
-  });
-}
-
-function claimSlot(pool, accessMode) {
-  if (accessMode === "shared") {
-    const candidates = pool.slots.filter((slot) => !slot.exclusiveActive);
-    if (candidates.length === 0) return null;
-    const slot = [...candidates].sort((left, right) => left.activeSharedCount - right.activeSharedCount)[0];
-    slot.activeSharedCount += 1;
-    slot.lastAccessMode = "shared";
-    return slot;
-  }
-
-  const slot = pool.slots.find((candidate) => !candidate.exclusiveActive && candidate.activeSharedCount === 0);
-  if (!slot) return null;
-  slot.exclusiveActive = true;
-  slot.lastAccessMode = "exclusive";
-  return slot;
-}
-
-async function getReadyContext(slot, graphByKey, productDir, batch, lifecycle) {
-  if (!slot.context) {
-    slot.context = createStackContext(slot.stackId, slot.graph, productDir);
-    lifecycle.trackGraphContext(slot.context);
-  }
-  if (!slot.contextPromise) {
-    slot.contextPromise = Promise.resolve(slot.context);
-  }
-  await slot.contextPromise;
-  await ensureStackContextReady(slot.context, batch, lifecycle);
-  return slot.context;
-}
-
-function releaseSlot(slot, accessMode) {
-  if (accessMode === "shared") {
-    slot.activeSharedCount = Math.max(0, slot.activeSharedCount - 1);
-    return;
-  }
-  slot.exclusiveActive = false;
-}
-
-async function invalidateSlot(slot, lifecycle) {
-  if (!slot.context) return;
-  await cleanupStackContext(slot.context, lifecycle);
-  slot.context = null;
-  slot.contextPromise = null;
-  slot.activeSharedCount = 0;
-  slot.exclusiveActive = false;
-}
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}