@elench/testkit 0.1.82 → 0.1.83

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

@@ -36,13 +36,21 @@ export function createHttpClient(config) {
     throw new Error("baseUrl is required");
   }
 
-  function buildHeaders(builder, context, extraHeaders = {}) {
-    return {
-      ...defaultHeaders,
+  function buildHeaders(builder, context, extraHeaders = {}, options = {}) {
+    const { includeDefaultHeaders = true, contentTypeJson = true } = options;
+    const resolvedHeaders = {
+      ...(includeDefaultHeaders ? defaultHeaders : {}),
       ...safeHeaders(builder, context),
       ...routeHeaders,
       ...extraHeaders,
     };
+
+    if (contentTypeJson === false) {
+      delete resolvedHeaders["Content-Type"];
+      delete resolvedHeaders["content-type"];
+    }
+
+    return resolvedHeaders;
   }
 
   function buildHeaderContext(actorName = null) {
@@ -60,23 +68,75 @@ export function createHttpClient(config) {
     }
   }
 
-  function requestAs(actorName, method, path, body, extraHeaders = {}) {
+  function resolvedHeadersFor(actorName, extraHeaders = {}) {
+    ensureKnownActor(actorName);
+    const headerContext = buildHeaderContext(actorName);
+    return buildHeaders(getHeaders, headerContext, extraHeaders);
+  }
+
+  function resolvedRawHeadersFor(actorName = null, extraHeaders = {}) {
+    ensureKnownActor(actorName);
+    const headerContext = buildHeaderContext(actorName);
+    return buildHeaders(getRawHeaders, headerContext, extraHeaders);
+  }
+
+  function requestAs(actorName, method, path, body, extraHeaders = {}, options = {}) {
     ensureKnownActor(actorName);
     const url = `${baseUrl}${path}`;
     const headerContext = buildHeaderContext(actorName);
-    const headers = buildHeaders(getHeaders, headerContext, extraHeaders);
-    return runHttpRequest(method, path, url, body, headers, headerContext.actor);
+    const headers = buildHeaders(getHeaders, headerContext, extraHeaders, {
+      contentTypeJson: options.contentTypeJson !== false,
+      includeDefaultHeaders: options.includeDefaultHeaders !== false,
+    });
+    return runHttpRequest(method, path, url, body, headers, headerContext.actor, options);
   }
 
-  function raw(method, path, body, extraHeaders = {}) {
+  function rawAs(actorName, method, path, body, extraHeaders = {}, options = {}) {
+    ensureKnownActor(actorName);
     const url = `${baseUrl}${path}`;
-    const headerContext = buildHeaderContext(null);
-    const headers = buildHeaders(getRawHeaders, headerContext, extraHeaders);
-    return runHttpRequest(method, path, url, body, headers, null);
+    const headerContext = buildHeaderContext(actorName);
+    const headers = buildHeaders(getRawHeaders, headerContext, extraHeaders, {
+      contentTypeJson: options.contentTypeJson !== false,
+      includeDefaultHeaders: options.includeDefaultHeaders !== false,
+    });
+    return runHttpRequest(method, path, url, body, headers, headerContext.actor, options);
+  }
+
+  function raw(method, path, body, extraHeaders = {}) {
+    return rawAs(null, method, path, body, extraHeaders);
+  }
+
+  function requestMultipart(actorName, method, path, payload, extraHeaders = {}, options = {}) {
+    const body = buildMultipartBody(payload);
+    return requestAs(actorName, method, path, body, extraHeaders, {
+      ...options,
+      contentTypeJson: false,
+      includeDefaultHeaders: false,
+      serialize: "raw",
+    });
+  }
+
+  function rawMultipart(actorName, method, path, payload, extraHeaders = {}, options = {}) {
+    const body = buildMultipartBody(payload);
+    return rawAs(actorName, method, path, body, extraHeaders, {
+      ...options,
+      contentTypeJson: false,
+      includeDefaultHeaders: false,
+      serialize: "raw",
+    });
   }
 
   function createActorClient(actorName) {
+    const actorRawReq = createRawInvoker(actorName);
+
     return {
+      headers(extraHeaders = {}) {
+        return resolvedHeadersFor(actorName, extraHeaders);
+      },
+      rawHeaders(extraHeaders = {}) {
+        return resolvedRawHeadersFor(actorName, extraHeaders);
+      },
+      rawReq: actorRawReq,
       delete(path, extraHeaders = {}) {
         return requestAs(actorName, "DELETE", path, null, extraHeaders);
       },
@@ -95,19 +155,98 @@ export function createHttpClient(config) {
       request(method, path, body, extraHeaders = {}) {
         return requestAs(actorName, method, path, body, extraHeaders);
       },
+      raw(method, path, body, extraHeaders = {}) {
+        return actorRawReq(method, path, body, extraHeaders);
+      },
+      rawDelete(path, extraHeaders = {}) {
+        return actorRawReq.delete(path, extraHeaders);
+      },
+      rawGet(path, extraHeaders = {}) {
+        return actorRawReq.get(path, extraHeaders);
+      },
+      rawPatch(path, body, extraHeaders = {}) {
+        return actorRawReq.patch(path, body, extraHeaders);
+      },
+      rawPost(path, body, extraHeaders = {}) {
+        return actorRawReq.post(path, body, extraHeaders);
+      },
+      rawPut(path, body, extraHeaders = {}) {
+        return actorRawReq.put(path, body, extraHeaders);
+      },
+      multipart: {
+        post(path, payload, extraHeaders = {}) {
+          return requestMultipart(actorName, "POST", path, payload, extraHeaders);
+        },
+        put(path, payload, extraHeaders = {}) {
+          return requestMultipart(actorName, "PUT", path, payload, extraHeaders);
+        },
+        patch(path, payload, extraHeaders = {}) {
+          return requestMultipart(actorName, "PATCH", path, payload, extraHeaders);
+        },
+      },
+      rawMultipart: {
+        post(path, payload, extraHeaders = {}) {
+          return actorRawReq.multipart.post(path, payload, extraHeaders);
+        },
+        put(path, payload, extraHeaders = {}) {
+          return actorRawReq.multipart.put(path, payload, extraHeaders);
+        },
+        patch(path, payload, extraHeaders = {}) {
+          return actorRawReq.multipart.patch(path, payload, extraHeaders);
+        },
+      },
+    };
+  }
+
+  function createRawInvoker(defaultRawActor = null) {
+    const invoker = (method, path, body, extraHeaders = {}) =>
+      rawAs(defaultRawActor, method, path, body, extraHeaders);
+
+    invoker.request = (method, path, body, extraHeaders = {}) =>
+      rawAs(defaultRawActor, method, path, body, extraHeaders);
+    invoker.get = (path, extraHeaders = {}) => rawAs(defaultRawActor, "GET", path, null, extraHeaders);
+    invoker.post = (path, body, extraHeaders = {}) => rawAs(defaultRawActor, "POST", path, body, extraHeaders);
+    invoker.put = (path, body, extraHeaders = {}) => rawAs(defaultRawActor, "PUT", path, body, extraHeaders);
+    invoker.patch = (path, body, extraHeaders = {}) => rawAs(defaultRawActor, "PATCH", path, body, extraHeaders);
+    invoker.delete = (path, extraHeaders = {}) =>
+      rawAs(defaultRawActor, "DELETE", path, null, extraHeaders);
+    invoker.headers = (extraHeaders = {}) => resolvedRawHeadersFor(defaultRawActor, extraHeaders);
+    invoker.as = (actorName) => {
+      ensureKnownActor(actorName);
+      return createRawInvoker(actorName);
+    };
+    invoker.multipart = {
+      post(path, payload, extraHeaders = {}) {
+        return rawMultipart(defaultRawActor, "POST", path, payload, extraHeaders);
+      },
+      put(path, payload, extraHeaders = {}) {
+        return rawMultipart(defaultRawActor, "PUT", path, payload, extraHeaders);
+      },
+      patch(path, payload, extraHeaders = {}) {
+        return rawMultipart(defaultRawActor, "PATCH", path, payload, extraHeaders);
+      },
     };
+
+    return invoker;
   }
 
   const defaultClient = createActorClient(defaultActor);
+  const rawClient = createRawInvoker(null);
 
   return {
     rawHttp: http,
+    headers(extraHeaders = {}) {
+      return resolvedHeadersFor(defaultActor, extraHeaders);
+    },
+    rawHeaders(actorName = null, extraHeaders = {}) {
+      return resolvedRawHeadersFor(actorName, extraHeaders);
+    },
     as(actorName) {
       ensureKnownActor(actorName);
       return createActorClient(actorName);
     },
     request: defaultClient.request,
-    raw,
+    raw: rawClient,
     get(path, extraHeaders = {}) {
       return defaultClient.get(path, extraHeaders);
     },
@@ -124,19 +263,41 @@ export function createHttpClient(config) {
       return defaultClient.delete(path, extraHeaders);
     },
     rawGet(path, extraHeaders = {}) {
-      return raw("GET", path, null, extraHeaders);
+      return rawClient.get(path, extraHeaders);
     },
     rawPost(path, body, extraHeaders = {}) {
-      return raw("POST", path, body, extraHeaders);
+      return rawClient.post(path, body, extraHeaders);
     },
     rawPut(path, body, extraHeaders = {}) {
-      return raw("PUT", path, body, extraHeaders);
+      return rawClient.put(path, body, extraHeaders);
     },
     rawPatch(path, body, extraHeaders = {}) {
-      return raw("PATCH", path, body, extraHeaders);
+      return rawClient.patch(path, body, extraHeaders);
     },
     rawDelete(path, extraHeaders = {}) {
-      return raw("DELETE", path, null, extraHeaders);
+      return rawClient.delete(path, extraHeaders);
+    },
+    multipart: {
+      post(path, payload, extraHeaders = {}) {
+        return requestMultipart(defaultActor, "POST", path, payload, extraHeaders);
+      },
+      put(path, payload, extraHeaders = {}) {
+        return requestMultipart(defaultActor, "PUT", path, payload, extraHeaders);
+      },
+      patch(path, payload, extraHeaders = {}) {
+        return requestMultipart(defaultActor, "PATCH", path, payload, extraHeaders);
+      },
+    },
+    rawMultipart: {
+      post(path, payload, extraHeaders = {}) {
+        return rawClient.multipart.post(path, payload, extraHeaders);
+      },
+      put(path, payload, extraHeaders = {}) {
+        return rawClient.multipart.put(path, payload, extraHeaders);
+      },
+      patch(path, payload, extraHeaders = {}) {
+        return rawClient.multipart.patch(path, payload, extraHeaders);
+      },
     },
   };
 }
@@ -159,7 +320,7 @@ export function makeRawReq(baseUrl, routeHeaders = {}, getRawHeaders = null) {
   }).raw;
 }
 
-function runHttpRequest(method, path, url, body, headers, actorRecord = null) {
+function runHttpRequest(method, path, url, body, headers, actorRecord = null, requestOptions = {}) {
   const ordinal = nextTraceOrdinal();
   const requestId = buildRequestId(ordinal);
   const finalHeaders = {
@@ -175,14 +336,15 @@ function runHttpRequest(method, path, url, body, headers, actorRecord = null) {
     actorRecord,
     requestHeaders: finalHeaders,
   });
-  const options = { headers: finalHeaders };
+  const transportOptions = { headers: finalHeaders };
 
   let rawResponse;
-  if (method === "GET") rawResponse = http.get(url, options);
-  else if (method === "PUT") rawResponse = http.put(url, JSON.stringify(body), options);
-  else if (method === "POST") rawResponse = http.post(url, JSON.stringify(body), options);
-  else if (method === "PATCH") rawResponse = http.patch(url, JSON.stringify(body), options);
-  else if (method === "DELETE") rawResponse = http.del(url, null, options);
+  const requestBody = serializeRequestBody(body, requestOptions.serialize || "json");
+  if (method === "GET") rawResponse = http.get(url, transportOptions);
+  else if (method === "PUT") rawResponse = http.put(url, requestBody, transportOptions);
+  else if (method === "POST") rawResponse = http.post(url, requestBody, transportOptions);
+  else if (method === "PATCH") rawResponse = http.patch(url, requestBody, transportOptions);
+  else if (method === "DELETE") rawResponse = http.del(url, null, transportOptions);
   else throw new Error(`unsupported method: ${method}`);
 
   finalizeTrace(trace, rawResponse);
@@ -420,3 +582,31 @@ function decodeQueryComponent(value) {
     return String(value || "");
   }
 }
+
+function serializeRequestBody(body, mode = "json") {
+  if (body == null) return body;
+  if (mode === "raw") return body;
+  if (typeof body === "string") return body;
+  return JSON.stringify(body);
+}
+
+function buildMultipartBody(payload = {}) {
+  const fields = payload?.fields || {};
+  const files = Array.isArray(payload?.files) ? payload.files : [];
+  const body = { ...fields };
+
+  for (const fileEntry of files) {
+    if (!fileEntry || typeof fileEntry !== "object") {
+      throw new Error("multipart file entries must be objects");
+    }
+
+    const field = String(fileEntry.field || "").trim();
+    if (!field) {
+      throw new Error("multipart file entries require a field name");
+    }
+
+    body[field] = http.file(fileEntry.data, fileEntry.filename, fileEntry.contentType);
+  }
+
+  return body;
+}

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/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, "\\$&");
+}