@testomatio/reporter 2.0.1-beta-2-ignore-xml → 2.0.1-beta.2

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/reporter.d.ts

@@ -8,7 +8,7 @@ export type log = typeof import("./reporter-functions.js");
 export const log: (...args: any[]) => void;
 export type logger = typeof import("./services/index.js");
 export const logger: {
-    "__#12@#originalUserLogger": {
+    "__#13@#originalUserLogger": {
         assert(condition?: boolean, ...data: any[]): void;
         assert(value: any, message?: string, ...optionalParams: any[]): void;
         clear(): void;
@@ -53,13 +53,13 @@ export const logger: {
         profile(label?: string): void;
         profileEnd(label?: string): void;
     };
-    "__#12@#userLoggerWithOverridenMethods": any;
+    "__#13@#userLoggerWithOverridenMethods": any;
     logLevel: string;
     step(strings: any, ...values: any[]): void;
     getLogs(context: string): string[];
-    "__#12@#stringifyLogs"(...args: any[]): string;
+    "__#13@#stringifyLogs"(...args: any[]): string;
     _templateLiteralLog(strings: any, ...args: any[]): void;
-    "__#12@#logWrapper"(argsArray: any, level: any): void;
+    "__#13@#logWrapper"(argsArray: any, level: any): void;
     assert(...args: any[]): void;
     debug(...args: any[]): void;
     error(...args: any[]): void;
@@ -83,7 +83,7 @@ export type step = typeof import("./reporter-functions.js");
 export const step: (message: string) => void;
 declare namespace _default {
     let testomatioLogger: {
-        "__#12@#originalUserLogger": {
+        "__#13@#originalUserLogger": {
             assert(condition?: boolean, ...data: any[]): void;
             assert(value: any, message?: string, ...optionalParams: any[]): void;
             clear(): void;
@@ -128,13 +128,13 @@ declare namespace _default {
             profile(label?: string): void;
             profileEnd(label?: string): void;
         };
-        "__#12@#userLoggerWithOverridenMethods": any;
+        "__#13@#userLoggerWithOverridenMethods": any;
         logLevel: string;
         step(strings: any, ...values: any[]): void;
         getLogs(context: string): string[];
-        "__#12@#stringifyLogs"(...args: any[]): string;
+        "__#13@#stringifyLogs"(...args: any[]): string;
         _templateLiteralLog(strings: any, ...args: any[]): void;
-        "__#12@#logWrapper"(argsArray: any, level: any): void;
+        "__#13@#logWrapper"(argsArray: any, level: any): void;
         assert(...args: any[]): void;
         debug(...args: any[]): void;
         error(...args: any[]): void;
@@ -157,7 +157,7 @@ declare namespace _default {
     }, context?: any) => void;
     let log: (...args: any[]) => void;
     let logger: {
-        "__#12@#originalUserLogger": {
+        "__#13@#originalUserLogger": {
             assert(condition?: boolean, ...data: any[]): void;
             assert(value: any, message?: string, ...optionalParams: any[]): void;
             clear(): void;
@@ -202,13 +202,13 @@ declare namespace _default {
             profile(label?: string): void;
             profileEnd(label?: string): void;
         };
-        "__#12@#userLoggerWithOverridenMethods": any;
+        "__#13@#userLoggerWithOverridenMethods": any;
         logLevel: string;
         step(strings: any, ...values: any[]): void;
         getLogs(context: string): string[];
-        "__#12@#stringifyLogs"(...args: any[]): string;
+        "__#13@#stringifyLogs"(...args: any[]): string;
         _templateLiteralLog(strings: any, ...args: any[]): void;
-        "__#12@#logWrapper"(argsArray: any, level: any): void;
+        "__#13@#logWrapper"(argsArray: any, level: any): void;
         assert(...args: any[]): void;
         debug(...args: any[]): void;
         error(...args: any[]): void;

package/lib/services/artifacts.d.ts

@@ -3,7 +3,7 @@ export const artifactStorage: ArtifactStorage;
  * Artifact storage is supposed to store file paths
  */
 declare class ArtifactStorage {
-    static "__#13@#instance": any;
+    static "__#14@#instance": any;
     /**
      * Singleton
      * @returns {ArtifactStorage}

package/lib/services/key-values.d.ts

@@ -1,6 +1,6 @@
 export const keyValueStorage: KeyValueStorage;
 declare class KeyValueStorage {
-    static "__#14@#instance": any;
+    static "__#15@#instance": any;
     /**
      *
      * @returns {KeyValueStorage}

package/lib/services/logger.d.ts

@@ -5,7 +5,7 @@ export const logger: Logger;
  * Supports different syntaxes to satisfy any user preferences.
  */
 declare class Logger {
-    static "__#12@#instance": any;
+    static "__#13@#instance": any;
     /**
      *
      * @returns {Logger}

package/lib/services/logger.js

@@ -90,7 +90,6 @@ class Logger {
             }
             else {
                 try {
-                    // eslint-disable-next-line no-unused-expressions
                     this.prettyObjects ? logs.push(JSON.stringify(arg, null, 2)) : logs.push(JSON.stringify(arg));
                 }
                 catch (e) {
@@ -119,7 +118,7 @@ class Logger {
                 current +
                 // strings are splitted by args when use tagged template, thus we add arg after each string
                 // it looks like: `string1 arg1 string2 arg2 string3`
-                (args[index] !== undefined // eslint-disable-line no-nested-ternary
+                (args[index] !== undefined
                     ? typeof args[index] === 'string'
                         ? args[index] // add arg as it is
                         : this.#stringifyLogs(args[index]) // stringify arg