@elench/testkit 0.1.81 → 0.1.83

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

@@ -0,0 +1,151 @@
+import { createHttpClient, getEnv } from "./http.js";
+import { resolveHttpProfile } from "../../config-api/runtime.mjs";
+
+export 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 };
+}
+
+export 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,
+    __testkitAuthProfile: config.__testkitAuthProfile ?? profile.__testkitAuthProfile ?? null,
+  };
+}
+
+export function resolveRuntimeConfig(config, sessionBundle = null) {
+  const resolvedConfig = mergeProfileConfig(config);
+  const env = {
+    ...(resolvedConfig.env || getEnv()),
+    rawEnv: __ENV,
+  };
+  const auth = resolvedConfig.auth || null;
+  const profileMeta = resolvedConfig.__testkitAuthProfile || null;
+  const client = createHttpClient({
+    baseUrl: env.BASE,
+    defaultActor: profileMeta?.primaryActor || sessionBundle?.primaryActor || null,
+    routeHeaders: env.routeParams,
+    sessionBundle,
+    getHeaders(context) {
+      return {
+        ...callHeaders(auth?.headers, sessionBundle, env, context.actorName),
+        ...callHeaders(resolvedConfig.headers, sessionBundle, env, context.actorName),
+      };
+    },
+    getRawHeaders(context) {
+      return callHeaders(resolvedConfig.rawHeaders, sessionBundle, env, context.actorName);
+    },
+  });
+
+  return {
+    auth,
+    client,
+    env,
+    profileMeta,
+    resolvedConfig,
+  };
+}
+
+export function createSuiteActors(sessionBundle, client, profileMeta) {
+  const actorNames = profileMeta?.actorNames || Object.keys(sessionBundle?.actors || {});
+  const entries = actorNames.map((actorName) => {
+    const actorRecord = sessionBundle?.actors?.[actorName] || null;
+    const actorClient = client.as(actorName);
+    return {
+      email: actorRecord?.email || null,
+      headers: actorClient.headers(),
+      index: Number(actorRecord?.actorIndex ?? 0),
+      key: actorName,
+      name: actorRecord?.name || null,
+      organizationKey: actorRecord?.organizationKey || null,
+      organizationName: actorRecord?.organizationName || null,
+      rawHeaders: actorClient.rawHeaders(),
+      rawReq: actorClient.rawReq,
+      req: actorClient,
+      session: actorRecord?.session || null,
+    };
+  });
+  const byName = new Map(entries.map((entry, index) => [actorNames[index], entry]));
+  const primaryName = profileMeta?.primaryActor || sessionBundle?.primaryActor || null;
+  const primary = primaryName ? byName.get(primaryName) || null : null;
+
+  return {
+    actor: primary,
+    actors: {
+      names: actorNames,
+      primary,
+      get(name) {
+        const actor = byName.get(name);
+        if (!actor) {
+          throw new Error(`Unknown testkit actor "${name}"`);
+        }
+        return actor;
+      },
+      has(name) {
+        return byName.has(name);
+      },
+      list() {
+        return entries.slice();
+      },
+    },
+  };
+}
+
+export 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)}`;
+}
+
+export 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 callHeaders(builder, sessionBundle, env, actorName) {
+  if (typeof builder !== "function") return {};
+  return builder(sessionBundle, { actor: actorName || null, env }) || {};
+}
+
+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/http.js

@@ -24,8 +24,10 @@ export function getEnv() {
 export function createHttpClient(config) {
   const {
     baseUrl,
+    defaultActor = null,
     routeHeaders = {},
     defaultHeaders = { "Content-Type": "application/json" },
+    sessionBundle = null,
     getHeaders = null,
     getRawHeaders = null,
   } = config;
@@ -34,81 +36,280 @@ export function createHttpClient(config) {
     throw new Error("baseUrl is required");
   }
 
-  function buildHeaders(builder, setupData, extraHeaders = {}) {
-    return {
-      ...defaultHeaders,
-      ...safeHeaders(builder, setupData),
+  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) {
+    return {
+      actor: actorName && sessionBundle?.actors ? sessionBundle.actors[actorName] || null : null,
+      actorName,
+      sessionBundle,
+    };
+  }
+
+  function ensureKnownActor(actorName) {
+    if (!actorName || !sessionBundle?.actors) return;
+    if (!sessionBundle.actors[actorName]) {
+      throw new Error(`Unknown testkit actor "${actorName}"`);
+    }
   }
 
-  function request(method, path, setupData, 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 headers = buildHeaders(getHeaders, setupData, extraHeaders);
-    return runHttpRequest(method, path, url, body, headers);
+    const headerContext = buildHeaderContext(actorName);
+    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 headers = buildHeaders(getRawHeaders, null, extraHeaders);
-    return runHttpRequest(method, path, url, body, headers);
+    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 getWithHeaders(path, setupData, extraHeaders = {}) {
-    return runHttpRequest(
-      "GET",
-      path,
-      `${baseUrl}${path}`,
-      null,
-      buildHeaders(getHeaders, setupData, extraHeaders)
-    );
+  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);
+      },
+      get(path, extraHeaders = {}) {
+        return requestAs(actorName, "GET", path, null, extraHeaders);
+      },
+      patch(path, body, extraHeaders = {}) {
+        return requestAs(actorName, "PATCH", path, body, extraHeaders);
+      },
+      post(path, body, extraHeaders = {}) {
+        return requestAs(actorName, "POST", path, body, extraHeaders);
+      },
+      put(path, body, extraHeaders = {}) {
+        return requestAs(actorName, "PUT", path, body, extraHeaders);
+      },
+      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,
-    request,
-    raw,
-    get(path, setupData, extraHeaders = {}) {
-      return request("GET", path, setupData, null, extraHeaders);
+    headers(extraHeaders = {}) {
+      return resolvedHeadersFor(defaultActor, extraHeaders);
+    },
+    rawHeaders(actorName = null, extraHeaders = {}) {
+      return resolvedRawHeadersFor(actorName, extraHeaders);
+    },
+    as(actorName) {
+      ensureKnownActor(actorName);
+      return createActorClient(actorName);
     },
-    put(path, setupData, body, extraHeaders = {}) {
-      return request("PUT", path, setupData, body, extraHeaders);
+    request: defaultClient.request,
+    raw: rawClient,
+    get(path, extraHeaders = {}) {
+      return defaultClient.get(path, extraHeaders);
     },
-    post(path, setupData, body, extraHeaders = {}) {
-      return request("POST", path, setupData, body, extraHeaders);
+    put(path, body, extraHeaders = {}) {
+      return defaultClient.put(path, body, extraHeaders);
     },
-    patch(path, setupData, body, extraHeaders = {}) {
-      return request("PATCH", path, setupData, body, extraHeaders);
+    post(path, body, extraHeaders = {}) {
+      return defaultClient.post(path, body, extraHeaders);
     },
-    delete(path, setupData, extraHeaders = {}) {
-      return request("DELETE", path, setupData, null, extraHeaders);
+    patch(path, body, extraHeaders = {}) {
+      return defaultClient.patch(path, body, extraHeaders);
+    },
+    delete(path, extraHeaders = {}) {
+      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);
+      },
     },
-    getWithHeaders,
   };
 }
 
-export function makeReq(baseUrl, routeHeaders = {}, getHeaders = null) {
+export function makeReq(baseUrl, sessionBundle = null, routeHeaders = {}, getHeaders = null, defaultActor = null) {
   return createHttpClient({
     baseUrl,
     routeHeaders,
+    sessionBundle,
+    defaultActor,
     getHeaders,
-  }).request;
+  });
 }
 
 export function makeRawReq(baseUrl, routeHeaders = {}, getRawHeaders = null) {
@@ -119,15 +320,7 @@ export function makeRawReq(baseUrl, routeHeaders = {}, getRawHeaders = null) {
   }).raw;
 }
 
-export function makeGetWithHeaders(baseUrl, routeHeaders = {}, getHeaders = null) {
-  return createHttpClient({
-    baseUrl,
-    routeHeaders,
-    getHeaders,
-  }).getWithHeaders;
-}
-
-function runHttpRequest(method, path, url, body, headers) {
+function runHttpRequest(method, path, url, body, headers, actorRecord = null, requestOptions = {}) {
   const ordinal = nextTraceOrdinal();
   const requestId = buildRequestId(ordinal);
   const finalHeaders = {
@@ -140,16 +333,18 @@ function runHttpRequest(method, path, url, body, headers) {
     method,
     path,
     url,
+    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);
@@ -190,7 +385,10 @@ export function summarizeHttpTrace(response) {
   const trace = getHttpTrace(response);
   if (!trace) return null;
   return {
+    actorName: trace.actorName,
     id: trace.id,
+    organizationKey: trace.organizationKey,
+    organizationName: trace.organizationName,
     requestId: trace.requestId,
     method: trace.method,
     path: trace.path,
@@ -235,9 +433,12 @@ export function toBodyPreview(response) {
   return truncate(rawBody, TRACE_PREVIEW_LIMIT);
 }
 
-function createTrace({ ordinal, requestId, method, path, url, requestHeaders }) {
+function createTrace({ ordinal, requestId, method, path, url, actorRecord, requestHeaders }) {
   return {
+    actorName: actorRecord?.actorName || null,
     id: `${traceState.phase}-${String(ordinal).padStart(3, "0")}`,
+    organizationKey: actorRecord?.organizationKey || null,
+    organizationName: actorRecord?.organizationName || null,
     requestId,
     startedAt: new Date().toISOString(),
     method,
@@ -342,9 +543,9 @@ function normalizeLabel(value, fallback) {
   return normalized.length > 0 ? normalized : fallback;
 }
 
-function safeHeaders(builder, setupData) {
+function safeHeaders(builder, context) {
   if (typeof builder !== "function") return {};
-  return builder(setupData) || {};
+  return builder(context) || {};
 }
 
 function createWrappedResponse(rawResponse, trace) {
@@ -381,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;
+}