@elench/testkit 0.1.81 → 0.1.83

package/lib/runtime-src/k6/http.test.mjs

@@ -0,0 +1,205 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mockHttp = {
+  del: vi.fn(),
+  file: vi.fn((data, filename, contentType) => ({
+    __testkitFile: true,
+    contentType,
+    data,
+    filename,
+  })),
+  get: vi.fn(),
+  patch: vi.fn(),
+  post: vi.fn(),
+  put: vi.fn(),
+};
+
+vi.mock("k6/http", () => ({
+  default: mockHttp,
+}));
+
+vi.mock("k6", () => ({
+  check: vi.fn((value, checks) =>
+    Object.values(checks).every((predicate) => predicate(value))
+  ),
+  group: vi.fn((name, fn) => fn()),
+}));
+
+vi.mock("k6/metrics", () => ({
+  Rate: class {
+    add() {}
+  },
+}));
+
+const { createHttpClient } = await import("./http.js");
+
+function makeResponse(status = 200, body = { ok: true }) {
+  return {
+    status,
+    body: JSON.stringify(body),
+    headers: { "content-type": "application/json" },
+  };
+}
+
+function makeSessionBundle() {
+  return {
+    primaryActor: "userA",
+    actors: {
+      userA: {
+        actorIndex: 0,
+        actorName: "userA",
+        email: "testkit+fixture.user-a@example.test",
+        jwt: "jwt-user-a",
+        organizationId: "org-alpha",
+        organizationKey: "primary",
+        organizationName: "Primary Org",
+        session: {
+          jwt: "jwt-user-a",
+          organizationId: "org-alpha",
+        },
+      },
+      userB: {
+        actorIndex: 1,
+        actorName: "userB",
+        email: "testkit+fixture.user-b@example.test",
+        jwt: "jwt-user-b",
+        organizationId: "org-beta",
+        organizationKey: "secondary",
+        organizationName: "Secondary Org",
+        session: {
+          jwt: "jwt-user-b",
+          organizationId: "org-beta",
+        },
+      },
+    },
+  };
+}
+
+describe("runtime http client", () => {
+  beforeEach(() => {
+    globalThis.__ENV = { TESTKIT_RUNTIME_ID: "unit" };
+    mockHttp.del.mockReset();
+    mockHttp.file.mockClear();
+    mockHttp.get.mockReset();
+    mockHttp.patch.mockReset();
+    mockHttp.post.mockReset();
+    mockHttp.put.mockReset();
+
+    mockHttp.get.mockImplementation(() => makeResponse());
+    mockHttp.post.mockImplementation(() => makeResponse(201));
+    mockHttp.put.mockImplementation(() => makeResponse());
+    mockHttp.patch.mockImplementation(() => makeResponse());
+    mockHttp.del.mockImplementation(() => makeResponse(204));
+  });
+
+  it("resolves actor-aware auth headers and raw headers", () => {
+    const client = createHttpClient({
+      baseUrl: "http://api.test",
+      defaultActor: "userA",
+      routeHeaders: { "x-route": "route-a" },
+      sessionBundle: makeSessionBundle(),
+      getHeaders({ actor }) {
+        return actor?.jwt
+          ? {
+              Authorization: `Bearer ${actor.jwt}`,
+              "Content-Type": "application/json",
+              "X-Organization-Id": actor.organizationId,
+            }
+          : {};
+      },
+      getRawHeaders({ actor }) {
+        return actor?.organizationId
+          ? {
+              "X-Organization-Id": actor.organizationId,
+            }
+          : {
+              "X-Testkit-Mode": "raw",
+            };
+      },
+    });
+
+    expect(client.headers({ "X-Test": "1" })).toEqual({
+      "Content-Type": "application/json",
+      Authorization: "Bearer jwt-user-a",
+      "X-Organization-Id": "org-alpha",
+      "x-route": "route-a",
+      "X-Test": "1",
+    });
+
+    expect(client.raw.headers()).toEqual({
+      "Content-Type": "application/json",
+      "X-Testkit-Mode": "raw",
+      "x-route": "route-a",
+    });
+
+    expect(client.raw.as("userB").headers({ "X-Trace": "secondary" })).toEqual({
+      "Content-Type": "application/json",
+      "X-Organization-Id": "org-beta",
+      "x-route": "route-a",
+      "X-Trace": "secondary",
+    });
+
+    client.as("userB").rawReq.get("/api/v1/context", { "X-Test": "1" });
+
+    expect(mockHttp.get).toHaveBeenCalledWith("http://api.test/api/v1/context", {
+      headers: expect.objectContaining({
+        "Content-Type": "application/json",
+        "X-Organization-Id": "org-beta",
+        "x-route": "route-a",
+        "X-Test": "1",
+        "x-request-id": expect.stringContaining("tk_unit_exec_"),
+      }),
+    });
+  });
+
+  it("builds multipart requests without forcing json content type", () => {
+    const client = createHttpClient({
+      baseUrl: "http://api.test",
+      defaultActor: "userA",
+      sessionBundle: makeSessionBundle(),
+      getHeaders({ actor }) {
+        return actor?.jwt
+          ? {
+              Authorization: `Bearer ${actor.jwt}`,
+              "Content-Type": "application/json",
+              "X-Organization-Id": actor.organizationId,
+            }
+          : {};
+      },
+    });
+
+    client.multipart.post("/api/v1/uploads", {
+      fields: { name: "fixture-upload" },
+      files: [
+        {
+          field: "file",
+          data: "hello world",
+          filename: "fixture.txt",
+          contentType: "text/plain",
+        },
+      ],
+    });
+
+    expect(mockHttp.file).toHaveBeenCalledWith("hello world", "fixture.txt", "text/plain");
+    expect(mockHttp.post).toHaveBeenCalledWith(
+      "http://api.test/api/v1/uploads",
+      {
+        file: {
+          __testkitFile: true,
+          contentType: "text/plain",
+          data: "hello world",
+          filename: "fixture.txt",
+        },
+        name: "fixture-upload",
+      },
+      {
+        headers: expect.objectContaining({
+          Authorization: "Bearer jwt-user-a",
+          "X-Organization-Id": "org-alpha",
+          "x-request-id": expect.stringContaining("tk_unit_exec_"),
+        }),
+      }
+    );
+    expect(mockHttp.post.mock.calls[0][2].headers["Content-Type"]).toBeUndefined();
+  });
+});

package/lib/runtime-src/k6/scenario-suite.js

@@ -7,17 +7,22 @@ import {
   startFailureCollection,
 } from "./checks.js";
 import {
-  createHttpClient,
   emitHttpTraceCollectionArtifact,
-  getEnv,
   startHttpTraceCollection,
 } from "./http.js";
 import {
   clearRuntimeContext,
   registerRuntimeContext,
-  resolveHttpProfile,
 } from "../../config-api/runtime.mjs";
 import { createScenarioRuntime } from "./scenario-runtime.js";
+import {
+  buildRuntimeExceptionDetail,
+  createSuiteActors,
+  formatFatalSuiteError,
+  mergeProfileConfig,
+  normalizeSuiteArgs,
+  resolveRuntimeConfig,
+} from "./http-suite-runtime.js";
 
 export function defineScenarioSuite(configOrRun, maybeRun) {
   const { config, run } = normalizeSuiteArgs(configOrRun, maybeRun);
@@ -45,7 +50,8 @@ export function defineScenarioSuite(configOrRun, maybeRun) {
       }
     },
     exec(setupData) {
-      const resolved = resolveRuntimeConfig(config);
+      const resolved = resolveRuntimeConfig(config, setupData);
+      const actorContext = createSuiteActors(setupData, resolved.client, resolved.profileMeta);
       const scenario = createScenarioRuntime({
         seed: resolved.env.rawEnv.TESTKIT_SCENARIO_SEED,
       });
@@ -54,12 +60,11 @@ export function defineScenarioSuite(configOrRun, maybeRun) {
       try {
         registerRuntimeContext({ env: resolved.env, http: resolved.client.rawHttp || null });
         return run({
+          actor: actorContext.actor,
+          actors: actorContext.actors,
           env: resolved.env,
-          req: resolved.client.request,
+          req: resolved.client,
           rawReq: resolved.client.raw,
-          getWithHeaders: resolved.client.getWithHeaders,
-          setupData,
-          session: setupData,
           scenario,
         });
       } catch (error) {
@@ -75,105 +80,3 @@ export function defineScenarioSuite(configOrRun, maybeRun) {
     },
   };
 }
-
-function normalizeSuiteArgs(configOrRun, maybeRun) {
-  if (typeof configOrRun === "function") {
-    return { config: {}, run: configOrRun };
-  }
-  if (typeof maybeRun !== "function") {
-    throw new Error("suite factory requires a run callback");
-  }
-  return { config: configOrRun || {}, run: maybeRun };
-}
-
-function callHeaders(builder, setupData, env) {
-  if (typeof builder !== "function") return {};
-  return builder(setupData, { env }) || {};
-}
-
-function mergeProfileConfig(config) {
-  if (!config?.profile) return config || {};
-
-  const profile = resolveHttpProfile(config.profile) || {};
-  return {
-    ...profile,
-    ...config,
-    auth: config.auth ?? profile.auth ?? null,
-    headers: config.headers ?? profile.headers,
-    rawHeaders: config.rawHeaders ?? profile.rawHeaders,
-    options: config.options ?? profile.options,
-    env: config.env ?? profile.env,
-  };
-}
-
-function resolveRuntimeConfig(config) {
-  const resolvedConfig = mergeProfileConfig(config);
-  const env = {
-    ...(resolvedConfig.env || getEnv()),
-    rawEnv: __ENV,
-  };
-  const auth = resolvedConfig.auth || null;
-  const client = createHttpClient({
-    baseUrl: env.BASE,
-    routeHeaders: env.routeParams,
-    getHeaders(setupData) {
-      return {
-        ...callHeaders(auth?.headers, setupData, env),
-        ...callHeaders(resolvedConfig.headers, setupData, env),
-      };
-    },
-    getRawHeaders(setupData) {
-      return callHeaders(resolvedConfig.rawHeaders, setupData, env);
-    },
-  });
-
-  return {
-    resolvedConfig,
-    env,
-    auth,
-    client,
-  };
-}
-
-function formatFatalSuiteError(phase, error) {
-  if (error instanceof Error) {
-    return `Uncaught testkit suite error during ${phase}: ${error.message}`;
-  }
-  return `Uncaught testkit suite error during ${phase}: ${String(error)}`;
-}
-
-function buildRuntimeExceptionDetail(phase, error) {
-  const message = error instanceof Error ? error.message : String(error);
-  const stack = error instanceof Error && typeof error.stack === "string" ? error.stack : "";
-  const location = extractLocationFromStack(stack);
-  return {
-    kind: "runtime-exception",
-    key: location
-      ? `${location.path}:${location.line}:${location.column}`
-      : `runtime-exception:${phase}:${message}`,
-    title: "Uncaught runtime exception",
-    message: `Uncaught testkit suite error during ${phase}: ${message}`,
-    location,
-    stack,
-  };
-}
-
-function extractLocationFromStack(stack) {
-  if (!stack) return null;
-  const matches = [...String(stack).matchAll(/(file:\/\/[^\s)]+|\/[^\s):]+):(\d+):(\d+)/g)].map(
-    (match) => ({
-      path: normalizeStackPath(match[1]),
-      line: Number(match[2]),
-      column: Number(match[3]),
-    })
-  );
-  return matches[0] || null;
-}
-
-function normalizeStackPath(rawPath) {
-  if (typeof rawPath !== "string") return rawPath;
-  if (rawPath.startsWith("file://")) {
-    return rawPath.slice("file://".length);
-  }
-  return rawPath;
-}

package/lib/runtime-src/k6/suite.js

@@ -7,16 +7,21 @@ import {
   startFailureCollection,
 } from "./checks.js";
 import {
-  createHttpClient,
   emitHttpTraceCollectionArtifact,
-  getEnv,
   startHttpTraceCollection,
 } from "./http.js";
 import {
   clearRuntimeContext,
   registerRuntimeContext,
-  resolveHttpProfile,
 } from "../../config-api/runtime.mjs";
+import {
+  buildRuntimeExceptionDetail,
+  createSuiteActors,
+  formatFatalSuiteError,
+  mergeProfileConfig,
+  normalizeSuiteArgs,
+  resolveRuntimeConfig,
+} from "./http-suite-runtime.js";
 
 export function defineHttpSuite(configOrRun, maybeRun) {
   const { config, run } = normalizeSuiteArgs(configOrRun, maybeRun);
@@ -44,18 +49,18 @@ export function defineHttpSuite(configOrRun, maybeRun) {
       }
     },
     exec(setupData) {
-      const resolved = resolveRuntimeConfig(config);
+      const resolved = resolveRuntimeConfig(config, setupData);
+      const actorContext = createSuiteActors(setupData, resolved.client, resolved.profileMeta);
       startFailureCollection("exec");
       startHttpTraceCollection("exec");
       try {
         registerRuntimeContext({ env: resolved.env, http: resolved.client.rawHttp || null });
         return run({
+          actor: actorContext.actor,
+          actors: actorContext.actors,
           env: resolved.env,
-          req: resolved.client.request,
+          req: resolved.client,
           rawReq: resolved.client.raw,
-          getWithHeaders: resolved.client.getWithHeaders,
-          setupData,
-          session: setupData,
         });
       } catch (error) {
         recordFailureDetail(buildRuntimeExceptionDetail("exec", error));
@@ -69,102 +74,3 @@ export function defineHttpSuite(configOrRun, maybeRun) {
     },
   };
 }
-
-function normalizeSuiteArgs(configOrRun, maybeRun) {
-  if (typeof configOrRun === "function") {
-    return { config: {}, run: configOrRun };
-  }
-  if (typeof maybeRun !== "function") {
-    throw new Error("suite factory requires a run callback");
-  }
-  return { config: configOrRun || {}, run: maybeRun };
-}
-
-function callHeaders(builder, setupData, env) {
-  if (typeof builder !== "function") return {};
-  return builder(setupData, { env }) || {};
-}
-
-function mergeProfileConfig(config) {
-  if (!config?.profile) return config || {};
-
-  const profile = resolveHttpProfile(config.profile) || {};
-  return {
-    ...profile,
-    ...config,
-    auth: config.auth ?? profile.auth ?? null,
-    headers: config.headers ?? profile.headers,
-    rawHeaders: config.rawHeaders ?? profile.rawHeaders,
-    options: config.options ?? profile.options,
-    env: config.env ?? profile.env,
-  };
-}
-
-function resolveRuntimeConfig(config) {
-  const resolvedConfig = mergeProfileConfig(config);
-  const env = {
-    ...(resolvedConfig.env || getEnv()),
-    rawEnv: __ENV,
-  };
-  const auth = resolvedConfig.auth || null;
-  const client = createHttpClient({
-    baseUrl: env.BASE,
-    routeHeaders: env.routeParams,
-    getHeaders(setupData) {
-      return {
-        ...callHeaders(auth?.headers, setupData, env),
-        ...callHeaders(resolvedConfig.headers, setupData, env),
-      };
-    },
-    getRawHeaders(setupData) {
-      return callHeaders(resolvedConfig.rawHeaders, setupData, env);
-    },
-  });
-
-  return {
-    resolvedConfig,
-    env,
-    auth,
-    client,
-  };
-}
-
-function formatFatalSuiteError(phase, error) {
-  if (error instanceof Error) {
-    return `Uncaught testkit suite error during ${phase}: ${error.message}`;
-  }
-  return `Uncaught testkit suite error during ${phase}: ${String(error)}`;
-}
-
-function buildRuntimeExceptionDetail(phase, error) {
-  const message =
-    error instanceof Error ? error.message : String(error);
-  const stack = error instanceof Error && typeof error.stack === "string" ? error.stack : "";
-  const location = extractLocationFromStack(stack);
-  return {
-    kind: "runtime-exception",
-    key: location ? `${location.path}:${location.line}:${location.column}` : `runtime-exception:${phase}:${message}`,
-    title: "Uncaught runtime exception",
-    message: `Uncaught testkit suite error during ${phase}: ${message}`,
-    location,
-    stack,
-  };
-}
-
-function extractLocationFromStack(stack) {
-  if (!stack) return null;
-  const matches = [...String(stack).matchAll(/(file:\/\/[^\s)]+|\/[^\s):]+):(\d+):(\d+)/g)].map((match) => ({
-    path: normalizeStackPath(match[1]),
-    line: Number(match[2]),
-    column: Number(match[3]),
-  }));
-  return matches[0] || null;
-}
-
-function normalizeStackPath(rawPath) {
-  if (typeof rawPath !== "string") return rawPath;
-  if (rawPath.startsWith("file://")) {
-    return rawPath.slice("file://".length);
-  }
-  return rawPath;
-}

package/lib/runtime-src/shared/error-body.mjs

@@ -0,0 +1,42 @@
+export function extractErrorMessageFromBody(body) {
+  if (!body || typeof body !== "object") return null;
+
+  if ("error" in body) {
+    const error = body.error;
+    if (typeof error === "string" && error.length > 0) return error;
+    if (error && typeof error === "object" && "message" in error) {
+      const message = error.message;
+      if (typeof message === "string" && message.length > 0) return message;
+    }
+  }
+
+  if ("message" in body) {
+    const message = body.message;
+    if (typeof message === "string" && message.length > 0) return message;
+  }
+
+  return null;
+}
+
+export function hasStandardErrorShape(body) {
+  if (!body || typeof body !== "object") return false;
+  const error = body.error;
+  if (!error || typeof error !== "object") return false;
+  return typeof error.code === "string" && typeof error.message === "string";
+}
+
+export function deriveDeterministicIp(seed, offset = 0) {
+  const hash = numericSeed(`${seed}:${offset}`);
+  const thirdOctet = (hash % 250) + 1;
+  const fourthOctet = (Math.floor(hash / 250) % 250) + 1;
+  return `198.51.${thirdOctet}.${fourthOctet}`;
+}
+
+function numericSeed(seed) {
+  let hash = 0;
+  const text = String(seed);
+  for (let index = 0; index < text.length; index += 1) {
+    hash = (hash * 31 + text.charCodeAt(index)) >>> 0;
+  }
+  return hash;
+}

package/lib/runtime-src/shared/http-parsing.mjs

@@ -0,0 +1,68 @@
+export function parseJsonBody(response) {
+  return JSON.parse(response.body);
+}
+
+export function extractCookie(response, cookieName) {
+  const cookies = Object.entries(response?.headers || {})
+    .filter(([name]) => String(name).toLowerCase() === "set-cookie")
+    .flatMap(([, value]) => (Array.isArray(value) ? value : value ? [value] : []));
+
+  if (cookies.length === 0) return null;
+
+  const cookiePattern = new RegExp(`(?:^|,\\s*)${escapeRegExp(cookieName)}=([^;,]+)`);
+  for (const headerValue of cookies) {
+    const match = cookiePattern.exec(String(headerValue));
+    if (match?.[1]) {
+      return match[1];
+    }
+  }
+
+  return null;
+}
+
+export function parseSseEvents(body) {
+  return String(body || "")
+    .split(/\n\n+/)
+    .map((block) => block.trim())
+    .filter(Boolean)
+    .map((block) => {
+      const lines = block.split("\n");
+      let event = null;
+      const dataLines = [];
+
+      for (const line of lines) {
+        if (line.startsWith("event:")) {
+          event = line.slice("event:".length).trim() || null;
+        }
+        if (line.startsWith("data:")) {
+          dataLines.push(line.slice("data:".length).trim());
+        }
+      }
+
+      const rawData = dataLines.join("\n");
+      if (!rawData) {
+        return { event, data: null };
+      }
+
+      try {
+        return {
+          event,
+          data: JSON.parse(rawData),
+        };
+      } catch {
+        return {
+          event,
+          data: rawData,
+        };
+      }
+    });
+}
+
+export function getSseEventData(body, eventName) {
+  const match = parseSseEvents(body).find((event) => event.event === eventName);
+  return match?.data ?? null;
+}
+
+function escapeRegExp(value) {
+  return String(value || "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/lib/runtime-src/shared/http-parsing.test.mjs

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vitest";
+import {
+  extractCookie,
+  getSseEventData,
+  parseJsonBody,
+  parseSseEvents,
+} from "./http-parsing.mjs";
+import {
+  deriveDeterministicIp,
+  extractErrorMessageFromBody,
+  hasStandardErrorShape,
+} from "./error-body.mjs";
+
+describe("runtime shared parsing", () => {
+  it("extracts cookies from set-cookie headers", () => {
+    const response = {
+      headers: {
+        "set-cookie": [
+          "fixture_session=jwt-primary; Path=/",
+          "fixture_refresh=refresh-primary; Path=/",
+        ],
+      },
+    };
+
+    expect(extractCookie(response, "fixture_session")).toBe("jwt-primary");
+    expect(extractCookie(response, "fixture_refresh")).toBe("refresh-primary");
+    expect(extractCookie(response, "missing")).toBeNull();
+  });
+
+  it("parses JSON response bodies", () => {
+    expect(parseJsonBody({ body: "{\"ok\":true}" })).toEqual({ ok: true });
+  });
+
+  it("parses SSE events and extracts typed event data", () => {
+    const body = [
+      "event: progress",
+      "data: {\"step\":1}",
+      "",
+      "event: complete",
+      "data: {\"success\":true}",
+      "",
+    ].join("\n");
+
+    expect(parseSseEvents(body)).toEqual([
+      { event: "progress", data: { step: 1 } },
+      { event: "complete", data: { success: true } },
+    ]);
+    expect(getSseEventData(body, "complete")).toEqual({ success: true });
+  });
+});
+
+describe("runtime shared error helpers", () => {
+  it("extracts human-readable error messages", () => {
+    expect(extractErrorMessageFromBody({ error: "bad request" })).toBe("bad request");
+    expect(extractErrorMessageFromBody({ error: { message: "nested" } })).toBe("nested");
+    expect(extractErrorMessageFromBody({ message: "top-level" })).toBe("top-level");
+    expect(extractErrorMessageFromBody({ ok: true })).toBeNull();
+  });
+
+  it("detects the standard structured error shape", () => {
+    expect(hasStandardErrorShape({ error: { code: "BAD", message: "boom" } })).toBe(true);
+    expect(hasStandardErrorShape({ error: { message: "boom" } })).toBe(false);
+  });
+
+  it("derives deterministic test-network IPs", () => {
+    expect(deriveDeterministicIp("bourne", 1)).toBe(deriveDeterministicIp("bourne", 1));
+    expect(deriveDeterministicIp("bourne", 1)).not.toBe(deriveDeterministicIp("bourne", 2));
+  });
+});

package/node_modules/@elench/next-analysis/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/next-analysis",
-  "version": "0.1.81",
+  "version": "0.1.83",
   "description": "SWC-backed Next.js source analysis primitives for Erench tools",
   "type": "module",
   "exports": {