@elench/testkit 0.1.81 → 0.1.83

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

@@ -1,10 +1,10 @@
 import { describe, expect, it } from "vitest";
 import {
+  auth,
   app,
   database,
   defineConfig,
   defineFile,
-  profiles,
   toolchain,
 } from "./index.mjs";
 import { clearRuntimeContext, registerRuntimeContext } from "./runtime.mjs";
@@ -16,27 +16,7 @@ describe("config api", () => {
     });
   });
 
-  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", () => {
+  it("builds generated auth fixture profiles with actor-aware sessions and headers", () => {
     const requests = [];
     registerRuntimeContext({
       env: {
@@ -45,100 +25,13 @@ describe("config api", () => {
       },
       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";
+          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({
@@ -157,68 +50,71 @@ describe("config api", () => {
       },
     });
 
-    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: {
+    const fixture = auth.fixture({
+      contract: auth.contracts.jsonSession({
         authCookie: "fixture_session",
         refreshCookie: "fixture_refresh",
         organizationIdPath: "data.organizations[0].id",
-      },
-      headers: {
-        contentTypeJson: true,
         forwardedFor: "deterministic",
-        organization: "X-Organization-Id",
-      },
+        organizationHeader: "X-Organization-Id",
+      }),
+      topology: auth.topologies.crossOrg({
+        namespace: "fixture",
+        actors: {
+          primary: { org: "primary" },
+          userA: { org: "primary" },
+          userB: { org: "secondary" },
+        },
+      }),
     });
 
-    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",
+    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(defaultProfile.auth.headers(defaultSetup)).toEqual({
+
+    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(defaultProfile.headers(defaultSetup, { env: { BASE: "http://api.test" } })).toMatchObject({
+    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 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({
+    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",
     });
 
-    const rawProfile = auth.raw();
-    expect(rawProfile.rawHeaders(null, { env: { BASE: "http://api.test" } })).toMatchObject({
+    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",
@@ -230,71 +126,68 @@ describe("config api", () => {
     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=/" },
-      },
-    };
+  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) {
+        post(url, body) {
           const payload = JSON.parse(body);
-          return payload.email.startsWith("alpha") ? responses.alpha : responses.beta;
-        },
-      },
-    });
+          if (url.endsWith("/signup")) {
+            return {
+              status: 500,
+              body: JSON.stringify({ error: "Failed to create account" }),
+              headers: {},
+            };
+          }
 
-    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" } },
-          },
+          return {
+            status: 200,
+            body: JSON.stringify({
+              data: {
+                organizations: [{ id: "org-primary" }],
+              },
+            }),
+            headers: {
+              "set-cookie": ["fixture_session=jwt-primary; Path=/"],
+            },
+          };
         },
       },
-      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",
+    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"],
+      }),
     });
-    expect(profile.headers(setupData, { env: { BASE: "http://api.test" } })).toMatchObject({
-      "X-Organization-Id": "org-alpha",
+
+    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();
   });
 

package/lib/discovery/index.mjs

@@ -494,7 +494,7 @@ function normalizePath(filePath) {
   return String(filePath).split(path.sep).join("/").replace(/^\.\/+/, "");
 }
 
-function fileDisplayName(filePath) {
+export function fileDisplayName(filePath) {
   const base = path.posix
     .basename(filePath)
     .replace(/(\.int|\.e2e|\.scenario|\.dal|\.load|\.pw)\.testkit\.ts$/, "");

package/lib/index.d.ts

@@ -1,6 +1,8 @@
 import type {
+  ActorRequestClient,
   HttpClient,
   HttpClientConfig,
+  RawRequestClient,
   RuntimeDb,
   RuntimeDalContext,
   RuntimeEnv,
@@ -16,6 +18,7 @@ export interface TestkitSuite<TSetup = unknown> {
 }
 
 export interface HeaderBuilderContext {
+  actor?: string | null;
   env: RuntimeEnv;
 }
 
@@ -29,13 +32,34 @@ export interface AuthAdapter<TSetup = unknown> {
   headers?: HeaderBuilder<TSetup>;
 }
 
-export interface HttpSuiteContext<TSetup = unknown> {
+export interface SuiteActor<TSession = Record<string, unknown>> {
+  email: string | null;
+  headers: RuntimeHeaders;
+  index: number;
+  key: string;
+  name: string | null;
+  organizationKey: string | null;
+  organizationName: string | null;
+  rawHeaders: RuntimeHeaders;
+  rawReq: RawRequestClient;
+  req: ActorRequestClient;
+  session: TSession | null;
+}
+
+export interface SuiteActors<TSession = Record<string, unknown>> {
+  readonly names: string[];
+  readonly primary: SuiteActor<TSession> | null;
+  get(name: string): SuiteActor<TSession>;
+  has(name: string): boolean;
+  list(): SuiteActor<TSession>[];
+}
+
+export interface HttpSuiteContext<TSession = Record<string, unknown>> {
+  actor: SuiteActor<TSession> | null;
+  actors: SuiteActors<TSession>;
   env: RuntimeEnv;
-  req: HttpClient<TSetup>["request"];
-  rawReq: HttpClient["raw"];
-  getWithHeaders: HttpClient<TSetup>["getWithHeaders"];
-  setupData: TSetup | null;
-  session: TSetup | null;
+  req: HttpClient<TSession>;
+  rawReq: RawRequestClient;
 }
 
 export interface ScenarioStepResult {
@@ -83,14 +107,14 @@ export interface ScenarioRuntime {
   };
 }
 
-export interface ScenarioSuiteContext<TSetup = unknown> extends HttpSuiteContext<TSetup> {
+export interface ScenarioSuiteContext<TSession = Record<string, unknown>> extends HttpSuiteContext<TSession> {
   scenario: ScenarioRuntime;
 }
 
-export interface HttpSuiteConfig<TSetup = unknown> {
-  auth?: AuthAdapter<TSetup> | null;
+export interface HttpSuiteConfig<TSession = unknown> {
+  auth?: AuthAdapter<TSession> | null;
   env?: RuntimeEnv;
-  headers?: HeaderBuilder<TSetup>;
+  headers?: HeaderBuilder<TSession>;
   profile?: string;
   rawHeaders?: HeaderBuilder<never>;
   options?: RuntimeOptions;

package/lib/runner/orchestrator.mjs

@@ -85,6 +85,7 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
     execution,
     reporter
   );
+  reporter?.setServicePlans?.(servicePlans);
   const trackers = buildServiceTrackers(servicePlans, startedAt);
   let writeLiveSnapshot = () => {};
   const setupRegistry = createSetupOperationRegistry({ logRegistry, onChange: () => writeLiveSnapshot() });