@testomatio/reporter 2.3.9 → 2.5.0

package/src/bin/cli.js

@@ -7,7 +7,7 @@ import createDebugMessages from 'debug';
 import TestomatClient from '../client.js';
 import XmlReader from '../xmlReader.js';
 import { APP_PREFIX, STATUS } from '../constants.js';
-import { cleanLatestRunId, getPackageVersion } from '../utils/utils.js';
+import { cleanLatestRunId, getPackageVersion, applyFilter } from '../utils/utils.js';
 import { config } from '../config.js';
 import { readLatestRunId } from '../utils/utils.js';
 import pc from 'picocolors';
@@ -81,6 +81,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.TESTOMATIO;
@@ -93,17 +94,39 @@ program
 
     const client = new TestomatClient({ 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(APP_PREFIX, pc.yellow('No tests found.'));
+          return;
         }
-      } catch (err) {
-        console.log(APP_PREFIX, err);
+
+        const pattern = `(${tests.join('|')})`;
+        const filteredCommand = applyFilter(command, tests);
+
+        debug(`Execution pattern: "${pattern}"`);
+
+        if(opts.filterList) {
+          console.log(APP_PREFIX, pc.blue(`Matched test/suite IDs: ${tests.join(', ')}`));
+          console.log(APP_PREFIX, pc.green(`Full Running Command: ${filteredCommand}`));
+          return;
+        }
+        
+        command = filteredCommand;
+      } 
+      catch (err) {
+        console.log(APP_PREFIX, err.message || err);
+        return;
       }
     }
 
@@ -113,7 +136,7 @@ program
       const testCmds = command.split(' ');
       const cmd = 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 => {
@@ -128,6 +151,9 @@ program
     };
 
     const createRunParams = {};
+    if (title) {
+      createRunParams.title = title;
+    }
     if (opts.kind) {
       createRunParams.kind = opts.kind;
     }

package/src/client.js

@@ -65,35 +65,43 @@ class Client {
    * array containing the prepared execution list,
    * or resolves to undefined if no valid results are found or if all pipes are disabled.
    */
+
   async prepareRun(params) {
-    this.pipes = await 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 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`);
+      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 (!filterPipe?.isEnabled) {
-        // TODO:for the future for the another pipes
+      if (!p?.isEnabled) {
         console.warn(
           APP_PREFIX,
-          `At the moment processing is available only for the "testomatio" key. Example: "testomatio:tag-name=xxx"`,
+          "🚫 No active pipes were found in the system. Execution aborted!"
         );
         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) {
-        return;
-      }
+      // Run only the selected pipe
+      const rawResult = await p.prepareRun(pipeOptions);
+      const result = Array.isArray(rawResult) ? rawResult : [];
 
       debug('Execution tests list', result);
 

package/src/helpers.js

@@ -0,0 +1 @@
+export const isPlaywright = Boolean(process.env.PLAYWRIGHT_TEST || process.env.PLAYWRIGHT);

package/src/pipe/coverage.js

@@ -0,0 +1,440 @@
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+import { execSync } from 'child_process';
+import { Gaxios } from 'gaxios';
+import { minimatch } from 'minimatch';
+import { APP_PREFIX, AXIOS_TIMEOUT, REPORTER_REQUEST_RETRIES } from '../constants.js';
+import { generateFilterRequestParams } from '../utils/pipe_utils.js';
+import { parsePipeOptions } from '../utils/pipe_utils.js';
+import { config } from '../config.js';
+import createDebugMessages from 'debug';
+
+const debug = createDebugMessages('@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 { // or Changes for the future???
+    #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 = 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(
+                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.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({
+            baseURL: `${this.url.trim()}`,
+            timeout: AXIOS_TIMEOUT,
+            proxy: proxy ? proxy.toString() : undefined,
+            retry: true,
+            retryConfig: {
+            retry: REPORTER_REQUEST_RETRIES.retriesPerRequest,
+            retryDelay: 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(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(
+                    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(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 = 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(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(
+                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 = 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(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(APP_PREFIX, err.message);
+            return undefined;
+        }
+        
+        console.error(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(
+                        APP_PREFIX,
+                        'ℹ️  No files changed in the latest Git commit. Skipping coverage processing.'
+                    );
+
+                    return undefined;
+                }
+            }
+        }
+        catch (err) {
+            console.error(APP_PREFIX, err.message);
+            console.error(APP_PREFIX, "🔍 Pls, check this Git command manually to understand the original problem.");
+            return undefined;
+        }        
+
+        console.log(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.existsSync(this.coverageFilePath)) {
+            console.log(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.statSync(this.coverageFilePath);
+        if (!stat.isFile()) {
+            console.log(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.extname(this.coverageFilePath) !== ".yml") {
+            console.log(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.readFileSync(this.coverageFilePath, 'utf8');
+            this.parsedCoverage = yaml.load(rawYml) || {};
+
+            debug(`Coverage filepath = ${this.coverageFilePath})`);
+            console.log(APP_PREFIX, `✅ Coverage file parsed successfully: ${this.coverageFilePath}`);
+
+            return this;
+        }
+        catch (err) {
+            console.error(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 (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;
+    }
+}
+
+export default CoveragePipe;

package/src/pipe/index.js

@@ -7,6 +7,7 @@ import GitHubPipe from './github.js';
 import GitLabPipe from './gitlab.js';
 import CsvPipe from './csv.js';
 import HtmlPipe from './html.js';
+import CoveragePipe from './coverage.js';
 import { BitbucketPipe } from './bitbucket.js';
 import { DebugPipe } from './debug.js';
 
@@ -48,6 +49,7 @@ export async function pipesFactory(params, opts) {
     new CsvPipe(params, opts),
     new HtmlPipe(params, opts),
     new BitbucketPipe(params, opts),
+    new CoveragePipe(params, opts),
     new DebugPipe(params, opts),
     ...extraPipes,
   ];

package/src/pipe/testomatio.js

@@ -3,7 +3,12 @@ import pc from 'picocolors';
 import { Gaxios } from 'gaxios';
 import JsonCycle from 'json-cycle';
 import { APP_PREFIX, STATUS, AXIOS_TIMEOUT, REPORTER_REQUEST_RETRIES } from '../constants.js';
-import { isValidUrl, foundedTestLog, readLatestRunId, transformEnvVarToBoolean } from '../utils/utils.js';
+import { isValidUrl, 
+  foundedTestLog, 
+  readLatestRunId, 
+  transformEnvVarToBoolean, 
+  getGitCommitSha 
+} from '../utils/utils.js';
 import { parseFilterParams, generateFilterRequestParams, setS3Credentials } from '../utils/pipe_utils.js';
 import { config } from '../config.js';
 
@@ -46,7 +51,25 @@ 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 = getGitCommitSha();
+      if (sha) {
+        this.title = `Shared Run - ${sha}`;
+        console.log(APP_PREFIX, `🔄 Auto-generated title for shared run: ${this.title}`);
+      } else {
+        console.log(APP_PREFIX, pc.red('Failed to resolve git commit SHA for shared run title.'));
+        console.log(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;
@@ -129,17 +152,23 @@ class TestomatioPipe {
   async prepareRun(opts) {
     if (!this.isEnabled) return [];
 
-    const { type, id } = parseFilterParams(opts);
+    const clearOptions = parseFilterParams(opts);
+
+    if (!clearOptions) {
+      return [];
+    }
+
+    const { type, id } = clearOptions;
 
     try {
       const q = generateFilterRequestParams({
         type,
         id,
-        apiKey: this.apiKey.trim(),
+        apiKey: this?.apiKey?.trim(),
       });
 
       if (!q) {
-        return;
+        return [];
       }
 
       const resp = await this.client.request({