qase-javascript-commons 2.5.4 → 2.5.6

package/changelog.md

@@ -1,3 +1,25 @@
+# qase-javascript-commons@2.5.6
+
+## What's new
+
+- Added Network Profiler framework for automatic HTTP/HTTPS request interception during test execution.
+- Added `StepType.REQUEST` step type for network request data in test results.
+- Added configurable profiler options in `qase.config.json` (`profilers` and `networkProfiler` fields).
+
+# qase-javascript-commons@2.5.5
+
+## What's new
+
+Significantly improved startup performance by optimizing host data collection:
+
+- Replaced slow `npm list --depth=10 --json` fallback with fast `require.resolve()`-based package version lookup.
+- Replaced `execSync('node --version')` with `process.version`.
+- Replaced `execSync('npm --version')` with `process.env.npm_config_user_agent` parsing (with execSync fallback).
+- Eliminated duplicate `getHostInfo()` call in `ReportReporter.complete()` by passing pre-collected host data from `QaseReporter`.
+- Included `report` mode in the `needsHostData` guard so host data is collected once during init.
+
+Worst-case startup time reduced from ~10-25 seconds to ~55 ms.
+
 # qase-javascript-commons@2.5.4
 
 ## What's new

package/dist/client/clientV2.d.ts

@@ -21,6 +21,7 @@ export declare class ClientV2 extends ClientV1 {
     private createBaseResultStep;
     private processTextStep;
     private processGherkinStep;
+    private processRequestStep;
     private getExecution;
     private getRelation;
     private getDefaultSuiteRelation;

package/dist/client/clientV2.js

@@ -173,9 +173,12 @@ class ClientV2 extends clientV1_1.ClientV1 {
         if (step.step_type === models_1.StepType.TEXT) {
             this.processTextStep(step, resultStep, testTitle);
         }
-        else {
+        else if (step.step_type === models_1.StepType.GHERKIN) {
             this.processGherkinStep(step, resultStep);
         }
+        else if (step.step_type === models_1.StepType.REQUEST) {
+            this.processRequestStep(step, resultStep);
+        }
         if (step.steps.length > 0) {
             resultStep.steps = await this.transformSteps(step.steps, testTitle);
         }
@@ -215,6 +218,13 @@ class ClientV2 extends clientV1_1.ClientV1 {
         const stepData = step.data;
         resultStep.data.action = stepData.keyword;
     }
+    processRequestStep(step, resultStep) {
+        if (!('request_method' in step.data) || !resultStep.data) {
+            return;
+        }
+        const stepData = step.data;
+        resultStep.data.action = `${stepData.request_method} ${stepData.request_url}`;
+    }
     getExecution(exec) {
         return {
             status: ClientV2.statusMap[exec.status],

package/dist/config/config-validation-schema.d.ts

@@ -298,5 +298,29 @@ export declare const configValidationSchema: {
                 };
             };
         };
+        profilers: {
+            type: string;
+            items: {
+                type: string;
+            };
+            nullable: boolean;
+        };
+        networkProfiler: {
+            type: string;
+            nullable: boolean;
+            properties: {
+                skip_domains: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    nullable: boolean;
+                };
+                track_on_fail: {
+                    type: string;
+                    nullable: boolean;
+                };
+            };
+        };
     };
 };

package/dist/config/config-validation-schema.js

@@ -282,5 +282,27 @@ exports.configValidationSchema = {
                 },
             },
         },
+        profilers: {
+            type: 'array',
+            items: {
+                type: 'string',
+            },
+            nullable: true,
+        },
+        networkProfiler: {
+            type: 'object',
+            nullable: true,
+            properties: {
+                skip_domains: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    nullable: true,
+                },
+                track_on_fail: {
+                    type: 'boolean',
+                    nullable: true,
+                },
+            },
+        },
     },
 };

package/dist/index.d.ts

@@ -6,6 +6,7 @@ export * from './models';
 export * from './options';
 export * from './reporters';
 export * from './writer';
+export * from './profilers';
 export * from './utils/get-package-version';
 export * from './utils/mimeTypes';
 export * from './utils/project-mapping-utils';

package/dist/index.js

@@ -22,6 +22,7 @@ __exportStar(require("./models"), exports);
 __exportStar(require("./options"), exports);
 __exportStar(require("./reporters"), exports);
 __exportStar(require("./writer"), exports);
+__exportStar(require("./profilers"), exports);
 __exportStar(require("./utils/get-package-version"), exports);
 __exportStar(require("./utils/mimeTypes"), exports);
 __exportStar(require("./utils/project-mapping-utils"), exports);

package/dist/models/index.d.ts

@@ -2,6 +2,7 @@ export { TestResultType } from './test-result';
 export type { Relation, Suite, SuiteData, TestopsProjectMapping } from './test-result';
 export { TestExecution, TestStatusEnum } from './test-execution';
 export { TestStepType, StepType } from './test-step';
+export type { StepRequestData, StepTextData, StepGherkinData } from './step-data';
 export { StepStatusEnum } from './step-execution';
 export type { Attachment } from './attachment';
 export type { Report } from './report';

package/dist/models/step-data.d.ts

@@ -8,3 +8,12 @@ export interface StepGherkinData {
     name: string;
     line: number;
 }
+export interface StepRequestData {
+    request_method: string;
+    request_url: string;
+    request_headers: Record<string, string> | null;
+    request_body: string | null;
+    status_code: number | null;
+    response_body: string | null;
+    response_headers: Record<string, string> | null;
+}

package/dist/models/test-step.d.ts

@@ -1,14 +1,15 @@
-import { StepGherkinData, StepTextData } from './step-data';
+import { StepGherkinData, StepRequestData, StepTextData } from './step-data';
 import { StepExecution } from './step-execution';
 import { Attachment } from './attachment';
 export declare enum StepType {
     TEXT = "text",
-    GHERKIN = "gherkin"
+    GHERKIN = "gherkin",
+    REQUEST = "request"
 }
 export declare class TestStepType {
     id: string;
     step_type: StepType;
-    data: StepTextData | StepGherkinData;
+    data: StepTextData | StepGherkinData | StepRequestData;
     parent_id: string | null;
     execution: StepExecution;
     attachments: Attachment[];

package/dist/models/test-step.js

@@ -6,6 +6,7 @@ var StepType;
 (function (StepType) {
     StepType["TEXT"] = "text";
     StepType["GHERKIN"] = "gherkin";
+    StepType["REQUEST"] = "request";
 })(StepType || (exports.StepType = StepType = {}));
 class TestStepType {
     id;
@@ -29,13 +30,24 @@ class TestStepType {
                 data: null,
             };
         }
-        else {
+        else if (type === StepType.GHERKIN) {
             this.data = {
                 keyword: '',
                 name: '',
                 line: 0,
             };
         }
+        else {
+            this.data = {
+                request_method: '',
+                request_url: '',
+                request_headers: null,
+                request_body: null,
+                status_code: null,
+                response_body: null,
+                response_headers: null,
+            };
+        }
     }
 }
 exports.TestStepType = TestStepType;

package/dist/options/options-type.d.ts

@@ -31,6 +31,11 @@ export type OptionsType = {
     /** Multi-project configuration (used when mode is testops_multi). */
     testops_multi?: TestOpsMultiConfigType | undefined;
     report?: RecursivePartial<AdditionalReportOptionsType> | undefined;
+    profilers?: string[] | undefined;
+    networkProfiler?: {
+        skip_domains?: string[] | undefined;
+        track_on_fail?: boolean | undefined;
+    } | undefined;
 };
 export type FrameworkOptionsType<F extends string, O> = {
     framework?: Partial<Record<F, O>>;

package/dist/profilers/abstract-profiler.d.ts

@@ -0,0 +1,5 @@
+export declare abstract class AbstractProfiler {
+    abstract enable(): void;
+    abstract disable(): void;
+    abstract restore(): void;
+}

package/dist/profilers/abstract-profiler.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractProfiler = void 0;
+class AbstractProfiler {
+}
+exports.AbstractProfiler = AbstractProfiler;

package/dist/profilers/fetch-interceptor.d.ts

@@ -0,0 +1,60 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { TestStepType } from '../models/test-step';
+interface ProfilerRef {
+    shouldSkip(url: string): boolean;
+    trackOnFail: boolean;
+    fallbackSteps: TestStepType[];
+}
+/**
+ * FetchInterceptor subscribes to undici diagnostics_channel events to capture
+ * outgoing fetch() calls as REQUEST-type steps in the AsyncLocalStorage store.
+ *
+ * Works with Node.js 18+ global fetch (which uses undici internally).
+ * Gracefully skips subscription on Node < 18 (no global fetch).
+ *
+ * Key design decisions:
+ *  - WeakMap keyed on undici request objects (same reference across all events)
+ *  - ALS context captured at undici:request:create time, NOT at headers time.
+ *    This is critical because undici connection pooling can break AsyncLocalStorage
+ *    propagation between the create and headers events when connections are reused.
+ *  - globalThis.fetch wrapping intercepts error response bodies (undici:request:bodyChunkReceived
+ *    is not available in Node 22's built-in undici)
+ *  - All handlers wrapped in try/catch (INTC-06: silent failure)
+ *
+ * Event flow:
+ *  undici:request:create   → capture method, URL, start time, ALS context → WeakMap
+ *  undici:request:headers  → build step using WeakMap data, push to ALS accumulator
+ *  undici:request:trailers → cleanup WeakMap entry
+ *  fetch wrapper           → update response_body for error responses (>= 400)
+ */
+export declare class FetchInterceptor {
+    private readonly store;
+    private readonly profiler;
+    private readonly pendingRequests;
+    private readonly bodyHandlers;
+    private readonly createHandler;
+    private readonly headersHandler;
+    private readonly trailersHandler;
+    private origFetch;
+    constructor(store: AsyncLocalStorage<TestStepType[]>, profiler: ProfilerRef);
+    /**
+     * Subscribe to undici diagnostics_channel events and wrap global fetch for
+     * error response body capture.
+     *
+     * No-op on Node < 18 (no global fetch) or if diagnostics_channel unavailable.
+     */
+    subscribe(): void;
+    /**
+     * Unsubscribe from diagnostics_channel events and restore original global fetch.
+     */
+    unsubscribe(): void;
+    private handleCreate;
+    private handleHeaders;
+    private handleTrailers;
+    /**
+     * Called by the fetch wrapper when an error response body is available.
+     * Finds the most recently added step for this URL/status and updates its response_body.
+     */
+    private applyResponseBody;
+}
+export {};

package/dist/profilers/fetch-interceptor.js

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchInterceptor = void 0;
+const http_interceptor_1 = require("./http-interceptor");
+// ─── FetchInterceptor ─────────────────────────────────────────────────────────
+/**
+ * FetchInterceptor subscribes to undici diagnostics_channel events to capture
+ * outgoing fetch() calls as REQUEST-type steps in the AsyncLocalStorage store.
+ *
+ * Works with Node.js 18+ global fetch (which uses undici internally).
+ * Gracefully skips subscription on Node < 18 (no global fetch).
+ *
+ * Key design decisions:
+ *  - WeakMap keyed on undici request objects (same reference across all events)
+ *  - ALS context captured at undici:request:create time, NOT at headers time.
+ *    This is critical because undici connection pooling can break AsyncLocalStorage
+ *    propagation between the create and headers events when connections are reused.
+ *  - globalThis.fetch wrapping intercepts error response bodies (undici:request:bodyChunkReceived
+ *    is not available in Node 22's built-in undici)
+ *  - All handlers wrapped in try/catch (INTC-06: silent failure)
+ *
+ * Event flow:
+ *  undici:request:create   → capture method, URL, start time, ALS context → WeakMap
+ *  undici:request:headers  → build step using WeakMap data, push to ALS accumulator
+ *  undici:request:trailers → cleanup WeakMap entry
+ *  fetch wrapper           → update response_body for error responses (>= 400)
+ */
+class FetchInterceptor {
+    store;
+    profiler;
+    // WeakMap keyed on undici request objects (same reference across create/headers/trailers events)
+    pendingRequests = new WeakMap();
+    // Map from step to body-update callback (for error response body capture)
+    bodyHandlers = new WeakMap();
+    // Bound handler references (needed for subscribe/unsubscribe identity)
+    createHandler;
+    headersHandler;
+    trailersHandler;
+    // Saved original fetch for wrapping/unwrapping
+    origFetch = null;
+    constructor(store, profiler) {
+        this.store = store;
+        this.profiler = profiler;
+        // Bind handlers as arrow functions for subscribe/unsubscribe reference identity
+        this.createHandler = (msg) => {
+            try {
+                this.handleCreate(msg);
+            }
+            catch {
+                // INTC-06: silent failure
+            }
+        };
+        this.headersHandler = (msg) => {
+            try {
+                this.handleHeaders(msg);
+            }
+            catch {
+                // INTC-06: silent failure
+            }
+        };
+        this.trailersHandler = (msg) => {
+            try {
+                this.handleTrailers(msg);
+            }
+            catch {
+                // INTC-06: silent failure
+            }
+        };
+    }
+    /**
+     * Subscribe to undici diagnostics_channel events and wrap global fetch for
+     * error response body capture.
+     *
+     * No-op on Node < 18 (no global fetch) or if diagnostics_channel unavailable.
+     */
+    subscribe() {
+        // Guard: require global fetch (Node 18+)
+        if (typeof globalThis.fetch !== 'function') {
+            return;
+        }
+        let dc;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+            dc = require('node:diagnostics_channel');
+        }
+        catch {
+            return; // diagnostics_channel unavailable — skip entirely
+        }
+        if (typeof dc.subscribe !== 'function') {
+            return;
+        }
+        dc.subscribe('undici:request:create', this.createHandler);
+        dc.subscribe('undici:request:headers', this.headersHandler);
+        dc.subscribe('undici:request:trailers', this.trailersHandler);
+        // Wrap global fetch to intercept error response bodies
+        // (undici:request:bodyChunkReceived not available in Node 22 built-in undici)
+        this.origFetch = globalThis.fetch;
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+        globalThis.fetch = async function wrappedFetch(input, init) {
+            const origFetch = self.origFetch;
+            if (!origFetch) {
+                throw new Error('fetch not available');
+            }
+            const response = await origFetch.call(globalThis, input, init);
+            // Intercept error responses to capture body
+            if (response.status >= 400 && self.profiler.trackOnFail) {
+                try {
+                    // Clone to read body without consuming the original response
+                    const cloned = response.clone();
+                    void cloned.text().then((bodyText) => {
+                        try {
+                            self.applyResponseBody(input, response.status, bodyText);
+                        }
+                        catch {
+                            // INTC-06: silent failure
+                        }
+                    });
+                }
+                catch {
+                    // INTC-06: silent failure
+                }
+            }
+            return response;
+        };
+    }
+    /**
+     * Unsubscribe from diagnostics_channel events and restore original global fetch.
+     */
+    unsubscribe() {
+        // Restore original fetch
+        if (this.origFetch !== null) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+            globalThis.fetch = this.origFetch;
+            this.origFetch = null;
+        }
+        let dc;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+            dc = require('node:diagnostics_channel');
+        }
+        catch {
+            return;
+        }
+        // Feature-detect unsubscribe (Pitfall 5: not available in all Node versions)
+        if (typeof dc.unsubscribe !== 'function') {
+            return;
+        }
+        try {
+            dc.unsubscribe('undici:request:create', this.createHandler);
+        }
+        catch {
+            // silent
+        }
+        try {
+            dc.unsubscribe('undici:request:headers', this.headersHandler);
+        }
+        catch {
+            // silent
+        }
+        try {
+            dc.unsubscribe('undici:request:trailers', this.trailersHandler);
+        }
+        catch {
+            // silent
+        }
+    }
+    // ─── Private event handlers ─────────────────────────────────────────────────
+    handleCreate(msg) {
+        const message = msg;
+        const req = message.request;
+        if (!req)
+            return;
+        // CRITICAL: Capture ALS context HERE (at create time), not in headersHandler.
+        // Due to undici connection pooling, store.getStore() may return undefined in
+        // the headers event when connections are reused across test runs.
+        const acc = this.store.getStore();
+        // acc may be null/undefined when outside a run() context — use fallback accumulator in that case
+        const method = typeof req['method'] === 'string' ? req['method'] : 'GET';
+        const origin = typeof req['origin'] === 'string' ? req['origin'] : '';
+        const path = typeof req['path'] === 'string' ? req['path'] : '/';
+        const url = `${origin}${path}`;
+        // Check shouldSkip
+        if (this.profiler.shouldSkip(url)) {
+            return;
+        }
+        this.pendingRequests.set(req, {
+            method,
+            url,
+            startTime: Date.now(),
+            alsContext: acc ?? null,
+        });
+    }
+    handleHeaders(msg) {
+        const message = msg;
+        const req = message.request;
+        if (!req)
+            return;
+        const pending = this.pendingRequests.get(req);
+        if (!pending)
+            return;
+        // Use the ALS context captured at create time — do NOT call store.getStore() here.
+        // Connection pooling in undici can break ALS propagation between events.
+        const acc = pending.alsContext;
+        const endTime = Date.now();
+        const statusCode = message.response?.statusCode ?? 0;
+        const step = (0, http_interceptor_1.buildRequestStep)({
+            method: pending.method,
+            url: pending.url,
+            statusCode,
+            responseBody: null, // filled in later for errors via fetch wrapper
+            responseHeaders: null,
+            startTime: pending.startTime,
+            endTime,
+        });
+        if (acc !== null) {
+            acc.push(step);
+        }
+        else {
+            // No ALS context — push to fallback accumulator (for Jest/Vitest/WDIO workers)
+            this.profiler.fallbackSteps.push(step);
+        }
+        // Register body handler for error responses
+        if (statusCode >= 400 && this.profiler.trackOnFail) {
+            this.bodyHandlers.set(step, (bodyText) => {
+                step.data.response_body = bodyText;
+            });
+        }
+    }
+    handleTrailers(msg) {
+        const message = msg;
+        const req = message.request;
+        if (!req)
+            return;
+        // Clean up pending state
+        this.pendingRequests.delete(req);
+    }
+    /**
+     * Called by the fetch wrapper when an error response body is available.
+     * Finds the most recently added step for this URL/status and updates its response_body.
+     */
+    applyResponseBody(input, statusCode, bodyText) {
+        const url = typeof input === 'string'
+            ? input
+            : input instanceof URL
+                ? input.toString()
+                : input.url;
+        // Get all accumulated steps — use ALS context if available, fallback accumulator otherwise
+        const searchArray = this.store.getStore() ?? this.profiler.fallbackSteps;
+        if (searchArray.length === 0)
+            return;
+        // Find the last step that matches this response and has null body
+        for (let i = searchArray.length - 1; i >= 0; i--) {
+            const step = searchArray[i];
+            if (!step)
+                continue;
+            const data = step.data;
+            if (data.status_code !== statusCode)
+                continue;
+            if (data.response_body !== null)
+                continue;
+            // Check if URL matches (handle query strings, trailing slashes)
+            const stepUrl = data.request_url ?? '';
+            const inputUrlBase = url.split('?')[0] ?? url;
+            if (url.includes(stepUrl) || stepUrl.includes(inputUrlBase) || stepUrl === inputUrlBase) {
+                const handler = this.bodyHandlers.get(step);
+                if (handler) {
+                    handler(bodyText);
+                    this.bodyHandlers.delete(step);
+                    return;
+                }
+            }
+        }
+    }
+}
+exports.FetchInterceptor = FetchInterceptor;

package/dist/profilers/http-interceptor.d.ts

@@ -0,0 +1,69 @@
+import http from 'node:http';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { TestStepType } from '../models/test-step';
+interface ProfilerRef {
+    shouldSkip(url: string): boolean;
+    trackOnFail: boolean;
+    fallbackSteps: TestStepType[];
+}
+export interface RequestInfo {
+    method: string;
+    url: string;
+}
+/**
+ * Handles the 3 `http.request()` call signatures:
+ *  - (url: string, options?, callback?)
+ *  - (url: URL, options?, callback?)
+ *  - (options: RequestOptions, callback?)
+ *
+ * Returns `{ method, url }`. Default method is 'GET'.
+ */
+export declare function extractRequestInfo(args: [
+    string | URL | http.RequestOptions,
+    (http.RequestOptions | ((res: http.IncomingMessage) => void))?,
+    ((res: http.IncomingMessage) => void)?
+]): RequestInfo;
+/**
+ * Converts `http.IncomingHttpHeaders` (which has `string | string[] | undefined` values)
+ * to `Record<string, string>`. Multi-value headers joined with `', '`. Undefined values skipped.
+ */
+export declare function headersToRecord(headers: http.IncomingHttpHeaders): Record<string, string>;
+export declare function buildRequestStep(params: {
+    method: string;
+    url: string;
+    statusCode: number;
+    responseBody: string | null;
+    responseHeaders: Record<string, string> | null;
+    startTime: number;
+    endTime: number;
+}): TestStepType;
+/**
+ * HttpInterceptor monkey-patches Node.js http/https module functions to capture
+ * outgoing requests as REQUEST-type steps in the AsyncLocalStorage store.
+ *
+ * Pattern:
+ *  1. `install()` — saves originals, replaces with wrappers
+ *  2. `uninstall()` — restores originals
+ */
+export declare class HttpInterceptor {
+    private readonly store;
+    private readonly profiler;
+    private origHttpRequest;
+    private origHttpGet;
+    private origHttpsRequest;
+    private origHttpsGet;
+    constructor(store: AsyncLocalStorage<TestStepType[]>, profiler: ProfilerRef);
+    install(): void;
+    uninstall(): void;
+    /**
+     * Creates a wrapper around a http.request-like function.
+     * The wrapper:
+     *  1. Calls the original function to get the ClientRequest
+     *  2. Checks if there's an active ALS context — if not, returns unchanged
+     *  3. Checks shouldSkip — if true, returns unchanged
+     *  4. Intercepts the 'response' event via req.emit override
+     *  5. Builds a TestStepType on response end and pushes to accumulator
+     */
+    private wrapRequestFn;
+}
+export {};