qase-javascript-commons 2.5.4 → 2.5.6

package/dist/profilers/http-interceptor.js

@@ -0,0 +1,245 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpInterceptor = void 0;
+exports.extractRequestInfo = extractRequestInfo;
+exports.headersToRecord = headersToRecord;
+exports.buildRequestStep = buildRequestStep;
+const node_http_1 = __importDefault(require("node:http"));
+const node_https_1 = __importDefault(require("node:https"));
+const uuid_1 = require("uuid");
+const test_step_1 = require("../models/test-step");
+const step_execution_1 = require("../models/step-execution");
+/**
+ * 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'.
+ */
+function extractRequestInfo(args) {
+    const first = args[0];
+    if (typeof first === 'string') {
+        // Signature: (url: string, options?, callback?)
+        const options = args[1];
+        const method = options && typeof options === 'object' && !('emit' in options) && 'method' in options && typeof options.method === 'string'
+            ? options.method
+            : 'GET';
+        return { method, url: first };
+    }
+    if (first instanceof URL) {
+        // Signature: (url: URL, options?, callback?)
+        const options = args[1];
+        const method = options && typeof options === 'object' && !('emit' in options) && 'method' in options && typeof options.method === 'string'
+            ? options.method
+            : 'GET';
+        return { method, url: first.toString() };
+    }
+    // Signature: (options: RequestOptions, callback?)
+    const opts = first;
+    const method = opts.method ?? 'GET';
+    const protocol = opts.protocol ?? 'http:';
+    const hostname = opts.hostname ?? opts.host ?? 'localhost';
+    const port = opts.port !== undefined ? `:${String(opts.port)}` : '';
+    const path = opts.path ?? '/';
+    const url = `${protocol}//${hostname}${port}${path}`;
+    return { method, url };
+}
+// ─── Utility: headersToRecord ─────────────────────────────────────────────────
+/**
+ * Converts `http.IncomingHttpHeaders` (which has `string | string[] | undefined` values)
+ * to `Record<string, string>`. Multi-value headers joined with `', '`. Undefined values skipped.
+ */
+function headersToRecord(headers) {
+    const result = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (value === undefined)
+            continue;
+        if (Array.isArray(value)) {
+            result[key] = value.join(', ');
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+// ─── Utility: buildRequestStep ───────────────────────────────────────────────
+function buildRequestStep(params) {
+    const step = new test_step_1.TestStepType(test_step_1.StepType.REQUEST);
+    step.id = (0, uuid_1.v4)();
+    const data = step.data;
+    data.request_method = params.method;
+    data.request_url = params.url;
+    data.request_headers = null;
+    data.request_body = null;
+    data.status_code = params.statusCode;
+    data.response_body = params.responseBody;
+    data.response_headers = params.responseHeaders;
+    step.execution.start_time = params.startTime;
+    step.execution.end_time = params.endTime;
+    step.execution.duration = params.endTime - params.startTime;
+    step.execution.status = params.statusCode >= 400 ? step_execution_1.StepStatusEnum.failed : step_execution_1.StepStatusEnum.passed;
+    return step;
+}
+// ─── HttpInterceptor ─────────────────────────────────────────────────────────
+/**
+ * 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
+ */
+class HttpInterceptor {
+    store;
+    profiler;
+    origHttpRequest = null;
+    origHttpGet = null;
+    origHttpsRequest = null;
+    origHttpsGet = null;
+    constructor(store, profiler) {
+        this.store = store;
+        this.profiler = profiler;
+    }
+    install() {
+        this.origHttpRequest = node_http_1.default.request;
+        this.origHttpGet = node_http_1.default.get;
+        this.origHttpsRequest = node_https_1.default.request;
+        this.origHttpsGet = node_https_1.default.get;
+        const wrappedHttpRequest = this.wrapRequestFn(this.origHttpRequest);
+        const wrappedHttpGet = this.wrapRequestFn(this.origHttpGet);
+        const wrappedHttpsRequest = this.wrapRequestFn(this.origHttpsRequest);
+        const wrappedHttpsGet = this.wrapRequestFn(this.origHttpsGet);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+        node_http_1.default.request = wrappedHttpRequest;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+        node_http_1.default.get = wrappedHttpGet;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+        node_https_1.default.request = wrappedHttpsRequest;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+        node_https_1.default.get = wrappedHttpsGet;
+    }
+    uninstall() {
+        if (this.origHttpRequest !== null) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+            node_http_1.default.request = this.origHttpRequest;
+            this.origHttpRequest = null;
+        }
+        if (this.origHttpGet !== null) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+            node_http_1.default.get = this.origHttpGet;
+            this.origHttpGet = null;
+        }
+        if (this.origHttpsRequest !== null) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+            node_https_1.default.request = this.origHttpsRequest;
+            this.origHttpsRequest = null;
+        }
+        if (this.origHttpsGet !== null) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+            node_https_1.default.get = this.origHttpsGet;
+            this.origHttpsGet = null;
+        }
+    }
+    /**
+     * 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
+     */
+    wrapRequestFn(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    origFn) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return function (...args) {
+            // Call original first to get the ClientRequest
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            const req = origFn.apply(this, args);
+            // Extract request info
+            let reqInfo;
+            try {
+                reqInfo = extractRequestInfo(args);
+            }
+            catch {
+                return req;
+            }
+            // Check if this domain should be skipped
+            if (self.profiler.shouldSkip(reqInfo.url)) {
+                return req;
+            }
+            const startTime = Date.now();
+            const origEmit = req.emit.bind(req);
+            // Override req.emit to intercept the 'response' event
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            req.emit = function (event, ...emitArgs) {
+                if (event === 'response') {
+                    const res = emitArgs[0];
+                    try {
+                        const chunks = [];
+                        const isError = (res.statusCode ?? 0) >= 400;
+                        // Register data listener BEFORE calling original emit (Pitfall 2: stream consumption race)
+                        if (isError && self.profiler.trackOnFail) {
+                            res.on('data', (chunk) => {
+                                try {
+                                    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                                }
+                                catch {
+                                    // silent failure
+                                }
+                            });
+                        }
+                        res.on('end', () => {
+                            try {
+                                const endTime = Date.now();
+                                const statusCode = res.statusCode ?? 0;
+                                const captureBody = statusCode >= 400 && self.profiler.trackOnFail;
+                                const responseBody = captureBody ? Buffer.concat(chunks).toString('utf8') : null;
+                                const responseHeaders = statusCode >= 400 ? headersToRecord(res.headers) : null;
+                                const step = buildRequestStep({
+                                    method: reqInfo.method,
+                                    url: reqInfo.url,
+                                    statusCode,
+                                    responseBody,
+                                    responseHeaders,
+                                    startTime,
+                                    endTime,
+                                });
+                                // Push to accumulator — re-fetch in case context is still active
+                                const acc = self.store.getStore();
+                                if (acc !== undefined && acc !== null) {
+                                    acc.push(step);
+                                }
+                                else {
+                                    // No ALS context — push to fallback accumulator (for Jest/Vitest/WDIO workers)
+                                    self.profiler.fallbackSteps.push(step);
+                                }
+                            }
+                            catch {
+                                // INTC-06: silent failure — do not propagate to test
+                            }
+                        });
+                    }
+                    catch {
+                        // INTC-06: silent failure in setup — do not propagate
+                    }
+                    // CRITICAL: Call original emit LAST (after registering data listeners)
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                    return origEmit(event, ...emitArgs);
+                }
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                return origEmit(event, ...emitArgs);
+            };
+            return req;
+        };
+    }
+}
+exports.HttpInterceptor = HttpInterceptor;

package/dist/profilers/index.d.ts

@@ -0,0 +1,5 @@
+export { AbstractProfiler } from './abstract-profiler';
+export { NetworkProfiler } from './network-profiler';
+export type { NetworkProfilerOptions } from './network-profiler';
+export { HttpInterceptor } from './http-interceptor';
+export { FetchInterceptor } from './fetch-interceptor';

package/dist/profilers/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchInterceptor = exports.HttpInterceptor = exports.NetworkProfiler = exports.AbstractProfiler = void 0;
+var abstract_profiler_1 = require("./abstract-profiler");
+Object.defineProperty(exports, "AbstractProfiler", { enumerable: true, get: function () { return abstract_profiler_1.AbstractProfiler; } });
+var network_profiler_1 = require("./network-profiler");
+Object.defineProperty(exports, "NetworkProfiler", { enumerable: true, get: function () { return network_profiler_1.NetworkProfiler; } });
+var http_interceptor_1 = require("./http-interceptor");
+Object.defineProperty(exports, "HttpInterceptor", { enumerable: true, get: function () { return http_interceptor_1.HttpInterceptor; } });
+var fetch_interceptor_1 = require("./fetch-interceptor");
+Object.defineProperty(exports, "FetchInterceptor", { enumerable: true, get: function () { return fetch_interceptor_1.FetchInterceptor; } });

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

@@ -0,0 +1,61 @@
+import { AbstractProfiler } from './abstract-profiler';
+import { TestStepType } from '../models';
+export interface NetworkProfilerOptions {
+    skipDomains?: string[] | undefined;
+    trackOnFail?: boolean | undefined;
+}
+export declare class NetworkProfiler extends AbstractProfiler {
+    private readonly skipDomains;
+    private readonly _trackOnFail;
+    /**
+     * Fallback accumulator for steps captured outside any run() context.
+     * Used by frameworks where test bodies cannot be wrapped in run() (Jest, Vitest, WDIO).
+     * Public so interceptors can push to it via ProfilerRef.
+     */
+    readonly fallbackSteps: TestStepType[];
+    private httpInterceptor;
+    private fetchInterceptor;
+    constructor(options?: NetworkProfilerOptions);
+    get trackOnFail(): boolean;
+    shouldSkip(url: string): boolean;
+    /**
+     * Install HTTP/HTTPS monkey-patches and subscribe to undici diagnostics_channel
+     * so that outgoing requests inside a `run()` context are captured as REQUEST steps.
+     */
+    enable(): void;
+    /**
+     * No-op per v1.3 design decision (flag-based activation model).
+     * Satisfies the AbstractProfiler contract.
+     */
+    disable(): void;
+    /**
+     * Uninstall HTTP/HTTPS monkey-patches and unsubscribe from undici diagnostics_channel —
+     * permanently removes interception.
+     */
+    restore(): void;
+    /**
+     * Wraps `fn` in an AsyncLocalStorage context so that any HTTP requests
+     * made inside `fn` are attributed to the step accumulator for this call.
+     *
+     * Returns `{ result, steps }` where `result` is the return value of `fn`
+     * and `steps` is the array of REQUEST steps captured during execution.
+     */
+    run<T>(fn: () => Promise<T>): Promise<{
+        result: T;
+        steps: TestStepType[];
+    }>;
+    /**
+     * Returns the current ALS store when called inside a `run()` context.
+     * Returns an empty array when called outside (no active context).
+     */
+    getSteps(): TestStepType[];
+    /**
+     * Returns a copy of steps accumulated outside any run() context (fallback accumulator).
+     * Used by frameworks where test bodies cannot be wrapped in run() (Jest, Vitest, WDIO).
+     */
+    getAllSteps(): TestStepType[];
+    /**
+     * Clears the fallback step accumulator. Call after collecting steps per test.
+     */
+    clearSteps(): void;
+}

package/dist/profilers/network-profiler.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkProfiler = void 0;
+const node_async_hooks_1 = require("node:async_hooks");
+const abstract_profiler_1 = require("./abstract-profiler");
+const http_interceptor_1 = require("./http-interceptor");
+const fetch_interceptor_1 = require("./fetch-interceptor");
+const QASE_API_HOST = 'qase.io';
+// Module-level ALS store — shared across all NetworkProfiler instances to
+// allow nested run() calls to see the same context.
+const store = new node_async_hooks_1.AsyncLocalStorage();
+class NetworkProfiler extends abstract_profiler_1.AbstractProfiler {
+    skipDomains;
+    // Stored for Phase 13 use (controls whether to capture network steps on test failure)
+    _trackOnFail;
+    /**
+     * Fallback accumulator for steps captured outside any run() context.
+     * Used by frameworks where test bodies cannot be wrapped in run() (Jest, Vitest, WDIO).
+     * Public so interceptors can push to it via ProfilerRef.
+     */
+    fallbackSteps = [];
+    httpInterceptor = null;
+    fetchInterceptor = null;
+    constructor(options = {}) {
+        super();
+        this.skipDomains = options.skipDomains ?? [];
+        this._trackOnFail = options.trackOnFail ?? true;
+    }
+    get trackOnFail() {
+        return this._trackOnFail;
+    }
+    shouldSkip(url) {
+        if (url.includes(QASE_API_HOST)) {
+            return true;
+        }
+        return this.skipDomains.some((domain) => url.includes(domain));
+    }
+    /**
+     * Install HTTP/HTTPS monkey-patches and subscribe to undici diagnostics_channel
+     * so that outgoing requests inside a `run()` context are captured as REQUEST steps.
+     */
+    enable() {
+        this.httpInterceptor = new http_interceptor_1.HttpInterceptor(store, this);
+        this.httpInterceptor.install();
+        this.fetchInterceptor = new fetch_interceptor_1.FetchInterceptor(store, this);
+        this.fetchInterceptor.subscribe();
+    }
+    /**
+     * No-op per v1.3 design decision (flag-based activation model).
+     * Satisfies the AbstractProfiler contract.
+     */
+    disable() {
+        // Intentional no-op
+    }
+    /**
+     * Uninstall HTTP/HTTPS monkey-patches and unsubscribe from undici diagnostics_channel —
+     * permanently removes interception.
+     */
+    restore() {
+        this.fetchInterceptor?.unsubscribe();
+        this.fetchInterceptor = null;
+        this.httpInterceptor?.uninstall();
+        this.httpInterceptor = null;
+    }
+    /**
+     * Wraps `fn` in an AsyncLocalStorage context so that any HTTP requests
+     * made inside `fn` are attributed to the step accumulator for this call.
+     *
+     * Returns `{ result, steps }` where `result` is the return value of `fn`
+     * and `steps` is the array of REQUEST steps captured during execution.
+     */
+    async run(fn) {
+        const accumulator = [];
+        const result = await store.run(accumulator, fn);
+        return { result, steps: accumulator };
+    }
+    /**
+     * Returns the current ALS store when called inside a `run()` context.
+     * Returns an empty array when called outside (no active context).
+     */
+    getSteps() {
+        return store.getStore() ?? [];
+    }
+    /**
+     * Returns a copy of steps accumulated outside any run() context (fallback accumulator).
+     * Used by frameworks where test bodies cannot be wrapped in run() (Jest, Vitest, WDIO).
+     */
+    getAllSteps() {
+        return [...this.fallbackSteps];
+    }
+    /**
+     * Clears the fallback step accumulator. Call after collecting steps per test.
+     */
+    clearSteps() {
+        this.fallbackSteps.length = 0;
+    }
+}
+exports.NetworkProfiler = NetworkProfiler;

package/dist/qase.js

@@ -97,13 +97,7 @@ class QaseReporter {
         this.logger.logDebug(`Config: ${JSON.stringify(this.sanitizeOptions(composedOptions))}`);
         const effectiveMode = composedOptions.mode || options_1.ModeEnum.off;
         const effectiveFallback = composedOptions.fallback || options_1.ModeEnum.off;
-        const needsHostData = effectiveMode === options_1.ModeEnum.testops ||
-            effectiveMode === options_1.ModeEnum.testops_multi ||
-            effectiveFallback === options_1.ModeEnum.testops ||
-            effectiveFallback === options_1.ModeEnum.testops_multi;
-        this.hostData = needsHostData
-            ? (0, hostData_1.getHostInfo)(options.frameworkPackage, options.reporterName)
-            : (0, hostData_1.getMinimalHostData)();
+        this.hostData = (0, hostData_1.getHostInfo)(options.frameworkPackage, options.reporterName);
         this.logger.logDebug(`Host data: ${JSON.stringify(this.hostData)}`);
         this.captureLogs = composedOptions.captureLogs;
         try {
@@ -474,7 +468,7 @@ class QaseReporter {
             case options_1.ModeEnum.report: {
                 const localOptions = options.report?.connections?.[writer_1.DriverEnum.local];
                 const writer = new writer_1.FsWriter(localOptions);
-                return new reporters_1.ReportReporter(this.logger, writer, options.frameworkPackage, options.reporterName, options.environment, options.rootSuite, options.testops?.run?.id);
+                return new reporters_1.ReportReporter(this.logger, writer, options.frameworkPackage, options.reporterName, options.environment, options.rootSuite, options.testops?.run?.id, this.hostData);
             }
             case options_1.ModeEnum.off:
                 throw new disabled_exception_1.DisabledException();

package/dist/reporters/report-reporter.d.ts

@@ -2,6 +2,7 @@ import { AbstractReporter } from './abstract-reporter';
 import { Attachment } from '../models';
 import { WriterInterface } from '../writer';
 import { LoggerInterface } from '../utils/logger';
+import { HostData } from '../models/host-data';
 /**
  * @class ReportReporter
  * @extends AbstractReporter
@@ -13,6 +14,7 @@ export declare class ReportReporter extends AbstractReporter {
     private readonly environment;
     private readonly runId;
     private readonly rootSuite;
+    private readonly hostData;
     private startTime;
     /**
      * @param {LoggerInterface} logger
@@ -22,8 +24,9 @@ export declare class ReportReporter extends AbstractReporter {
      * @param {string | undefined} environment
      * @param {string | undefined} rootSuite
      * @param {number | undefined} runId
+     * @param {HostData | undefined} hostData
      */
-    constructor(logger: LoggerInterface, writer: WriterInterface, frameworkName: string, reporterName: string, environment?: string, rootSuite?: string, runId?: number);
+    constructor(logger: LoggerInterface, writer: WriterInterface, frameworkName: string, reporterName: string, environment?: string, rootSuite?: string, runId?: number, hostData?: HostData);
     /**
      * @returns {Promise<void>}
      */

package/dist/reporters/report-reporter.js

@@ -15,6 +15,7 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
     environment;
     runId;
     rootSuite;
+    hostData;
     startTime = Date.now();
     /**
      * @param {LoggerInterface} logger
@@ -24,8 +25,9 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
      * @param {string | undefined} environment
      * @param {string | undefined} rootSuite
      * @param {number | undefined} runId
+     * @param {HostData | undefined} hostData
      */
-    constructor(logger, writer, frameworkName, reporterName, environment, rootSuite, runId) {
+    constructor(logger, writer, frameworkName, reporterName, environment, rootSuite, runId, hostData) {
         super(logger);
         this.writer = writer;
         this.frameworkName = frameworkName;
@@ -33,6 +35,7 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
         this.environment = environment;
         this.runId = runId;
         this.rootSuite = rootSuite;
+        this.hostData = hostData;
     }
     /**
      * @returns {Promise<void>}
@@ -103,7 +106,7 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
             threads: [],
             suites: [],
             environment: this.environment ?? '',
-            host_data: (0, hostData_1.getHostInfo)(this.frameworkName, this.reporterName),
+            host_data: this.hostData ?? (0, hostData_1.getHostInfo)(this.frameworkName, this.reporterName),
         };
         for (const result of this.results) {
             report.stats.total++;
@@ -276,6 +279,10 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
                 input_data: null, // JS GherkinData has no data field
             };
         }
+        // For request steps, pass raw fields through (all 7 StepRequestData fields are preserved)
+        if (step.step_type === models_1.StepType.REQUEST && 'request_method' in data) {
+            return data;
+        }
         return data;
     }
 }

package/dist/utils/hostData.d.ts

@@ -1,10 +1,4 @@
 import { HostData } from '../models/host-data';
-/**
- * Returns minimal host data without slow operations (no npm list, no execSync for node/npm).
- * Use when reporter mode is "off" to avoid startup delay.
- * @returns {HostData} Minimal host information object
- */
-export declare function getMinimalHostData(): HostData;
 /**
  * Gets information about the current host environment
  * @param {string} framework The framework name to check version for