@elench/testkit 0.1.83 → 0.1.85

package/lib/config-api/index.test.mjs

@@ -1,398 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  auth,
-  app,
-  database,
-  defineConfig,
-  defineFile,
-  toolchain,
-} from "./index.mjs";
-import { clearRuntimeContext, registerRuntimeContext } from "./runtime.mjs";
-
-describe("config api", () => {
-  it("defines repo config plainly", () => {
-    expect(defineConfig({ execution: { workers: 4 } })).toEqual({
-      execution: { workers: 4 },
-    });
-  });
-
-  it("builds generated auth fixture profiles with actor-aware sessions and headers", () => {
-    const requests = [];
-    registerRuntimeContext({
-      env: {
-        BASE: "http://api.test",
-        routeParams: { "x-route": "route-a" },
-      },
-      http: {
-        post(url, body, params) {
-          const payload = JSON.parse(body);
-          requests.push({ url, payload, params });
-          const actor = payload.email.includes(".user-a@")
-            ? "userA"
-            : payload.email.includes(".user-b@")
-              ? "userB"
-              : "primary";
-          return {
-            status: url.endsWith("/signup") ? 201 : 200,
-            body: JSON.stringify({
-              data: {
-                organizations: [{ id: `org-${actor}` }],
-              },
-            }),
-            headers: {
-              "set-cookie": [
-                `fixture_session=jwt-${actor}; Path=/`,
-                `fixture_refresh=refresh-${actor}; Path=/`,
-              ],
-            },
-          };
-        },
-      },
-    });
-
-    const fixture = auth.fixture({
-      contract: auth.contracts.jsonSession({
-        authCookie: "fixture_session",
-        refreshCookie: "fixture_refresh",
-        organizationIdPath: "data.organizations[0].id",
-        forwardedFor: "deterministic",
-        organizationHeader: "X-Organization-Id",
-      }),
-      topology: auth.topologies.crossOrg({
-        namespace: "fixture",
-        actors: {
-          primary: { org: "primary" },
-          userA: { org: "primary" },
-          userB: { org: "secondary" },
-        },
-      }),
-    });
-
-    const builtProfiles = fixture.profiles({
-      default: auth.profile.actor("primary", {
-        headers: {
-          values: ({ actor }) => ({ "X-Testkit-Actor": actor || "primary" }),
-        },
-      }),
-      dual: auth.profile.actors({
-        primaryActor: "userA",
-        actors: ["userA", "userB"],
-      }),
-      raw: auth.profile.raw({
-        headers: {
-          values: {
-            "X-Testkit-Mode": "raw",
-          },
-        },
-      }),
-    });
-
-    expect(fixture.topology.actors.primary.email).toBe("testkit+fixture.primary@example.test");
-    expect(fixture.topology.actors.userA.name).toBe("Testkit Fixture User A");
-    expect(fixture.topology.actors.userB.organizationName).toBe("Testkit Fixture Secondary Org");
-
-    const defaultSetup = builtProfiles.default.auth.setup({ env: { BASE: "http://api.test", routeParams: { "x-route": "route-a" } } });
-    expect(defaultSetup.actors.primary.organizationId).toBe("org-primary");
-    expect(builtProfiles.default.auth.headers(defaultSetup, { env: { BASE: "http://api.test" } })).toEqual({
-      Authorization: "Bearer jwt-primary",
-    });
-    expect(builtProfiles.default.headers(defaultSetup, { env: { BASE: "http://api.test" } })).toMatchObject({
-      "Content-Type": "application/json",
-      "X-Organization-Id": "org-primary",
-      "X-Testkit-Actor": "primary",
-    });
-
-    const dualSetup = builtProfiles.dual.auth.setup({ env: { BASE: "http://api.test" } });
-    expect(dualSetup.actors.userA.organizationId).toBe("org-userA");
-    expect(dualSetup.actors.userB.organizationId).toBe("org-userB");
-    expect(builtProfiles.dual.auth.headers(dualSetup)).toEqual({
-      Authorization: "Bearer jwt-userA",
-    });
-
-    expect(builtProfiles.raw.rawHeaders(null, { env: { BASE: "http://api.test" } })).toMatchObject({
-      "Content-Type": "application/json",
-      "X-Testkit-Mode": "raw",
-    });
-
-    expect(requests[0].params.headers["x-route"]).toBe("route-a");
-    expect(requests.map((entry) => entry.url)).toEqual([
-      "http://api.test/api/v1/auth/signup",
-      "http://api.test/api/v1/auth/login",
-      "http://api.test/api/v1/auth/signup",
-      "http://api.test/api/v1/auth/login",
-      "http://api.test/api/v1/auth/signup",
-      "http://api.test/api/v1/auth/login",
-    ]);
-    clearRuntimeContext();
-  });
-
-  it("builds a single-org topology with deterministic defaults", () => {
-    const topology = auth.topologies.singleOrg({
-      namespace: "sample-app",
-      actors: ["primary", "reviewer"],
-    });
-
-    expect(topology.actors.primary.email).toBe("testkit+sample-app.primary@example.test");
-    expect(topology.actors.reviewer.name).toBe("Testkit Sample App Reviewer");
-    expect(topology.actors.primary.organizationName).toBe("Testkit Sample App Primary Org");
-  });
-
-  it("treats signup as best-effort when login still succeeds", () => {
-    registerRuntimeContext({
-      env: {
-        BASE: "http://api.test",
-        routeParams: {},
-      },
-      http: {
-        post(url, body) {
-          const payload = JSON.parse(body);
-          if (url.endsWith("/signup")) {
-            return {
-              status: 500,
-              body: JSON.stringify({ error: "Failed to create account" }),
-              headers: {},
-            };
-          }
-
-          return {
-            status: 200,
-            body: JSON.stringify({
-              data: {
-                organizations: [{ id: "org-primary" }],
-              },
-            }),
-            headers: {
-              "set-cookie": ["fixture_session=jwt-primary; Path=/"],
-            },
-          };
-        },
-      },
-    });
-
-    const fixture = auth.fixture({
-      contract: auth.contracts.jsonSession({
-        authCookie: "fixture_session",
-        organizationIdPath: "data.organizations[0].id",
-      }),
-      topology: auth.topologies.singleOrg({
-        namespace: "signup-race",
-        actors: ["primary"],
-      }),
-    });
-
-    const profiles = fixture.profiles({
-      default: auth.profile.actor("primary"),
-    });
-
-    const setup = profiles.default.auth.setup({ env: { BASE: "http://api.test", routeParams: {} } });
-    expect(setup.actors.primary.organizationId).toBe("org-primary");
-    expect(setup.actors.primary.jwt).toBe("jwt-primary");
-
-    clearRuntimeContext();
-  });
-
-  it("defines file-local metadata plainly", () => {
-    expect(defineFile({ skip: "Auth is stubbed", locks: ["background-workers"] })).toEqual({
-      skip: "Auth is stubbed",
-      locks: ["background-workers"],
-    });
-  });
-
-  it("builds a Next app preset for dev mode", () => {
-    const config = app.next({ port: 3000 });
-
-    expect(config.local.start).toBe("./node_modules/.bin/next dev -p {port}");
-  });
-
-  it("builds a Next app preset for start mode with managed runtime env defaults", () => {
-    const config = app.next({ cwd: "frontend", port: 3000, mode: "start" });
-
-    expect(config.local.start).toBe("./node_modules/.bin/next start --port {port}");
-    expect(config.local.env).toMatchObject({
-      NEXT_DIST_DIR: ".next-testkit/{runtimeId}/dist",
-      NEXT_TSCONFIG_PATH: ".next-testkit/{runtimeId}/tsconfig.json",
-    });
-    expect(config.runtime.build).toEqual({
-      kind: "next",
-      cwd: "frontend",
-      distDir: "dist",
-      tsconfig: "tsconfig.json",
-      inputs: undefined,
-    });
-  });
-
-  it("allows Next start apps to disable managed builds explicitly", () => {
-    const config = app.next({ cwd: "frontend", port: 3000, mode: "start", build: null });
-
-    expect(config.runtime.build).toBeNull();
-    expect(config.local.env).toMatchObject({
-      NEXT_DIST_DIR: ".next-testkit/{runtimeId}/dist",
-      NEXT_TSCONFIG_PATH: ".next-testkit/{runtimeId}/tsconfig.json",
-    });
-  });
-
-  it("builds a Node app preset with tsc build defaults", () => {
-    const config = app.node({ port: 3000, entry: "src/server.ts" });
-
-    expect(config.local.start).toBe("node {prepareDir}/dist/server.js");
-    expect(config.runtime.build).toEqual({
-      kind: "tsc",
-      cwd: ".",
-      entry: "src/server.ts",
-      tsconfig: "tsconfig.json",
-      outDir: "dist",
-      inputs: undefined,
-    });
-  });
-
-  it("builds node toolchain profiles with a node kind", () => {
-    expect(toolchain.node({ node: "20.19.5", install: "download" })).toEqual({
-      kind: "node",
-      node: "20.19.5",
-      install: "download",
-    });
-  });
-
-  it("builds declarative postgres database templates from plain objects", () => {
-    expect(
-      database.postgres({
-        template: {
-          inputs: ["db/schema.sql", "scripts/seed.ts"],
-          schema: "db/schema.sql",
-          seed: { kind: "command", run: "npm run db:seed" },
-          verify: { kind: "module", target: "scripts/verify.ts#verifySeed" },
-        },
-      })
-    ).toEqual({
-      provider: "local",
-      template: {
-        inputs: ["db/schema.sql", "scripts/seed.ts"],
-        migrate: [
-          {
-            kind: "sql-file",
-            path: "db/schema.sql",
-          },
-        ],
-        seed: [
-          {
-            kind: "command",
-            run: "npm run db:seed",
-          },
-        ],
-        verify: [
-          {
-            kind: "module",
-            target: "scripts/verify.ts#verifySeed",
-          },
-        ],
-      },
-    });
-  });
-
-  it("prepends schema before explicit migrate steps and normalizes singletons to arrays", () => {
-    expect(
-      database.postgres({
-        template: {
-          schema: { kind: "sql-file", path: "db/schema.sql", cwd: "db" },
-          migrate: { kind: "command", run: "echo migrate" },
-        },
-      })
-    ).toEqual({
-      provider: "local",
-      template: {
-        inputs: undefined,
-        migrate: [
-          {
-            kind: "sql-file",
-            path: "db/schema.sql",
-            cwd: "db",
-          },
-          {
-            kind: "command",
-            run: "echo migrate",
-          },
-        ],
-        seed: [],
-        verify: [],
-      },
-    });
-  });
-
-  it("builds support database presets and expands database env bindings declaratively", () => {
-    expect(
-      database.fixture({
-        reset: true,
-      })
-    ).toEqual({
-      discovery: {
-        roots: [".testkit-fixture"],
-      },
-      envFiles: undefined,
-      local: false,
-      database: {
-        provider: "local",
-        reset: true,
-      },
-    });
-
-    const config = app.node({
-      port: 3000,
-      env: {
-        values: { API_KEY: "test" },
-        databases: {
-          onix: { service: "catalog", prefix: "ONIX" },
-        },
-      },
-    });
-
-    expect(config.local.env).toEqual({
-      API_KEY: "test",
-      ONIX_DATABASE_HOST: "{dbHost:catalog}",
-      ONIX_DATABASE_PORT: "{dbPort:catalog}",
-      ONIX_DATABASE_NAME: "{dbName:catalog}",
-      ONIX_DATABASE_USER: "{dbUser:catalog}",
-      ONIX_DATABASE_PASSWORD: "{dbPassword:catalog}",
-      ONIX_DATABASE_SSL: "0",
-    });
-  });
-
-  it("rejects top-level database template lifecycle fields", () => {
-    expect(() =>
-      database.postgres({
-        schema: "db/schema.sql",
-      })
-    ).toThrow(/no longer accepts top-level "schema"/);
-    expect(() =>
-      database.fixture({
-        seed: { kind: "command", run: "npm run db:seed" },
-      })
-    ).toThrow(/no longer accepts top-level "seed"/);
-  });
-
-  it("does not leak preset-only helper fields into node app configs", () => {
-    const config = app.node({
-      port: 3000,
-      entry: "src/server.ts",
-      buildInputs: ["src", "package.json"],
-      env: { values: { API_KEY: "test" } },
-      readyPath: "/live",
-    });
-
-    expect(config).not.toHaveProperty("entry");
-    expect(config).not.toHaveProperty("buildInputs");
-    expect(config).not.toHaveProperty("readyPath");
-    expect(config.local.env).toEqual({ API_KEY: "test" });
-    expect(config.local.readyUrl).toBe("http://127.0.0.1:{port}/live");
-  });
-
-  it("rejects flat preset env maps in favor of env.values and env.databases", () => {
-    expect(() =>
-      app.node({
-        port: 3000,
-        env: {
-          API_KEY: "test",
-        },
-      })
-    ).toThrow(/Preset env only supports "values" and "databases"/);
-  });
-});

package/lib/config-api/next-runtime-tsconfig.test.mjs

@@ -1,58 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it } from "vitest";
-import { writeNextRuntimeTsconfig } from "./next-runtime-tsconfig.mjs";
-
-const cleanups = [];
-
-afterEach(() => {
-  while (cleanups.length > 0) {
-    cleanups.pop()();
-  }
-});
-
-describe("next runtime tsconfig helper", () => {
-  it("writes a runtime-specific tsconfig for next builds", async () => {
-    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-next-tsconfig-"));
-    cleanups.push(() => fs.rmSync(tempRoot, { recursive: true, force: true }));
-
-    const serviceDir = path.join(tempRoot, "frontend");
-    fs.mkdirSync(path.join(serviceDir, "src"), { recursive: true });
-    fs.writeFileSync(path.join(serviceDir, "tsconfig.json"), "{}\n");
-    fs.writeFileSync(path.join(serviceDir, "next-env.d.ts"), "// next\n");
-
-    await writeNextRuntimeTsconfig({
-      cwd: serviceDir,
-      productDir: tempRoot,
-      runtimeId: "runtime-1",
-    });
-
-    const generated = JSON.parse(
-      fs.readFileSync(path.join(serviceDir, ".next-testkit", "runtime-1", "tsconfig.json"), "utf8")
-    );
-    expect(generated).toEqual({
-      extends: "../../tsconfig.json",
-      compilerOptions: {
-        paths: {
-          "@/*": ["../../src/*"],
-        },
-      },
-      include: [
-        "../../next-env.d.ts",
-        "../../src/**/*.ts",
-        "../../src/**/*.tsx",
-        "../../src/**/*.mts",
-        "dist/types/**/*.ts",
-        "dist/dev/types/**/*.ts",
-      ],
-      exclude: [
-        "node_modules",
-        "../../src/**/__testkit__/**",
-        "../../tests/**",
-        ".next/cache",
-        ".next/dev",
-      ],
-    });
-  });
-});

package/lib/coverage/backend-discovery.test.mjs

@@ -1,61 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { extractBackendImports, extractDataImports } from "./backend-discovery.mjs";
-
-describe("coverage backend discovery", () => {
-  it("tracks local import names while anchoring capabilities to exported names", () => {
-    const content = [
-      'import { saveSettings as persistSettings } from "@/backend/server/settings";',
-      'import { loadProjects as fetchProjects } from "@/backend/data/projects";',
-    ].join("\n");
-
-    expect(
-      extractBackendImports({
-        serviceName: "web",
-        serviceRoot: "/repo",
-        filePath: "src/app/settings/actions.ts",
-        content,
-        resolveImport: () => "src/backend/server/settings.ts",
-      })
-    ).toEqual([
-      {
-        importName: "persistSettings",
-        node: {
-          id: "server_capability:src/backend/server/settings#saveSettings",
-          kind: "server_capability",
-          service: "web",
-          label: "saveSettings",
-          filePath: "src/backend/server/settings.ts",
-          metadata: {
-            specifier: "@/backend/server/settings",
-            localName: "persistSettings",
-          },
-        },
-      },
-    ]);
-
-    expect(
-      extractDataImports({
-        serviceName: "web",
-        serviceRoot: "/repo",
-        filePath: "src/backend/server/settings.ts",
-        content,
-        resolveImport: () => "src/backend/data/projects.ts",
-      })
-    ).toEqual([
-      {
-        importName: "fetchProjects",
-        node: {
-          id: "data_capability:src/backend/data/projects#loadProjects",
-          kind: "data_capability",
-          service: "web",
-          label: "loadProjects",
-          filePath: "src/backend/data/projects.ts",
-          metadata: {
-            specifier: "@/backend/data/projects",
-            localName: "fetchProjects",
-          },
-        },
-      },
-    ]);
-  });
-});

package/lib/coverage/evidence.test.mjs

@@ -1,87 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  buildEvidenceDetailsFromTargets,
-  extractPlaywrightTargetsFromContent,
-  inferDataCapabilitiesFromOwner,
-} from "./evidence.mjs";
-import { extractPlaywrightVisitedRoutes } from "@elench/ts-analysis";
-import { DYNAMIC_SEGMENT_TOKEN } from "./shared.mjs";
-
-describe("coverage evidence helpers", () => {
-  it("extracts and dedupes Playwright targets from source content", () => {
-    const content = `
-      await page.getByTestId("save-button").click();
-      await page.locator('[data-testid="save-button"]').click();
-      await page.getByTestId("drawer").click();
-    `;
-
-    expect(extractPlaywrightTargetsFromContent(content)).toEqual([
-      { kind: "testId", value: "save-button", confidence: "high" },
-      { kind: "testId", value: "drawer", confidence: "high" },
-    ]);
-  });
-
-  it("builds compact evidence details only when meaningful signals exist", () => {
-    expect(
-      buildEvidenceDetailsFromTargets({
-        routes: ["/campaigns"],
-        requestPaths: ["/api/campaigns"],
-        targets: [{ kind: "testId", value: "save-button", confidence: "high" }],
-      })
-    ).toEqual({
-      route: "/campaigns",
-      requestPaths: ["/api/campaigns"],
-      targets: [{ kind: "testId", value: "save-button", confidence: "high" }],
-    });
-
-    expect(buildEvidenceDetailsFromTargets({ routes: [], requestPaths: [], targets: [] })).toBeUndefined();
-  });
-
-  it("infers DAL coverage from owner directories", () => {
-    const dataCapabilities = [
-      { id: "data_capability:src/backend/data/campaigns#saveCampaignRow", filePath: "src/backend/data/campaigns/index.ts" },
-      { id: "data_capability:src/backend/data/users#saveUserRow", filePath: "src/backend/data/users/index.ts" },
-    ];
-
-    expect(inferDataCapabilitiesFromOwner("src/backend/data/campaigns", dataCapabilities)).toEqual([
-      "data_capability:src/backend/data/campaigns#saveCampaignRow",
-    ]);
-  });
-});
-
-describe("extractPlaywrightVisitedRoutes", () => {
-  it("extracts routes from page.goto() via AST", () => {
-    expect(extractPlaywrightVisitedRoutes(`
-      import { test } from "@playwright/test";
-      test("nav", async ({ page }) => {
-        await page.goto("/dashboard");
-        await page.goto("/settings/profile?tab=general");
-        await page.goto("/dashboard"); // duplicate
-        await page.goto("https://external.com/path"); // external
-        await page.goto("http://localhost:3000/events"); // same-origin absolute
-      });
-    `, {
-      filePath: "nav.pw.testkit.ts",
-      dynamicSegmentToken: DYNAMIC_SEGMENT_TOKEN,
-    })).toEqual(["/dashboard", "/settings/profile", "/events"]);
-  });
-
-  it("handles property chain: foo.page.goto()", () => {
-    expect(extractPlaywrightVisitedRoutes(`
-      await this.page.goto("/projects");
-    `, {
-      filePath: "test.pw.testkit.ts",
-      dynamicSegmentToken: DYNAMIC_SEGMENT_TOKEN,
-    })).toEqual(["/projects"]);
-  });
-
-  it("normalizes dynamic goto expressions into route patterns", () => {
-    expect(extractPlaywrightVisitedRoutes(`
-      await page.goto(\`/projects/\${id}\`);
-      await page.goto(someVar);
-    `, {
-      filePath: "test.pw.testkit.ts",
-      dynamicSegmentToken: DYNAMIC_SEGMENT_TOKEN,
-    })).toEqual([`/projects/${DYNAMIC_SEGMENT_TOKEN}`]);
-  });
-});