@testomatio/reporter 2.3.9 → 2.4.0

package/README.md

@@ -20,7 +20,7 @@ Testomat.io Reporter (this npm package) supports:
 - 💯 Free & open-source.
 - 📊 Public and private Run reports on cloud via [Testomat.io App](https://testomat.io) 👇
 
-![](./docs/images/app.png)
+<img width="1920" height="1085" alt="image" src="https://github.com/user-attachments/assets/cf823e8b-1305-4ed2-a7c5-712efec12ceb" />
 
 ## How It Works
 

package/lib/bin/cli.js

@@ -75,6 +75,7 @@ program
     .description('Run tests with the specified command')
     .argument('<command>', 'Test runner command')
     .option('--filter <filter>', 'Additional execution filter')
+    .option('--filter-list <filter>', 'Get a list of all tests by filter before running')
     .option('--kind <type>', 'Specify run type: automated, manual, or mixed')
     .action(async (command, opts) => {
     const apiKey = process.env['INPUT_TESTOMATIO-KEY'] || config_js_1.config.TESTOMATIO;
@@ -84,17 +85,32 @@ program
         return process.exit(255);
     }
     const client = new client_js_1.default({ apiKey, title });
-    if (opts.filter) {
-        const [pipe, ...optsArray] = opts.filter.split(':');
+    if (opts.filter || opts.filterList) {
+        // Example of use: npx @testomatio/reporter run "npx jest" --filter "testomatio:tag-name=frontend"
+        // Example of use: npx @testomatio/reporter run "npx jest" --filter "coverage:file=coverage.yml"
+        // Example of use: npx @testomatio/reporter run "npx jest" --filter-list "coverage:file=coverage.yml"
+        const [pipe, ...optsArray] = opts?.filter ? opts?.filter.split(':') : opts?.filterList.split(':');
         const pipeOptions = optsArray.join(':');
+        const prepareRunParams = { pipe, pipeOptions };
         try {
-            const tests = await client.prepareRun({ pipe, pipeOptions });
-            if (tests && tests.length > 0) {
-                command += ` --grep (${tests.join('|')})`;
+            const tests = await client.prepareRun(prepareRunParams);
+            if (!tests || tests.length === 0) {
+                console.log(constants_js_1.APP_PREFIX, picocolors_1.default.yellow('No tests found.'));
+                return;
             }
+            const pattern = `(${tests.join('|')})`;
+            const filteredCommand = (0, utils_js_1.applyFilter)(command, tests);
+            debug(`Execution pattern: "${pattern}"`);
+            if (opts.filterList) {
+                console.log(constants_js_1.APP_PREFIX, picocolors_1.default.blue(`Matched test/suite IDs: ${tests.join(', ')}`));
+                console.log(constants_js_1.APP_PREFIX, picocolors_1.default.green(`Full Running Command: ${filteredCommand}`));
+                return;
+            }
+            command = filteredCommand;
         }
         catch (err) {
-            console.log(constants_js_1.APP_PREFIX, err);
+            console.log(constants_js_1.APP_PREFIX, err.message || err);
+            return;
         }
     }
     console.log(constants_js_1.APP_PREFIX, `🚀 Running`, picocolors_1.default.green(command));
@@ -102,7 +118,7 @@ program
         const testCmds = command.split(' ');
         const cmd = (0, cross_spawn_1.spawn)(testCmds[0], testCmds.slice(1), {
             stdio: 'inherit',
-            env: { ...process.env, TESTOMATIO_PROCEED: 'true', runId: client.runId },
+            env: { ...process.env, TESTOMATIO_PROCEED: 'true', runId: client.runId, TESTOMATIO_RUN: client.runId },
         });
         cmd.on('close', async (code) => {
             const emoji = code === 0 ? '🟢' : '🔴';
@@ -115,6 +131,9 @@ program
         });
     };
     const createRunParams = {};
+    if (title) {
+        createRunParams.title = title;
+    }
     if (opts.kind) {
         createRunParams.kind = opts.kind;
     }

package/lib/client.js

@@ -64,24 +64,32 @@ class Client {
      * or resolves to undefined if no valid results are found or if all pipes are disabled.
      */
     async prepareRun(params) {
-        this.pipes = await (0, index_js_1.pipesFactory)(params || this.paramsForPipesFactory || {}, this.pipeStore);
         const { pipe, pipeOptions } = params;
+        // ❗ Validation: pipe is required
+        if (!pipe || !pipeOptions) {
+            console.warn(`❗ No valid pipe found in filter cmd. Expected format: <pipe>:<options>
+      Examples:
+        --filter "testomatio:tag-name=frontend"
+        --filter "coverage:file=coverage.yml"
+        --filter-list "coverage:file=coverage.yml"
+      Received: "${params}"`);
+            return;
+        }
+        this.pipes = await (0, index_js_1.pipesFactory)(params || this.paramsForPipesFactory || {}, this.pipeStore);
         // all pipes disabled, skipping
         if (!this.pipes.some(p => p.isEnabled)) {
             return Promise.resolve();
         }
         try {
-            const filterPipe = this.pipes.find(p => p.constructor.name.toLowerCase() === `${pipe.toLowerCase()}pipe`);
-            if (!filterPipe?.isEnabled) {
-                // TODO:for the future for the another pipes
-                console.warn(constants_js_1.APP_PREFIX, `At the moment processing is available only for the "testomatio" key. Example: "testomatio:tag-name=xxx"`);
-                return;
-            }
-            const results = await Promise.all(this.pipes.map(async (p) => ({ pipe: p.toString(), result: await p.prepareRun(pipeOptions) })));
-            const result = results.filter(p => p.pipe.includes('Testomatio'))[0]?.result;
-            if (!result || result.length === 0) {
+            const p = this.pipes.find(p => p.constructor.name.toLowerCase() === `${pipe.toLowerCase()}pipe`);
+            // const p = this.pipes.find(p => p.id === `${pipe.toLowerCase()}`); TODO: as future updates
+            if (!p?.isEnabled) {
+                console.warn(constants_js_1.APP_PREFIX, "🚫 No active pipes were found in the system. Execution aborted!");
                 return;
             }
+            // Run only the selected pipe
+            const rawResult = await p.prepareRun(pipeOptions);
+            const result = Array.isArray(rawResult) ? rawResult : [];
             debug('Execution tests list', result);
             return result;
         }

package/lib/data-storage.d.ts

@@ -1,6 +1,6 @@
 export const dataStorage: DataStorage;
 declare class DataStorage {
-    static "__#12@#instance": any;
+    static "__#13@#instance": any;
     /**
      *
      * @returns {DataStorage}

package/lib/helpers.d.ts

@@ -0,0 +1 @@
+export const isPlaywright: boolean;

package/lib/helpers.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlaywright = void 0;
+exports.isPlaywright = Boolean(process.env.PLAYWRIGHT_TEST || process.env.PLAYWRIGHT);

package/lib/pipe/coverage.d.ts

@@ -0,0 +1,82 @@
+export default CoveragePipe;
+declare class CoveragePipe {
+    constructor(params: any, store: any);
+    id: string;
+    store: any;
+    branch: any;
+    isDefaultGitChanges: boolean;
+    isEnabled: boolean;
+    coverageFilePath: any;
+    isBranchDefault: boolean;
+    formattedDate: string;
+    title: string;
+    apiKey: string;
+    url: any;
+    client: Gaxios;
+    parsedCoverage: {};
+    changedFiles: any[];
+    matchedLines: Set<any>;
+    tests: Set<any>;
+    suiteIds: Set<any>;
+    tagLabels: Set<any>;
+    results: any[];
+    prepareRun(opts: any): Promise<any[]>;
+    addTest(data: any): void;
+    createRun(): Promise<void>;
+    updateRun(): void;
+    finishRun(runParams: any): Promise<void>;
+    toString(): string;
+    /**
+     * Retrieves the list of files changed in the current Git working directory
+     * compared to a specified branch.
+     *
+     * This method builds a Git diff command and attempts to retrieve the changed
+     * files using that command. It logs helpful information and errors during the process.
+     *
+     * If no changed files are found, or an error occurs at any stage, the method logs
+     * the issue and returns `undefined`.
+     *
+     * @returns {this | undefined} Returns the current instance (`this`) if changed files are found;
+     * otherwise, returns `undefined`.
+     */
+    getGitChangedFiles(): this | undefined;
+    /**
+     * Validates the coverage file path (stored in `this.coverageFilePath`).
+     *
+     * This method checks:
+     * - That the file exists on disk.
+     * - That it is a regular file (not a directory or special file).
+     * - That it has a `.yml` extension to ensure it's a YAML file.
+     *
+     * Logs descriptive error messages for any failures.
+     *
+     * @returns {this | undefined} "true" in case if coverage file is valid and we can keep going;
+     * otherwise, `undefined`.
+     */
+    validateCoverageFile(): this | undefined;
+    /**
+     * Parses the YAML coverage file (located at `this.coverageFilePath`) into a JavaScript object.
+     *
+     * - Reads the file content using UTF-8 encoding.
+     * - Parses it as YAML using the `yaml` library.
+     * - Stores the result in `this.parsedCoverage`.
+     * - If parsing fails, logs an error and returns `undefined`.
+     *
+     * @returns {this | undefined} The current parsed coverage yml file change lines, or "undefined" if parsing fails.
+     */
+    parseCoverageFile(): this | undefined;
+    /**
+     * Extracts relevant test identifiers from changed files based on coverage mapping.
+     *
+     * Iterates over changed files and matches them against patterns in the parsed coverage data.
+     * For each match, it extracts test IDs or tags and stores them in corresponding sets:
+     * - Test IDs (starting with '@T' or '@S') are stored in `this.tests`
+     * - Tag labels (starting with 'tag:') are stored in `this.tagLabels`
+     * - Matched file paths are stored in `this.matchedLines`
+     *
+     * @returns {Promise <Set<string>>} A set of file paths that matched coverage patterns (`this.matchedLines`).
+     */
+    extractRelevantTestsFromChanges(): Promise<Set<string>>;
+    #private;
+}
+import { Gaxios } from 'gaxios';

package/lib/pipe/coverage.js

@@ -0,0 +1,373 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const child_process_1 = require("child_process");
+const gaxios_1 = require("gaxios");
+const minimatch_1 = require("minimatch");
+const constants_js_1 = require("../constants.js");
+const pipe_utils_js_1 = require("../utils/pipe_utils.js");
+const pipe_utils_js_2 = require("../utils/pipe_utils.js");
+const config_js_1 = require("../config.js");
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)('@testomatio/reporter:pipe:csv');
+// Example of use 'coverage:file=coverage/coverage.yml,diff=master' cmd:
+// | Option | Git command | Notes |
+// | --- | --- | --- |
+// | --filter "coverage:file=coverage/coverage.yml,diff=new-branch" | ✅ git diff new-branch --name-only | - |
+// | --filter "coverage:diff=master,file=coverage.yml" | ✅ git diff master --name-only | - |
+// | --filter "coverage:file=coverage/coverage.yml" | ✅ git diff master --name-only | default branch = "master" |
+// | --filter "coverage:file=coverage.yml,dif=noexist-branch" | ❌ Git command failed ...| - |
+// | --filter "coverage:file=coverage.yml,diff=noexist-branch" | ❌ Git command failed ...| because no branch found |
+// | --filter "coverage:file=no-exist-coverage.yml" | ❌ Coverage file not found: <>filename>.yml | - |
+// | --filter "coverage:filepath=coverage.yml" | 🚫 Missing required parameter: "file"... | - |
+// | --filter "coverage:diff=my-branch" | 🚫 Missing required parameter: "file"...| - |
+//maybe GitChanges or GitCoverage
+class CoveragePipe {
+    #GIT = {
+        default_branch: 'master',
+        diff_command: 'git diff',
+        only_file_opt: '--name-only',
+        uncommitted_marker: 'uncommitted',
+        // test_defaultGitChangedFile - uses only for unit tests in "coverage_pipe_test.js" file
+        test_defaultGitChangedFile: ['todomvc-tests/edit-todos_test.js'],
+    };
+    constructor(params, store) {
+        this.id = 'coverage'; // as future updates -> find by id in client.js
+        this.store = store || {};
+        this.branch = undefined;
+        this.isDefaultGitChanges = false; // COVERAGE_BY_DEFAULT_GIT_FILE env uses only for unit tests
+        this.isEnabled = false;
+        const { pipeOptions } = params;
+        const options = (0, pipe_utils_js_2.parsePipeOptions)(pipeOptions || "");
+        debug("Pipe options", options);
+        // this.isDefaultGitChanges - COVERAGE_BY_DEFAULT_GIT_FILE env uses only for unit tests
+        this.isDefaultGitChanges = process.env.COVERAGE_BY_DEFAULT_GIT_FILE === '1' ? true : false;
+        this.coverageFilePath = options?.file || process.env.COVERAGE_FILEPATH || undefined;
+        if (!this.coverageFilePath)
+            return;
+        this.branch = options?.diff || process.env.COVERAGE_BRANCH || this.#GIT.default_branch;
+        this.isBranchDefault = !options.diff && !process.env.COVERAGE_BRANCH;
+        if (this.isBranchDefault) {
+            console.log(constants_js_1.APP_PREFIX, `🟡 No "diff" branch provided. That's why we use default one = "${this.branch}".\n` +
+                '👉 You can set it via --filter "coverage:file=coverage.yml,diff=your-branch"');
+        }
+        // Client config section
+        this.formattedDate = new Date().toISOString().replace(/T/, '-').replace(/:/g, '-').split('.')[0];
+        this.title = process.env.TESTOMATIO_TITLE || `Testomatio Coverage Test Execution - ${this.formattedDate}`;
+        this.apiKey = process.env['INPUT_TESTOMATIO-KEY'] || config_js_1.config.TESTOMATIO;
+        this.url = params.testomatioUrl || process.env.TESTOMATIO_URL || 'https://app.testomat.io';
+        const proxyUrl = process.env.HTTP_PROXY || process.env.HTTPS_PROXY || null;
+        const proxy = proxyUrl ? new URL(proxyUrl) : null;
+        // Create a new instance of gaxios with a custom config
+        this.client = new gaxios_1.Gaxios({
+            baseURL: `${this.url.trim()}`,
+            timeout: constants_js_1.AXIOS_TIMEOUT,
+            proxy: proxy ? proxy.toString() : undefined,
+            retry: true,
+            retryConfig: {
+                retry: constants_js_1.REPORTER_REQUEST_RETRIES.retriesPerRequest,
+                retryDelay: constants_js_1.REPORTER_REQUEST_RETRIES.retryTimeout,
+                httpMethodsToRetry: ['GET', 'PUT', 'HEAD', 'OPTIONS', 'DELETE', 'POST'],
+                shouldRetry: (error) => {
+                    if (!error.response)
+                        return false;
+                    switch (error.response?.status) {
+                        case 400: // Bad request (probably wrong API key)
+                        case 404: // Test not matched
+                        case 429: // Rate limit exceeded
+                        case 500: // Internal server error
+                            return false;
+                        default:
+                            break;
+                    }
+                    return error.response?.status >= 401; // Retry on 401+ and 5xx
+                }
+            }
+        });
+        // In case if we have all needed data 
+        this.isEnabled = true;
+        debug('Coverage Pipe initialized', {
+            branch: this.branch,
+            coverageFilePath: this.coverageFilePath,
+        });
+        this.parsedCoverage = {};
+        this.changedFiles = [];
+        this.matchedLines = new Set();
+        this.tests = new Set();
+        this.suiteIds = new Set();
+        this.tagLabels = new Set();
+        this.results = [];
+        debug(`Coverage Pipe: is Enabled = ${this.isEnabled}`);
+    }
+    async prepareRun(opts) {
+        // Reset internal mutable state for isolation
+        this.tests.clear();
+        this.suiteIds.clear();
+        this.tagLabels.clear();
+        this.results = [];
+        if (!this.isEnabled)
+            return [];
+        // Step 1: Validate coverage file path & Git changes & Coverage parsing
+        if (!this.getGitChangedFiles()?.validateCoverageFile()?.parseCoverageFile())
+            return [];
+        // Step 2: Extract all available tests and compare with coverage file
+        const lines = await this.extractRelevantTestsFromChanges();
+        if (lines.size === 0) {
+            console.log(constants_js_1.APP_PREFIX, 'ℹ️  No matching entries in coverage file for provided Git changes.');
+            return [];
+        }
+        // Step 3: Handle tag labels tests from the server
+        // if (this.tagLabels && this.tagLabels.size > 0) { //TODO: in case if we add labels in future!!!
+        if (this.tagLabels.size > 0) {
+            for (const tag of this.tagLabels) {
+                const tagType = 'tag';
+                const tests = await this.#getTestomatioTestsByParam(tagType, tag);
+                if (!tests)
+                    return [];
+                console.log(constants_js_1.APP_PREFIX, `✅ We found ${tests.length === 1 ? 'one entry' : `${tests.length} (test/suite) entries`}` +
+                    ' in Testomat.io service side.');
+                tests.forEach(testId => this.tests.add(testId));
+            }
+        }
+        if (this.tests.size === 0) {
+            console.log(constants_js_1.APP_PREFIX, 'ℹ️  No tests found for execution based on Git changes.');
+            return [];
+        }
+        this.results = [...this.tests];
+        return this.results;
+    }
+    addTest(data) { }
+    async createRun() { }
+    updateRun() { }
+    async finishRun(runParams) { }
+    toString() {
+        return 'Coverage Reporter';
+    }
+    /**
+     * Fetches a list of tests from the Testomat.io server based on a given filter parameter.
+     *
+     * The method parses the provided filter (`type=id`), builds the appropriate request parameters,
+     * sends a GET request to the Testomat.io `/api/test_grep` endpoint, and returns the matching tests.
+     *
+     * If the filter is invalid, no query is generated, or the server responds with no matching tests,
+     * it logs relevant information and returns `undefined`.
+     *
+     * @async function
+     * @param {string} type - The filter string in the format like `tag-name` for tag by.
+     * @param {string} id - The filter string in the format like `smoke`.
+     * @returns {Promise<Array<Object>|undefined>} Resolves to an array of test objects if found, otherwise `undefined`.
+     */
+    async #getTestomatioTestsByParam(type, id) {
+        // Get tests from the server
+        try {
+            const q = (0, pipe_utils_js_1.generateFilterRequestParams)({
+                type,
+                id,
+                apiKey: this?.apiKey?.trim(),
+            });
+            if (!q) {
+                return;
+            }
+            const resp = await this.client.request({
+                method: 'GET',
+                url: '/api/test_grep',
+                ...q,
+            });
+            if (!Array.isArray(resp.data?.tests) && resp.data?.tests?.length === 0) {
+                console.log(constants_js_1.APP_PREFIX, `🔍 No test by ${type}=${id} were found on the Testomat.io server side!`);
+                return undefined;
+            }
+            return resp.data.tests;
+        }
+        catch (err) {
+            console.error(constants_js_1.APP_PREFIX, `🚩 Error getting available tests from the Testomat.io by "test_grep" option: ${err}`);
+            return undefined;
+        }
+    }
+    /**
+     * Executes a Git command to retrieve a list of changed files.
+     *
+     * @param {string} cmd - The Git command to execute.
+     * @returns {string[]} An array of changed file paths. Returns an empty array if an error occurs
+     * (e.g., not a Git repository or command failure).
+     */
+    #getChangedFilesFromGit(cmd) {
+        try {
+            const result = (0, child_process_1.execSync)(cmd, {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'ignore']
+            });
+            return result
+                .split('\n')
+                .map(f => f.trim())
+                .filter(Boolean);
+        }
+        catch (err) {
+            const errorMessage = err.message || '';
+            // Git edge: Not a git repository or other error
+            if (errorMessage.includes('Not a git repository')) {
+                console.error(constants_js_1.APP_PREFIX, '❌ Error: This folder is not a Git repository.');
+            }
+            else {
+                throw new Error(`❌ Git command failed ("${cmd}"):\n`, errorMessage);
+            }
+            return [];
+        }
+    }
+    /**
+     * Builds a Git command string to list file changes between the current state
+     * and a specified Git branch using `git diff --name-only`.
+     *
+     * Private pipe function
+     * @throws {Error} Throws an error if `this.branch` is not defined.
+     * @returns {string} A Git command string, e.g., 'git diff <branch> --name-only'.
+     */
+    #buildGitCommand() {
+        if (!this.branch)
+            throw new Error(`❌ Invalid changes option for setted branch!`);
+        return `git diff ${this.branch} --name-only`; // Example: 'git diff <master> --name-only' 
+    }
+    /**
+     * Retrieves the list of files changed in the current Git working directory
+     * compared to a specified branch.
+     *
+     * This method builds a Git diff command and attempts to retrieve the changed
+     * files using that command. It logs helpful information and errors during the process.
+     *
+     * If no changed files are found, or an error occurs at any stage, the method logs
+     * the issue and returns `undefined`.
+     *
+     * @returns {this | undefined} Returns the current instance (`this`) if changed files are found;
+     * otherwise, returns `undefined`.
+     */
+    getGitChangedFiles() {
+        let cmd;
+        try {
+            cmd = this.#buildGitCommand();
+        }
+        catch (err) {
+            console.error(constants_js_1.APP_PREFIX, err.message);
+            return undefined;
+        }
+        console.error(constants_js_1.APP_PREFIX, `ℹ️  We will use '${cmd}' Git command.`);
+        try {
+            // For clear unit testing process -> Like test_defaultGitChangedFile = todomvc-tests/edit-todos_test.js
+            if (this.isDefaultGitChanges) {
+                this.changedFiles = this.#GIT.test_defaultGitChangedFile;
+            }
+            else {
+                this.changedFiles = this.#getChangedFilesFromGit(cmd);
+                if (this.changedFiles.length === 0) {
+                    console.log(constants_js_1.APP_PREFIX, 'ℹ️  No files changed in the latest Git commit. Skipping coverage processing.');
+                    return undefined;
+                }
+            }
+        }
+        catch (err) {
+            console.error(constants_js_1.APP_PREFIX, err.message);
+            console.error(constants_js_1.APP_PREFIX, "🔍 Pls, check this Git command manually to understand the original problem.");
+            return undefined;
+        }
+        console.log(constants_js_1.APP_PREFIX, `📑  GIT changed files:\n  - ${this.changedFiles.join('\n  - ')}`);
+        return this;
+    }
+    /**
+     * Validates the coverage file path (stored in `this.coverageFilePath`).
+     *
+     * This method checks:
+     * - That the file exists on disk.
+     * - That it is a regular file (not a directory or special file).
+     * - That it has a `.yml` extension to ensure it's a YAML file.
+     *
+     * Logs descriptive error messages for any failures.
+     *
+     * @returns {this | undefined} "true" in case if coverage file is valid and we can keep going;
+     * otherwise, `undefined`.
+     */
+    validateCoverageFile() {
+        // Validate the presence of the coverage filepath
+        if (!fs_1.default.existsSync(this.coverageFilePath)) {
+            console.log(constants_js_1.APP_PREFIX, '❌ Coverage file not found:', this.coverageFilePath);
+            return undefined;
+        }
+        // Ensure the given path is a file (not a directory or other type)
+        const stat = fs_1.default.statSync(this.coverageFilePath);
+        if (!stat.isFile()) {
+            console.log(constants_js_1.APP_PREFIX, '❌ Provided coverage path is not a file:', this.coverageFilePath);
+            return undefined;
+        }
+        // Validate the file extension to be ".yml" to ensure it's a YAML file
+        if (path_1.default.extname(this.coverageFilePath) !== ".yml") {
+            console.log(constants_js_1.APP_PREFIX, '❌ Coverage file must have a .yml extension:', this.coverageFilePath);
+            return undefined;
+        }
+        debug('Coverage file validation is OK!');
+        return this;
+    }
+    /**
+     * Parses the YAML coverage file (located at `this.coverageFilePath`) into a JavaScript object.
+     *
+     * - Reads the file content using UTF-8 encoding.
+     * - Parses it as YAML using the `yaml` library.
+     * - Stores the result in `this.parsedCoverage`.
+     * - If parsing fails, logs an error and returns `undefined`.
+     *
+     * @returns {this | undefined} The current parsed coverage yml file change lines, or "undefined" if parsing fails.
+     */
+    parseCoverageFile() {
+        try {
+            // Read the contents of the YAML file and attempt to parse the YAML into a JavaScript object
+            const rawYml = fs_1.default.readFileSync(this.coverageFilePath, 'utf8');
+            this.parsedCoverage = js_yaml_1.default.load(rawYml) || {};
+            debug(`Coverage filepath = ${this.coverageFilePath})`);
+            console.log(constants_js_1.APP_PREFIX, `✅ Coverage file parsed successfully: ${this.coverageFilePath}`);
+            return this;
+        }
+        catch (err) {
+            console.error(constants_js_1.APP_PREFIX, '❌ Failed to parse YAML:', err.message);
+            return undefined;
+        }
+    }
+    /**
+     * Extracts relevant test identifiers from changed files based on coverage mapping.
+     *
+     * Iterates over changed files and matches them against patterns in the parsed coverage data.
+     * For each match, it extracts test IDs or tags and stores them in corresponding sets:
+     * - Test IDs (starting with '@T' or '@S') are stored in `this.tests`
+     * - Tag labels (starting with 'tag:') are stored in `this.tagLabels`
+     * - Matched file paths are stored in `this.matchedLines`
+     *
+     * @returns {Promise <Set<string>>} A set of file paths that matched coverage patterns (`this.matchedLines`).
+     */
+    async extractRelevantTestsFromChanges() {
+        for (const changedFile of this.changedFiles) {
+            for (const [pattern, ids] of Object.entries(this.parsedCoverage)) {
+                if ((0, minimatch_1.minimatch)(changedFile, pattern)) {
+                    this.matchedLines.add(changedFile);
+                    ids.forEach(id => {
+                        // Example: "@Tt74099t1"
+                        if (id.startsWith('@T')) {
+                            this.tests.add(id.slice(1));
+                        }
+                        // Example: "@Sd74099c1"
+                        else if (id.startsWith('@S')) {
+                            this.tests.add(id.slice(1));
+                        }
+                        // Example: "tag:@TestSmoke"
+                        else if (id.startsWith('tag')) {
+                            this.tagLabels.add(id.split(':')[1].slice(1));
+                        }
+                    });
+                }
+            }
+        }
+        debug(`Matched lines: ${this.matchedLines}`);
+        return this.matchedLines;
+    }
+}
+module.exports = CoveragePipe;

package/lib/pipe/index.js

@@ -46,6 +46,7 @@ const github_js_1 = __importDefault(require("./github.js"));
 const gitlab_js_1 = __importDefault(require("./gitlab.js"));
 const csv_js_1 = __importDefault(require("./csv.js"));
 const html_js_1 = __importDefault(require("./html.js"));
+const coverage_js_1 = __importDefault(require("./coverage.js"));
 const bitbucket_js_1 = require("./bitbucket.js");
 const debug_js_1 = require("./debug.js");
 async function pipesFactory(params, opts) {
@@ -83,6 +84,7 @@ async function pipesFactory(params, opts) {
         new csv_js_1.default(params, opts),
         new html_js_1.default(params, opts),
         new bitbucket_js_1.BitbucketPipe(params, opts),
+        new coverage_js_1.default(params, opts),
         new debug_js_1.DebugPipe(params, opts),
         ...extraPipes,
     ];

package/lib/pipe/testomatio.d.ts

@@ -26,7 +26,7 @@ declare class TestomatioPipe implements Pipe {
     store: any;
     title: any;
     sharedRun: boolean;
-    sharedRunTimeout: boolean;
+    sharedRunTimeout: number;
     groupTitle: any;
     env: string;
     label: string;

package/lib/pipe/testomatio.js

@@ -46,7 +46,24 @@ class TestomatioPipe {
         this.store = store || {};
         this.title = params.title || process.env.TESTOMATIO_TITLE;
         this.sharedRun = !!process.env.TESTOMATIO_SHARED_RUN;
-        this.sharedRunTimeout = !!process.env.TESTOMATIO_SHARED_RUN_TIMEOUT;
+        this.sharedRunTimeout = process.env.TESTOMATIO_SHARED_RUN_TIMEOUT
+            ? parseInt(process.env.TESTOMATIO_SHARED_RUN_TIMEOUT, 10)
+            : undefined;
+        if (this.sharedRunTimeout && !this.sharedRun) {
+            debug('Auto-enabling sharedRun because sharedRunTimeout is set');
+            this.sharedRun = true;
+        }
+        if (!this.title && (this.sharedRun || this.sharedRunTimeout)) {
+            const sha = (0, utils_js_1.getGitCommitSha)();
+            if (sha) {
+                this.title = `Shared Run - ${sha}`;
+                console.log(constants_js_1.APP_PREFIX, `🔄 Auto-generated title for shared run: ${this.title}`);
+            }
+            else {
+                console.log(constants_js_1.APP_PREFIX, picocolors_1.default.red('Failed to resolve git commit SHA for shared run title.'));
+                console.log(constants_js_1.APP_PREFIX, 'Please run the tests inside a Git repository or set TESTOMATIO_TITLE explicitly.');
+            }
+        }
         this.groupTitle = params.groupTitle || process.env.TESTOMATIO_RUNGROUP_TITLE;
         this.env = process.env.TESTOMATIO_ENV;
         this.label = process.env.TESTOMATIO_LABEL;
@@ -121,15 +138,19 @@ class TestomatioPipe {
     async prepareRun(opts) {
         if (!this.isEnabled)
             return [];
-        const { type, id } = (0, pipe_utils_js_1.parseFilterParams)(opts);
+        const clearOptions = (0, pipe_utils_js_1.parseFilterParams)(opts);
+        if (!clearOptions) {
+            return [];
+        }
+        const { type, id } = clearOptions;
         try {
             const q = (0, pipe_utils_js_1.generateFilterRequestParams)({
                 type,
                 id,
-                apiKey: this.apiKey.trim(),
+                apiKey: this?.apiKey?.trim(),
             });
             if (!q) {
-                return;
+                return [];
             }
             const resp = await this.client.request({
                 method: 'GET',