@elench/testkit 0.1.83 → 0.1.84

package/lib/cli/args.test.mjs

@@ -1,110 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  parseFileTimeoutOption,
-  parseShardOption,
-  parseSuiteOption,
-  parseTypeOption,
-  parseWorkersOption,
-  resolveRequestedFiles,
-  resolveCliSelection,
-} from "./args.mjs";
-
-describe("cli-args", () => {
-  it("resolves a positional suite type", () => {
-    expect(
-      resolveCliSelection({
-        first: "int",
-        second: null,
-        third: null,
-      })
-    ).toEqual({
-      dbAction: null,
-      lifecycle: null,
-      positionalType: "int",
-    });
-  });
-
-  it("resolves lifecycle commands", () => {
-    expect(
-      resolveCliSelection({
-        first: "status",
-        second: null,
-        third: null,
-      })
-    ).toEqual({
-      dbAction: null,
-      lifecycle: "status",
-      positionalType: null,
-    });
-  });
-
-  it("resolves db subcommands", () => {
-    expect(
-      resolveCliSelection({
-        first: "db",
-        second: "snapshot",
-        third: "capture",
-      })
-    ).toEqual({
-      dbAction: "snapshot-capture",
-      lifecycle: null,
-      positionalType: null,
-    });
-  });
-
-  it("rejects unknown positional arguments", () => {
-    expect(() =>
-      resolveCliSelection({
-        first: "mystery",
-        second: null,
-        third: null,
-      })
-    ).toThrow('Unknown argument "mystery"');
-  });
-
-  it("parses types and suite selectors", () => {
-    expect(parseTypeOption(["e2e,scenario,dal"], "int")).toEqual([
-      "int",
-      "e2e",
-      "scenario",
-      "dal",
-    ]);
-    expect(() => parseTypeOption(["all", "int"])).toThrow("cannot be combined");
-
-    expect(parseSuiteOption(["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" },
-    ]);
-  });
-
-  it("parses and validates execution options", () => {
-    expect(parseWorkersOption("3")).toBe(3);
-    expect(parseFileTimeoutOption("45")).toBe(45);
-    expect(() => parseWorkersOption("0")).toThrow("Invalid --workers value");
-    expect(() => parseFileTimeoutOption("0")).toThrow(
-      "Invalid --file-timeout-seconds value"
-    );
-  });
-
-  it("parses and validates shards", () => {
-    expect(parseShardOption("2/5")).toEqual({ index: 2, total: 5 });
-    expect(parseShardOption(null)).toBeNull();
-    expect(() => parseShardOption("2-of-5")).toThrow("Invalid --shard value");
-    expect(() => parseShardOption("3/2")).toThrow("Expected 1 <= i <= n");
-  });
-
-  it("normalizes requested file paths against the product directory", () => {
-    expect(
-      resolveRequestedFiles(
-        [
-          "/tmp/product/tests/api/integration/health.int.testkit.ts",
-          "./tests/api/integration/health.int.testkit.ts",
-          "product/tests/api/integration/health.int.testkit.ts",
-        ],
-        "/tmp/product",
-        "/tmp"
-      )
-    ).toEqual(["tests/api/integration/health.int.testkit.ts"]);
-  });
-});

package/lib/cli/command-helpers.test.mjs

@@ -1,122 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const loadManagedConfigsMock = vi.fn();
-const runAllMock = vi.fn();
-const createRunReporterMock = vi.fn();
-const createTreeReporterMock = vi.fn();
-const createRunEventsReporterMock = vi.fn();
-
-vi.mock("../app/configs.mjs", () => ({
-  loadManagedConfigs: loadManagedConfigsMock,
-}));
-
-vi.mock("../runner/index.mjs", () => ({
-  runAll: runAllMock,
-}));
-
-vi.mock("./presentation/run-reporter.mjs", () => ({
-  createRunReporter: createRunReporterMock,
-}));
-
-vi.mock("./presentation/tree-reporter.mjs", () => ({
-  createTreeReporter: createTreeReporterMock,
-}));
-
-vi.mock("./presentation/events-reporter.mjs", () => ({
-  createRunEventsReporter: createRunEventsReporterMock,
-}));
-
-const originalIsTTY = process.stdout.isTTY;
-const originalStdoutGetWindowSize = process.stdout.getWindowSize;
-const originalStderrGetWindowSize = process.stderr.getWindowSize;
-
-beforeEach(() => {
-  loadManagedConfigsMock.mockResolvedValue({
-    allConfigs: [{ name: "api", productDir: "/tmp/product" }],
-    configs: [{ name: "api", productDir: "/tmp/product" }],
-  });
-  runAllMock.mockResolvedValue({ ok: true });
-  createRunReporterMock.mockReturnValue({ outputMode: "compact" });
-  createRunEventsReporterMock.mockReturnValue({ outputMode: "events" });
-  createTreeReporterMock.mockReturnValue({
-    reporter: { outputMode: "compact" },
-    finalize: Promise.resolve(),
-    close: vi.fn(),
-  });
-  Object.defineProperty(process.stdout, "isTTY", {
-    configurable: true,
-    value: true,
-  });
-  process.stdout.getWindowSize = vi.fn(() => [100, 40]);
-  process.stderr.getWindowSize = vi.fn(() => [100, 40]);
-});
-
-afterEach(() => {
-  loadManagedConfigsMock.mockReset();
-  runAllMock.mockReset();
-  createRunReporterMock.mockReset();
-  createTreeReporterMock.mockReset();
-  createRunEventsReporterMock.mockReset();
-  Object.defineProperty(process.stdout, "isTTY", {
-    configurable: true,
-    value: originalIsTTY,
-  });
-  process.stdout.getWindowSize = originalStdoutGetWindowSize;
-  process.stderr.getWindowSize = originalStderrGetWindowSize;
-});
-
-describe("executeRunCommand", () => {
-  it("uses the tree reporter for compact TTY runs and awaits finalization", async () => {
-    let finalizeResolved = false;
-    createTreeReporterMock.mockReturnValueOnce({
-      reporter: { outputMode: "compact" },
-      finalize: Promise.resolve().then(() => {
-        finalizeResolved = true;
-      }),
-      close: vi.fn(),
-    });
-
-    const { executeRunCommand } = await import("./command-helpers.mjs");
-    const result = await executeRunCommand({ jsonEnabled: () => false }, {}, null);
-
-    expect(createTreeReporterMock).toHaveBeenCalledWith(
-      expect.objectContaining({ productDir: "/tmp/product" })
-    );
-    expect(runAllMock).toHaveBeenCalledWith(
-      expect.any(Array),
-      expect.any(Array),
-      expect.any(Array),
-      expect.objectContaining({ reporter: { outputMode: "compact" } }),
-      expect.any(Array)
-    );
-    expect(finalizeResolved).toBe(true);
-    expect(result.outputMode).toBe("compact");
-  });
-
-  it("uses the events reporter when requested", async () => {
-    const { executeRunCommand } = await import("./command-helpers.mjs");
-    await executeRunCommand(
-      { jsonEnabled: () => false },
-      { "output-mode": "events" },
-      null
-    );
-
-    expect(createRunEventsReporterMock).toHaveBeenCalled();
-    expect(createRunReporterMock).not.toHaveBeenCalled();
-  });
-
-  it("closes the tree reporter when runner.runAll throws", async () => {
-    const close = vi.fn();
-    createTreeReporterMock.mockReturnValueOnce({
-      reporter: { outputMode: "compact" },
-      finalize: Promise.resolve(),
-      close,
-    });
-    runAllMock.mockRejectedValueOnce(new Error("boom"));
-
-    const { executeRunCommand } = await import("./command-helpers.mjs");
-
-    await expect(executeRunCommand({ jsonEnabled: () => false }, {}, null)).rejects.toThrow("boom");
-    expect(close).toHaveBeenCalled();
-  });
-});

package/lib/cli/commands/investigate.test.mjs

@@ -1,83 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-const loadCurrentRunArtifactMock = vi.fn();
-const resolveFileSubjectMock = vi.fn();
-const startHostedInvestigationMock = vi.fn();
-const runInteractiveInvestigationMock = vi.fn();
-
-vi.mock("../viewer.mjs", () => ({
-  loadCurrentRunArtifact: loadCurrentRunArtifactMock,
-  resolveFileSubject: resolveFileSubjectMock,
-}));
-
-vi.mock("../agents/investigate.mjs", () => ({
-  startHostedInvestigation: startHostedInvestigationMock,
-  runInteractiveInvestigation: runInteractiveInvestigationMock,
-}));
-
-afterEach(() => {
-  loadCurrentRunArtifactMock.mockReset();
-  resolveFileSubjectMock.mockReset();
-  startHostedInvestigationMock.mockReset();
-  runInteractiveInvestigationMock.mockReset();
-});
-
-function seedSubject() {
-  loadCurrentRunArtifactMock.mockReturnValue({});
-  resolveFileSubjectMock.mockReturnValue({
-    service: { name: "api" },
-    suite: { name: "users", type: "integration" },
-    file: { path: "tests/api/users.int.testkit.ts" },
-  });
-}
-
-describe("InvestigateCommand", () => {
-  it("runs hosted investigation and returns the final text", async () => {
-    seedSubject();
-    startHostedInvestigationMock.mockReturnValue({
-      completion: Promise.resolve({
-        provider: "codex",
-        exitCode: 0,
-        finalText: "Likely root cause.",
-      }),
-    });
-
-    const { default: InvestigateCommand } = await import("./investigate.mjs");
-    const result = await InvestigateCommand.run(["--json"]);
-
-    expect(startHostedInvestigationMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        productDir: process.cwd(),
-        serviceName: "api",
-        filePath: "tests/api/users.int.testkit.ts",
-      })
-    );
-    expect(result).toMatchObject({
-      provider: "codex",
-      finalText: "Likely root cause.",
-      file: "tests/api/users.int.testkit.ts",
-      service: "api",
-    });
-  });
-
-  it("runs handoff investigation when requested", async () => {
-    seedSubject();
-    runInteractiveInvestigationMock.mockResolvedValue({
-      provider: "claude",
-      exitCode: 0,
-    });
-
-    const { default: InvestigateCommand } = await import("./investigate.mjs");
-    const result = await InvestigateCommand.run(["--json", "--handoff", "--provider", "claude"]);
-
-    expect(runInteractiveInvestigationMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        productDir: process.cwd(),
-        serviceName: "api",
-        filePath: "tests/api/users.int.testkit.ts",
-        provider: "claude",
-      })
-    );
-    expect(result).toMatchObject({ provider: "claude", exitCode: 0 });
-  });
-});

package/lib/cli/presentation/code-frames.test.mjs

@@ -1,71 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it } from "vitest";
-import { findFailureLocation, formatLocation, renderCodeFrame } from "./code-frames.mjs";
-
-const cleanups = [];
-
-afterEach(() => {
-  while (cleanups.length > 0) {
-    cleanups.pop()();
-  }
-});
-
-describe("code frame presentation", () => {
-  it("finds a location from structured failure metadata", () => {
-    expect(
-      findFailureLocation({
-        location: {
-          path: "/tmp/example.ts",
-          line: 10,
-          column: 2,
-        },
-      })
-    ).toEqual({
-      path: "/tmp/example.ts",
-      line: 10,
-      column: 2,
-    });
-  });
-
-  it("renders a code frame for a local file", () => {
-    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-code-frame-"));
-    cleanups.push(() => fs.rmSync(tempDir, { recursive: true, force: true }));
-    const filePath = path.join(tempDir, "example.ts");
-    fs.writeFileSync(
-      filePath,
-      [
-        "export function run() {",
-        "  const value = 1;",
-        "  return value + missing;",
-        "}",
-      ].join("\n")
-    );
-
-    const lines = renderCodeFrame(
-      {
-        path: filePath,
-        line: 3,
-        column: 18,
-      },
-      { cwd: tempDir }
-    );
-
-    expect(lines.join("\n")).toContain("example.ts:3:18");
-    expect(lines.join("\n")).toContain("return value + missing;");
-  });
-
-  it("formats locations relative to the cwd", () => {
-    expect(
-      formatLocation(
-        {
-          path: "/tmp/example.ts",
-          line: 7,
-          column: 3,
-        },
-        "/tmp"
-      )
-    ).toBe("example.ts:7:3");
-  });
-});

package/lib/cli/presentation/events-reporter.test.mjs

@@ -1,73 +0,0 @@
-import { Writable } from "stream";
-import { describe, expect, it } from "vitest";
-import { createRunEventsReporter } from "./events-reporter.mjs";
-
-function createCapture() {
-  let output = "";
-  const stream = new Writable({
-    write(chunk, _encoding, callback) {
-      output += chunk.toString();
-      callback();
-    },
-  });
-  return {
-    stream,
-    lines() {
-      return output.trim().split("\n").filter(Boolean).map((line) => JSON.parse(line));
-    },
-  };
-}
-
-describe("events reporter", () => {
-  it("emits structured run lifecycle events", () => {
-    const capture = createCapture();
-    const reporter = createRunEventsReporter({ stdout: capture.stream });
-
-    reporter.setTotalFileCount(2);
-    reporter.taskStarted({
-      serviceName: "api",
-      file: "tests/api/users.int.testkit.ts",
-      suiteName: "users",
-      type: "integration",
-      framework: "k6",
-    });
-    reporter.taskFinished(
-      {
-        serviceName: "api",
-        file: "tests/api/users.int.testkit.ts",
-        suiteName: "users",
-        type: "integration",
-        framework: "k6",
-      },
-      { failed: true, error: "status 500" }
-    );
-    reporter.runSummary([{ name: "api", failed: true }], 1200, null);
-
-    expect(capture.lines()).toEqual([
-      { type: "run.total_files", total: 2 },
-      {
-        type: "run.task_started",
-        service: "api",
-        file: "tests/api/users.int.testkit.ts",
-        suite: "users",
-        type: "integration",
-        framework: "k6",
-      },
-      {
-        type: "run.task_finished",
-        service: "api",
-        file: "tests/api/users.int.testkit.ts",
-        suite: "users",
-        type: "integration",
-        framework: "k6",
-        outcome: { failed: true, error: "status 500" },
-      },
-      {
-        type: "run.summary",
-        results: [{ name: "api", failed: true }],
-        durationMs: 1200,
-        regressionReport: null,
-      },
-    ]);
-  });
-});

package/lib/cli/presentation/run-reporter.test.mjs

@@ -1,192 +0,0 @@
-import { Writable } from "stream";
-import figures from "figures";
-import { describe, expect, it } from "vitest";
-import { createRunReporter } from "./run-reporter.mjs";
-
-function createCapture(columns = 100) {
-  let stdout = "";
-  const stream = new Writable({
-    write(chunk, _encoding, callback) {
-      stdout += chunk.toString();
-      callback();
-    },
-  });
-  stream.columns = columns;
-  return {
-    stream,
-    read() {
-      return stdout;
-    },
-  };
-}
-
-describe("run reporter setup output", () => {
-  it("prints concise high-level setup summaries in compact mode", () => {
-    const capture = createCapture();
-    const reporter = createRunReporter({
-      outputMode: "compact",
-      stdout: capture.stream,
-    });
-
-    reporter.setupOperationFinished({
-      serviceName: "api",
-      stage: "template",
-      kind: "database-template",
-      summary: "template rebuild",
-      status: "passed",
-      durationMs: 8_000,
-    });
-
-    expect(capture.read()).toContain(`${figures.play} RUN SETUP api template rebuild`);
-    expect(capture.read()).toContain("8s");
-  });
-
-  it("does not print low-level setup steps in compact mode", () => {
-    const capture = createCapture();
-    const reporter = createRunReporter({
-      outputMode: "compact",
-      stdout: capture.stream,
-    });
-
-    reporter.setupOperationFinished({
-      serviceName: "api",
-      stage: "template:migrate:api:1",
-      kind: "setup-step",
-      summary: "sql-file: db/schema.sql",
-      status: "passed",
-      durationMs: 8_000,
-    });
-
-    expect(capture.read()).toBe("");
-  });
-
-  it("prints concise setup failures", () => {
-    const capture = createCapture();
-    const reporter = createRunReporter({
-      outputMode: "compact",
-      stdout: capture.stream,
-    });
-
-    reporter.setupOperationFinished({
-      serviceName: "api",
-      stage: "runtime:prepare",
-      kind: "runtime-prepare",
-      summary: "runtime prepare",
-      status: "failed",
-      durationMs: 1_200,
-      error: "Command failed with exit code 1: node scripts/fail-prepare.mjs",
-    });
-
-    expect(capture.read()).toContain(`${figures.cross} FAIL SETUP api runtime:prepare`);
-    expect(capture.read()).toContain("Command failed with exit code 1");
-  });
-});
-
-describe("run reporter task output", () => {
-  it("prints failure details on lines beneath the failed file result", () => {
-    const capture = createCapture(88);
-    const reporter = createRunReporter({
-      outputMode: "compact",
-      stdout: capture.stream,
-    });
-
-    reporter.setTotalFileCount(3);
-    reporter.taskFinished(
-      {
-        serviceName: "api",
-        type: "integration",
-        framework: "k6",
-        file: "__testkit__/health/health.int.testkit.ts",
-      },
-      {
-        status: "failed",
-        failed: true,
-        durationMs: 4_000,
-        error: "Default runtime thresholds failed: checks(rate==1.0)",
-        failureDetails: [
-          {
-            kind: "http-assertion",
-            title: "status is 200",
-            message: "GET /health expected 200, got 404",
-            request: {
-              method: "GET",
-              path: "/health",
-              requestId: "req-1",
-            },
-            response: {
-              status: 404,
-              bodyPreview: '{"error":"route not found"}',
-            },
-          },
-        ],
-      }
-    );
-
-    const lines = capture.read().trimEnd().split("\n");
-    expect(lines[0]).toContain("[1/3]");
-    expect(lines[0]).toContain(`${figures.cross} FAIL api int __testkit__/health/health.int.testkit.ts 4s`);
-    expect(lines[1]).toBe("    GET /health expected 200, got 404");
-    expect(lines[2]).toContain('    response: {"error":"route not found"}');
-    expect(lines[3]).toBe("    regression: new");
-    expect(lines[4]).toBe("    logs: requestId=req-1");
-  });
-
-  it("renders a compact aggregate summary box", () => {
-    const capture = createCapture(72);
-    const reporter = createRunReporter({
-      outputMode: "compact",
-      stdout: capture.stream,
-    });
-
-    reporter.runSummary(
-      [
-        {
-          name: "api",
-          skipped: false,
-          failed: true,
-          suiteCount: 1,
-          completedSuiteCount: 1,
-          skippedSuiteCount: 0,
-          failedSuiteCount: 1,
-          totalFileCount: 3,
-          passedFileCount: 2,
-          failedFileCount: 1,
-          skippedFileCount: 0,
-          notRunFileCount: 0,
-          durationMs: 10_000,
-          suites: [],
-          errors: [],
-        },
-      ],
-      20_000,
-      {
-        summary: {
-          newRegressions: 1,
-          knownRegressions: 2,
-          fixedKnownRegressions: 3,
-          catalogStale: 4,
-          catalogSyncUnavailable: false,
-          usedStaleCache: true,
-        },
-      }
-    );
-
-    const output = capture.read();
-    expect(output).toContain("┌");
-    expect(output).toContain("│ Result");
-    expect(output).toContain("FAILED");
-    expect(output).toContain("│ Passed");
-    expect(output).toContain("│ Failed");
-    expect(output).toContain("│ Skipped");
-    expect(output).toContain("│ Not run");
-    expect(output).toContain("│ Files");
-    expect(output).toContain("│ Duration");
-    expect(output).toContain("│ New regressions");
-    expect(output).toContain("│ Known regressions");
-    expect(output).toContain("│ Fixed known");
-    expect(output).toContain("│ Catalog stale");
-    expect(output).toContain("│ Catalog sync");
-    expect(output).not.toContain("Failures:");
-    expect(output).not.toContain("Runtime Errors:");
-  });
-});