@tiden/reporter-commons 0.1.0

package/dist/profilers/network-profiler.js

@@ -0,0 +1,94 @@
+"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");
+// 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) {
+        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/reporters/abstract-reporter.d.ts

@@ -0,0 +1,68 @@
+import { Attachment, TestResultType } from '../models';
+import { LoggerInterface } from '../utils/logger';
+export interface InternalReporterInterface {
+    addTestResult(result: TestResultType): Promise<void>;
+    publish(): Promise<void>;
+    startTestRun(): Promise<void>;
+    getTestResults(): TestResultType[];
+    setTestResults(results: TestResultType[]): void;
+    sendResults(): Promise<void>;
+    complete(): Promise<void>;
+    uploadAttachment(attachments: Attachment): Promise<string>;
+}
+/**
+ * @abstract
+ * @class AbstractReporter
+ * @implements InternalReporterInterface
+ */
+export declare abstract class AbstractReporter implements InternalReporterInterface {
+    /**
+     * @type {LoggerInterface}
+     * @private
+     */
+    protected readonly logger: LoggerInterface;
+    /**
+     * @type {TestResultType[]}
+     * @protected
+     */
+    protected results: TestResultType[];
+    /**
+     * @returns {Promise<void>}
+     */
+    abstract publish(): Promise<void>;
+    /**
+     * @returns {Promise<void>}
+     */
+    abstract startTestRun(): Promise<void>;
+    /**
+     * @returns {Promise<void>}
+     */
+    abstract complete(): Promise<void>;
+    /**
+     * @returns {Promise<void>}
+     */
+    abstract sendResults(): Promise<void>;
+    /**
+     * @param {Attachment} attachment
+     * @returns {Promise<string>}
+     */
+    abstract uploadAttachment(attachment: Attachment): Promise<string>;
+    /**
+     * @protected
+     * @param {LoggerInterface} logger
+     */
+    protected constructor(logger: LoggerInterface);
+    /**
+     * @returns {TestResultType[]}
+     */
+    getTestResults(): TestResultType[];
+    /**
+     * @param {TestResultType} result
+     */
+    addTestResult(result: TestResultType): Promise<void>;
+    /**
+     * @param {TestResultType[]} results
+     */
+    setTestResults(results: TestResultType[]): void;
+    protected removeAnsiEscapeCodes(str: string): string;
+}

package/dist/reporters/abstract-reporter.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractReporter = void 0;
+const uuid_1 = require("uuid");
+/**
+ * @abstract
+ * @class AbstractReporter
+ * @implements InternalReporterInterface
+ */
+class AbstractReporter {
+    /**
+     * @type {LoggerInterface}
+     * @private
+     */
+    logger;
+    /**
+     * @type {TestResultType[]}
+     * @protected
+     */
+    results = [];
+    /**
+     * @protected
+     * @param {LoggerInterface} logger
+     */
+    constructor(logger) {
+        this.logger = logger;
+    }
+    /**
+     * @returns {TestResultType[]}
+     */
+    getTestResults() {
+        const results = this.results;
+        this.results = [];
+        return results;
+    }
+    /**
+     * @param {TestResultType} result
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async addTestResult(result) {
+        this.logger.logDebug(`Adding test result: ${JSON.stringify(result)}`);
+        if (result.execution.stacktrace) {
+            result.execution.stacktrace = this.removeAnsiEscapeCodes(result.execution.stacktrace);
+        }
+        if (result.message) {
+            result.message = this.removeAnsiEscapeCodes(result.message);
+        }
+        if (result.case_id === null || !Array.isArray(result.case_id)) {
+            this.results.push(result);
+            return;
+        }
+        // if we have multiple ids, we need to create multiple test results and set duration to 0 for all but the first one
+        let firstCase = true;
+        for (const id of result.case_id) {
+            const testResultCopy = { ...result, execution: { ...result.execution } };
+            testResultCopy.case_id = id;
+            testResultCopy.id = (0, uuid_1.v4)();
+            if (!firstCase) {
+                testResultCopy.execution.duration = 0;
+            }
+            firstCase = false;
+            this.results.push(testResultCopy);
+        }
+    }
+    /**
+     * @param {TestResultType[]} results
+     */
+    setTestResults(results) {
+        this.results = results;
+    }
+    removeAnsiEscapeCodes(str) {
+        const ansiEscapeSequences = new RegExp([
+            '\x1B[[(?);]{0,2}(;?\\d)*.',
+        ].join('|'), 'g');
+        return str.replace(ansiEscapeSequences, '');
+    }
+}
+exports.AbstractReporter = AbstractReporter;

package/dist/reporters/index.d.ts

@@ -0,0 +1,3 @@
+export { AbstractReporter, type InternalReporterInterface, } from './abstract-reporter';
+export { ReportReporter } from './report-reporter';
+export { RunReporter } from './run-reporter';

package/dist/reporters/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunReporter = exports.ReportReporter = exports.AbstractReporter = void 0;
+var abstract_reporter_1 = require("./abstract-reporter");
+Object.defineProperty(exports, "AbstractReporter", { enumerable: true, get: function () { return abstract_reporter_1.AbstractReporter; } });
+var report_reporter_1 = require("./report-reporter");
+Object.defineProperty(exports, "ReportReporter", { enumerable: true, get: function () { return report_reporter_1.ReportReporter; } });
+var run_reporter_1 = require("./run-reporter");
+Object.defineProperty(exports, "RunReporter", { enumerable: true, get: function () { return run_reporter_1.RunReporter; } });

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

@@ -0,0 +1,50 @@
+import { AbstractReporter } from './abstract-reporter';
+import { Attachment } from '../models';
+import { WriterInterface } from '../writer';
+import { LoggerInterface } from '../utils/logger';
+import { HostData } from '../models/host-data';
+import { ReportSerializerInterface } from '../formatter/report-serializer';
+/**
+ * @class ReportReporter
+ * @extends AbstractReporter
+ */
+export declare class ReportReporter extends AbstractReporter {
+    private writer;
+    private frameworkName;
+    private reporterName;
+    private readonly environment;
+    private readonly runId;
+    private readonly rootSuite;
+    private readonly hostData;
+    private readonly serializer;
+    private startTime;
+    /**
+     * @param {LoggerInterface} logger
+     * @param {WriterInterface} writer
+     * @param {string} frameworkName
+     * @param {string} reporterName
+     * @param {string | undefined} environment
+     * @param {string | undefined} rootSuite
+     * @param {number | undefined} runId
+     * @param {HostData | undefined} hostData
+     * @param {ReportSerializerInterface} serializer
+     */
+    constructor(logger: LoggerInterface, writer: WriterInterface, frameworkName: string, reporterName: string, environment?: string, rootSuite?: string, runId?: number, hostData?: HostData, serializer?: ReportSerializerInterface);
+    /**
+     * @returns {Promise<void>}
+     */
+    startTestRun(): Promise<void>;
+    /**
+     * @returns {Promise<void>}
+     *
+     */
+    publish(): Promise<void>;
+    sendResults(): Promise<void>;
+    complete(): Promise<void>;
+    uploadAttachment(attachment: Attachment): Promise<string>;
+    /**
+     * @param {TestStepType[]} steps
+     * @returns {TestStepType[]}
+     */
+    private copyStepAttachments;
+}

package/dist/reporters/report-reporter.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportReporter = void 0;
+const abstract_reporter_1 = require("./abstract-reporter");
+const models_1 = require("../models");
+const hostData_1 = require("../utils/hostData");
+const report_serializer_1 = require("../formatter/report-serializer");
+/**
+ * @class ReportReporter
+ * @extends AbstractReporter
+ */
+class ReportReporter extends abstract_reporter_1.AbstractReporter {
+    writer;
+    frameworkName;
+    reporterName;
+    environment;
+    runId;
+    rootSuite;
+    hostData;
+    serializer;
+    startTime = Date.now();
+    /**
+     * @param {LoggerInterface} logger
+     * @param {WriterInterface} writer
+     * @param {string} frameworkName
+     * @param {string} reporterName
+     * @param {string | undefined} environment
+     * @param {string | undefined} rootSuite
+     * @param {number | undefined} runId
+     * @param {HostData | undefined} hostData
+     * @param {ReportSerializerInterface} serializer
+     */
+    constructor(logger, writer, frameworkName, reporterName, environment, rootSuite, runId, hostData, serializer = new report_serializer_1.ReportSerializer()) {
+        super(logger);
+        this.writer = writer;
+        this.frameworkName = frameworkName;
+        this.reporterName = reporterName;
+        this.environment = environment;
+        this.runId = runId;
+        this.rootSuite = rootSuite;
+        this.hostData = hostData;
+        this.serializer = serializer;
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async startTestRun() {
+        this.startTime = Date.now();
+    }
+    /**
+     * @returns {Promise<void>}
+     *
+     */
+    async publish() {
+        await this.sendResults();
+        await this.complete();
+    }
+    async sendResults() {
+        this.writer.clearPreviousResults();
+        for (const result of this.results) {
+            if (result.attachments.length > 0) {
+                result.attachments = this.writer.writeAttachment(result.attachments);
+            }
+            result.steps = this.copyStepAttachments(result.steps);
+            result.run_id = this.runId ?? null;
+            if (result.relations != null && this.rootSuite != null) {
+                const data = {
+                    title: this.rootSuite,
+                    public_id: null,
+                };
+                result.relations.suite?.data.unshift(data);
+            }
+            else if (this.rootSuite != null) {
+                result.relations = {
+                    suite: {
+                        data: [
+                            {
+                                title: this.rootSuite,
+                                public_id: null,
+                            },
+                        ],
+                    },
+                };
+            }
+            // Serialize to spec-compliant format before writing
+            const serialized = this.serializer.serializeResult(result);
+            await this.writer.writeTestResult(serialized);
+        }
+    }
+    async complete() {
+        const endTime = Date.now();
+        const report = {
+            title: 'Test run',
+            execution: {
+                start_time: this.startTime / 1000,
+                end_time: endTime / 1000,
+                duration: endTime - this.startTime,
+                cumulative_duration: 0,
+            },
+            stats: {
+                total: 0,
+                passed: 0,
+                failed: 0,
+                skipped: 0,
+                blocked: 0,
+                invalid: 0,
+                muted: 0,
+            },
+            results: [],
+            threads: [],
+            suites: [],
+            environment: this.environment ?? '',
+            host_data: this.hostData ?? (0, hostData_1.getHostInfo)(this.frameworkName, this.reporterName),
+        };
+        for (const result of this.results) {
+            report.stats.total++;
+            switch (result.execution.status) {
+                case models_1.TestStatusEnum.passed:
+                    report.stats.passed++;
+                    break;
+                case models_1.TestStatusEnum.failed:
+                    report.stats.failed++;
+                    break;
+                case models_1.TestStatusEnum.skipped:
+                    report.stats.skipped++;
+                    break;
+                case models_1.TestStatusEnum.invalid:
+                    report.stats.invalid++;
+                    break;
+                case models_1.TestStatusEnum.blocked:
+                    report.stats.blocked++;
+                    break;
+            }
+            report.execution.cumulative_duration += result.execution.duration ?? 0;
+            report.results.push({
+                duration: result.execution.duration ?? 0,
+                id: result.id,
+                status: result.execution.status,
+                thread: result.execution.thread,
+                title: result.title,
+            });
+        }
+        const path = await this.writer.writeReport(report);
+        this.logger.log(`Report saved to ${path}`);
+    }
+    uploadAttachment(attachment) {
+        this.writer.writeAttachment([attachment]);
+        return Promise.resolve('');
+    }
+    /**
+     * @param {TestStepType[]} steps
+     * @returns {TestStepType[]}
+     */
+    copyStepAttachments(steps) {
+        for (const step of steps) {
+            if (step.attachments.length > 0) {
+                step.attachments = this.writer.writeAttachment(step.attachments);
+            }
+            if (step.steps.length > 0) {
+                step.steps = this.copyStepAttachments(step.steps);
+            }
+        }
+        return steps;
+    }
+}
+exports.ReportReporter = ReportReporter;

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

@@ -0,0 +1,65 @@
+import { AbstractReporter } from './abstract-reporter';
+import { Attachment, TestResultType } from '../models';
+import { LoggerInterface } from '../utils/logger';
+import { IClient } from '../client/interface';
+/**
+ * @class RunReporter
+ * @extends AbstractReporter
+ */
+export declare class RunReporter extends AbstractReporter {
+    private api;
+    private withState;
+    /** Not read internally (no dashboard link without a workspace id) — kept for callers/telemetry. */
+    readonly projectCode: string;
+    private readonly batchSize;
+    private runId;
+    private firstIndex;
+    private isTestRunReady;
+    private mutex;
+    /**
+     * @param {LoggerInterface} logger
+     * @param {IClient} api
+     * @param {boolean} withState
+     * @param {string} projectCode
+     * @param {number | undefined} batchSize
+     */
+    constructor(logger: LoggerInterface, api: IClient, withState: boolean, 
+    /** Not read internally (no dashboard link without a workspace id) — kept for callers/telemetry. */
+    projectCode: string, batchSize?: number, runId?: number);
+    /**
+     * @returns {Promise<void>}
+     */
+    startTestRun(): Promise<void>;
+    /**
+     * @param {TestResultType} result
+     * @returns {Promise<void>}
+     */
+    addTestResult(result: TestResultType): Promise<void>;
+    /**
+     * @returns {Promise<void>}
+     */
+    private checkOrCreateTestRun;
+    /**
+     * @returns {Promise<void>}
+     * @param testResults
+     * @private
+     */
+    private publishResults;
+    /**
+     * @returns {Promise<void>}
+     */
+    publish(): Promise<void>;
+    /**
+     * @returns {Promise<void>}
+     */
+    sendResults(): Promise<void>;
+    /**
+     * @param {Attachment} attachment
+     * @returns {Promise<string>}
+     */
+    uploadAttachment(attachment: Attachment): Promise<string>;
+    /**
+     * @returns {Promise<void>}
+     */
+    complete(): Promise<void>;
+}

package/dist/reporters/run-reporter.js

@@ -0,0 +1,155 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunReporter = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const abstract_reporter_1 = require("./abstract-reporter");
+const models_1 = require("../models");
+const state_1 = require("../state/state");
+const async_mutex_1 = require("async-mutex");
+const run_constants_1 = require("./shared/run-constants");
+/**
+ * @class RunReporter
+ * @extends AbstractReporter
+ */
+class RunReporter extends abstract_reporter_1.AbstractReporter {
+    api;
+    withState;
+    projectCode;
+    batchSize;
+    runId;
+    firstIndex = 0;
+    isTestRunReady = false;
+    mutex = new async_mutex_1.Mutex();
+    /**
+     * @param {LoggerInterface} logger
+     * @param {IClient} api
+     * @param {boolean} withState
+     * @param {string} projectCode
+     * @param {number | undefined} batchSize
+     */
+    constructor(logger, api, withState, 
+    /** Not read internally (no dashboard link without a workspace id) — kept for callers/telemetry. */
+    projectCode, batchSize, runId) {
+        super(logger);
+        this.api = api;
+        this.withState = withState;
+        this.projectCode = projectCode;
+        this.batchSize = Math.min(batchSize ?? run_constants_1.DEFAULT_BATCH_SIZE, run_constants_1.MAX_BATCH_SIZE);
+        this.runId = runId;
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async startTestRun() {
+        this.runId = undefined;
+        this.isTestRunReady = false;
+        this.firstIndex = 0;
+        this.results = [];
+        await this.checkOrCreateTestRun();
+    }
+    /**
+     * @param {TestResultType} result
+     * @returns {Promise<void>}
+     */
+    async addTestResult(result) {
+        if (result.execution.status === models_1.TestStatusEnum.failed) {
+            this.logger.logDebug(`Test run #${this.runId ?? 'unknown'}`);
+        }
+        const release = await this.mutex.acquire();
+        try {
+            await super.addTestResult(result);
+            if (!this.isTestRunReady) {
+                return;
+            }
+            const countOfResults = this.batchSize + this.firstIndex;
+            if (this.results.length >= countOfResults) {
+                const firstIndex = this.firstIndex;
+                this.firstIndex = countOfResults;
+                await this.publishResults(this.results.slice(firstIndex, countOfResults));
+            }
+        }
+        finally {
+            release();
+        }
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async checkOrCreateTestRun() {
+        const runId = await this.api.createRun();
+        this.runId = runId;
+        process.env['TIDEN_RUN_ID'] = String(runId);
+        this.logger.log(`Test run created: #${runId}`);
+        if (this.withState) {
+            state_1.StateManager.setRunId(runId);
+        }
+        this.isTestRunReady = true;
+    }
+    /**
+     * @returns {Promise<void>}
+     * @param testResults
+     * @private
+     */
+    async publishResults(testResults) {
+        if (!this.runId) {
+            throw new Error('Run ID is not set');
+        }
+        await this.api.uploadResults(this.runId, testResults);
+        this.logger.logDebug(`Results sent to Tiden: ${testResults.length}`);
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async publish() {
+        const release = await this.mutex.acquire();
+        try {
+            await this.sendResults();
+        }
+        finally {
+            release();
+        }
+        await this.complete();
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async sendResults() {
+        if (this.results.length === 0) {
+            this.logger.log((0, chalk_1.default) `{yellow No results to send to Tiden}`);
+            return;
+        }
+        const remainingResults = this.results.slice(this.firstIndex);
+        if (this.firstIndex < this.results.length) {
+            if (remainingResults.length <= run_constants_1.DEFAULT_BATCH_SIZE) {
+                await this.publishResults(remainingResults);
+                return;
+            }
+            for (let i = 0; i < remainingResults.length; i += run_constants_1.DEFAULT_BATCH_SIZE) {
+                await this.publishResults(remainingResults.slice(i, i + run_constants_1.DEFAULT_BATCH_SIZE));
+            }
+        }
+        // Clear results because we don't need to send them again then we use Cypress reporter
+        this.results.length = 0;
+    }
+    /**
+     * @param {Attachment} attachment
+     * @returns {Promise<string>}
+     */
+    async uploadAttachment(attachment) {
+        return await this.api.uploadAttachment(attachment);
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async complete() {
+        if (!this.runId) {
+            throw new Error('Run ID is not set');
+        }
+        await this.api.completeRun(this.runId);
+        this.logger.log((0, chalk_1.default) `{green Run ${this.runId} completed}`);
+    }
+}
+exports.RunReporter = RunReporter;