@gfdelarue/testkit 0.3.0

package/dist/engines/k6/runtime/suite.js

@@ -0,0 +1 @@
+import{fail as n}from"k6";import{emitFailureCollectionArtifact as c,recordFailureDetail as u,startFailureCollection as a}from"./checks.js";import{emitHttpTraceCollectionArtifact as l,startHttpTraceCollection as s}from"./http.js";import{emitFixtureUsageArtifact as p}from"./fixtures.js";import{buildRuntimeExceptionDetail as f,defaultSuiteOptions as v,createSuiteActors as C,executeSuiteSetup as A,formatFatalSuiteError as m,invokeSuiteRun as F,mergeProfileConfig as y,normalizeSuiteArgs as H,resolveRuntimeConfig as x}from"./http-suite-runtime.js";export function defineHttpSuite(S,d){const{config:r,run:g}=H(S,d);return{get options(){return y(r).options||v},setup(){const t=x(r);a("setup"),s("setup");try{return A(t.auth,t.env,t.runtimeHttp)}catch(e){u(f("setup",e)),n(m("setup",e))}finally{p("setup"),c(),l()}},exec(t){const e=x(r,t),o=C(e.sessionBundle,e.client);a("exec"),s("exec");try{return F(g,{actor:o.actor,actors:o.actors,env:e.env,req:e.client,rawReq:e.client.raw,setupData:t})}catch(i){u(f("exec",i)),n(m("exec",i))}finally{p("exec"),c(),l()}}}}

package/dist/engines/k6/runtime/types.d.ts

@@ -0,0 +1,242 @@
+import type { HttpMethods, RawHttpMethods, BodyMethods } from "../../../config/authoring/http-methods.js";
+import type { HttpRequestParams, RuntimeHeaders, RuntimeHttpClient, RuntimeMethod, RuntimeResponse, RuntimeResponseBody } from "../../../config/authoring/http-execution-contract.js";
+import type { RuntimeFixtureManifestEntry } from "../../contracts/fixture-manifest.js";
+export type { HttpRequestParams, RuntimeCookie, RuntimeEnv, RuntimeHeaderValue, RuntimeHeaders, RuntimeHttpClient, RuntimeHttpTrace, RuntimeHttpTraceResponse, RuntimeMethod, RuntimeOptions, RuntimeResponse, RuntimeResponseBody, RuntimeResponseBodyFor, RuntimeResponseType, } from "../../../config/authoring/http-execution-contract.js";
+export type { RuntimeFixtureManifestEntry } from "../../contracts/fixture-manifest.js";
+export type RuntimeTypeName = "array" | "bigint" | "boolean" | "function" | "null" | "number" | "object" | "string" | "symbol" | "undefined";
+export interface RuntimeArtifactOptions {
+    contentType?: string;
+    kind?: string;
+    summary?: string;
+}
+export interface RuntimeBinaryFixture {
+    __testkitFixture: true;
+    contentType: string;
+    data: ArrayBuffer;
+    filename: string;
+    path: string;
+    sha256: string;
+    sizeBytes: number;
+}
+export interface WaitForOptions {
+    description?: string;
+    intervalSeconds?: number;
+}
+export interface TestkitRuntimeContext {
+    active: boolean;
+    leaseId: string | null;
+    namespace: string;
+    rawEnv: Record<string, string | undefined>;
+    runtimeId: string | null;
+}
+export interface RuntimeDb {
+    exec(sql: string): unknown;
+    query<T = Record<string, unknown>>(sql: string): T[];
+}
+export interface RuntimeDalContext {
+    db: RuntimeDb;
+    truncate(...tables: string[]): void;
+}
+export interface RuntimeFixtureLocation {
+    column: number;
+    line: number;
+    path: string;
+}
+export interface RuntimeFixtureReference {
+    key: string;
+    kind: string;
+}
+export interface RuntimeFixtureRecord {
+    dependencies: RuntimeFixtureReference[];
+    key: string;
+    kind: string;
+    location?: RuntimeFixtureLocation;
+    order: number;
+    reuseCount: number;
+    signature: unknown;
+}
+export interface RuntimeFixtureStringOptions {
+    fallback?: string;
+    maxLength?: number;
+    prefix?: string;
+    suffixLength?: number;
+}
+export interface RuntimeFixtureEmailOptions {
+    domain?: string;
+    fallback?: string;
+    suffixLength?: number;
+}
+export interface RuntimeFixtureSlugOptions {
+    fallback?: string;
+    maxLength?: number;
+}
+export interface RuntimeFixtureValueHelpers {
+    email(label: string, options?: RuntimeFixtureEmailOptions): string;
+    slug(label: string, options?: RuntimeFixtureSlugOptions): string;
+    string(label: string, options?: RuntimeFixtureStringOptions): string;
+    token(label: string, options?: RuntimeFixtureStringOptions): string;
+    uuid(label: string): string;
+}
+export interface RuntimeFixtureScope {
+    email(label: string, options?: RuntimeFixtureEmailOptions): string;
+    id(label: string): string;
+    namespace: string;
+    records(): RuntimeFixtureRecord[];
+    seed<TResult>(kind: string, key: string, signature: unknown, create: () => TResult): TResult;
+    slug(label: string, options?: RuntimeFixtureSlugOptions): string;
+    string(label: string, options?: RuntimeFixtureStringOptions): string;
+    token(label: string, options?: RuntimeFixtureStringOptions): string;
+    uuid(label: string): string;
+    values: RuntimeFixtureValueHelpers;
+}
+export interface DalFixtureDefinitionContext {
+    dal: RuntimeDalContext;
+    db: RuntimeDb;
+    fixtureScope: RuntimeFixtureScope;
+    seed: RuntimeFixtureScope["seed"];
+    values: RuntimeFixtureValueHelpers;
+}
+export interface DalFixtureDefinition<TFixtures extends object = Record<string, unknown>> {
+    create(context: DalFixtureDefinitionContext): TFixtures;
+}
+export interface RuntimeActorRecord<TSession = Record<string, unknown>> {
+    actorIndex: number;
+    actorName: string;
+    email?: string;
+    name?: string;
+    organizationKey?: string;
+    organizationName?: string;
+    session: TSession | null;
+}
+export type RuntimeActor<TSession extends object = Record<string, unknown>> = RuntimeActorRecord<TSession> & TSession;
+export interface AuthSessionBundle<TSession extends object = Record<string, unknown>> {
+    actors: Record<string, RuntimeActor<TSession> | undefined>;
+    primaryActor: string | null;
+}
+export interface HttpHeaderBuildContext<TSession extends object = Record<string, unknown>> {
+    actor: RuntimeActor<TSession> | null;
+    actorName: string | null;
+    sessionBundle: AuthSessionBundle<TSession> | null;
+}
+export interface HttpClientConfig<TSession extends object = Record<string, unknown>> {
+    baseUrl: string;
+    defaultActor?: string | null;
+    defaultHeaders?: RuntimeHeaders;
+    getHeaders?: (context: HttpHeaderBuildContext<TSession>) => RuntimeHeaders | undefined;
+    getRawHeaders?: (context: HttpHeaderBuildContext<TSession>) => RuntimeHeaders | undefined;
+    sessionBundle?: AuthSessionBundle<TSession> | null;
+}
+export interface MultipartFileInput {
+    contentType?: string;
+    data?: string | ArrayBuffer;
+    field: string;
+    file?: RuntimeBinaryFixture;
+    fixture?: string | RuntimeBinaryFixture;
+    filename?: string;
+}
+export interface MultipartPayload {
+    fields?: Record<string, string>;
+    files?: MultipartFileInput[];
+}
+export type MultipartRequestClient<TBody extends RuntimeResponseBody = string> = BodyMethods<MultipartPayload, RuntimeResponse<TBody>, [
+    extraHeaders?: RuntimeHeaders
+]>;
+export interface RawRequestClient<TBody extends RuntimeResponseBody = string> extends HttpMethods<RuntimeResponse<TBody>, [
+    extraHeaders?: RuntimeHeaders,
+    options?: HttpRequestParams
+]> {
+    (method: RuntimeMethod, path: string, body?: unknown, extraHeaders?: RuntimeHeaders, options?: HttpRequestParams): RuntimeResponse<TBody>;
+    as(actorName: string): RawRequestClient<TBody>;
+    headers: (extraHeaders?: RuntimeHeaders) => RuntimeHeaders;
+    multipart: MultipartRequestClient<TBody>;
+    request: (method: RuntimeMethod, path: string, body?: unknown, extraHeaders?: RuntimeHeaders, options?: HttpRequestParams) => RuntimeResponse<TBody>;
+}
+export interface ActorRequestClient<TBody extends RuntimeResponseBody = string> extends HttpMethods<RuntimeResponse<TBody>, [extraHeaders?: RuntimeHeaders]>, RawHttpMethods<RuntimeResponse<TBody>, [extraHeaders?: RuntimeHeaders, options?: HttpRequestParams]> {
+    headers: (extraHeaders?: RuntimeHeaders) => RuntimeHeaders;
+    multipart: MultipartRequestClient<TBody>;
+    raw(method: RuntimeMethod, path: string, body?: unknown, extraHeaders?: RuntimeHeaders, options?: HttpRequestParams): RuntimeResponse<TBody>;
+    rawHeaders(extraHeaders?: RuntimeHeaders): RuntimeHeaders;
+    rawMultipart: MultipartRequestClient<TBody>;
+    rawReq: RawRequestClient<TBody>;
+    request: (method: RuntimeMethod, path: string, body?: unknown, extraHeaders?: RuntimeHeaders) => RuntimeResponse<TBody>;
+}
+export interface HttpClient<TSetup = unknown, TBody extends RuntimeResponseBody = string> extends HttpMethods<RuntimeResponse<TBody>, [extraHeaders?: RuntimeHeaders]>, RawHttpMethods<RuntimeResponse<TBody>, [extraHeaders?: RuntimeHeaders, options?: HttpRequestParams]> {
+    (method: RuntimeMethod, path: string, setupData?: TSetup | null, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse<TBody>;
+    as(actorName: string): ActorRequestClient<TBody>;
+    headers: (extraHeaders?: RuntimeHeaders) => RuntimeHeaders;
+    multipart: MultipartRequestClient<TBody>;
+    raw: RawRequestClient<TBody>;
+    rawHttp: RuntimeHttpClient;
+    rawHeaders(actorName?: string | null, extraHeaders?: RuntimeHeaders): RuntimeHeaders;
+    rawMultipart: MultipartRequestClient<TBody>;
+    request: (method: RuntimeMethod, path: string, body?: unknown, extraHeaders?: RuntimeHeaders) => RuntimeResponse<TBody>;
+}
+export type RuntimePredicate<T> = (value: T) => boolean;
+export type RuntimeActualValue = bigint | boolean | null | number | object | string | symbol;
+export type RuntimeActualResolver<T> = ((value: T) => unknown) | RuntimeActualValue;
+export type RuntimeConditionActualResolver = (() => unknown) | RuntimeActualValue;
+export interface RuntimeAssertionOptions<T> {
+    actual?: RuntimeActualResolver<T>;
+    describeFailure?: ((value: T) => string) | string;
+    expected?: unknown;
+    kind?: string;
+}
+export interface RuntimeConditionAssertionOptions {
+    actual?: RuntimeConditionActualResolver;
+    describeFailure?: (() => string) | string;
+    expected?: unknown;
+    kind?: string;
+}
+export interface RuntimeFailureLocation {
+    column: number;
+    line: number;
+    path: string;
+}
+export interface RuntimeFailureDetail {
+    actual?: unknown;
+    checkName?: string;
+    count: number;
+    expected?: unknown;
+    groupPath?: string[];
+    key: string;
+    kind: string;
+    location?: Record<string, unknown>;
+    message?: string;
+    phase?: string;
+    request?: Record<string, unknown>;
+    response?: Record<string, unknown>;
+    stack?: string;
+    title: string;
+    traceId?: string;
+}
+export interface RuntimeFailureDetailInput {
+    actual?: unknown;
+    checkName?: string;
+    count?: number;
+    expected?: unknown;
+    key: string;
+    kind: string;
+    location?: object | null;
+    message?: string;
+    phase?: string;
+    request?: object | null;
+    response?: object | null;
+    stack?: string;
+    title: string;
+    traceId?: string;
+}
+export interface RuntimeFixtureEntry extends RuntimeFixtureManifestEntry {
+    data: ArrayBuffer;
+}
+export interface RuntimeFixtureManifest {
+    entries: RuntimeFixtureManifestEntry[];
+}
+export interface SafeJsonSuccess<T> {
+    ok: true;
+    value: T;
+}
+export interface SafeJsonFailure {
+    error: string;
+    ok: false;
+}
+export type SafeJsonResult<T> = SafeJsonSuccess<T> | SafeJsonFailure;

package/dist/engines/k6/runtime/types.js

@@ -0,0 +1 @@
+export{};

package/dist/engines/k6/runtime/xk6-sql-driver-postgres.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Declaration producer for the native xk6-sql PostgreSQL driver module.
+ * Consumer typechecks map the native module specifier to the generated
+ * declaration; k6 itself supplies the runtime symbol.
+ */
+declare const postgresDriver: symbol;
+export default postgresDriver;

package/dist/engines/k6/runtime/xk6-sql-driver-postgres.js

@@ -0,0 +1 @@
+const e=Symbol.for("elench.testkit.k6.xk6-sql-driver-postgres");export default e;

package/dist/engines/managed-module-resolution-policy-input.d.ts

@@ -0,0 +1,9 @@
+export declare function normalizeExistingFileRecord(value: Readonly<Record<string, string>>, label: string): Readonly<Record<string, string>>;
+export declare function normalizeAbsoluteFiles(values: readonly string[], label: string, mustExist: boolean): readonly string[];
+export declare function normalizeDirectories(values: readonly string[], label: string): readonly string[];
+export declare function normalizeStrings(values: readonly string[]): readonly string[];
+export declare function requireDirectTargetsWithinRoots(direct: Readonly<Record<string, string>>, roots: readonly string[]): void;
+export declare function requireExistingFile(value: string, label: string): string;
+export declare function readRecord(file: string): Record<string, unknown>;
+export declare function isErrorCode(error: unknown, code: string): boolean;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/engines/managed-module-resolution-policy-input.js

@@ -0,0 +1 @@
+import{isPathWithin as l}from"../process/files/paths.js";import s from"node:fs";import c from"node:path";export function normalizeExistingFileRecord(e,r){const o={};for(const[t,n]of Object.entries(e).sort(([i],[u])=>i.localeCompare(u)))o[t]=requireExistingFile(n,`${r}.${t}`);return Object.freeze(o)}export function normalizeAbsoluteFiles(e,r,o){return normalizeStrings(e.map((t,n)=>{const i=`${r}[${n.toString()}]`;return o?requireExistingFile(t,i):a(t,i)}))}export function normalizeDirectories(e,r){return normalizeStrings(e.map((o,t)=>{const n=a(o,`${r}[${t.toString()}]`),i=s.realpathSync(n);if(!s.statSync(i).isDirectory())throw new Error(`Managed module-resolution policy ${r} must contain directories`);return i}))}export function normalizeStrings(e){return Object.freeze([...new Set(e)].sort())}export function requireDirectTargetsWithinRoots(e,r){for(const[o,t]of Object.entries(e))if(!r.some(n=>l(n,t)||c.basename(t)==="package.json"&&c.dirname(t)===c.dirname(n)))throw new Error(`Managed direct module ${o} is outside every direct bridge root`)}export function requireExistingFile(e,r){const o=a(e,r),t=s.realpathSync(o);if(!s.statSync(t).isFile())throw new Error(`Managed module-resolution policy ${r} must be a file`);return t}function a(e,r){if(!c.isAbsolute(e))throw new Error(`Managed module-resolution policy ${r} must be absolute`);return c.resolve(e)}export function readRecord(e){const r=JSON.parse(s.readFileSync(e,"utf8"));if(!isRecord(r))throw new Error(`Invalid package manifest: ${e}`);return r}export function isErrorCode(e,r){return typeof e=="object"&&e!==null&&"code"in e&&Reflect.get(e,"code")===r}export function isRecord(e){return typeof e=="object"&&e!==null&&!Array.isArray(e)}

package/dist/engines/managed-module-resolution-policy.d.ts

@@ -0,0 +1,25 @@
+export interface ManagedNodeModuleResolutionPolicy {
+    readonly consumerRoots: readonly string[];
+    readonly direct: Readonly<Record<string, string>>;
+    readonly directBridgeRoots: readonly string[];
+    readonly engineLabel: string;
+    readonly forbiddenConsumerPackagePrefixes: readonly string[];
+    readonly packageAnchors: Readonly<Record<string, string>>;
+    readonly reservedPackageNames: readonly string[];
+    readonly stateSymbol: string;
+    readonly trustedImporterFiles: readonly string[];
+    readonly trustedInternalEntrypoints: readonly string[];
+    readonly verifiedParentlessPackageFiles: Readonly<Record<string, readonly string[]>>;
+    readonly verifiedProcessEntrypoints: readonly string[];
+}
+type RuntimeExportTargets = Readonly<Record<"default" | "import" | "require", string | null>>;
+export interface InspectedManagedNodeModuleResolutionPolicy extends Omit<ManagedNodeModuleResolutionPolicy, "packageAnchors" | "verifiedParentlessPackageFiles"> {
+    readonly dependencyRoots: readonly string[];
+    readonly managedImporterRoots: readonly string[];
+    readonly packageExports: Readonly<Record<string, RuntimeExportTargets>>;
+    readonly packageRoots: Readonly<Record<string, string>>;
+    readonly trustedInternalRoots: readonly string[];
+    readonly verifiedParentlessPackageFiles: readonly string[];
+}
+export declare function inspectManagedNodeModuleResolutionPolicy(policy: Readonly<ManagedNodeModuleResolutionPolicy>): InspectedManagedNodeModuleResolutionPolicy;
+export {};

package/dist/engines/managed-module-resolution-policy.js

@@ -0,0 +1 @@
+import{isPathWithin as m}from"../process/files/paths.js";import d from"node:fs";import a from"node:path";import{isErrorCode as j,isRecord as b,normalizeAbsoluteFiles as g,normalizeDirectories as w,normalizeExistingFileRecord as v,normalizeStrings as E,readRecord as k,requireDirectTargetsWithinRoots as y,requireExistingFile as h}from"./managed-module-resolution-policy-input.js";export function inspectManagedNodeModuleResolutionPolicy(t){const{engineLabel:o,stateSymbol:r}=t,e=w(t.consumerRoots,"consumerRoots"),n=v(t.direct,"direct"),s=w(t.directBridgeRoots,"directBridgeRoots");y(n,s);const i=S(t.packageAnchors,"packageAnchors"),c=E(t.reservedPackageNames),f=F(i);return Object.freeze({consumerRoots:e,dependencyRoots:f,managedImporterRoots:Object.freeze([...Object.values(i),...f.flatMap(l=>t.forbiddenConsumerPackagePrefixes.map(u=>a.join(l,u)).filter(u=>d.existsSync(u)).map(u=>d.realpathSync(u)))]),direct:n,directBridgeRoots:s,engineLabel:o,forbiddenConsumerPackagePrefixes:E(t.forbiddenConsumerPackagePrefixes),packageExports:$(i,o),packageRoots:i,reservedPackageNames:c,stateSymbol:r,trustedImporterFiles:g(t.trustedImporterFiles,"trustedImporterFiles",!1),trustedInternalEntrypoints:g(t.trustedInternalEntrypoints,"trustedInternalEntrypoints",!0),trustedInternalRoots:R(t.trustedInternalEntrypoints,c),verifiedParentlessPackageFiles:x(t.verifiedParentlessPackageFiles,i),verifiedProcessEntrypoints:g(t.verifiedProcessEntrypoints,"verifiedProcessEntrypoints",!0)})}function R(t,o){const r=new Set;for(const e of t){let n=a.dirname(h(e,"trustedInternalEntrypoints"));for(;;){const s=a.join(n,"package.json");if(d.existsSync(s)){const c=k(s);if(typeof c.name=="string"&&o.includes(c.name)){const f=a.relative(n,e),[l]=f.split(a.sep);if(l&&l!==".."&&!a.isAbsolute(f)){const u=a.join(n,l);d.statSync(u).isDirectory()&&r.add(d.realpathSync(u))}}break}const i=a.dirname(n);if(i===n)break;n=i}}return Object.freeze([...r].sort())}function x(t,o){const r=new Set;for(const[e,n]of Object.entries(t)){if(!Object.hasOwn(o,e))throw new Error(`Parentless preload package is not managed: ${e}`);const s=o[e];for(const[i,c]of n.entries()){if(a.isAbsolute(c)||c.length===0||c.includes("\0"))throw new Error(`Parentless preload ${e}[${i.toString()}] must be a relative file`);const f=a.resolve(s,c);if(!m(s,f))throw new Error(`Parentless preload escapes managed package ${e}`);const l=h(f,`verifiedParentlessPackageFiles.${e}[${i.toString()}]`);if(!m(s,l))throw new Error(`Parentless preload escapes managed package ${e}`);r.add(l)}}return Object.freeze([...r].sort())}function S(t,o){const r={};for(const[e,n]of Object.entries(t).sort(([s],[i])=>s.localeCompare(i)))r[e]=O(e,h(n,o));return Object.freeze(r)}function O(t,o){let r=a.dirname(o);for(;;){const e=a.join(r,"package.json");if(d.existsSync(e)&&k(e).name===t)return d.realpathSync(r);const n=a.dirname(r);if(n===r)throw new Error(`Managed package anchor has no matching package root: ${t}`);r=n}}function $(t,o){const r={};for(const[e,n]of Object.entries(t)){const s=k(a.join(n,"package.json"));if(s.name!==e||!b(s.exports))throw new Error(`Managed ${o} package manifest is invalid: ${e}`);for(const[i,c]of Object.entries(s.exports)){if(i!=="."&&!i.startsWith("./")||i.includes("*"))continue;const f=i==="."?e:`${e}${i.slice(1)}`;r[f]=Object.freeze({default:P(e,i,n,p(c,new Set(["node","default"]))),import:P(e,i,n,p(c,new Set(["node","import","default"]))),require:P(e,i,n,p(c,new Set(["node","require","default"])))})}}return Object.freeze(r)}function p(t,o){if(typeof t=="string")return t;if(Array.isArray(t)){for(const r of t){const e=p(r,o);if(e!==null)return e}return null}if(!b(t))return null;for(const[r,e]of Object.entries(t)){if(r==="types"||!o.has(r))continue;const n=p(e,o);if(n!==null)return n}return null}function P(t,o,r,e){if(e===null)return null;if(!e.startsWith("./"))throw new Error(`Managed package export must be relative: ${t}${o}`);const n=a.resolve(r,e);if(!m(r,n))throw new Error(`Managed package export escapes its verified root: ${t}${o}`);try{const s=d.realpathSync(n);if(!m(r,s)||!d.statSync(s).isFile())throw new Error(`Managed package export is not a verified file: ${t}${o}`);return s}catch(s){if(j(s,"ENOENT"))return null;throw s}}function F(t){const o=new Set;for(const[r,e]of Object.entries(t))o.add(r.startsWith("@")?a.dirname(a.dirname(e)):a.dirname(e));return Object.freeze([...o].sort())}

package/dist/engines/managed-module-resolution.d.ts

@@ -0,0 +1,13 @@
+import { type ManagedNodeModuleResolutionPolicy } from "./managed-module-resolution-policy.js";
+export type { ManagedNodeModuleResolutionPolicy } from "./managed-module-resolution-policy.js";
+export type ManagedNodeModuleResolution = ReturnType<typeof createManagedNodeModuleResolution>;
+/**
+ * Inspects one managed installation and produces every resolution view
+ * from that single decision: Node hooks, Vite aliases, and trusted roots.
+ */
+export declare function createManagedNodeModuleResolution(policy: Readonly<ManagedNodeModuleResolutionPolicy>): Readonly<{
+    aliases: Readonly<Record<string, string>>;
+    bootstrapSource: string;
+    dependencyRoots: readonly string[];
+}>;
+export declare function managedNodeModuleResolutionBootstrapSource(policy: Readonly<ManagedNodeModuleResolutionPolicy>): string;