@elench/testkit 0.1.76 → 0.1.78

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

@@ -1,35 +1,301 @@
 import { describe, expect, it } from "vitest";
 import {
-  databaseServiceEnv,
+  app,
+  database,
   defineConfig,
   defineFile,
-  defineHttpProfile,
-  nextApp,
-  nextBuild,
-  nodeToolchain,
-  nodeApp,
-  postgresDatabase,
-  postgresFixture,
-  schemaSql,
-  seedCommand,
-  seedModule,
-  stepsBuild,
-  templateDatabase,
-  tscBuild,
-  verifyCommand,
-  verifyModule,
+  profiles,
+  toolchain,
 } from "./index.mjs";
+import { clearRuntimeContext, registerRuntimeContext } from "./runtime.mjs";
 
-describe("config helpers", () => {
+describe("config api", () => {
   it("defines repo config plainly", () => {
     expect(defineConfig({ execution: { workers: 4 } })).toEqual({
       execution: { workers: 4 },
     });
   });
 
-  it("defines HTTP profiles plainly", () => {
-    const profile = defineHttpProfile({ headers: () => ({ Authorization: "Bearer token" }) });
-    expect(typeof profile.headers).toBe("function");
+  it("builds raw HTTP profiles with deterministic forwarded headers", () => {
+    const profile = profiles.raw({
+      headers: {
+        contentTypeJson: true,
+        forwardedFor: "deterministic",
+        values: { "X-Testkit-Mode": "raw" },
+      },
+    });
+
+    const headers = profile.headers?.(null, { env: { BASE: "http://api.test" } });
+    const rawHeaders = profile.rawHeaders?.(null, { env: { BASE: "http://api.test" } });
+
+    expect(headers).toMatchObject({
+      "Content-Type": "application/json",
+      "X-Testkit-Mode": "raw",
+    });
+    expect(headers["X-Forwarded-For"]).toMatch(/^10\.\d+\.\d+\.\d+$/);
+    expect(rawHeaders).toEqual(headers);
+  });
+
+  it("builds session profiles that perform bootstrap/login and derive auth/session headers", () => {
+    const requests = [];
+    registerRuntimeContext({
+      env: {
+        BASE: "http://api.test",
+        routeParams: { "x-route": "route-a" },
+      },
+      http: {
+        post(url, body, params) {
+          requests.push({ url, body, params });
+          if (url.endsWith("/signup")) {
+            return {
+              status: 201,
+              body: JSON.stringify({ data: { organizations: [{ id: "org-signup" }] } }),
+              headers: {
+                "set-cookie": ["fixture_session=signup-token; Path=/", "fixture_refresh=signup-refresh; Path=/"],
+              },
+            };
+          }
+          return {
+            status: 200,
+            body: JSON.stringify({ data: { organizations: [{ id: "org-123" }] } }),
+            headers: {
+              "set-cookie": ["fixture_session=jwt-123; Path=/", "fixture_refresh=refresh-123; Path=/"],
+            },
+          };
+        },
+      },
+    });
+
+    const profile = profiles.session({
+      actor: {
+        bootstrap: {
+          path: "/signup",
+          expect: [201, 409],
+          body: ({ actor }) => ({ email: `${actor}@example.com` }),
+        },
+        login: {
+          path: "/login",
+          expect: 200,
+          body: ({ actor }) => ({ email: `${actor}@example.com` }),
+        },
+        session: {
+          cookies: {
+            jwt: "fixture_session",
+            refreshToken: "fixture_refresh",
+          },
+          fields: {
+            organizationId: "data.organizations[0].id",
+          },
+          auth: {
+            source: { key: "jwt" },
+          },
+        },
+      },
+      headers: {
+        contentTypeJson: true,
+        forwardedFor: "deterministic",
+        fromSession: [{ header: "X-Organization-Id", field: "organizationId" }],
+        values: ({ actor }) => ({ "X-Testkit-Actor": actor || "primary" }),
+      },
+    });
+
+    const session = profile.auth.setup({
+      env: { BASE: "http://api.test", routeParams: { "x-route": "route-a" } },
+    });
+    const authHeaders = profile.auth.headers(session, { env: { BASE: "http://api.test" } });
+    const requestHeaders = profile.headers(session, { env: { BASE: "http://api.test" } });
+
+    expect(requests).toHaveLength(2);
+    expect(requests[0].params.headers["x-route"]).toBe("route-a");
+    expect(session).toEqual({
+      jwt: "jwt-123",
+      refreshToken: "refresh-123",
+      organizationId: "org-123",
+    });
+    expect(authHeaders).toEqual({
+      Authorization: "Bearer jwt-123",
+    });
+    expect(requestHeaders).toMatchObject({
+      "Content-Type": "application/json",
+      "X-Organization-Id": "org-123",
+      "X-Testkit-Actor": "primary",
+    });
+    expect(requestHeaders["X-Forwarded-For"]).toMatch(/^10\.\d+\.\d+\.\d+$/);
+    clearRuntimeContext();
+  });
+
+  it("builds local-json profile presets that derive session, multi-actor, and raw variants", () => {
+    const requests = [];
+    registerRuntimeContext({
+      env: {
+        BASE: "http://api.test",
+      },
+      http: {
+        post(url, body) {
+          const payload = JSON.parse(body);
+          requests.push({ url, payload });
+          const actor = payload.email.startsWith("primary")
+            ? "primary"
+            : payload.email.startsWith("user-a")
+              ? "userA"
+              : "userB";
+          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 auth = profiles.localJson({
+      password: "TestkitPass2026",
+      identities: {
+        primary: {
+          email: "primary@example.com",
+          name: "Primary User",
+          organizationName: "Primary Org",
+        },
+        userA: {
+          email: "user-a@example.com",
+          name: "User A",
+          organizationName: "Org A",
+        },
+        userB: {
+          email: "user-b@example.com",
+          name: "User B",
+          organizationName: "Org B",
+        },
+      },
+      session: {
+        authCookie: "fixture_session",
+        refreshCookie: "fixture_refresh",
+        organizationIdPath: "data.organizations[0].id",
+      },
+      headers: {
+        contentTypeJson: true,
+        forwardedFor: "deterministic",
+        organization: "X-Organization-Id",
+      },
+    });
+
+    const defaultProfile = auth.session();
+    const defaultSetup = defaultProfile.auth.setup({ env: { BASE: "http://api.test" } });
+    expect(defaultSetup).toEqual({
+      jwt: "jwt-primary",
+      refreshToken: "refresh-primary",
+      organizationId: "org-primary",
+    });
+    expect(defaultProfile.auth.headers(defaultSetup)).toEqual({
+      Authorization: "Bearer jwt-primary",
+    });
+    expect(defaultProfile.headers(defaultSetup, { env: { BASE: "http://api.test" } })).toMatchObject({
+      "Content-Type": "application/json",
+      "X-Organization-Id": "org-primary",
+    });
+
+    const dualProfile = auth.multiActor({
+      primaryActor: "userA",
+      actors: ["userA", "userB"],
+    });
+    const dualSetup = dualProfile.auth.setup({ env: { BASE: "http://api.test" } });
+    expect(dualSetup.userA.organizationId).toBe("org-userA");
+    expect(dualSetup.userB.organizationId).toBe("org-userB");
+    expect(dualProfile.auth.headers(dualSetup)).toEqual({
+      Authorization: "Bearer jwt-userA",
+    });
+
+    const rawProfile = auth.raw();
+    expect(rawProfile.rawHeaders(null, { env: { BASE: "http://api.test" } })).toMatchObject({
+      "Content-Type": "application/json",
+    });
+
+    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 multi-actor profiles and derives headers from the primary actor by default", () => {
+    const responses = {
+      alpha: {
+        status: 200,
+        body: JSON.stringify({ data: { organizations: [{ id: "org-alpha" }] } }),
+        headers: { "set-cookie": "fixture_session=token-alpha; Path=/" },
+      },
+      beta: {
+        status: 200,
+        body: JSON.stringify({ data: { organizations: [{ id: "org-beta" }] } }),
+        headers: { "set-cookie": "fixture_session=token-beta; Path=/" },
+      },
+    };
+    registerRuntimeContext({
+      env: {
+        BASE: "http://api.test",
+      },
+      http: {
+        post(_url, body) {
+          const payload = JSON.parse(body);
+          return payload.email.startsWith("alpha") ? responses.alpha : responses.beta;
+        },
+      },
+    });
+
+    const profile = profiles.multiActor({
+      primaryActor: "userA",
+      actors: {
+        userA: {
+          login: {
+            path: "/login",
+            body: () => ({ email: "alpha@example.com" }),
+          },
+          session: {
+            cookies: { jwt: "fixture_session" },
+            fields: { organizationId: "data.organizations[0].id" },
+            auth: { source: { key: "jwt" } },
+          },
+        },
+        userB: {
+          login: {
+            path: "/login",
+            body: () => ({ email: "beta@example.com" }),
+          },
+          session: {
+            cookies: { jwt: "fixture_session" },
+            fields: { organizationId: "data.organizations[0].id" },
+            auth: { source: { key: "jwt" } },
+          },
+        },
+      },
+      headers: {
+        fromSession: [{ header: "X-Organization-Id", field: "organizationId" }],
+      },
+    });
+
+    const setupData = profile.auth.setup({ env: { BASE: "http://api.test" } });
+    expect(setupData.userA.organizationId).toBe("org-alpha");
+    expect(setupData.userB.organizationId).toBe("org-beta");
+    expect(profile.auth.headers(setupData)).toEqual({
+      Authorization: "Bearer token-alpha",
+    });
+    expect(profile.headers(setupData, { env: { BASE: "http://api.test" } })).toMatchObject({
+      "X-Organization-Id": "org-alpha",
+    });
+    clearRuntimeContext();
   });
 
   it("defines file-local metadata plainly", () => {
@@ -40,13 +306,13 @@ describe("config helpers", () => {
   });
 
   it("builds a Next app preset for dev mode", () => {
-    const config = nextApp({ port: 3000 });
+    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 = nextApp({ cwd: "frontend", port: 3000, mode: "start" });
+    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({
@@ -63,7 +329,7 @@ describe("config helpers", () => {
   });
 
   it("allows Next start apps to disable managed builds explicitly", () => {
-    const config = nextApp({ cwd: "frontend", port: 3000, mode: "start", build: null });
+    const config = app.next({ cwd: "frontend", port: 3000, mode: "start", build: null });
 
     expect(config.runtime.build).toBeNull();
     expect(config.local.env).toMatchObject({
@@ -73,7 +339,7 @@ describe("config helpers", () => {
   });
 
   it("builds a Node app preset with tsc build defaults", () => {
-    const config = nodeApp({ port: 3000, entry: "src/server.ts" });
+    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({
@@ -87,88 +353,22 @@ describe("config helpers", () => {
   });
 
   it("builds node toolchain profiles with a node kind", () => {
-    expect(nodeToolchain({ node: "20.19.5", install: "download" })).toEqual({
+    expect(toolchain.node({ node: "20.19.5", install: "download" })).toEqual({
       kind: "node",
       node: "20.19.5",
       install: "download",
     });
   });
 
-  it("builds explicit build presets", () => {
-    expect(tscBuild({ entry: "src/server.ts", outDir: "build" })).toEqual({
-      kind: "tsc",
-      cwd: undefined,
-      entry: "src/server.ts",
-      tsconfig: "tsconfig.json",
-      outDir: "build",
-      inputs: undefined,
-    });
-    expect(nextBuild({ cwd: "frontend" })).toEqual({
-      kind: "next",
-      cwd: "frontend",
-      distDir: "dist",
-      tsconfig: "tsconfig.json",
-      inputs: undefined,
-    });
+  it("builds declarative postgres database templates from plain objects", () => {
     expect(
-      stepsBuild({
-        inputs: ["scripts/prepare.mjs"],
-        steps: [seedCommand("node scripts/prepare.mjs")],
-      })
-    ).toEqual({
-      kind: "steps",
-      inputs: ["scripts/prepare.mjs"],
-      steps: [
-        {
-          kind: "command",
-          cmd: "node scripts/prepare.mjs",
-          cwd: undefined,
-          inputs: undefined,
+      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" },
         },
-      ],
-    });
-  });
-
-  it("emits semantic database template steps using the underlying step shapes", () => {
-    expect(schemaSql("db/schema.sql")).toEqual({
-      kind: "sql-file",
-      path: "db/schema.sql",
-      cwd: undefined,
-      inputs: undefined,
-    });
-    expect(seedCommand("npm run db:seed")).toEqual({
-      kind: "command",
-      cmd: "npm run db:seed",
-      cwd: undefined,
-      inputs: undefined,
-    });
-    expect(seedModule("scripts/seed.ts#seed")).toEqual({
-      kind: "module",
-      specifier: "scripts/seed.ts#seed",
-      cwd: undefined,
-      inputs: undefined,
-    });
-    expect(verifyCommand("npm run db:verify")).toEqual({
-      kind: "command",
-      cmd: "npm run db:verify",
-      cwd: undefined,
-      inputs: undefined,
-    });
-    expect(verifyModule("scripts/verify.ts#verify")).toEqual({
-      kind: "module",
-      specifier: "scripts/verify.ts#verify",
-      cwd: undefined,
-      inputs: undefined,
-    });
-  });
-
-  it("builds declarative template databases from schema, seed, and verify intents", () => {
-    expect(
-      templateDatabase({
-        inputs: ["db/schema.sql", "scripts/seed.ts"],
-        schema: "db/schema.sql",
-        seed: seedCommand("npm run db:seed"),
-        verify: verifyModule("scripts/verify.ts#verifySeed"),
       })
     ).toEqual({
       provider: "local",
@@ -178,24 +378,18 @@ describe("config helpers", () => {
           {
             kind: "sql-file",
             path: "db/schema.sql",
-            cwd: undefined,
-            inputs: undefined,
           },
         ],
         seed: [
           {
             kind: "command",
-            cmd: "npm run db:seed",
-            cwd: undefined,
-            inputs: undefined,
+            run: "npm run db:seed",
           },
         ],
         verify: [
           {
             kind: "module",
-            specifier: "scripts/verify.ts#verifySeed",
-            cwd: undefined,
-            inputs: undefined,
+            target: "scripts/verify.ts#verifySeed",
           },
         ],
       },
@@ -204,9 +398,11 @@ describe("config helpers", () => {
 
   it("prepends schema before explicit migrate steps and normalizes singletons to arrays", () => {
     expect(
-      templateDatabase({
-        schema: schemaSql("db/schema.sql", { cwd: "db" }),
-        migrate: seedCommand("echo migrate"),
+      database.postgres({
+        template: {
+          schema: { kind: "sql-file", path: "db/schema.sql", cwd: "db" },
+          migrate: { kind: "command", run: "echo migrate" },
+        },
       })
     ).toEqual({
       provider: "local",
@@ -217,13 +413,10 @@ describe("config helpers", () => {
             kind: "sql-file",
             path: "db/schema.sql",
             cwd: "db",
-            inputs: undefined,
           },
           {
             kind: "command",
-            cmd: "echo migrate",
-            cwd: undefined,
-            inputs: undefined,
+            run: "echo migrate",
           },
         ],
         seed: [],
@@ -232,46 +425,9 @@ describe("config helpers", () => {
     });
   });
 
-  it("builds declarative postgres database helpers", () => {
-    expect(postgresDatabase({ reset: false })).toEqual({
-      provider: "local",
-      reset: false,
-    });
-    expect(
-      templateDatabase({
-        reset: true,
-        schema: "db/schema.sql",
-        seed: seedCommand("npm run db:seed"),
-      })
-    ).toEqual({
-      provider: "local",
-      reset: true,
-      template: {
-        inputs: undefined,
-        migrate: [
-          {
-            kind: "sql-file",
-            path: "db/schema.sql",
-            cwd: undefined,
-            inputs: undefined,
-          },
-        ],
-        seed: [
-          {
-            kind: "command",
-            cmd: "npm run db:seed",
-            cwd: undefined,
-            inputs: undefined,
-          },
-        ],
-        verify: [],
-      },
-    });
-  });
-
-  it("builds support database presets and env bindings", () => {
+  it("builds support database presets and expands database env bindings declaratively", () => {
     expect(
-      postgresFixture({
+      database.fixture({
         reset: true,
       })
     ).toEqual({
@@ -285,7 +441,19 @@ describe("config helpers", () => {
         reset: true,
       },
     });
-    expect(databaseServiceEnv("ONIX", "catalog")).toEqual({
+
+    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}",
@@ -295,12 +463,25 @@ describe("config helpers", () => {
     });
   });
 
+  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 = nodeApp({
+    const config = app.node({
       port: 3000,
       entry: "src/server.ts",
       buildInputs: ["src", "package.json"],
-      env: { API_KEY: "test" },
+      env: { values: { API_KEY: "test" } },
       readyPath: "/live",
     });
 
@@ -310,4 +491,15 @@ describe("config helpers", () => {
     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"/);
+  });
 });