qase-javascript-commons 2.4.18 → 2.5.1

package/dist/options/mode-enum.js

@@ -8,5 +8,7 @@ var ModeEnum;
 (function (ModeEnum) {
     ModeEnum["report"] = "report";
     ModeEnum["testops"] = "testops";
+    /** Multi-project mode: send results to multiple Qase projects. */
+    ModeEnum["testops_multi"] = "testops_multi";
     ModeEnum["off"] = "off";
 })(ModeEnum || (exports.ModeEnum = ModeEnum = {}));

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

@@ -1,6 +1,6 @@
 import { ModeEnum } from './mode-enum';
 import { DriverEnum, FsWriterOptionsType } from '../writer';
-import { TestOpsOptionsType } from '../models/config/TestOpsOptionsType';
+import { TestOpsOptionsType, TestOpsMultiConfigType } from '../models/config/TestOpsOptionsType';
 type RecursivePartial<T> = {
     [K in keyof T]?: RecursivePartial<T[K]> | undefined;
 };
@@ -28,6 +28,8 @@ export type OptionsType = {
     statusMapping?: Record<string, string> | undefined;
     logging?: RecursivePartial<LoggingOptionsType> | undefined;
     testops?: RecursivePartial<TestOpsOptionsType> | undefined;
+    /** Multi-project configuration (used when mode is testops_multi). */
+    testops_multi?: TestOpsMultiConfigType | undefined;
     report?: RecursivePartial<AdditionalReportOptionsType> | undefined;
 };
 export type FrameworkOptionsType<F extends string, O> = {

package/dist/qase.js

@@ -97,7 +97,10 @@ 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 || effectiveFallback === options_1.ModeEnum.testops;
+        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)();
@@ -453,6 +456,21 @@ class QaseReporter {
                 const apiClient = new clientV2_1.ClientV2(this.logger, options.testops, options.environment, options.rootSuite, this.hostData, options.reporterName, options.frameworkPackage);
                 return new reporters_1.TestOpsReporter(this.logger, apiClient, this.withState, options.testops.project, options.testops.api.host, options.testops.batch?.size, options.testops.run?.id, options.testops.showPublicReportLink);
             }
+            case options_1.ModeEnum.testops_multi: {
+                if (!options.testops?.api?.token) {
+                    throw new Error(`Either "testops.api.token" parameter or "${env_1.EnvApiEnum.token}" environment variable is required in "testops_multi" mode`);
+                }
+                const multi = options.testops_multi;
+                if (!multi?.projects?.length) {
+                    throw new Error('"testops_multi.projects" must contain at least one project with a "code" field');
+                }
+                for (const p of multi.projects) {
+                    if (!p?.code) {
+                        throw new Error('Each project in "testops_multi.projects" must have a "code" field');
+                    }
+                }
+                return new reporters_1.TestOpsMultiReporter(this.logger, options.testops, multi, this.withState, this.hostData, options.reporterName, options.frameworkPackage, options.environment, options.testops.api?.host, options.testops.batch?.size, options.testops.showPublicReportLink);
+            }
             case options_1.ModeEnum.report: {
                 const localOptions = options.report?.connections?.[writer_1.DriverEnum.local];
                 const writer = new writer_1.FsWriter(localOptions);

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

@@ -64,5 +64,5 @@ export declare abstract class AbstractReporter implements InternalReporterInterf
      * @param {TestResultType[]} results
      */
     setTestResults(results: TestResultType[]): void;
-    private removeAnsiEscapeCodes;
+    protected removeAnsiEscapeCodes(str: string): string;
 }

package/dist/reporters/index.d.ts

@@ -1,3 +1,4 @@
 export { AbstractReporter, type InternalReporterInterface, } from './abstract-reporter';
 export { ReportReporter } from './report-reporter';
 export { TestOpsReporter } from './testops-reporter';
+export { TestOpsMultiReporter } from './testops-multi-reporter';

package/dist/reporters/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TestOpsReporter = exports.ReportReporter = exports.AbstractReporter = void 0;
+exports.TestOpsMultiReporter = exports.TestOpsReporter = 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 testops_reporter_1 = require("./testops-reporter");
 Object.defineProperty(exports, "TestOpsReporter", { enumerable: true, get: function () { return testops_reporter_1.TestOpsReporter; } });
+var testops_multi_reporter_1 = require("./testops-multi-reporter");
+Object.defineProperty(exports, "TestOpsMultiReporter", { enumerable: true, get: function () { return testops_multi_reporter_1.TestOpsMultiReporter; } });

package/dist/reporters/testops-multi-reporter.d.ts

@@ -0,0 +1,50 @@
+import { AbstractReporter } from './abstract-reporter';
+import { Attachment, TestResultType } from '../models';
+import type { TestOpsOptionsType, TestOpsMultiConfigType } from '../models/config/TestOpsOptionsType';
+import { LoggerInterface } from '../utils/logger';
+import { HostData } from '../models/host-data';
+/**
+ * Multi-project TestOps reporter. Sends test results to multiple Qase projects
+ * with different test case IDs per project. Each project gets its own run.
+ */
+export declare class TestOpsMultiReporter extends AbstractReporter {
+    private readonly baseUrl;
+    private readonly batchSize;
+    /** Project code -> run ID */
+    private readonly runIds;
+    /** Project code -> API client for that project */
+    private readonly clients;
+    /** Project code -> queue of results to send */
+    private readonly projectQueues;
+    /** Project code -> first unsent index (for batch tracking) */
+    private readonly firstIndexByProject;
+    private isTestRunReady;
+    private readonly mutex;
+    private readonly defaultProject;
+    private readonly projectCodes;
+    private readonly showPublicReportLink;
+    constructor(logger: LoggerInterface, testopsOptions: TestOpsOptionsType, multiConfig: TestOpsMultiConfigType, withState: boolean, hostData: HostData, reporterName: string | undefined, frameworkPackage: string | undefined, environment?: string, baseUrl?: string, batchSize?: number, showPublicReportLink?: boolean);
+    private buildProjectOptions;
+    startTestRun(): Promise<void>;
+    addTestResult(result: TestResultType): Promise<void>;
+    /**
+     * Get list of (projectCode, ids) for a result (multi-project mapping or legacy testops_id).
+     * Caller must hold mutex when using projectQueues.
+     */
+    private getProjectsToUseForResult;
+    /**
+     * Push a result into project queues (by project / case IDs). Used by addTestResult and by
+     * sendResults() when results were set via setTestResults() (e.g. Cypress hooks in another process).
+     * Caller must hold mutex.
+     */
+    private distributeResultToProjectQueues;
+    private copyResultForProject;
+    private checkOrCreateTestRuns;
+    private sendResultsForProject;
+    sendResults(): Promise<void>;
+    publish(): Promise<void>;
+    complete(): Promise<void>;
+    uploadAttachment(attachment: Attachment): Promise<string>;
+    private getBaseUrl;
+    private showLink;
+}

package/dist/reporters/testops-multi-reporter.js

@@ -0,0 +1,299 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestOpsMultiReporter = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const uuid_1 = require("uuid");
+const abstract_reporter_1 = require("./abstract-reporter");
+const models_1 = require("../models");
+const async_mutex_1 = require("async-mutex");
+const clientV2_1 = require("../client/clientV2");
+const defaultChunkSize = 200;
+/**
+ * Multi-project TestOps reporter. Sends test results to multiple Qase projects
+ * with different test case IDs per project. Each project gets its own run.
+ */
+class TestOpsMultiReporter extends abstract_reporter_1.AbstractReporter {
+    baseUrl;
+    batchSize;
+    /** Project code -> run ID */
+    runIds = new Map();
+    /** Project code -> API client for that project */
+    clients = new Map();
+    /** Project code -> queue of results to send */
+    projectQueues = new Map();
+    /** Project code -> first unsent index (for batch tracking) */
+    firstIndexByProject = new Map();
+    isTestRunReady = false;
+    mutex = new async_mutex_1.Mutex();
+    defaultProject;
+    projectCodes;
+    showPublicReportLink;
+    constructor(logger, testopsOptions, multiConfig, withState, hostData, reporterName, frameworkPackage, environment, baseUrl, batchSize, showPublicReportLink) {
+        super(logger);
+        this.baseUrl = this.getBaseUrl(baseUrl ?? testopsOptions.api?.host);
+        this.batchSize = batchSize ?? testopsOptions.batch?.size ?? defaultChunkSize;
+        this.showPublicReportLink = showPublicReportLink ?? testopsOptions.showPublicReportLink;
+        this.defaultProject =
+            multiConfig.default_project ??
+                (multiConfig.projects.length > 0 ? multiConfig.projects[0].code : '');
+        this.projectCodes = multiConfig.projects
+            .filter((p) => Boolean(p?.code))
+            .map((p) => p.code);
+        void withState; // reserved for future StateManager integration
+        for (const proj of multiConfig.projects) {
+            if (!proj?.code)
+                continue;
+            const projectOptions = this.buildProjectOptions(testopsOptions, proj);
+            const env = proj.environment ?? environment;
+            const client = new clientV2_1.ClientV2(logger, projectOptions, env, undefined, hostData, reporterName, frameworkPackage);
+            this.clients.set(proj.code, client);
+            this.projectQueues.set(proj.code, []);
+            this.firstIndexByProject.set(proj.code, 0);
+        }
+    }
+    buildProjectOptions(global, proj) {
+        const opts = {
+            project: proj.code,
+            api: global.api,
+            run: proj.run ?? global.run ?? {},
+            plan: proj.plan ?? global.plan ?? {},
+            uploadAttachments: global.uploadAttachments,
+            defect: global.defect,
+            configurations: global.configurations,
+            statusFilter: global.statusFilter,
+            showPublicReportLink: this.showPublicReportLink,
+        };
+        if (global.batch !== undefined) {
+            opts.batch = global.batch;
+        }
+        return opts;
+    }
+    async startTestRun() {
+        await this.checkOrCreateTestRuns();
+    }
+    async addTestResult(result) {
+        if (result.execution.status === models_1.TestStatusEnum.failed) {
+            const mapping = result.getTestopsProjectMapping?.() ?? result.testops_project_mapping ?? null;
+            if (mapping) {
+                for (const [projectCode, ids] of Object.entries(mapping)) {
+                    for (const id of ids) {
+                        this.showLink(projectCode, id, result.title);
+                    }
+                }
+            }
+            else {
+                const ids = Array.isArray(result.testops_id) ? result.testops_id : [result.testops_id];
+                for (const id of ids) {
+                    if (id != null) {
+                        this.showLink(this.defaultProject, id, result.title);
+                    }
+                }
+            }
+        }
+        const release = await this.mutex.acquire();
+        try {
+            // Keep original in this.results for getTestResults / fallback
+            if (result.execution.stacktrace) {
+                result.execution.stacktrace = this.removeAnsiEscapeCodes(result.execution.stacktrace);
+            }
+            if (result.message) {
+                result.message = this.removeAnsiEscapeCodes(result.message);
+            }
+            this.results.push(result);
+            if (!this.isTestRunReady) {
+                return;
+            }
+            for (const { code, ids } of this.getProjectsToUseForResult(result)) {
+                const copy = this.copyResultForProject(result, code, ids);
+                const queue = this.projectQueues.get(code);
+                queue.push(copy);
+                const first = this.firstIndexByProject.get(code) ?? 0;
+                if (queue.length >= first + this.batchSize) {
+                    await this.sendResultsForProject(code);
+                }
+            }
+        }
+        finally {
+            release();
+        }
+    }
+    /**
+     * Get list of (projectCode, ids) for a result (multi-project mapping or legacy testops_id).
+     * Caller must hold mutex when using projectQueues.
+     */
+    getProjectsToUseForResult(result) {
+        const mapping = result.getTestopsProjectMapping?.() ?? result.testops_project_mapping ?? null;
+        const projectsToUse = [];
+        if (mapping && Object.keys(mapping).length > 0) {
+            for (const [code, ids] of Object.entries(mapping)) {
+                if (this.projectCodes.includes(code) && ids.length > 0) {
+                    projectsToUse.push({ code, ids });
+                }
+            }
+        }
+        else {
+            // Backward compatibility: use default project + testops_id, or send without case ID to default project
+            const ids = Array.isArray(result.testops_id)
+                ? result.testops_id
+                : result.testops_id != null
+                    ? [result.testops_id]
+                    : [];
+            if (this.defaultProject) {
+                projectsToUse.push({ code: this.defaultProject, ids });
+            }
+        }
+        return projectsToUse;
+    }
+    /**
+     * Push a result into project queues (by project / case IDs). Used by addTestResult and by
+     * sendResults() when results were set via setTestResults() (e.g. Cypress hooks in another process).
+     * Caller must hold mutex.
+     */
+    distributeResultToProjectQueues(result) {
+        for (const { code, ids } of this.getProjectsToUseForResult(result)) {
+            const copy = this.copyResultForProject(result, code, ids);
+            const queue = this.projectQueues.get(code);
+            queue.push(copy);
+        }
+    }
+    copyResultForProject(result, _projectCode, ids) {
+        const copy = { ...result };
+        copy.id = (0, uuid_1.v4)();
+        copy.testops_id = ids.length === 0 ? null : ids.length === 1 ? ids[0] : ids;
+        copy.testops_project_mapping = null;
+        return copy;
+    }
+    async checkOrCreateTestRuns() {
+        for (const code of this.projectCodes) {
+            const client = this.clients.get(code);
+            const runId = await client.createRun();
+            this.runIds.set(code, runId);
+            this.logger.logDebug(`[${code}] Run ID: ${runId}`);
+        }
+        this.isTestRunReady = true;
+    }
+    async sendResultsForProject(projectCode) {
+        const queue = this.projectQueues.get(projectCode);
+        const first = this.firstIndexByProject.get(projectCode) ?? 0;
+        const client = this.clients.get(projectCode);
+        const runId = this.runIds.get(projectCode);
+        if (!queue || !client || runId === undefined) {
+            return false;
+        }
+        const toSend = queue.slice(first, first + this.batchSize);
+        if (toSend.length === 0) {
+            return false;
+        }
+        try {
+            await client.uploadResults(runId, toSend);
+            this.firstIndexByProject.set(projectCode, first + toSend.length);
+            this.logger.logDebug(`[${projectCode}] Sent ${toSend.length} results to Qase`);
+            return true;
+        }
+        catch (error) {
+            this.logger.logError(`[${projectCode}] Error sending results:`, error);
+            return false;
+        }
+    }
+    async sendResults() {
+        const release = await this.mutex.acquire();
+        try {
+            // Only flush this.results when projectQueues are empty (e.g. Cypress: results set via
+            // setTestResults() in another process). When addTestResult() already queued results
+            // (same process, e.g. Cucumber), do not flush to avoid sending each result twice.
+            const queuesEmpty = this.projectCodes.every((code) => (this.projectQueues.get(code)?.length ?? 0) === 0);
+            if (this.results.length > 0 && this.isTestRunReady && queuesEmpty) {
+                for (const result of this.results) {
+                    this.distributeResultToProjectQueues(result);
+                }
+                this.results = [];
+            }
+            for (const code of this.projectCodes) {
+                let sent;
+                do {
+                    sent = await this.sendResultsForProject(code);
+                } while (sent);
+            }
+            for (const code of this.projectCodes) {
+                this.projectQueues.set(code, []);
+                this.firstIndexByProject.set(code, 0);
+            }
+        }
+        finally {
+            release();
+        }
+    }
+    async publish() {
+        // Do not hold mutex here: sendResults() and complete() acquire it themselves.
+        // Holding mutex would deadlock when sendResults() tries to acquire the same mutex.
+        await this.sendResults();
+        await this.complete();
+    }
+    async complete() {
+        const release = await this.mutex.acquire();
+        try {
+            // Send any remaining results per project
+            for (const code of this.projectCodes) {
+                let sent;
+                do {
+                    sent = await this.sendResultsForProject(code);
+                } while (sent);
+            }
+            for (const code of this.projectCodes) {
+                this.projectQueues.set(code, []);
+                this.firstIndexByProject.set(code, 0);
+            }
+        }
+        finally {
+            release();
+        }
+        const completePromises = this.projectCodes.map(async (code) => {
+            const client = this.clients.get(code);
+            const runId = this.runIds.get(code);
+            if (client && runId !== undefined) {
+                try {
+                    await client.completeRun(runId);
+                    if (this.showPublicReportLink) {
+                        try {
+                            await client.enablePublicReport(runId);
+                        }
+                        catch {
+                            // Error already logged in enablePublicReport
+                        }
+                    }
+                    this.logger.log((0, chalk_1.default) `{green [${code}] Run ${runId} completed}`);
+                }
+                catch (error) {
+                    this.logger.logError(`[${code}] Error completing run:`, error);
+                }
+            }
+        });
+        await Promise.all(completePromises);
+    }
+    async uploadAttachment(attachment) {
+        // Attachments are uploaded per project when results are sent; use default project's client
+        const client = this.clients.get(this.defaultProject);
+        if (client) {
+            return await client.uploadAttachment(attachment);
+        }
+        return '';
+    }
+    getBaseUrl(url) {
+        if (!url || url === 'qase.io') {
+            return 'https://app.qase.io';
+        }
+        return `https://${url.replace('api', 'app')}`;
+    }
+    showLink(projectCode, id, title) {
+        const runId = this.runIds.get(projectCode);
+        if (runId === undefined)
+            return;
+        const baseLink = `${this.baseUrl}/run/${projectCode}/dashboard/${runId}?source=logs&search=`;
+        const link = id != null ? `${baseLink}${projectCode}-${id}` : `${baseLink}${encodeURI(title)}`;
+        this.logger.log((0, chalk_1.default) `{blue See why this test failed: ${link}}`);
+    }
+}
+exports.TestOpsMultiReporter = TestOpsMultiReporter;

package/dist/utils/project-mapping-utils.d.ts

@@ -0,0 +1,46 @@
+import type { TestopsProjectMapping } from '../models';
+/**
+ * Result of parsing project/ID markers from a test title.
+ * - legacyIds: from "(Qase ID: 123)" or "(Qase ID: 123,124)" — single-project mode.
+ * - projectMapping: from "(Qase PROJ1: 123)" etc. — multi-project mode (project code -> IDs).
+ * - cleanedTitle: title with all such patterns removed.
+ */
+export interface ParsedProjectMapping {
+    legacyIds: number[];
+    projectMapping: TestopsProjectMapping;
+    cleanedTitle: string;
+}
+/**
+ * Result of parsing @qaseid / @qaseid.PROJ tags.
+ * - legacyIds: from @qaseid(123) or @qaseid(123,124).
+ * - projectMapping: from @qaseid.PROJ1(123,124).
+ */
+export interface ParsedTagsProjectMapping {
+    legacyIds: number[];
+    projectMapping: TestopsProjectMapping;
+}
+/**
+ * Parse @qaseid and @qaseid.PROJECT tags into legacy IDs and project mapping.
+ *
+ * @param tags — e.g. ["@qaseid(1,2)", "@qaseid.PROJ2(3)"]
+ * @returns legacyIds from @qaseid(...), projectMapping from @qaseid.PROJ(...)
+ */
+export declare function parseProjectMappingFromTags(tags: string[]): ParsedTagsProjectMapping;
+/**
+ * Parse multi-project and legacy Qase ID markers from a test title.
+ * - "(Qase ID: 123)" or "(Qase ID: 123,124)" → legacyIds, single-project.
+ * - "(Qase PROJ1: 123)" or "(Qase PROJ2: 456)" → projectMapping for testops_multi.
+ *
+ * @param title — test title that may contain "(Qase ID: …)" or "(Qase PROJECT_CODE: …)".
+ * @returns legacyIds, projectMapping, and cleanedTitle with all markers stripped.
+ */
+export declare function parseProjectMappingFromTitle(title: string): ParsedProjectMapping;
+/**
+ * Build a test title with multi-project markers for use in test names.
+ * Use this (or framework-specific qase.projects()) so the reporter can parse project and IDs.
+ *
+ * @param title — base test title (e.g. "Login flow").
+ * @param mapping — project code → list of test case IDs (e.g. { PROJ1: [1, 2], PROJ2: [3] }).
+ * @returns title with appended markers, e.g. "Login flow (Qase PROJ1: 1,2) (Qase PROJ2: 3)".
+ */
+export declare function formatTitleWithProjectMapping(title: string, mapping: TestopsProjectMapping): string;

package/dist/utils/project-mapping-utils.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseProjectMappingFromTags = parseProjectMappingFromTags;
+exports.parseProjectMappingFromTitle = parseProjectMappingFromTitle;
+exports.formatTitleWithProjectMapping = formatTitleWithProjectMapping;
+/** Matches @qaseid(123) or @qaseid.PROJ1(123,124). */
+const QASEID_TAG_REGEXP = /@qaseid(?:\.([A-Za-z0-9_]+))?\(([\d,]+)\)/gi;
+/**
+ * Parse @qaseid and @qaseid.PROJECT tags into legacy IDs and project mapping.
+ *
+ * @param tags — e.g. ["@qaseid(1,2)", "@qaseid.PROJ2(3)"]
+ * @returns legacyIds from @qaseid(...), projectMapping from @qaseid.PROJ(...)
+ */
+function parseProjectMappingFromTags(tags) {
+    const legacyIds = [];
+    const projectMapping = {};
+    for (const tag of tags) {
+        let m;
+        const re = new RegExp(QASEID_TAG_REGEXP.source, 'gi');
+        while ((m = re.exec(tag)) !== null) {
+            const projectCode = m[1]; // undefined for @qaseid(1)
+            const idsStr = m[2] ?? '';
+            const ids = idsStr.split(',').map((s) => parseInt(s, 10)).filter((n) => !Number.isNaN(n));
+            if (!projectCode || projectCode.toUpperCase() === 'ID') {
+                legacyIds.push(...ids);
+            }
+            else if (ids.length > 0) {
+                const existing = projectMapping[projectCode] ?? [];
+                projectMapping[projectCode] = [...existing, ...ids];
+            }
+        }
+    }
+    return { legacyIds, projectMapping };
+}
+/** Matches "(Qase ID: 123)" or "(Qase PROJ1: 123,124)" — optional space after "Qase". */
+const QASE_MARKER_REGEXP = /\(Qase\s+([A-Za-z0-9_]+):\s*([\d,]+)\)/gi;
+/**
+ * Parse multi-project and legacy Qase ID markers from a test title.
+ * - "(Qase ID: 123)" or "(Qase ID: 123,124)" → legacyIds, single-project.
+ * - "(Qase PROJ1: 123)" or "(Qase PROJ2: 456)" → projectMapping for testops_multi.
+ *
+ * @param title — test title that may contain "(Qase ID: …)" or "(Qase PROJECT_CODE: …)".
+ * @returns legacyIds, projectMapping, and cleanedTitle with all markers stripped.
+ */
+function parseProjectMappingFromTitle(title) {
+    const legacyIds = [];
+    const projectMapping = {};
+    let cleanedTitle = title;
+    let m;
+    const re = new RegExp(QASE_MARKER_REGEXP.source, 'gi');
+    while ((m = re.exec(title)) !== null) {
+        const projectCode = m[1] ?? '';
+        const idsStr = m[2] ?? '';
+        const ids = idsStr.split(',').map((s) => parseInt(s, 10)).filter((n) => !Number.isNaN(n));
+        if (projectCode.toUpperCase() === 'ID') {
+            legacyIds.push(...ids);
+        }
+        else if (projectCode && ids.length > 0) {
+            const existing = projectMapping[projectCode] ?? [];
+            projectMapping[projectCode] = [...existing, ...ids];
+        }
+        cleanedTitle = cleanedTitle.replace(m[0], '');
+    }
+    cleanedTitle = cleanedTitle.replace(/\s+/g, ' ').trim();
+    return { legacyIds, projectMapping, cleanedTitle };
+}
+/**
+ * Build a test title with multi-project markers for use in test names.
+ * Use this (or framework-specific qase.projects()) so the reporter can parse project and IDs.
+ *
+ * @param title — base test title (e.g. "Login flow").
+ * @param mapping — project code → list of test case IDs (e.g. { PROJ1: [1, 2], PROJ2: [3] }).
+ * @returns title with appended markers, e.g. "Login flow (Qase PROJ1: 1,2) (Qase PROJ2: 3)".
+ */
+function formatTitleWithProjectMapping(title, mapping) {
+    if (!title || typeof title !== 'string') {
+        return title;
+    }
+    const parts = Object.entries(mapping)
+        .filter(([, ids]) => Array.isArray(ids) && ids.length > 0)
+        .map(([code, ids]) => `(Qase ${code}: ${ids.join(',')})`);
+    if (parts.length === 0) {
+        return title.trim();
+    }
+    return `${title.trim()} ${parts.join(' ')}`;
+}

package/dist/utils/test-status-utils.js

@@ -14,7 +14,7 @@ function determineTestStatus(error, originalStatus) {
         return mapOriginalStatus(originalStatus);
     }
     // Check if it's an assertion error
-    if (isAssertionError(error)) {
+    if (isAssertionError(error, originalStatus)) {
         return test_execution_1.TestStatusEnum.failed;
     }
     // For all other errors, return invalid
@@ -23,16 +23,19 @@ function determineTestStatus(error, originalStatus) {
 /**
  * Checks if error is an assertion error
  * @param error - Error object
+ * @param originalStatus - Original test status from test runner
  * @returns boolean - true if assertion error
  */
-function isAssertionError(error) {
+function isAssertionError(error, originalStatus) {
     const errorMessage = error.message.toLowerCase();
     const errorStack = error.stack?.toLowerCase() || '';
+    const normalizedOriginalStatus = originalStatus.toLowerCase();
     // Common assertion error patterns
     const assertionPatterns = [
         'expect',
         'assert',
         'matcher',
+        'objectcontaining',
         'assertion',
         'expected',
         'actual',
@@ -77,6 +80,14 @@ function isAssertionError(error) {
     const nonAssertionPatternsWithoutTimeout = nonAssertionPatterns.filter(pattern => pattern !== 'timeout');
     const hasNonAssertionPattern = nonAssertionPatternsWithoutTimeout.some(pattern => errorMessage.includes(pattern) || errorStack.includes(pattern));
     if (hasNonAssertionPattern) {
+        const hasAssertionContext = assertionPatterns.some(pattern => errorMessage.includes(pattern) || errorStack.includes(pattern));
+        const isRunnerFailed = normalizedOriginalStatus === 'failed' || normalizedOriginalStatus === 'timedout' || normalizedOriginalStatus === 'interrupted';
+        const isSyntaxError = errorMessage.includes('syntaxerror') || errorStack.includes('syntaxerror');
+        // When runner reported failure and error has assertion context (expect, ObjectContaining, diff),
+        // treat as Failed. Exception: SyntaxError (e.g. "Unexpected token") contains "expected" as false positive.
+        if (isRunnerFailed && hasAssertionContext && !isSyntaxError) {
+            return true;
+        }
         return false;
     }
     // For timeout errors without expect, treat as invalid
@@ -99,6 +110,7 @@ function isAssertionError(error) {
  * @returns TestStatusEnum
  */
 function mapOriginalStatus(originalStatus) {
+    // Keys must be lowercase to match normalizedStatus (case-insensitive matching)
     const statusMap = {
         'passed': test_execution_1.TestStatusEnum.passed,
         'failed': test_execution_1.TestStatusEnum.failed,
@@ -107,10 +119,9 @@ function mapOriginalStatus(originalStatus) {
         'pending': test_execution_1.TestStatusEnum.skipped,
         'todo': test_execution_1.TestStatusEnum.disabled,
         'focused': test_execution_1.TestStatusEnum.passed,
-        'timedOut': test_execution_1.TestStatusEnum.failed,
+        'timedout': test_execution_1.TestStatusEnum.failed,
         'interrupted': test_execution_1.TestStatusEnum.failed,
     };
-    // Convert to lowercase for case-insensitive matching
     const normalizedStatus = originalStatus.toLowerCase();
     return statusMap[normalizedStatus] || test_execution_1.TestStatusEnum.skipped;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qase-javascript-commons",
-  "version": "2.4.18",
+  "version": "2.5.1",
   "description": "Qase JS Reporters",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",