@elench/testkit 0.1.80 → 0.1.82

package/lib/runtime/index.d.ts

@@ -23,6 +23,9 @@ export interface RuntimeResponse {
 
 export interface RuntimeHttpTrace {
   id: string;
+  actorName: string | null;
+  organizationKey?: string | null;
+  organizationName?: string | null;
   requestId: string;
   startedAt: string;
   finishedAt?: string;
@@ -93,6 +96,27 @@ export interface RuntimeHttpClient {
   put(url: string, body?: unknown, params?: HttpRequestParams): RuntimeResponse;
 }
 
+export interface RuntimeActorRecord<TSession = Record<string, unknown>> {
+  actorIndex: number;
+  actorName: string;
+  email?: string;
+  name?: string;
+  organizationKey?: string;
+  organizationName?: string;
+  session: TSession | null;
+}
+
+export interface AuthSessionBundle<TSession = Record<string, unknown>> {
+  actors: Record<string, RuntimeActorRecord<TSession> & TSession>;
+  primaryActor: string | null;
+}
+
+export interface HttpHeaderBuildContext<TSession = Record<string, unknown>> {
+  actor: (RuntimeActorRecord<TSession> & TSession) | null;
+  actorName: string | null;
+  sessionBundle: AuthSessionBundle<TSession> | null;
+}
+
 export interface Metric {
   add(value: number): void;
 }
@@ -109,38 +133,35 @@ export declare class Trend implements Metric {
 
 export interface HttpClientConfig<TSetup = unknown> {
   baseUrl: string;
+  defaultActor?: string | null;
   defaultHeaders?: RuntimeHeaders;
-  getHeaders?: (setupData?: TSetup | null) => RuntimeHeaders | void;
-  getRawHeaders?: (setupData?: TSetup | null) => RuntimeHeaders | void;
+  getHeaders?: (context: HttpHeaderBuildContext<TSetup>) => RuntimeHeaders | void;
+  getRawHeaders?: (context: HttpHeaderBuildContext<TSetup>) => RuntimeHeaders | void;
   routeHeaders?: RuntimeHeaders;
+  sessionBundle?: AuthSessionBundle<TSetup> | null;
 }
 
-export interface HttpClient<TSetup = unknown> {
-  delete(path: string, setupData?: TSetup | null, extraHeaders?: RuntimeHeaders): RuntimeResponse;
-  get(path: string, setupData?: TSetup | null, extraHeaders?: RuntimeHeaders): RuntimeResponse;
-  getWithHeaders(
-    path: string,
-    setupData?: TSetup | null,
-    extraHeaders?: RuntimeHeaders
-  ): RuntimeResponse;
-  patch(
-    path: string,
-    setupData?: TSetup | null,
-    body?: unknown,
-    extraHeaders?: RuntimeHeaders
-  ): RuntimeResponse;
-  post(
-    path: string,
-    setupData?: TSetup | null,
-    body?: unknown,
-    extraHeaders?: RuntimeHeaders
-  ): RuntimeResponse;
-  put(
+export interface ActorRequestClient {
+  delete(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  get(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  patch(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  post(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  put(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  request(
+    method: RuntimeMethod,
     path: string,
-    setupData?: TSetup | null,
     body?: unknown,
     extraHeaders?: RuntimeHeaders
   ): RuntimeResponse;
+}
+
+export interface HttpClient<TSetup = unknown> {
+  as(actorName: string): ActorRequestClient;
+  delete(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  get(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  patch(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  post(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  put(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   raw(
     method: RuntimeMethod,
     path: string,
@@ -155,7 +176,6 @@ export interface HttpClient<TSetup = unknown> {
   request(
     method: RuntimeMethod,
     path: string,
-    setupData?: TSetup | null,
     body?: unknown,
     extraHeaders?: RuntimeHeaders
   ): RuntimeResponse;
@@ -226,19 +246,16 @@ export declare function createHttpClient<TSetup = unknown>(
 ): HttpClient<TSetup>;
 export declare function makeReq<TSetup = unknown>(
   baseUrl: string,
+  sessionBundle?: AuthSessionBundle<TSetup> | null,
   routeHeaders?: RuntimeHeaders,
-  getHeaders?: (setupData?: TSetup | null) => RuntimeHeaders | void
-): HttpClient<TSetup>["request"];
+  getHeaders?: (context: HttpHeaderBuildContext<TSetup>) => RuntimeHeaders | void,
+  defaultActor?: string | null
+): HttpClient<TSetup>;
 export declare function makeRawReq(
   baseUrl: string,
   routeHeaders?: RuntimeHeaders,
-  getRawHeaders?: (setupData?: never) => RuntimeHeaders | void
+  getRawHeaders?: (context: HttpHeaderBuildContext<never>) => RuntimeHeaders | void
 ): HttpClient["raw"];
-export declare function makeGetWithHeaders<TSetup = unknown>(
-  baseUrl: string,
-  routeHeaders?: RuntimeHeaders,
-  getHeaders?: (setupData?: TSetup | null) => RuntimeHeaders | void
-): HttpClient<TSetup>["getWithHeaders"];
 
 export declare function expectStatus(
   response: RuntimeResponse,

package/lib/runtime/index.mjs

@@ -48,7 +48,6 @@ export {
   defaultOptions as httpDefaultOptions,
   getEnv,
   getHttpTrace,
-  makeGetWithHeaders,
   makeRawReq,
   makeReq,
   safeJson,

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

@@ -0,0 +1,147 @@
+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;
+    return {
+      email: actorRecord?.email || null,
+      index: Number(actorRecord?.actorIndex ?? 0),
+      key: actorName,
+      name: actorRecord?.name || null,
+      organizationKey: actorRecord?.organizationKey || null,
+      organizationName: actorRecord?.organizationName || null,
+      req: client.as(actorName),
+      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,55 +36,92 @@ export function createHttpClient(config) {
     throw new Error("baseUrl is required");
   }
 
-  function buildHeaders(builder, setupData, extraHeaders = {}) {
+  function buildHeaders(builder, context, extraHeaders = {}) {
     return {
       ...defaultHeaders,
-      ...safeHeaders(builder, setupData),
+      ...safeHeaders(builder, context),
       ...routeHeaders,
       ...extraHeaders,
     };
   }
 
-  function request(method, path, setupData, body, extraHeaders = {}) {
+  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 requestAs(actorName, method, path, body, extraHeaders = {}) {
+    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);
+    return runHttpRequest(method, path, url, body, headers, headerContext.actor);
   }
 
   function raw(method, path, body, extraHeaders = {}) {
     const url = `${baseUrl}${path}`;
-    const headers = buildHeaders(getRawHeaders, null, extraHeaders);
-    return runHttpRequest(method, path, url, body, headers);
+    const headerContext = buildHeaderContext(null);
+    const headers = buildHeaders(getRawHeaders, headerContext, extraHeaders);
+    return runHttpRequest(method, path, url, body, headers, null);
   }
 
-  function getWithHeaders(path, setupData, extraHeaders = {}) {
-    return runHttpRequest(
-      "GET",
-      path,
-      `${baseUrl}${path}`,
-      null,
-      buildHeaders(getHeaders, setupData, extraHeaders)
-    );
+  function createActorClient(actorName) {
+    return {
+      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);
+      },
+    };
   }
 
+  const defaultClient = createActorClient(defaultActor);
+
   return {
     rawHttp: http,
-    request,
+    as(actorName) {
+      ensureKnownActor(actorName);
+      return createActorClient(actorName);
+    },
+    request: defaultClient.request,
     raw,
-    get(path, setupData, extraHeaders = {}) {
-      return request("GET", path, setupData, null, extraHeaders);
+    get(path, extraHeaders = {}) {
+      return defaultClient.get(path, extraHeaders);
     },
-    put(path, setupData, body, extraHeaders = {}) {
-      return request("PUT", path, setupData, body, extraHeaders);
+    put(path, body, extraHeaders = {}) {
+      return defaultClient.put(path, body, extraHeaders);
     },
-    post(path, setupData, body, extraHeaders = {}) {
-      return request("POST", path, setupData, body, extraHeaders);
+    post(path, body, extraHeaders = {}) {
+      return defaultClient.post(path, body, extraHeaders);
     },
-    patch(path, setupData, body, extraHeaders = {}) {
-      return request("PATCH", path, setupData, body, extraHeaders);
+    patch(path, body, extraHeaders = {}) {
+      return defaultClient.patch(path, body, extraHeaders);
     },
-    delete(path, setupData, extraHeaders = {}) {
-      return request("DELETE", path, setupData, null, extraHeaders);
+    delete(path, extraHeaders = {}) {
+      return defaultClient.delete(path, extraHeaders);
     },
     rawGet(path, extraHeaders = {}) {
       return raw("GET", path, null, extraHeaders);
@@ -99,16 +138,17 @@ export function createHttpClient(config) {
     rawDelete(path, extraHeaders = {}) {
       return raw("DELETE", path, null, 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 +159,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) {
   const ordinal = nextTraceOrdinal();
   const requestId = buildRequestId(ordinal);
   const finalHeaders = {
@@ -140,6 +172,7 @@ function runHttpRequest(method, path, url, body, headers) {
     method,
     path,
     url,
+    actorRecord,
     requestHeaders: finalHeaders,
   });
   const options = { headers: finalHeaders };
@@ -190,7 +223,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 +271,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 +381,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) {

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;
-}