@elench/testkit 0.1.77 → 0.1.78

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

@@ -4,9 +4,10 @@ import {
   database,
   defineConfig,
   defineFile,
-  defineHttpProfile,
+  profiles,
   toolchain,
 } from "./index.mjs";
+import { clearRuntimeContext, registerRuntimeContext } from "./runtime.mjs";
 
 describe("config api", () => {
   it("defines repo config plainly", () => {
@@ -15,9 +16,286 @@ describe("config api", () => {
     });
   });
 
-  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", () => {