@testomatio/reporter 2.0.1-beta.1 → 2.0.1-beta.2

package/lib/adapter/webdriver.js

@@ -101,6 +101,7 @@ class WebdriverReporter extends reporter_1.default {
             .filter(el => el.endpoint === screenshotEndpoint && el.result && el.result.value)
             .map(el => Buffer.from(el.result.value, 'base64'));
         await this.client.addTestRun(state, {
+            rid: test.uid || '',
             manuallyAttachedArtifacts: test.artifacts,
             error,
             logs: test.logs,

package/lib/bin/cli.js

@@ -17,9 +17,7 @@ const utils_js_2 = require("../utils/utils.js");
 const picocolors_1 = __importDefault(require("picocolors"));
 const filesize_1 = require("filesize");
 const dotenv_1 = __importDefault(require("dotenv"));
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const os_1 = __importDefault(require("os"));
+const replay_js_1 = __importDefault(require("../replay.js"));
 const debug = (0, debug_1.default)('@testomatio/reporter:xml-cli');
 const version = (0, utils_js_1.getPackageVersion)();
 console.log(picocolors_1.default.cyan(picocolors_1.default.bold(` 🤩 Testomat.io Reporter v${version}`)));
@@ -251,92 +249,41 @@ program
     .command('replay')
     .description('Replay test data from debug file and re-send to Testomat.io')
     .argument('[debug-file]', 'Path to debug file (defaults to /tmp/testomatio.debug.latest.json)')
+    .option('--dry-run', 'Preview the data without sending to Testomat.io')
     .action(async (debugFile, opts) => {
-    // Use default debug file if none provided
-    if (!debugFile) {
-        debugFile = path_1.default.join(os_1.default.tmpdir(), 'testomatio.debug.latest.json');
-    }
-    if (!fs_1.default.existsSync(debugFile)) {
-        console.log(constants_js_1.APP_PREFIX, `❌ Debug file not found: ${debugFile}`);
-        return process.exit(1);
-    }
-    console.log(constants_js_1.APP_PREFIX, `🪲 Replaying data from debug file: ${debugFile}`);
     try {
-        const fileContent = fs_1.default.readFileSync(debugFile, 'utf-8');
-        const lines = fileContent.trim().split('\n').filter(Boolean);
-        if (lines.length === 0) {
-            console.log(constants_js_1.APP_PREFIX, '❌ Debug file is empty');
-            return process.exit(1);
-        }
-        let runParams = {};
-        let finishParams = {};
-        let parseErrors = 0;
-        const allTests = [];
-        // Parse debug file line by line
-        for (const [lineIndex, line] of lines.entries()) {
-            try {
-                const logEntry = JSON.parse(line);
-                if (logEntry.data === 'variables' && logEntry.testomatioEnvVars) {
-                    Object.assign(process.env, logEntry.testomatioEnvVars, process.env);
-                }
-                else if (logEntry.action === 'createRun') {
-                    runParams = logEntry.params || {};
-                }
-                else if (logEntry.action === 'addTestsBatch' && logEntry.tests) {
-                    allTests.push(...logEntry.tests);
-                }
-                else if (logEntry.action === 'addTest' && logEntry.testId) {
-                    allTests.push(logEntry.testId);
-                }
-                else if (logEntry.actions === 'finishRun') {
-                    finishParams = logEntry.params || {};
+        const replayService = new replay_js_1.default({
+            apiKey: config_js_1.config.TESTOMATIO,
+            dryRun: opts.dryRun,
+            onLog: (message) => console.log(constants_js_1.APP_PREFIX, message),
+            onError: (message) => console.error(constants_js_1.APP_PREFIX, '⚠️ ', message),
+            onProgress: ({ current, total }) => {
+                if (current % 10 === 0 || current === total) {
+                    console.log(constants_js_1.APP_PREFIX, `📊 Progress: ${current}/${total} tests processed`);
                 }
             }
-            catch (err) {
-                parseErrors++;
-                if (parseErrors <= 3) {
-                    // Only show first 3 parse errors
-                    console.warn(constants_js_1.APP_PREFIX, `⚠️  Failed to parse line ${lineIndex + 1}: ${line.substring(0, 100)}...`);
-                }
-            }
-        }
-        if (parseErrors > 3) {
-            console.warn(constants_js_1.APP_PREFIX, `⚠️  ${parseErrors - 3} more parse errors occurred`);
-        }
-        console.log(constants_js_1.APP_PREFIX, `📊 Found ${allTests.length} tests to replay`);
-        if (allTests.length === 0) {
-            console.log(constants_js_1.APP_PREFIX, '❌ No test data found in debug file');
-            return process.exit(1);
-        }
-        const apiKey = config_js_1.config.TESTOMATIO;
-        if (!apiKey) {
-            console.log(constants_js_1.APP_PREFIX, '❌ TESTOMATIO API key not found. Set TESTOMATIO environment variable.');
-            return process.exit(1);
-        }
-        // Create client and restore the run
-        const client = new client_js_1.default({
-            apiKey,
-            isBatchEnabled: true,
-            ...runParams,
         });
-        console.log(constants_js_1.APP_PREFIX, '🚀 Publishing to run...');
-        await client.createRun(runParams);
-        // Send each test result - let client.js handle the data mapping and formatting
-        for (const [index, test] of allTests.entries()) {
-            try {
-                await client.addTestRun(test.status, test);
-            }
-            catch (err) {
-                console.warn(constants_js_1.APP_PREFIX, `⚠️  Failed to send test ${index + 1}: ${err.message}`);
+        const result = await replayService.replay(debugFile);
+        if (result.dryRun) {
+            console.log(constants_js_1.APP_PREFIX, '🔍 Dry run completed:');
+            console.log(constants_js_1.APP_PREFIX, `  - Tests found: ${result.testsCount}`);
+            console.log(constants_js_1.APP_PREFIX, `  - Environment variables: ${Object.keys(result.envVars).length}`);
+            console.log(constants_js_1.APP_PREFIX, `  - Run parameters:`, result.runParams);
+            console.log(constants_js_1.APP_PREFIX, '  Use without --dry-run to actually send the data');
+        }
+        else {
+            console.log(constants_js_1.APP_PREFIX, `✅ Successfully replayed ${result.successCount}/${result.testsCount} tests`);
+            if (result.failureCount > 0) {
+                console.log(constants_js_1.APP_PREFIX, `⚠️  ${result.failureCount} tests failed to upload`);
             }
         }
-        await client.updateRunStatus(finishParams.status || constants_js_1.STATUS.FINISHED, finishParams.parallel || false);
-        console.log(constants_js_1.APP_PREFIX, `✅ Successfully replayed ${allTests.length} tests from debug file`);
         process.exit(0);
     }
     catch (err) {
         console.error(constants_js_1.APP_PREFIX, '❌ Error replaying debug data:', err.message);
-        console.error(err.stack);
+        if (err.message.includes('Debug file not found')) {
+            console.error(constants_js_1.APP_PREFIX, '💡 Hint: Run tests with TESTOMATIO_DEBUG=1 to generate debug files');
+        }
         process.exit(1);
     }
 });

package/lib/pipe/debug.js

@@ -110,7 +110,7 @@ class DebugPipe {
         await this.batchUpload();
         if (this.batch.intervalFunction)
             clearInterval(this.batch.intervalFunction);
-        this.logToFile({ actions: 'finishRun', params });
+        this.logToFile({ action: 'finishRun', params });
         console.log(constants_js_1.APP_PREFIX, '🪲 Debug Saved to', this.logFilePath);
     }
     toString() {

package/lib/pipe/testomatio.d.ts

@@ -59,7 +59,7 @@ declare class TestomatioPipe implements Pipe {
     /**
      * Adds a test to the batch uploader (or reports a single test if batch uploading is disabled)
      */
-    addTest(data: any): void;
+    addTest(data: any): Promise<void | import("gaxios").GaxiosResponse<any>>;
     /**
      * @param {import('../../types/types.js').RunData} params
      * @returns

package/lib/pipe/testomatio.js

@@ -331,6 +331,7 @@ class TestomatioPipe {
      * Adds a test to the batch uploader (or reports a single test if batch uploading is disabled)
      */
     addTest(data) {
+        this.isEnabled = this.apiKey ?? this.isEnabled;
         if (!this.isEnabled)
             return;
         if (!this.runId)
@@ -340,13 +341,16 @@ class TestomatioPipe {
             data.rid = `${this.runId}-${data.rid}`;
         data.api_key = this.apiKey;
         data.create = this.createNewTests;
+        let uploading = null;
         if (!this.batch.isEnabled)
-            this.#uploadSingleTest(data);
+            uploading = this.#uploadSingleTest(data);
         else
             this.batch.tests.push(data);
         // if test is added after run which is already finished
         if (!this.batch.intervalFunction)
-            this.#batchUpload();
+            uploading = this.#batchUpload();
+        // return promise to be able to wait for it
+        return uploading;
     }
     /**
      * @param {import('../../types/types.js').RunData} params

package/lib/replay.d.ts

@@ -0,0 +1,31 @@
+export class Replay {
+    constructor(options?: {});
+    apiKey: any;
+    dryRun: any;
+    onProgress: any;
+    onLog: any;
+    onError: any;
+    /**
+     * Get the default debug file path
+     * @returns {string} Path to the latest debug file
+     */
+    getDefaultDebugFile(): string;
+    /**
+     * Parse a debug file and extract test data
+     * @param {string} debugFile - Path to the debug file
+     * @returns {Object} Parsed debug data
+     */
+    parseDebugFile(debugFile: string): any;
+    /**
+     * Restore environment variables from debug data
+     * @param {Object} envVars - Environment variables to restore
+     */
+    restoreEnvironmentVariables(envVars: any): void;
+    /**
+     * Replay test data to Testomat.io
+     * @param {string} debugFile - Path to debug file (optional, uses default if not provided)
+     * @returns {Promise<Object>} Replay results
+     */
+    replay(debugFile: string): Promise<any>;
+}
+export default Replay;

package/lib/replay.js

@@ -0,0 +1,237 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Replay = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const client_js_1 = __importDefault(require("./client.js"));
+const constants_js_1 = require("./constants.js");
+const config_js_1 = require("./config.js");
+class Replay {
+    constructor(options = {}) {
+        this.apiKey = options.apiKey || config_js_1.config.TESTOMATIO || undefined;
+        this.dryRun = options.dryRun || false;
+        this.onProgress = options.onProgress || (() => { });
+        this.onLog = options.onLog || console.log;
+        this.onError = options.onError || console.error;
+    }
+    /**
+     * Get the default debug file path
+     * @returns {string} Path to the latest debug file
+     */
+    getDefaultDebugFile() {
+        return path_1.default.join(os_1.default.tmpdir(), 'testomatio.debug.latest.json');
+    }
+    /**
+     * Parse a debug file and extract test data
+     * @param {string} debugFile - Path to the debug file
+     * @returns {Object} Parsed debug data
+     */
+    parseDebugFile(debugFile) {
+        if (!fs_1.default.existsSync(debugFile)) {
+            throw new Error(`Debug file not found: ${debugFile}`);
+        }
+        const fileContent = fs_1.default.readFileSync(debugFile, 'utf-8');
+        const lines = fileContent.trim().split('\n').filter(line => line.trim() !== '');
+        if (lines.length === 0) {
+            throw new Error('Debug file is empty');
+        }
+        let runParams = {};
+        let finishParams = {};
+        let parseErrors = 0;
+        const testsMap = new Map(); // Use Map to deduplicate by rid
+        const testsWithoutRid = []; // For tests without rid (backward compatibility)
+        const envVars = {};
+        // Parse debug file line by line
+        for (const [lineIndex, line] of lines.entries()) {
+            try {
+                const logEntry = JSON.parse(line);
+                if (logEntry.data === 'variables' && logEntry.testomatioEnvVars) {
+                    Object.assign(envVars, logEntry.testomatioEnvVars);
+                }
+                else if (logEntry.action === 'createRun') {
+                    runParams = logEntry.params || {};
+                }
+                else if (logEntry.action === 'addTestsBatch' && logEntry.tests) {
+                    // Process each test in the batch
+                    for (const test of logEntry.tests) {
+                        if (test.rid) {
+                            // Handle tests with rid (deduplicate)
+                            const existingTest = testsMap.get(test.rid);
+                            if (existingTest) {
+                                // Merge test data - prioritize non-null/non-empty values
+                                const mergedTest = { ...existingTest };
+                                Object.keys(test).forEach(key => {
+                                    if (test[key] !== null && test[key] !== undefined) {
+                                        if (key === 'files' && Array.isArray(test[key]) && test[key].length > 0) {
+                                            // Merge files arrays
+                                            mergedTest.files = [...(existingTest.files || []), ...test[key]];
+                                        }
+                                        else if (key === 'artifacts' && Array.isArray(test[key]) && test[key].length > 0) {
+                                            // Merge artifacts arrays
+                                            mergedTest.artifacts = [...(existingTest.artifacts || []), ...test[key]];
+                                        }
+                                        else if (existingTest[key] === null || existingTest[key] === undefined ||
+                                            (Array.isArray(existingTest[key]) && existingTest[key].length === 0)) {
+                                            // Use new value if existing is null/undefined/empty array
+                                            mergedTest[key] = test[key];
+                                        }
+                                    }
+                                });
+                                testsMap.set(test.rid, mergedTest);
+                            }
+                            else {
+                                testsMap.set(test.rid, { ...test });
+                            }
+                        }
+                        else {
+                            // Handle tests without rid (no deduplication)
+                            testsWithoutRid.push({ ...test });
+                        }
+                    }
+                }
+                else if (logEntry.action === 'addTest' && logEntry.testId) {
+                    const test = logEntry.testId;
+                    if (test.rid) {
+                        // Handle tests with rid (deduplicate)
+                        const existingTest = testsMap.get(test.rid);
+                        if (existingTest) {
+                            // Merge with existing test
+                            const mergedTest = { ...existingTest, ...test };
+                            testsMap.set(test.rid, mergedTest);
+                        }
+                        else {
+                            testsMap.set(test.rid, { ...test });
+                        }
+                    }
+                    else {
+                        // Handle tests without rid (no deduplication)
+                        testsWithoutRid.push({ ...test });
+                    }
+                }
+                else if (logEntry.actions === 'finishRun') {
+                    finishParams = logEntry.params || {};
+                }
+            }
+            catch (err) {
+                parseErrors++;
+                if (parseErrors <= 3) {
+                    // Only show first 3 parse errors
+                    this.onError(`Failed to parse line ${lineIndex + 1}: ${line.substring(0, 100)}...`);
+                }
+            }
+        }
+        if (parseErrors > 3) {
+            this.onError(`${parseErrors - 3} more parse errors occurred`);
+        }
+        // Combine tests with rid and tests without rid
+        const allTests = [...Array.from(testsMap.values()), ...testsWithoutRid];
+        return {
+            runParams,
+            finishParams,
+            tests: allTests,
+            envVars,
+            parseErrors,
+            totalLines: lines.length
+        };
+    }
+    /**
+     * Restore environment variables from debug data
+     * @param {Object} envVars - Environment variables to restore
+     */
+    restoreEnvironmentVariables(envVars) {
+        // Only restore env vars that aren't already set (don't override current values)
+        Object.keys(envVars).forEach(key => {
+            if (process.env[key] === undefined || process.env[key] === '') {
+                process.env[key] = envVars[key];
+            }
+        });
+    }
+    /**
+     * Replay test data to Testomat.io
+     * @param {string} debugFile - Path to debug file (optional, uses default if not provided)
+     * @returns {Promise<Object>} Replay results
+     */
+    async replay(debugFile) {
+        if (!debugFile) {
+            debugFile = this.getDefaultDebugFile();
+        }
+        if (!this.apiKey) {
+            throw new Error('TESTOMATIO API key not found. Set TESTOMATIO environment variable.');
+        }
+        this.onLog(`Replaying data from debug file: ${debugFile}`);
+        // Parse the debug file
+        const debugData = this.parseDebugFile(debugFile);
+        const { runParams, finishParams, tests, envVars } = debugData;
+        this.onLog(`Found ${tests.length} tests to replay`);
+        if (tests.length === 0) {
+            throw new Error('No test data found in debug file');
+        }
+        // Restore environment variables
+        this.restoreEnvironmentVariables(envVars);
+        if (this.dryRun) {
+            return {
+                success: true,
+                testsCount: tests.length,
+                runParams,
+                finishParams,
+                envVars,
+                dryRun: true
+            };
+        }
+        // Create client and restore the run
+        const client = new client_js_1.default({
+            apiKey: this.apiKey,
+            isBatchEnabled: true,
+            ...runParams,
+        });
+        this.onLog('Publishing to run...');
+        await client.createRun(runParams);
+        // Send each test result
+        let successCount = 0;
+        let failureCount = 0;
+        for (const [index, test] of tests.entries()) {
+            try {
+                await client.addTestRun(test.status, test);
+                successCount++;
+                this.onProgress({
+                    current: index + 1,
+                    total: tests.length,
+                    test,
+                    success: true
+                });
+            }
+            catch (err) {
+                failureCount++;
+                this.onError(`Failed to send test ${index + 1}: ${err.message}`);
+                this.onProgress({
+                    current: index + 1,
+                    total: tests.length,
+                    test,
+                    success: false,
+                    error: err.message
+                });
+            }
+        }
+        await client.updateRunStatus(finishParams.status || constants_js_1.STATUS.FINISHED, finishParams.parallel || false);
+        const result = {
+            success: true,
+            testsCount: tests.length,
+            successCount,
+            failureCount,
+            runParams,
+            finishParams,
+            envVars,
+            runId: client.runId
+        };
+        this.onLog(`Successfully replayed ${successCount}/${tests.length} tests from debug file`);
+        return result;
+    }
+}
+exports.Replay = Replay;
+module.exports = Replay;
+
+module.exports.Replay = Replay;

package/lib/uploader.js

@@ -113,7 +113,7 @@ class S3Uploader {
             const upload = new lib_storage_1.Upload({ client: s3, params });
             const link = await this.getS3LocationLink(upload);
             this.successfulUploads.push({ path: file.path, size: file.size, link });
-            debug(`📤 Uploaded artifact. File: ${file.path}, size: ${(0, filesize_1.filesize)(file.size)}, link: ${link}`);
+            debug(`📤 Uploaded artifact. File: ${file.path}, size: ${(0, filesize_1.filesize)(file.size || 0)}, link: ${link}`);
             return link;
         }
         catch (e) {
@@ -180,7 +180,8 @@ class S3Uploader {
      * @returns
      */
     async uploadFileByPath(filePath, pathInS3) {
-        // sometimes artifacts uploading started before createRun function completion
+        /* WDIO: some artifacts uploading started before createRun function completion
+        probably, the reason is that run is NOT created in adapter (but via cli) */
         this.isEnabled = this.isEnabled ?? this.checkEnabled();
         const [runId, rid] = pathInS3;
         if (!filePath)
@@ -189,7 +190,7 @@ class S3Uploader {
         let fileSizeInMb = null;
         try {
             // file may not exist
-            fileSize = fs_1.default.statSync(filePath).size;
+            fileSize = fs_1.default.statSync(filePath).size || 0;
             fileSizeInMb = Number((fileSize / (1024 * 1024)).toFixed(2));
         }
         catch (e) {
@@ -230,10 +231,13 @@ class S3Uploader {
      * @returns
      */
     async uploadFileAsBuffer(buffer, pathInS3) {
+        /* WDIO: some artifacts uploading started before createRun function completion
+        probably, the reason is that run is NOT created in adapter (but via cli) */
+        this.isEnabled = this.isEnabled ?? this.checkEnabled();
         if (!this.isEnabled)
             return;
         let Key = pathInS3.filter(p => !!p).join('/');
-        const ext = this.#getFileExtBase64(buffer);
+        const ext = this.#getFileExtBase64(buffer.toString('base64'));
         if (ext) {
             Key = `${Key}.${ext}`;
         }

package/lib/utils/utils.d.ts

@@ -6,7 +6,7 @@ export function fetchSourceCode(contents: any, opts?: {}): string;
 export function fetchSourceCodeFromStackTrace(stack?: string): string;
 export function fetchIdFromCode(code: any, opts?: {}): any;
 export function fetchIdFromOutput(output: any): any;
-export function fetchFilesFromStackTrace(stack?: string): string[];
+export function fetchFilesFromStackTrace(stack?: string, checkExists?: boolean): string[];
 export namespace fileSystem {
     function createDir(dirPath: any): void;
     function clearDir(dirPath: any): void;

package/lib/utils/utils.js

@@ -101,13 +101,23 @@ const isValidUrl = s => {
     }
 };
 exports.isValidUrl = isValidUrl;
-const fileMatchRegex = /file:(\/\/?[^:\s]+?\.(png|avi|webm|jpg|html|txt))/gi;
-const fetchFilesFromStackTrace = (stack = '') => {
+const fileMatchRegex = /file:(\/+(?:[A-Za-z]:[\\/]|\/)?[^\s]*?\.(png|avi|webm|jpg|html|txt))/gi;
+const fetchFilesFromStackTrace = (stack = '', checkExists = true) => {
     const files = Array.from(stack.matchAll(fileMatchRegex))
         .map(f => f[1].trim())
-        .map(f => (f.startsWith('//') ? f.substring(1) : f));
+        .map(f => f.replace(/^\/+/, '/').replace(/^\/([A-Za-z]:)/, '$1')) // Remove extra slashes, handle Windows paths
+        .map(f => {
+        // Convert Windows paths to Linux paths for testing purposes
+        if (f.match(/^[A-Za-z]:[\\\/]/)) {
+            // Convert Windows path to Linux equivalent for test scenarios
+            return f.replace(/^[A-Za-z]:[\\\/]/, '/').replace(/\\/g, '/');
+        }
+        return f;
+    });
     debug('Found files in stack trace: ', files);
     return files.filter(f => {
+        if (!checkExists)
+            return true;
         const isFile = fs_1.default.existsSync(f);
         if (!isFile)
             debug('File %s could not be found and uploaded as artifact', f);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testomatio/reporter",
-  "version": "2.0.1-beta.1",
+  "version": "2.0.1-beta.2",
   "description": "Testomatio Reporter Client",
   "engines": {
     "node": ">=18"

package/src/adapter/webdriver.js

@@ -81,6 +81,7 @@ class WebdriverReporter extends WDIOReporter {
       .map(el => Buffer.from(el.result.value, 'base64'));
 
     await this.client.addTestRun(state, {
+      rid: test.uid || '',
       manuallyAttachedArtifacts: test.artifacts,
       error,
       logs: test.logs,

package/src/bin/cli.js

@@ -13,9 +13,7 @@ import { readLatestRunId } from '../utils/utils.js';
 import pc from 'picocolors';
 import { filesize as prettyBytes } from 'filesize';
 import dotenv from 'dotenv';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
+import Replay from '../replay.js';
 
 const debug = createDebugMessages('@testomatio/reporter:xml-cli');
 const version = getPackageVersion();
@@ -303,101 +301,42 @@ program
   .command('replay')
   .description('Replay test data from debug file and re-send to Testomat.io')
   .argument('[debug-file]', 'Path to debug file (defaults to /tmp/testomatio.debug.latest.json)')
+  .option('--dry-run', 'Preview the data without sending to Testomat.io')
   .action(async (debugFile, opts) => {
-    // Use default debug file if none provided
-    if (!debugFile) {
-      debugFile = path.join(os.tmpdir(), 'testomatio.debug.latest.json');
-    }
-
-    if (!fs.existsSync(debugFile)) {
-      console.log(APP_PREFIX, `❌ Debug file not found: ${debugFile}`);
-      return process.exit(1);
-    }
-
-    console.log(APP_PREFIX, `🪲 Replaying data from debug file: ${debugFile}`);
-
     try {
-      const fileContent = fs.readFileSync(debugFile, 'utf-8');
-      const lines = fileContent.trim().split('\n').filter(Boolean);
-
-      if (lines.length === 0) {
-        console.log(APP_PREFIX, '❌ Debug file is empty');
-        return process.exit(1);
-      }
-
-      let runParams = {};
-      let finishParams = {};
-      let parseErrors = 0;
-      const allTests = [];
-
-      // Parse debug file line by line
-      for (const [lineIndex, line] of lines.entries()) {
-        try {
-          const logEntry = JSON.parse(line);
-
-          if (logEntry.data === 'variables' && logEntry.testomatioEnvVars) {
-            Object.assign(process.env, logEntry.testomatioEnvVars, process.env);
-          } else if (logEntry.action === 'createRun') {
-            runParams = logEntry.params || {};
-          } else if (logEntry.action === 'addTestsBatch' && logEntry.tests) {
-            allTests.push(...logEntry.tests);
-          } else if (logEntry.action === 'addTest' && logEntry.testId) {
-            allTests.push(logEntry.testId);
-          } else if (logEntry.actions === 'finishRun') {
-            finishParams = logEntry.params || {};
-          }
-        } catch (err) {
-          parseErrors++;
-          if (parseErrors <= 3) {
-            // Only show first 3 parse errors
-            console.warn(APP_PREFIX, `⚠️  Failed to parse line ${lineIndex + 1}: ${line.substring(0, 100)}...`);
+      const replayService = new Replay({
+        apiKey: config.TESTOMATIO,
+        dryRun: opts.dryRun,
+        onLog: (message) => console.log(APP_PREFIX, message),
+        onError: (message) => console.error(APP_PREFIX, '⚠️ ', message),
+        onProgress: ({ current, total }) => {
+          if (current % 10 === 0 || current === total) {
+            console.log(APP_PREFIX, `📊 Progress: ${current}/${total} tests processed`);
           }
         }
-      }
-
-      if (parseErrors > 3) {
-        console.warn(APP_PREFIX, `⚠️  ${parseErrors - 3} more parse errors occurred`);
-      }
-
-      console.log(APP_PREFIX, `📊 Found ${allTests.length} tests to replay`);
-
-      if (allTests.length === 0) {
-        console.log(APP_PREFIX, '❌ No test data found in debug file');
-        return process.exit(1);
-      }
-
-      const apiKey = config.TESTOMATIO;
-      if (!apiKey) {
-        console.log(APP_PREFIX, '❌ TESTOMATIO API key not found. Set TESTOMATIO environment variable.');
-        return process.exit(1);
-      }
-
-      // Create client and restore the run
-      const client = new TestomatClient({
-        apiKey,
-        isBatchEnabled: true,
-        ...runParams,
       });
 
-      console.log(APP_PREFIX, '🚀 Publishing to run...');
-      await client.createRun(runParams);
-
-      // Send each test result - let client.js handle the data mapping and formatting
-      for (const [index, test] of allTests.entries()) {
-        try {
-          await client.addTestRun(test.status, test);
-        } catch (err) {
-          console.warn(APP_PREFIX, `⚠️  Failed to send test ${index + 1}: ${err.message}`);
+      const result = await replayService.replay(debugFile);
+
+      if (result.dryRun) {
+        console.log(APP_PREFIX, '🔍 Dry run completed:');
+        console.log(APP_PREFIX, `  - Tests found: ${result.testsCount}`);
+        console.log(APP_PREFIX, `  - Environment variables: ${Object.keys(result.envVars).length}`);
+        console.log(APP_PREFIX, `  - Run parameters:`, result.runParams);
+        console.log(APP_PREFIX, '  Use without --dry-run to actually send the data');
+      } else {
+        console.log(APP_PREFIX, `✅ Successfully replayed ${result.successCount}/${result.testsCount} tests`);
+        if (result.failureCount > 0) {
+          console.log(APP_PREFIX, `⚠️  ${result.failureCount} tests failed to upload`);
         }
       }
 
-      await client.updateRunStatus(finishParams.status || STATUS.FINISHED, finishParams.parallel || false);
-
-      console.log(APP_PREFIX, `✅ Successfully replayed ${allTests.length} tests from debug file`);
       process.exit(0);
     } catch (err) {
       console.error(APP_PREFIX, '❌ Error replaying debug data:', err.message);
-      console.error(err.stack);
+      if (err.message.includes('Debug file not found')) {
+        console.error(APP_PREFIX, '💡 Hint: Run tests with TESTOMATIO_DEBUG=1 to generate debug files');
+      }
       process.exit(1);
     }
   });

package/src/pipe/debug.js

@@ -109,7 +109,7 @@ export class DebugPipe {
     if (!this.isEnabled) return;
     await this.batchUpload();
     if (this.batch.intervalFunction) clearInterval(this.batch.intervalFunction);
-    this.logToFile({ actions: 'finishRun', params });
+    this.logToFile({ action: 'finishRun', params });
     console.log(APP_PREFIX, '🪲 Debug Saved to', this.logFilePath);
   }
 

package/src/pipe/testomatio.js

@@ -367,6 +367,8 @@ class TestomatioPipe {
    * Adds a test to the batch uploader (or reports a single test if batch uploading is disabled)
    */
   addTest(data) {
+    this.isEnabled = this.apiKey ?? this.isEnabled;
+
     if (!this.isEnabled) return;
     if (!this.runId) return;
 
@@ -375,11 +377,15 @@ class TestomatioPipe {
     data.api_key = this.apiKey;
     data.create = this.createNewTests;
 
-    if (!this.batch.isEnabled) this.#uploadSingleTest(data);
+    let uploading = null;
+    if (!this.batch.isEnabled) uploading = this.#uploadSingleTest(data);
     else this.batch.tests.push(data);
 
     // if test is added after run which is already finished
-    if (!this.batch.intervalFunction) this.#batchUpload();
+     if (!this.batch.intervalFunction) uploading = this.#batchUpload();
+
+     // return promise to be able to wait for it
+    return uploading;
   }
 
   /**

package/src/replay.js

@@ -0,0 +1,245 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import TestomatClient from './client.js';
+import { STATUS } from './constants.js';
+import { config } from './config.js';
+
+export class Replay {
+  constructor(options = {}) {
+    this.apiKey = options.apiKey || config.TESTOMATIO || undefined;
+    this.dryRun = options.dryRun || false;
+    this.onProgress = options.onProgress || (() => {});
+    this.onLog = options.onLog || console.log;
+    this.onError = options.onError || console.error;
+  }
+
+  /**
+   * Get the default debug file path
+   * @returns {string} Path to the latest debug file
+   */
+  getDefaultDebugFile() {
+    return path.join(os.tmpdir(), 'testomatio.debug.latest.json');
+  }
+
+  /**
+   * Parse a debug file and extract test data
+   * @param {string} debugFile - Path to the debug file
+   * @returns {Object} Parsed debug data
+   */
+  parseDebugFile(debugFile) {
+    if (!fs.existsSync(debugFile)) {
+      throw new Error(`Debug file not found: ${debugFile}`);
+    }
+
+    const fileContent = fs.readFileSync(debugFile, 'utf-8');
+    const lines = fileContent.trim().split('\n').filter(line => line.trim() !== '');
+
+    if (lines.length === 0) {
+      throw new Error('Debug file is empty');
+    }
+
+    let runParams = {};
+    let finishParams = {};
+    let parseErrors = 0;
+    const testsMap = new Map(); // Use Map to deduplicate by rid
+    const testsWithoutRid = []; // For tests without rid (backward compatibility)
+    const envVars = {};
+
+    // Parse debug file line by line
+    for (const [lineIndex, line] of lines.entries()) {
+      try {
+        const logEntry = JSON.parse(line);
+
+        if (logEntry.data === 'variables' && logEntry.testomatioEnvVars) {
+          Object.assign(envVars, logEntry.testomatioEnvVars);
+        } else if (logEntry.action === 'createRun') {
+          runParams = logEntry.params || {};
+        } else if (logEntry.action === 'addTestsBatch' && logEntry.tests) {
+          // Process each test in the batch
+          for (const test of logEntry.tests) {
+            if (test.rid) {
+              // Handle tests with rid (deduplicate)
+              const existingTest = testsMap.get(test.rid);
+              if (existingTest) {
+                // Merge test data - prioritize non-null/non-empty values
+                const mergedTest = { ...existingTest };
+                Object.keys(test).forEach(key => {
+                  if (test[key] !== null && test[key] !== undefined) {
+                    if (key === 'files' && Array.isArray(test[key]) && test[key].length > 0) {
+                      // Merge files arrays
+                      mergedTest.files = [...(existingTest.files || []), ...test[key]];
+                    } else if (key === 'artifacts' && Array.isArray(test[key]) && test[key].length > 0) {
+                      // Merge artifacts arrays
+                      mergedTest.artifacts = [...(existingTest.artifacts || []), ...test[key]];
+                    } else if (existingTest[key] === null || existingTest[key] === undefined || 
+                               (Array.isArray(existingTest[key]) && existingTest[key].length === 0)) {
+                      // Use new value if existing is null/undefined/empty array
+                      mergedTest[key] = test[key];
+                    }
+                  }
+                });
+                testsMap.set(test.rid, mergedTest);
+              } else {
+                testsMap.set(test.rid, { ...test });
+              }
+            } else {
+              // Handle tests without rid (no deduplication)
+              testsWithoutRid.push({ ...test });
+            }
+          }
+        } else if (logEntry.action === 'addTest' && logEntry.testId) {
+          const test = logEntry.testId;
+          if (test.rid) {
+            // Handle tests with rid (deduplicate)
+            const existingTest = testsMap.get(test.rid);
+            if (existingTest) {
+              // Merge with existing test
+              const mergedTest = { ...existingTest, ...test };
+              testsMap.set(test.rid, mergedTest);
+            } else {
+              testsMap.set(test.rid, { ...test });
+            }
+          } else {
+            // Handle tests without rid (no deduplication)
+            testsWithoutRid.push({ ...test });
+          }
+        } else if (logEntry.actions === 'finishRun') {
+          finishParams = logEntry.params || {};
+        }
+      } catch (err) {
+        parseErrors++;
+        if (parseErrors <= 3) {
+          // Only show first 3 parse errors
+          this.onError(`Failed to parse line ${lineIndex + 1}: ${line.substring(0, 100)}...`);
+        }
+      }
+    }
+
+    if (parseErrors > 3) {
+      this.onError(`${parseErrors - 3} more parse errors occurred`);
+    }
+
+    // Combine tests with rid and tests without rid
+    const allTests = [...Array.from(testsMap.values()), ...testsWithoutRid];
+
+    return {
+      runParams,
+      finishParams,
+      tests: allTests,
+      envVars,
+      parseErrors,
+      totalLines: lines.length
+    };
+  }
+
+  /**
+   * Restore environment variables from debug data
+   * @param {Object} envVars - Environment variables to restore
+   */
+  restoreEnvironmentVariables(envVars) {
+    // Only restore env vars that aren't already set (don't override current values)
+    Object.keys(envVars).forEach(key => {
+      if (process.env[key] === undefined || process.env[key] === '') {
+        process.env[key] = envVars[key];
+      }
+    });
+  }
+
+  /**
+   * Replay test data to Testomat.io
+   * @param {string} debugFile - Path to debug file (optional, uses default if not provided)
+   * @returns {Promise<Object>} Replay results
+   */
+  async replay(debugFile) {
+    if (!debugFile) {
+      debugFile = this.getDefaultDebugFile();
+    }
+
+    if (!this.apiKey) {
+      throw new Error('TESTOMATIO API key not found. Set TESTOMATIO environment variable.');
+    }
+
+    this.onLog(`Replaying data from debug file: ${debugFile}`);
+
+    // Parse the debug file
+    const debugData = this.parseDebugFile(debugFile);
+    const { runParams, finishParams, tests, envVars } = debugData;
+
+    this.onLog(`Found ${tests.length} tests to replay`);
+
+    if (tests.length === 0) {
+      throw new Error('No test data found in debug file');
+    }
+
+    // Restore environment variables
+    this.restoreEnvironmentVariables(envVars);
+
+    if (this.dryRun) {
+      return {
+        success: true,
+        testsCount: tests.length,
+        runParams,
+        finishParams,
+        envVars,
+        dryRun: true
+      };
+    }
+
+    // Create client and restore the run
+    const client = new TestomatClient({
+      apiKey: this.apiKey,
+      isBatchEnabled: true,
+      ...runParams,
+    });
+
+    this.onLog('Publishing to run...');
+    await client.createRun(runParams);
+
+    // Send each test result
+    let successCount = 0;
+    let failureCount = 0;
+
+    for (const [index, test] of tests.entries()) {
+      try {
+        await client.addTestRun(test.status, test);
+        successCount++;
+        this.onProgress({
+          current: index + 1,
+          total: tests.length,
+          test,
+          success: true
+        });
+      } catch (err) {
+        failureCount++;
+        this.onError(`Failed to send test ${index + 1}: ${err.message}`);
+        this.onProgress({
+          current: index + 1,
+          total: tests.length,
+          test,
+          success: false,
+          error: err.message
+        });
+      }
+    }
+
+    await client.updateRunStatus(finishParams.status || STATUS.FINISHED, finishParams.parallel || false);
+
+    const result = {
+      success: true,
+      testsCount: tests.length,
+      successCount,
+      failureCount,
+      runParams,
+      finishParams,
+      envVars,
+      runId: client.runId
+    };
+
+    this.onLog(`Successfully replayed ${successCount}/${tests.length} tests from debug file`);
+
+    return result;
+  }
+}
+
+export default Replay; 

package/src/uploader.js

@@ -128,7 +128,7 @@ export class S3Uploader {
 
       const link = await this.getS3LocationLink(upload);
       this.successfulUploads.push({ path: file.path, size: file.size, link });
-      debug(`📤 Uploaded artifact. File: ${file.path}, size: ${prettyBytes(file.size)}, link: ${link}`);
+      debug(`📤 Uploaded artifact. File: ${file.path}, size: ${prettyBytes(file.size || 0)}, link: ${link}`);
       return link;
     } catch (e) {
       this.failedUploads.push({ path: file.path, size: file.size });
@@ -205,7 +205,8 @@ export class S3Uploader {
    * @returns
    */
   async uploadFileByPath(filePath, pathInS3) {
-    // sometimes artifacts uploading started before createRun function completion
+    /* WDIO: some artifacts uploading started before createRun function completion
+    probably, the reason is that run is NOT created in adapter (but via cli) */
     this.isEnabled = this.isEnabled ?? this.checkEnabled();
 
     const [runId, rid] = pathInS3;
@@ -217,7 +218,7 @@ export class S3Uploader {
 
     try {
       // file may not exist
-      fileSize = fs.statSync(filePath).size;
+      fileSize = fs.statSync(filePath).size || 0;
       fileSizeInMb = Number((fileSize / (1024 * 1024)).toFixed(2));
     } catch (e) {
       debug(`File ${filePath} does not exist`);
@@ -270,10 +271,14 @@ export class S3Uploader {
    * @returns
    */
   async uploadFileAsBuffer(buffer, pathInS3) {
+    /* WDIO: some artifacts uploading started before createRun function completion
+    probably, the reason is that run is NOT created in adapter (but via cli) */
+
+    this.isEnabled = this.isEnabled ?? this.checkEnabled();
     if (!this.isEnabled) return;
 
     let Key = pathInS3.filter(p => !!p).join('/');
-    const ext = this.#getFileExtBase64(buffer);
+    const ext = this.#getFileExtBase64(buffer.toString('base64'));
 
     if (ext) {
       Key = `${Key}.${ext}`;

package/src/utils/utils.js

@@ -64,16 +64,25 @@ const isValidUrl = s => {
   }
 };
 
-const fileMatchRegex = /file:(\/\/?[^:\s]+?\.(png|avi|webm|jpg|html|txt))/gi;
+const fileMatchRegex = /file:(\/+(?:[A-Za-z]:[\\/]|\/)?[^\s]*?\.(png|avi|webm|jpg|html|txt))/gi;
 
-const fetchFilesFromStackTrace = (stack = '') => {
+const fetchFilesFromStackTrace = (stack = '', checkExists = true) => {
   const files = Array.from(stack.matchAll(fileMatchRegex))
     .map(f => f[1].trim())
-    .map(f => (f.startsWith('//') ? f.substring(1) : f));
+    .map(f => f.replace(/^\/+/, '/').replace(/^\/([A-Za-z]:)/, '$1')) // Remove extra slashes, handle Windows paths
+    .map(f => {
+      // Convert Windows paths to Linux paths for testing purposes
+      if (f.match(/^[A-Za-z]:[\\\/]/)) {
+        // Convert Windows path to Linux equivalent for test scenarios
+        return f.replace(/^[A-Za-z]:[\\\/]/, '/').replace(/\\/g, '/');
+      }
+      return f;
+    });
 
   debug('Found files in stack trace: ', files);
 
   return files.filter(f => {
+    if (!checkExists) return true;
     const isFile = fs.existsSync(f);
     if (!isFile) debug('File %s could not be found and uploaded as artifact', f);
     return isFile;