@testomatio/reporter 2.0.1-beta.5-timestamp → 2.0.1-beta.6

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,255 @@
+"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 = {};
+        let runId = null;
+        // 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) {
+                    // Extract runId if available
+                    if (logEntry.runId && !runId) {
+                        runId = logEntry.runId;
+                    }
+                    // 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) {
+                    // Extract runId if available
+                    if (logEntry.runId && !runId) {
+                        runId = logEntry.runId;
+                    }
+                    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,
+            runId
+        };
+    }
+    /**
+     * 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, runId } = 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,
+                runId,
+                dryRun: true
+            };
+        }
+        // Create client and restore the run
+        const client = new client_js_1.default({
+            apiKey: this.apiKey,
+            isBatchEnabled: true,
+            ...runParams,
+        });
+        // Use the stored runId if available, otherwise create a new run
+        if (runId) {
+            this.onLog(`Using existing run ID: ${runId}`);
+            client.runId = runId;
+        }
+        else {
+            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: 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-functions.d.ts

@@ -0,0 +1,34 @@
+declare namespace _default {
+    export { saveArtifact as artifact };
+    export { logMessage as log };
+    export { addStep as step };
+    export { setKeyValue as keyValue };
+}
+export default _default;
+/**
+ * Stores path to file as artifact and uploads it to the S3 storage
+ * @param {string | {path: string, type: string, name: string}} data - path to file or object with path, type and name
+ */
+declare function saveArtifact(data: string | {
+    path: string;
+    type: string;
+    name: string;
+}, context?: any): void;
+/**
+ * Attach log message(s) to the test report
+ * @param  string
+ */
+declare function logMessage(...args: any[]): void;
+/**
+ * Similar to "log" function but marks message in report as a step
+ * @param {string} message
+ */
+declare function addStep(message: string): void;
+/**
+ * Add key-value pair(s) to the test report
+ * @param {{[key: string]: string} | string} keyValue object { key: value } (multiple props allowed) or key (string)
+ * @param {string?} value
+ */
+declare function setKeyValue(keyValue: {
+    [key: string]: string;
+} | string, value?: string | null): void;

package/lib/reporter-functions.js

@@ -1,50 +1,52 @@
-const { services } = require('./services');
-const { initPlaywrightForStorage } = require('./adapter/playwright');
-
-if (process.env.PLAYWRIGHT_TEST_BASE_URL) {
-  initPlaywrightForStorage();
-}
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("./services/index.js");
 /**
  * Stores path to file as artifact and uploads it to the S3 storage
  * @param {string | {path: string, type: string, name: string}} data - path to file or object with path, type and name
  */
 function saveArtifact(data, context = null) {
-  if (!data) return;
-  services.artifacts.put(data, context);
+    if (process.env.IS_PLAYWRIGHT)
+        throw new Error(`This function is not available in Playwright framework.
+    /Playwright supports artifacts out of the box`);
+    if (!data)
+        return;
+    index_js_1.services.artifacts.put(data, context);
 }
-
 /**
  * Attach log message(s) to the test report
- * @param  {...any} args
+ * @param  string
  */
 function logMessage(...args) {
-  services.logger._templateLiteralLog(...args);
+    if (process.env.IS_PLAYWRIGHT)
+        throw new Error('This function is not available in Playwright framework');
+    index_js_1.services.logger._templateLiteralLog(...args);
 }
-
 /**
  * Similar to "log" function but marks message in report as a step
- * @param {*} message
+ * @param {string} message
  */
 function addStep(message) {
-  services.logger.step(message);
+    if (process.env.IS_PLAYWRIGHT)
+        throw new Error('This function is not available in Playwright framework. Use playwright steps');
+    index_js_1.services.logger.step(message);
 }
-
 /**
  * Add key-value pair(s) to the test report
- * @param {*} keyValue or key
+ * @param {{[key: string]: string} | string} keyValue object { key: value } (multiple props allowed) or key (string)
  * @param {string?} value
  */
 function setKeyValue(keyValue, value = null) {
-  if (value && typeof keyValue === 'string') {
-    keyValue = { [keyValue]: value };
-  }
-  services.keyValues.put(keyValue);
+    if (process.env.IS_PLAYWRIGHT)
+        throw new Error('This function is not available in Playwright framework. Use test tag instead.');
+    if (typeof keyValue === 'string') {
+        keyValue = { [keyValue]: value };
+    }
+    index_js_1.services.keyValues.put(keyValue);
 }
-
 module.exports = {
-  artifact: saveArtifact,
-  log: logMessage,
-  step: addStep,
-  keyValue: setKeyValue,
+    artifact: saveArtifact,
+    log: logMessage,
+    step: addStep,
+    keyValue: setKeyValue,
 };

package/lib/reporter.d.ts

@@ -0,0 +1,232 @@
+export type artifact = typeof import("./reporter-functions.js");
+export const artifact: (data: string | {
+    path: string;
+    type: string;
+    name: string;
+}, context?: any) => void;
+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: {
+    "__#13@#originalUserLogger": {
+        assert(condition?: boolean, ...data: any[]): void;
+        assert(value: any, message?: string, ...optionalParams: any[]): void;
+        clear(): void;
+        clear(): void;
+        count(label?: string): void;
+        count(label?: string): void;
+        countReset(label?: string): void;
+        countReset(label?: string): void;
+        debug(...data: any[]): void;
+        debug(message?: any, ...optionalParams: any[]): void;
+        dir(item?: any, options?: any): void;
+        dir(obj: any, options?: import("util").InspectOptions): void;
+        dirxml(...data: any[]): void;
+        dirxml(...data: any[]): void;
+        error(...data: any[]): void;
+        error(message?: any, ...optionalParams: any[]): void;
+        group(...data: any[]): void;
+        group(...label: any[]): void;
+        groupCollapsed(...data: any[]): void;
+        groupCollapsed(...label: any[]): void;
+        groupEnd(): void;
+        groupEnd(): void;
+        info(...data: any[]): void;
+        info(message?: any, ...optionalParams: any[]): void;
+        log(...data: any[]): void;
+        log(message?: any, ...optionalParams: any[]): void;
+        table(tabularData?: any, properties?: string[]): void;
+        table(tabularData: any, properties?: readonly string[]): void;
+        time(label?: string): void;
+        time(label?: string): void;
+        timeEnd(label?: string): void;
+        timeEnd(label?: string): void;
+        timeLog(label?: string, ...data: any[]): void;
+        timeLog(label?: string, ...data: any[]): void;
+        timeStamp(label?: string): void;
+        timeStamp(label?: string): void;
+        trace(...data: any[]): void;
+        trace(message?: any, ...optionalParams: any[]): void;
+        warn(...data: any[]): void;
+        warn(message?: any, ...optionalParams: any[]): void;
+        Console: console.ConsoleConstructor;
+        profile(label?: string): void;
+        profileEnd(label?: string): void;
+    };
+    "__#13@#userLoggerWithOverridenMethods": any;
+    logLevel: string;
+    step(strings: any, ...values: any[]): void;
+    getLogs(context: string): string[];
+    "__#13@#stringifyLogs"(...args: any[]): string;
+    _templateLiteralLog(strings: any, ...args: any[]): void;
+    "__#13@#logWrapper"(argsArray: any, level: any): void;
+    assert(...args: any[]): void;
+    debug(...args: any[]): void;
+    error(...args: any[]): void;
+    info(...args: any[]): void;
+    log(...args: any[]): void;
+    trace(...args: any[]): void;
+    warn(...args: any[]): void;
+    intercept(userLogger: any): void;
+    stopInterception(): void;
+    configure(config?: {
+        logLevel?: string;
+        prettyObjects?: boolean;
+    }): void;
+    prettyObjects: boolean;
+};
+export type meta = typeof import("./reporter-functions.js");
+export const meta: (keyValue: {
+    [key: string]: string;
+} | string, value?: string | null) => void;
+export type step = typeof import("./reporter-functions.js");
+export const step: (message: string) => void;
+declare namespace _default {
+    let testomatioLogger: {
+        "__#13@#originalUserLogger": {
+            assert(condition?: boolean, ...data: any[]): void;
+            assert(value: any, message?: string, ...optionalParams: any[]): void;
+            clear(): void;
+            clear(): void;
+            count(label?: string): void;
+            count(label?: string): void;
+            countReset(label?: string): void;
+            countReset(label?: string): void;
+            debug(...data: any[]): void;
+            debug(message?: any, ...optionalParams: any[]): void;
+            dir(item?: any, options?: any): void;
+            dir(obj: any, options?: import("util").InspectOptions): void;
+            dirxml(...data: any[]): void;
+            dirxml(...data: any[]): void;
+            error(...data: any[]): void;
+            error(message?: any, ...optionalParams: any[]): void;
+            group(...data: any[]): void;
+            group(...label: any[]): void;
+            groupCollapsed(...data: any[]): void;
+            groupCollapsed(...label: any[]): void;
+            groupEnd(): void;
+            groupEnd(): void;
+            info(...data: any[]): void;
+            info(message?: any, ...optionalParams: any[]): void;
+            log(...data: any[]): void;
+            log(message?: any, ...optionalParams: any[]): void;
+            table(tabularData?: any, properties?: string[]): void;
+            table(tabularData: any, properties?: readonly string[]): void;
+            time(label?: string): void;
+            time(label?: string): void;
+            timeEnd(label?: string): void;
+            timeEnd(label?: string): void;
+            timeLog(label?: string, ...data: any[]): void;
+            timeLog(label?: string, ...data: any[]): void;
+            timeStamp(label?: string): void;
+            timeStamp(label?: string): void;
+            trace(...data: any[]): void;
+            trace(message?: any, ...optionalParams: any[]): void;
+            warn(...data: any[]): void;
+            warn(message?: any, ...optionalParams: any[]): void;
+            Console: console.ConsoleConstructor;
+            profile(label?: string): void;
+            profileEnd(label?: string): void;
+        };
+        "__#13@#userLoggerWithOverridenMethods": any;
+        logLevel: string;
+        step(strings: any, ...values: any[]): void;
+        getLogs(context: string): string[];
+        "__#13@#stringifyLogs"(...args: any[]): string;
+        _templateLiteralLog(strings: any, ...args: any[]): void;
+        "__#13@#logWrapper"(argsArray: any, level: any): void;
+        assert(...args: any[]): void;
+        debug(...args: any[]): void;
+        error(...args: any[]): void;
+        info(...args: any[]): void;
+        log(...args: any[]): void;
+        trace(...args: any[]): void;
+        warn(...args: any[]): void;
+        intercept(userLogger: any): void;
+        stopInterception(): void;
+        configure(config?: {
+            logLevel?: string;
+            prettyObjects?: boolean;
+        }): void;
+        prettyObjects: boolean;
+    };
+    let artifact: (data: string | {
+        path: string;
+        type: string;
+        name: string;
+    }, context?: any) => void;
+    let log: (...args: any[]) => void;
+    let logger: {
+        "__#13@#originalUserLogger": {
+            assert(condition?: boolean, ...data: any[]): void;
+            assert(value: any, message?: string, ...optionalParams: any[]): void;
+            clear(): void;
+            clear(): void;
+            count(label?: string): void;
+            count(label?: string): void;
+            countReset(label?: string): void;
+            countReset(label?: string): void;
+            debug(...data: any[]): void;
+            debug(message?: any, ...optionalParams: any[]): void;
+            dir(item?: any, options?: any): void;
+            dir(obj: any, options?: import("util").InspectOptions): void;
+            dirxml(...data: any[]): void;
+            dirxml(...data: any[]): void;
+            error(...data: any[]): void;
+            error(message?: any, ...optionalParams: any[]): void;
+            group(...data: any[]): void;
+            group(...label: any[]): void;
+            groupCollapsed(...data: any[]): void;
+            groupCollapsed(...label: any[]): void;
+            groupEnd(): void;
+            groupEnd(): void;
+            info(...data: any[]): void;
+            info(message?: any, ...optionalParams: any[]): void;
+            log(...data: any[]): void;
+            log(message?: any, ...optionalParams: any[]): void;
+            table(tabularData?: any, properties?: string[]): void;
+            table(tabularData: any, properties?: readonly string[]): void;
+            time(label?: string): void;
+            time(label?: string): void;
+            timeEnd(label?: string): void;
+            timeEnd(label?: string): void;
+            timeLog(label?: string, ...data: any[]): void;
+            timeLog(label?: string, ...data: any[]): void;
+            timeStamp(label?: string): void;
+            timeStamp(label?: string): void;
+            trace(...data: any[]): void;
+            trace(message?: any, ...optionalParams: any[]): void;
+            warn(...data: any[]): void;
+            warn(message?: any, ...optionalParams: any[]): void;
+            Console: console.ConsoleConstructor;
+            profile(label?: string): void;
+            profileEnd(label?: string): void;
+        };
+        "__#13@#userLoggerWithOverridenMethods": any;
+        logLevel: string;
+        step(strings: any, ...values: any[]): void;
+        getLogs(context: string): string[];
+        "__#13@#stringifyLogs"(...args: any[]): string;
+        _templateLiteralLog(strings: any, ...args: any[]): void;
+        "__#13@#logWrapper"(argsArray: any, level: any): void;
+        assert(...args: any[]): void;
+        debug(...args: any[]): void;
+        error(...args: any[]): void;
+        info(...args: any[]): void;
+        log(...args: any[]): void;
+        trace(...args: any[]): void;
+        warn(...args: any[]): void;
+        intercept(userLogger: any): void;
+        stopInterception(): void;
+        configure(config?: {
+            logLevel?: string;
+            prettyObjects?: boolean;
+        }): void;
+        prettyObjects: boolean;
+    };
+    let meta: (keyValue: {
+        [key: string]: string;
+    } | string, value?: string | null) => void;
+    let step: (message: string) => void;
+}
+export default _default;