@elench/testkit 0.1.83 → 0.1.85

package/lib/runner/runtime-manager.test.mjs

@@ -1,252 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it } from "vitest";
-import { createRuntimeManager } from "./runtime-manager.mjs";
-
-const cleanups = [];
-
-afterEach(() => {
-  while (cleanups.length > 0) {
-    cleanups.pop()();
-  }
-});
-
-function makeTempDir(prefix) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-  cleanups.push(() => fs.rmSync(dir, { recursive: true, force: true }));
-  return dir;
-}
-
-function makeLifecycle() {
-  return {
-    signal: new AbortController().signal,
-    isStopRequested() {
-      return false;
-    },
-    trackGraphContext() {},
-  };
-}
-
-function makeTask(id, extras = {}) {
-  return {
-    id,
-    graphKey: "api",
-    locks: [],
-    ...extras,
-  };
-}
-
-function makeHooks(events) {
-  return {
-    createRuntimeInstanceContext(runtimeId, graph, productDir) {
-      const runtimeDir = path.join(productDir, ".testkit", "_graphs", graph.dirName, "runtimes", runtimeId);
-      fs.mkdirSync(runtimeDir, { recursive: true });
-      events.created.push(runtimeId);
-      return {
-        graphKey: graph.key,
-        runtimeDir,
-        runtimeId,
-        targetNames: [...graph.targetNames],
-      };
-    },
-    async ensureRuntimeInstanceReady(context) {
-      events.ready.push(context.runtimeId);
-    },
-    async cleanupRuntimeInstanceContext(context) {
-      events.cleaned.push(context.runtimeId);
-      fs.rmSync(context.runtimeDir, { recursive: true, force: true });
-    },
-    async sleep() {
-      await new Promise((resolve) => setTimeout(resolve, 0));
-    },
-  };
-}
-
-describe("runtime-manager", () => {
-  it("spreads concurrent leases across runtime instances", async () => {
-    const productDir = makeTempDir("testkit-runtime-manager-");
-    const events = { created: [], ready: [], cleaned: [] };
-    const manager = createRuntimeManager({
-      productDir,
-      lifecycle: makeLifecycle(),
-      graphs: [
-        {
-          key: "api",
-          dirName: "api",
-          targetNames: ["api"],
-          instanceCount: 2,
-          maxConcurrentTasks: 1,
-        },
-      ],
-      hooks: makeHooks(events),
-    });
-
-    const leaseOne = await manager.acquire(makeTask(1));
-    const leaseTwo = await manager.acquire(makeTask(2));
-
-    expect(leaseOne.slot.runtimeId).toBe("runtime-1");
-    expect(leaseTwo.slot.runtimeId).toBe("runtime-2");
-    expect(events.created).toEqual(["runtime-1", "runtime-2"]);
-
-    await manager.release(leaseOne);
-    await manager.release(leaseTwo);
-    await manager.cleanupAll();
-  });
-
-  it("marks conflicting locks unavailable until the first lease releases", async () => {
-    const productDir = makeTempDir("testkit-runtime-manager-");
-    const manager = createRuntimeManager({
-      productDir,
-      lifecycle: makeLifecycle(),
-      graphs: [
-        {
-          key: "api",
-          dirName: "api",
-          targetNames: ["api"],
-          instanceCount: 1,
-          maxConcurrentTasks: 1,
-        },
-      ],
-      hooks: makeHooks({ created: [], ready: [], cleaned: [] }),
-    });
-
-    const firstLease = await manager.acquire(makeTask(1, { locks: ["shared-lock"] }));
-    expect(manager.canAcquire(makeTask(2, { locks: ["shared-lock"] }))).toBe(false);
-
-    await manager.release(firstLease);
-    const secondLease = await manager.acquire(makeTask(2, { locks: ["shared-lock"] }));
-
-    await manager.release(secondLease);
-    await manager.cleanupAll();
-  });
-
-  it("does not drain an invalidated runtime slot until all active leases release", async () => {
-    const productDir = makeTempDir("testkit-runtime-manager-");
-    const events = { created: [], ready: [], cleaned: [] };
-    const manager = createRuntimeManager({
-      productDir,
-      lifecycle: makeLifecycle(),
-      graphs: [
-        {
-          key: "api",
-          dirName: "api",
-          targetNames: ["api"],
-          instanceCount: 1,
-          maxConcurrentTasks: 2,
-        },
-      ],
-      hooks: makeHooks(events),
-    });
-
-    const leaseOne = await manager.acquire(makeTask(1));
-    const leaseTwo = await manager.acquire(makeTask(2));
-
-    await manager.release(leaseOne, { invalidate: true });
-    expect(events.cleaned).toEqual([]);
-
-    await manager.release(leaseTwo);
-    expect(events.cleaned).toEqual(["runtime-1"]);
-  });
-
-  it("removes lease directories on release", async () => {
-    const productDir = makeTempDir("testkit-runtime-manager-");
-    const manager = createRuntimeManager({
-      productDir,
-      lifecycle: makeLifecycle(),
-      graphs: [
-        {
-          key: "api",
-          dirName: "api",
-          targetNames: ["api"],
-          instanceCount: 1,
-          maxConcurrentTasks: 1,
-        },
-      ],
-      hooks: makeHooks({ created: [], ready: [], cleaned: [] }),
-    });
-
-    const lease = await manager.acquire(makeTask(1));
-    expect(fs.existsSync(lease.leaseDir)).toBe(true);
-
-    await manager.release(lease);
-    expect(fs.existsSync(lease.leaseDir)).toBe(false);
-
-    await manager.cleanupAll();
-  });
-
-  it("exposes runtime capacity through canAcquire", async () => {
-    const productDir = makeTempDir("testkit-runtime-manager-");
-    const manager = createRuntimeManager({
-      productDir,
-      lifecycle: makeLifecycle(),
-      graphs: [
-        {
-          key: "api",
-          dirName: "api",
-          targetNames: ["api"],
-          instanceCount: 1,
-          maxConcurrentTasks: 2,
-        },
-      ],
-      hooks: makeHooks({ created: [], ready: [], cleaned: [] }),
-    });
-
-    expect(manager.canAcquire(makeTask(1))).toBe(true);
-    const leaseOne = await manager.acquire(makeTask(1));
-    expect(manager.canAcquire(makeTask(2))).toBe(true);
-    const leaseTwo = await manager.acquire(makeTask(2));
-    expect(manager.canAcquire(makeTask(3))).toBe(false);
-
-    await manager.release(leaseOne);
-    expect(manager.canAcquire(makeTask(3))).toBe(true);
-    await manager.release(leaseTwo);
-    await manager.cleanupAll();
-  });
-
-  it("blocks a graph after fatal runtime initialization failure and drains remaining tasks", async () => {
-    const productDir = makeTempDir("testkit-runtime-manager-");
-    const manager = createRuntimeManager({
-      productDir,
-      lifecycle: makeLifecycle(),
-      graphs: [
-        {
-          key: "api",
-          dirName: "api",
-          targetNames: ["api"],
-          instanceCount: 1,
-          maxConcurrentTasks: 1,
-        },
-      ],
-      hooks: {
-        ...makeHooks({ created: [], ready: [], cleaned: [] }),
-        async ensureRuntimeInstanceReady() {
-          throw new Error("prepare failed");
-        },
-      },
-    });
-
-    const firstTask = makeTask(1, { file: "tests/a.int.testkit.ts", targetName: "api" });
-    const secondTask = makeTask(2, { file: "tests/b.int.testkit.ts", targetName: "api" });
-
-    await expect(manager.acquire(firstTask)).rejects.toThrow(/prepare failed/);
-    expect(manager.canAcquire(secondTask)).toBe(false);
-
-    const queue = [secondTask];
-    expect(manager.drainFailedTasks(queue)).toEqual([
-      {
-        task: secondTask,
-        reason: "Not run because runtime graph failed to initialize: prepare failed",
-        message: "prepare failed",
-        graph: {
-          key: "api",
-          dirName: "api",
-          targetNames: ["api"],
-          instanceCount: 1,
-          maxConcurrentTasks: 1,
-        },
-      },
-    ]);
-    expect(queue).toEqual([]);
-  });
-});

package/lib/runner/runtime-preparation.test.mjs

@@ -1,141 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it } from "vitest";
-import { prepareRuntimeService } from "./runtime-preparation.mjs";
-import { resolveRuntimeInstanceConfigs } from "./template.mjs";
-
-const tempDirs = [];
-
-afterEach(() => {
-  while (tempDirs.length > 0) {
-    fs.rmSync(tempDirs.pop(), { recursive: true, force: true });
-  }
-});
-
-function makeTempDir(prefix) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-  tempDirs.push(dir);
-  return dir;
-}
-
-function writeFile(filePath, contents) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, contents);
-}
-
-function makeResolvedRuntimeConfig(productDir, prepareConfig) {
-  const rawConfig = {
-    name: "api",
-    productDir,
-    testkit: {
-      envFiles: [],
-      serviceEnv: {},
-      runtime: {
-        instances: 1,
-        maxConcurrentTasks: 1,
-        prepare: prepareConfig,
-      },
-      local: {
-        cwd: ".",
-        start: "node {prepareDir}/server.mjs",
-        port: 3010,
-        baseUrl: "http://127.0.0.1:{port}",
-        readyUrl: "http://127.0.0.1:{port}/health",
-        env: {},
-      },
-    },
-  };
-
-  const runtimeDir = path.join(productDir, ".testkit", "_graphs", "api", "runtimes", "runtime-1");
-  fs.mkdirSync(runtimeDir, { recursive: true });
-  return resolveRuntimeInstanceConfigs([rawConfig], "runtime-1", runtimeDir, {
-    graphDirName: "api",
-    portNamespaceIndex: 0,
-    portNamespaceStride: 1,
-  })[0];
-}
-
-describe("runtime preparation", () => {
-  it("runs prepare steps once and reuses the manifest until inputs change", async () => {
-    const productDir = makeTempDir("testkit-runtime-prepare-");
-    writeFile(path.join(productDir, "src", "message.txt"), "hello one\n");
-    writeFile(
-      path.join(productDir, "scripts", "prepare.mjs"),
-      [
-        'import fs from "fs";',
-        'import path from "path";',
-        'const prepareDir = process.argv[2];',
-        'const productDir = process.cwd();',
-        'const message = fs.readFileSync(path.join(productDir, "src", "message.txt"), "utf8").trim();',
-        'const counterDir = path.join(productDir, ".runtime", "prepared");',
-        'const counterFile = path.join(counterDir, "build-count.txt");',
-        'const current = fs.existsSync(counterFile) ? Number.parseInt(fs.readFileSync(counterFile, "utf8"), 10) || 0 : 0;',
-        'fs.mkdirSync(counterDir, { recursive: true });',
-        'fs.mkdirSync(prepareDir, { recursive: true });',
-        'fs.writeFileSync(counterFile, `${current + 1}\\n`);',
-        'fs.writeFileSync(path.join(prepareDir, "message.txt"), `${message}\\n`);',
-      ].join("\n")
-    );
-
-    const config = makeResolvedRuntimeConfig(productDir, {
-      inputs: ["src/message.txt"],
-      steps: [
-        {
-          kind: "command",
-          cmd: "node scripts/prepare.mjs {prepareDir}",
-        },
-      ],
-    });
-
-    await prepareRuntimeService(config);
-    expect(
-      fs.readFileSync(path.join(productDir, ".runtime", "prepared", "build-count.txt"), "utf8").trim()
-    ).toBe("1");
-    expect(fs.readFileSync(path.join(config.testkit.prepareDir, "message.txt"), "utf8").trim()).toBe(
-      "hello one"
-    );
-
-    await prepareRuntimeService(config);
-    expect(
-      fs.readFileSync(path.join(productDir, ".runtime", "prepared", "build-count.txt"), "utf8").trim()
-    ).toBe("1");
-
-    fs.writeFileSync(path.join(productDir, "src", "message.txt"), "hello two\n");
-    await prepareRuntimeService(config);
-    expect(
-      fs.readFileSync(path.join(productDir, ".runtime", "prepared", "build-count.txt"), "utf8").trim()
-    ).toBe("2");
-    expect(fs.readFileSync(path.join(config.testkit.prepareDir, "message.txt"), "utf8").trim()).toBe(
-      "hello two"
-    );
-  });
-
-  it("cleans incomplete prepared output when a prepare step fails", async () => {
-    const productDir = makeTempDir("testkit-runtime-prepare-fail-");
-    writeFile(
-      path.join(productDir, "scripts", "prepare-fail.mjs"),
-      [
-        'import fs from "fs";',
-        'import path from "path";',
-        'const prepareDir = process.argv[2];',
-        'fs.mkdirSync(prepareDir, { recursive: true });',
-        'fs.writeFileSync(path.join(prepareDir, "partial.txt"), "partial\\n");',
-        'throw new Error("prepare failed");',
-      ].join("\n")
-    );
-
-    const config = makeResolvedRuntimeConfig(productDir, {
-      steps: [
-        {
-          kind: "command",
-          cmd: "node scripts/prepare-fail.mjs {prepareDir}",
-        },
-      ],
-    });
-
-    await expect(prepareRuntimeService(config)).rejects.toThrow("Command failed with exit code 1");
-    expect(fs.existsSync(config.testkit.prepareDir)).toBe(false);
-    expect(fs.existsSync(path.join(productDir, ".testkit", "_graphs", "api", "runtimes", "runtime-1", "services", "api", "prepared", "prepare-manifest.json"))).toBe(false);
-  });
-});

package/lib/runner/selection.test.mjs

@@ -1,24 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { findUnmatchedRequestedFiles, isFullRunSelection } from "./selection.mjs";
-
-describe("runner selection", () => {
-  it("finds unmatched requested files", () => {
-    const unmatched = findUnmatchedRequestedFiles(
-      [{ name: "api" }],
-      ["int"],
-      [],
-      ["tests/a.int.testkit.ts", "tests/missing.int.testkit.ts"],
-      () => [{ files: ["tests/a.int.testkit.ts"] }],
-      (value) => value
-    );
-
-    expect(unmatched).toEqual(["tests/missing.int.testkit.ts"]);
-  });
-
-  it("detects a full run selection", () => {
-    expect(isFullRunSelection(["all"], [], [], null, null)).toBe(true);
-    expect(isFullRunSelection(["all"], [{ raw: "auth" }], [], null, null)).toBe(false);
-    expect(isFullRunSelection(["all"], [], ["a"], null, null)).toBe(false);
-    expect(isFullRunSelection(["int"], [], [], null, null)).toBe(false);
-  });
-});

package/lib/runner/setup-operations.test.mjs

@@ -1,94 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it } from "vitest";
-import { createRunLogRegistry } from "./logs.mjs";
-import { createSetupOperationRegistry } from "./setup-operations.mjs";
-
-const tempDirs = [];
-
-afterEach(() => {
-  while (tempDirs.length > 0) {
-    fs.rmSync(tempDirs.pop(), { recursive: true, force: true });
-  }
-});
-
-function makeTempDir(prefix) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-  tempDirs.push(dir);
-  return dir;
-}
-
-function makeConfig(productDir) {
-  return {
-    name: "api",
-    runtimeLabel: "api",
-    productDir,
-  };
-}
-
-describe("setup operation registry", () => {
-  it("tracks running and finished setup operations with log refs", () => {
-    const productDir = makeTempDir("testkit-setup-ops-");
-    const logRegistry = createRunLogRegistry(productDir);
-    const changes = [];
-    const registry = createSetupOperationRegistry({
-      logRegistry,
-      onChange(operations) {
-        changes.push(operations);
-      },
-    });
-
-    const operation = registry.start({
-      config: makeConfig(productDir),
-      stage: "template:migrate:api:1",
-      kind: "setup-step",
-      summary: "command: node scripts/migrate.mjs",
-    });
-
-    expect(operation.logRef).toMatchObject({
-      path: ".testkit/results/setup/api__api__template-migrate-api-1.log",
-      stage: "template:migrate:api:1",
-    });
-
-    const finished = registry.finish(operation, {
-      status: "passed",
-      summary: "command: node scripts/migrate.mjs",
-    });
-
-    expect(finished.status).toBe("passed");
-    expect(finished.durationMs).toBeGreaterThanOrEqual(0);
-    expect(registry.listOperations()).toEqual([
-      expect.objectContaining({
-        stage: "template:migrate:api:1",
-        kind: "setup-step",
-        status: "passed",
-        summary: "command: node scripts/migrate.mjs",
-        logRef: operation.logRef,
-      }),
-    ]);
-    expect(changes).toHaveLength(2);
-
-    logRegistry.closeAll();
-  });
-
-  it("records cached setup operations without logs", () => {
-    const productDir = makeTempDir("testkit-setup-ops-cached-");
-    const registry = createSetupOperationRegistry();
-
-    const operation = registry.recordCached({
-      config: makeConfig(productDir),
-      stage: "template",
-      kind: "database-template",
-      summary: "template cache hit",
-    });
-
-    expect(operation).toMatchObject({
-      stage: "template",
-      kind: "database-template",
-      status: "cached",
-      summary: "template cache hit",
-      logRef: null,
-    });
-  });
-});

package/lib/runner/state.test.mjs

@@ -1,62 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it } from "vitest";
-import {
-  findGraphDirsForService,
-  findRuntimeStateDirs,
-  normalizePathSeparators,
-  readGraphMetadata,
-  writeGraphMetadata,
-} from "./state.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-state-"));
-  tempDirs.push(dir);
-  return dir;
-}
-
-describe("runner-state", () => {
-  it("finds runtime state directories", () => {
-    const rootDir = mkTempDir();
-    const deep = path.join(rootDir, "workers", "w1", "deps", "api");
-    fs.mkdirSync(deep, { recursive: true });
-    fs.writeFileSync(path.join(rootDir, "workers", "database_backend"), "local");
-    fs.writeFileSync(path.join(deep, "database_backend"), "local");
-
-    const found = findRuntimeStateDirs(
-      rootDir,
-      (dir) => fs.existsSync(path.join(dir, "database_backend"))
-    );
-
-    expect(found).toEqual([
-      deep,
-      path.join(rootDir, "workers"),
-    ]);
-  });
-
-  it("writes, reads, and finds graph metadata", () => {
-    const productDir = mkTempDir();
-    const graphDir = path.join(productDir, ".testkit", "_graphs", "api__frontend");
-    writeGraphMetadata(graphDir, {
-      runtimeNames: ["api", "frontend"],
-      targetNames: ["frontend", "api"],
-    });
-
-    expect(readGraphMetadata(graphDir)).toEqual({
-      runtimeServices: ["api", "frontend"],
-      targetServices: ["api", "frontend"],
-    });
-
-    expect(findGraphDirsForService(productDir, "frontend")).toEqual([graphDir]);
-    expect(normalizePathSeparators(`a${path.sep}b${path.sep}c`)).toBe("a/b/c");
-  });
-});

package/lib/runner/suite-selection.test.mjs

@@ -1,49 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  isAllTypeSelection,
-  matchesSelectedTypes,
-  matchesSuiteSelectors,
-  normalizeTypeValues,
-  parseSuiteSelectors,
-  suiteSelectionType,
-} from "./suite-selection.mjs";
-
-describe("runner suite selection", () => {
-  it("normalizes selected type values", () => {
-    expect(normalizeTypeValues([])).toEqual(["all"]);
-    expect(normalizeTypeValues(["int,e2e,scenario", "dal"])).toEqual([
-      "int",
-      "e2e",
-      "scenario",
-      "dal",
-    ]);
-    expect(() => normalizeTypeValues(["all", "int"])).toThrow("cannot be combined");
-    expect(() => normalizeTypeValues(["jest"])).toThrow("Unknown type");
-  });
-
-  it("parses suite selectors", () => {
-    expect(parseSuiteSelectors(["auth,scenario:journeys,dal:queries"])).toEqual([
-      { kind: "plain", name: "auth", raw: "auth" },
-      { kind: "typed", type: "scenario", name: "journeys", raw: "scenario:journeys" },
-      { kind: "typed", type: "dal", name: "queries", raw: "dal:queries" },
-    ]);
-    expect(() => parseSuiteSelectors(["all:auth"])).toThrow("Unknown suite selector type");
-    expect(() => parseSuiteSelectors(["int:"])).toThrow("Invalid suite selector");
-  });
-
-  it("matches suite types and selectors", () => {
-    expect(isAllTypeSelection(["all"])).toBe(true);
-    expect(matchesSelectedTypes("int", ["int", "dal"])).toBe(true);
-    expect(matchesSelectedTypes("pw", ["int", "dal"])).toBe(false);
-    expect(matchesSuiteSelectors("int", "auth", parseSuiteSelectors(["auth"]))).toBe(true);
-    expect(matchesSuiteSelectors("e2e", "auth", parseSuiteSelectors(["int:auth"]))).toBe(false);
-    expect(matchesSuiteSelectors("int", "auth", parseSuiteSelectors(["int:auth"]))).toBe(true);
-  });
-
-  it("maps discovered suites to user-facing selection types", () => {
-    expect(suiteSelectionType("integration", "k6")).toBe("int");
-    expect(suiteSelectionType("scenario", "k6")).toBe("scenario");
-    expect(suiteSelectionType("e2e", "playwright")).toBe("pw");
-    expect(suiteSelectionType("dal", "k6")).toBe("dal");
-  });
-});