@elench/testkit 0.1.83 → 0.1.85

package/lib/runner/planning.test.mjs

@@ -1,371 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  applyShard,
-  buildGraphDirName,
-  buildRuntimeGraphs,
-  buildTaskQueue,
-  claimNextTask,
-  collectSuites,
-  resolveRuntimeConfigs,
-} from "./planning.mjs";
-
-function makeConfig(name, extras = {}) {
-  const providedTestkit = extras.testkit || {};
-  return {
-    name,
-    suites: extras.suites || {},
-    testkit: {
-      dependsOn: extras.dependsOn || providedTestkit.dependsOn || [],
-      execution: providedTestkit.execution || {
-        workers: 1,
-        fileTimeoutSeconds: 60,
-      },
-      runtime: providedTestkit.runtime || {
-        instances: 1,
-        maxConcurrentTasks: Number.POSITIVE_INFINITY,
-      },
-      requirements: providedTestkit.requirements || {
-        suites: [],
-        files: [],
-        fileLocksByPath: new Map(),
-      },
-      ...providedTestkit,
-    },
-    ...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 user-facing type selection", () => {
-    const config = makeConfig("api", {
-      suites: {
-        integration: [
-          { name: "health", files: ["tests/api/integration/health.int.testkit.ts"] },
-        ],
-        e2e: [
-          {
-            name: "auth",
-            framework: "playwright",
-            files: [
-              "tests/frontend/e2e/auth.pw.testkit.ts",
-              "tests/frontend/e2e/signup.pw.testkit.ts",
-            ],
-          },
-        ],
-      },
-    });
-
-    expect(collectSuites(config, ["int"], [], [])[0]).toMatchObject({
-      name: "health",
-      type: "integration",
-      displayType: "int",
-      framework: "k6",
-      weight: 1,
-    });
-
-    expect(collectSuites(config, ["pw"], [], [])[0]).toMatchObject({
-      name: "auth",
-      displayType: "pw",
-      framework: "playwright",
-      weight: 2,
-    });
-
-    expect(
-      collectSuites(
-        config,
-        ["all"],
-        [],
-        ["tests/frontend/e2e/signup.pw.testkit.ts"]
-      )[0]
-    ).toMatchObject({
-      name: "auth",
-      files: ["tests/frontend/e2e/signup.pw.testkit.ts"],
-    });
-  });
-
-  it("keeps skipped files visible while removing them from runnable work", () => {
-    const config = makeConfig("api", {
-      suites: {
-        integration: [
-          {
-            name: "billing",
-            files: [
-              "__testkit__/billing/a.int.testkit.ts",
-              "__testkit__/billing/b.int.testkit.ts",
-            ],
-          },
-        ],
-      },
-      testkit: {
-        skip: {
-          fileReasonByPath: new Map([
-            ["__testkit__/billing/a.int.testkit.ts", "Billing is stubbed"],
-          ]),
-          suites: [],
-        },
-      },
-    });
-
-    expect(collectSuites(config, ["int"], [], [])).toEqual([
-      expect.objectContaining({
-        name: "billing",
-        files: ["__testkit__/billing/b.int.testkit.ts"],
-        skippedFiles: [
-          {
-            path: "__testkit__/billing/a.int.testkit.ts",
-            reason: "Billing is stubbed",
-          },
-        ],
-        totalFileCount: 2,
-      }),
-    ]);
-  });
-
-  it("does not require repo-level skip config when file metadata is present", () => {
-    const config = makeConfig("api", {
-      suites: {
-        integration: [
-          {
-            name: "health",
-            files: ["__testkit__/health/health.int.testkit.ts"],
-          },
-        ],
-      },
-      testkit: {
-        fileMetadataByPath: new Map([
-          ["__testkit__/health/health.int.testkit.ts", { skipReason: null, locks: [] }],
-        ]),
-      },
-    });
-
-    expect(collectSuites(config, ["int"], [], [])).toEqual([
-      expect.objectContaining({
-        name: "health",
-        files: ["__testkit__/health/health.int.testkit.ts"],
-        skippedFiles: [],
-      }),
-    ]);
-  });
-
-  it("applies lock requirements to matching suites and files", () => {
-    const api = makeConfig("api", {
-      suites: {
-        integration: [
-          {
-            name: "routes",
-            framework: "k6",
-            files: [
-              "src/api/routes/__testkit__/health.int.testkit.ts",
-              "src/api/routes/__testkit__/crawls-worker-concurrency.int.testkit.ts",
-            ],
-            orderIndex: 0,
-            weight: 2,
-          },
-        ],
-      },
-      testkit: {
-        runtime: {
-          instances: 3,
-          maxConcurrentTasks: 2,
-        },
-        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",
-              locks: ["worker-loop"],
-            },
-          ],
-          fileLocksByPath: new Map([
-            [
-              "src/api/routes/__testkit__/crawls-worker-concurrency.int.testkit.ts",
-              ["worker-loop"],
-            ],
-          ]),
-        },
-      },
-    });
-
-    const graphs = buildRuntimeGraphs([
-      {
-        config: api,
-        skipped: false,
-        runtimeConfigs: [api],
-        runtimeNames: ["api"],
-        runtimeKey: "api",
-        suites: collectSuites(api, ["int"], [], []),
-      },
-    ]);
-
-    const queue = buildTaskQueue(
-      [
-        {
-          config: api,
-          skipped: false,
-          runtimeConfigs: [api],
-          runtimeNames: ["api"],
-          runtimeKey: "api",
-          assignedGraphKey: "api",
-          suites: collectSuites(api, ["int"], [], []),
-        },
-      ],
-      graphs,
-      { files: {} }
-    );
-
-    expect(queue).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          file: "src/api/routes/__testkit__/health.int.testkit.ts",
-          locks: ["suite-lock"],
-        }),
-        expect.objectContaining({
-          file: "src/api/routes/__testkit__/crawls-worker-concurrency.int.testkit.ts",
-          locks: ["suite-lock", "worker-loop"],
-        }),
-      ])
-    );
-  });
-
-  it("builds exact runtime graphs and claims single file tasks", () => {
-    const api = makeConfig("api", {
-      testkit: {
-        runtime: {
-          instances: 2,
-          maxConcurrentTasks: 4,
-        },
-      },
-    });
-    const frontend = makeConfig("frontend", {
-      dependsOn: ["api"],
-      testkit: {
-        runtime: {
-          instances: 1,
-          maxConcurrentTasks: 2,
-        },
-      },
-    });
-
-    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,
-          },
-        ],
-      },
-      {
-        config: frontend,
-        skipped: false,
-        runtimeConfigs: [api, frontend],
-        runtimeNames: ["api", "frontend"],
-        runtimeKey: "api|frontend",
-        suites: [
-          {
-            name: "auth",
-            type: "e2e",
-            framework: "playwright",
-            files: ["auth.spec.js"],
-            orderIndex: 0,
-            weight: 1,
-          },
-        ],
-      },
-    ];
-
-    expect(applyShard(["a", "b", "c", "d"], { index: 2, total: 2 })).toEqual(["b", "d"]);
-
-    const graphs = buildRuntimeGraphs(plans);
-    expect(graphs).toEqual([
-      expect.objectContaining({
-        key: "api",
-        instanceCount: 2,
-        maxConcurrentTasks: 4,
-        targetNames: ["api"],
-      }),
-      expect.objectContaining({
-        key: "api|frontend",
-        instanceCount: 1,
-        maxConcurrentTasks: 2,
-        targetNames: ["frontend"],
-      }),
-    ]);
-    expect(buildGraphDirName(["api", "frontend"])).toBe("api__frontend");
-
-    const queue = buildTaskQueue(plans, graphs, { files: {} });
-    expect(queue).toHaveLength(3);
-    expect(claimNextTask(queue, "api|frontend")).toMatchObject({
-      framework: "playwright",
-      graphKey: "api|frontend",
-      file: "auth.spec.js",
-    });
-    expect(claimNextTask(queue, "api")).toMatchObject({
-      framework: "k6",
-      graphKey: "api",
-    });
-  });
-
-  it("skips blocked preferred-graph work and claims the next runnable task", () => {
-    const queue = [
-      {
-        id: 1,
-        graphKey: "api",
-        file: "blocked.js",
-      },
-      {
-        id: 2,
-        graphKey: "api|frontend",
-        file: "runnable.js",
-      },
-    ];
-
-    const claimed = claimNextTask(
-      queue,
-      "api",
-      (task) => task.file === "runnable.js"
-    );
-
-    expect(claimed).toMatchObject({
-      id: 2,
-      file: "runnable.js",
-    });
-    expect(queue).toEqual([
-      expect.objectContaining({
-        id: 1,
-        file: "blocked.js",
-      }),
-    ]);
-  });
-});

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

@@ -1,78 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { pathToFileURL } from "url";
-import { afterEach, describe, expect, it } from "vitest";
-import {
-  ensurePlaywrightTestConfig,
-  findPlaywrightConfig,
-  resolvePlaywrightOutputDir,
-} from "./playwright-config.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;
-}
-
-describe("runner-playwright-config", () => {
-  it("uses a lease-local output directory under the lease dir", async () => {
-    const productDir = makeTempDir("testkit-playwright-product-");
-    const leaseDir = path.join(productDir, ".testkit", "leases", "lease-12");
-    const cwd = path.join(productDir, "frontend");
-    fs.mkdirSync(cwd, { recursive: true });
-    fs.writeFileSync(
-      path.join(cwd, "playwright.config.mjs"),
-      "export default { outputDir: 'shared-test-results', workers: 8, fullyParallel: true, webServer: { command: 'npm run dev', url: 'http://127.0.0.1:3000' } };\n"
-    );
-
-    const configPath = ensurePlaywrightTestConfig(
-      { name: "frontend", productDir, stateDir: path.join(productDir, ".testkit", "frontend") },
-      cwd,
-      ["frontend/__testkit__/homepage/homepage.pw.testkit.ts"],
-      { leaseDir }
-    );
-    const generated = await import(pathToFileURL(configPath).href + `?t=${Date.now()}`);
-
-    const expectedOutputDir = resolvePlaywrightOutputDir(leaseDir);
-    expect(generated.default.outputDir).toBe(expectedOutputDir);
-    expect(generated.default.workers).toBe(1);
-    expect(generated.default.fullyParallel).toBe(false);
-    expect(generated.default.webServer).toBeUndefined();
-    expect(fs.existsSync(expectedOutputDir)).toBe(true);
-    expect(fs.readFileSync(configPath, "utf8")).toContain(
-      `outputDir: ${JSON.stringify(expectedOutputDir)}`
-    );
-    expect(fs.readFileSync(configPath, "utf8")).toContain("workers: 1");
-    expect(fs.readFileSync(configPath, "utf8")).toContain("fullyParallel: false");
-  });
-
-  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");
-
-    expect(findPlaywrightConfig(cwd)).toBe(path.join(cwd, "playwright.config.ts"));
-  });
-});

package/lib/runner/processes.test.mjs

@@ -1,21 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { normalizeServiceStartCommand } from "./processes.mjs";
-
-describe("runner processes", () => {
-  it("strips a single leading exec prefix for backward compatibility", () => {
-    expect(normalizeServiceStartCommand("exec node server.mjs")).toBe("node server.mjs");
-    expect(normalizeServiceStartCommand("  exec ./node_modules/.bin/next dev -p {port}  ")).toBe(
-      "./node_modules/.bin/next dev -p {port}"
-    );
-  });
-
-  it("leaves plain commands unchanged", () => {
-    expect(normalizeServiceStartCommand("node server.mjs")).toBe("node server.mjs");
-  });
-
-  it("rejects empty commands", () => {
-    expect(() => normalizeServiceStartCommand("   ")).toThrow(
-      /Service start command must not be empty/
-    );
-  });
-});

package/lib/runner/regressions.test.mjs

@@ -1,168 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { normalizeRegressionCatalogDocument } from "../regressions/index.mjs";
-import { applyRegressionAnalysisToArtifacts } from "./regressions.mjs";
-
-describe("runner regressions", () => {
-  it("classifies known failed regressions and enriches both artifacts", () => {
-    const regressionCatalog = normalizeRegressionCatalogDocument({
-      schemaVersion: 1,
-      issueRepo: "acme/repo",
-      entries: [
-        {
-          id: "bad-message",
-          classification: "product_bug",
-          issue: {
-            repo: "acme/repo",
-            number: 12,
-          },
-          summary: "API returns the wrong message",
-          cause: "The endpoint payload is wrong.",
-          lastReviewedAt: "2026-05-04",
-          fingerprints: [
-            {
-              service: "api",
-              type: "int",
-              path: "__testkit__/http/failing.int.testkit.ts",
-              failureKey: "returns the wrong message",
-            },
-          ],
-        },
-      ],
-    });
-
-    const runArtifact = {
-      services: [
-        {
-          name: "api",
-          suites: [
-            {
-              type: "int",
-              files: [
-                {
-                  path: "__testkit__/http/failing.int.testkit.ts",
-                  status: "failed",
-                  error: "Default runtime thresholds failed: checks(rate==1.0)",
-                  failureDetails: [
-                    {
-                      kind: "k6-check",
-                      key: "returns the wrong message",
-                      title: "returns the wrong message",
-                      count: 1,
-                    },
-                  ],
-                },
-              ],
-            },
-          ],
-        },
-      ],
-    };
-    const statusArtifact = {
-      tests: [
-        {
-          service: "api",
-          type: "int",
-          path: "__testkit__/http/failing.int.testkit.ts",
-          status: "failed",
-          error: "Default runtime thresholds failed: checks(rate==1.0)",
-          failureDetails: [
-            {
-              kind: "k6-check",
-              key: "returns the wrong message",
-              title: "returns the wrong message",
-              count: 1,
-            },
-          ],
-        },
-      ],
-    };
-
-    const enriched = applyRegressionAnalysisToArtifacts(
-      runArtifact,
-      statusArtifact,
-      regressionCatalog,
-      {
-        entries: [
-          {
-            id: "bad-message",
-            status: "open_and_failing",
-            github: {
-              state: "OPEN",
-              url: "https://github.com/acme/repo/issues/12",
-              cached: false,
-            },
-            findings: [],
-          },
-        ],
-        findings: [],
-      }
-    );
-
-    expect(enriched.statusArtifact.tests[0].diagnosis).toMatchObject({
-      status: "known_regression",
-      classifications: ["product_bug"],
-    });
-    expect(enriched.runArtifact.services[0].suites[0].files[0].diagnosis.entries[0]).toMatchObject({
-      id: "bad-message",
-      issue: {
-        number: 12,
-      },
-    });
-    expect(enriched.statusArtifact.regressions.summary).toEqual({
-      newRegressions: 0,
-      knownRegressions: 1,
-      fixedKnownRegressions: 0,
-      catalogStale: 0,
-      catalogSyncUnavailable: false,
-      usedStaleCache: false,
-    });
-  });
-
-  it("marks unmatched failed tests as new regressions and emits drafts", () => {
-    const enriched = applyRegressionAnalysisToArtifacts(
-      {
-        services: [
-          {
-            name: "api",
-            suites: [
-              {
-                type: "int",
-                files: [
-                  {
-                    path: "__testkit__/http/failing.int.testkit.ts",
-                    status: "failed",
-                    error: "boom",
-                  },
-                ],
-              },
-            ],
-          },
-        ],
-      },
-      {
-        tests: [
-          {
-            service: "api",
-            type: "int",
-            path: "__testkit__/http/failing.int.testkit.ts",
-            status: "failed",
-            error: "boom",
-          },
-        ],
-      },
-      normalizeRegressionCatalogDocument({
-        schemaVersion: 1,
-        entries: [],
-      }),
-      null
-    );
-
-    expect(enriched.statusArtifact.tests[0].diagnosis).toEqual({
-      status: "new_regression",
-      classifications: [],
-      entries: [],
-    });
-    expect(enriched.statusArtifact.regressions.summary.newRegressions).toBe(1);
-    expect(enriched.statusArtifact.regressions.drafts.newRegressions).toHaveLength(1);
-  });
-});