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

package/src/replay.js

@@ -0,0 +1,262 @@
+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 = {};
+    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 TestomatClient({
+      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 || 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;
+  }
+}
+
+export default Replay; 

package/src/reporter-functions.js

@@ -0,0 +1,96 @@
+import { services } from './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 (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;
+  services.artifacts.put(data, context);
+}
+
+/**
+ * Attach log message(s) to the test report
+ * @param  string
+ */
+function logMessage(...args) {
+  if (process.env.IS_PLAYWRIGHT) throw new Error('This function is not available in Playwright framework');
+  services.logger._templateLiteralLog(...args);
+}
+
+/**
+ * Similar to "log" function but marks message in report as a step
+ * @param {string} message
+ */
+function addStep(message) {
+  if (process.env.IS_PLAYWRIGHT)
+    throw new Error('This function is not available in Playwright framework. Use playwright steps');
+
+  services.logger.step(message);
+}
+
+/**
+ * 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
+ */
+function setKeyValue(keyValue, value = null) {
+  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 };
+  }
+  services.keyValues.put(keyValue);
+}
+
+/**
+ * Add a single label to the test report
+ * @param {string} key - label key (e.g. 'severity', 'feature', or just 'smoke' for labels without values)
+ * @param {string} [value] - optional label value (e.g. 'high', 'login')
+ */
+function setLabel(key, value = null) {
+  if (!key || typeof key !== 'string') {
+    console.warn('Label key must be a non-empty string');
+    return;
+  }
+
+  // Limit key length to 255 characters
+  if (key.length > 255) {
+    console.warn('Label key is too long, trimmed to 255 characters:', key);
+    key = key.substring(0, 255);
+  }
+
+  let labelString = key;
+  if (value !== null && value !== undefined && value !== '') {
+    if (typeof value !== 'string') {
+      console.warn('Label value must be a string, converting:', value);
+      value = String(value);
+    }
+    // Limit value length to 255 characters
+    if (value.length > 255) {
+      console.warn('Label value is too long, trimmed to 255 characters:', value);
+      value = value.substring(0, 255);
+    }
+    labelString = `${key}:${value}`;
+  }
+
+  // Limit total label length to 255 characters
+  if (labelString.length > 255) {
+    console.warn('Label is too long, trimmed to 255 characters:', labelString);
+    labelString = labelString.substring(0, 255);
+  }
+
+  services.labels.put([labelString]);
+}
+
+export default {
+  artifact: saveArtifact,
+  log: logMessage,
+  step: addStep,
+  keyValue: setKeyValue,
+  label: setLabel,
+};

package/src/reporter.cjs_decprecated

@@ -0,0 +1,21 @@
+// const _reporter = require('../lib/reporter.js');
+
+
+// /**
+//  * @typedef {import('../lib/reporter-functions.js').saveArtifact} artifact
+//  * @typedef {import('../lib/reporter-functions.js').log} log
+//  * @typedef {import('../lib/reporter-functions.js').logger} logger
+//  * @typedef {import('../lib/reporter-functions.js')} meta
+//  * @typedef {import('../lib/reporter-functions.js')} step
+//  * 
+//  * "Reporter" type which is object containing all types from the above
+//  * @typedef {{artifact: artifact, log: log, logger: logger, meta: meta, step: step, }} Reporter
+//  */
+
+// // const reporter = _reporter;
+
+// /**
+//  * @type {Reporter}
+//  */
+// const reporter = _reporter;
+// module.exports = reporter;

package/src/reporter.js

@@ -0,0 +1,36 @@
+// import TestomatClient from './client.js';
+// import * as TRConstants from './constants.js';
+import { services } from './services/index.js';
+import reporterFunctions from './reporter-functions.js';
+
+export const artifact = reporterFunctions.artifact;
+export const log = reporterFunctions.log;
+export const logger = services.logger;
+export const meta = reporterFunctions.keyValue;
+export const step = reporterFunctions.step;
+export const label = reporterFunctions.label;
+
+/**
+ * @typedef {import('./reporter-functions.js')} artifact
+ * @typedef {import('./reporter-functions.js')} log
+ * @typedef {import('./services/index.js')} logger
+ * @typedef {import('./reporter-functions.js')} meta
+ * @typedef {import('./reporter-functions.js')} step
+ * @typedef {import('./reporter-functions.js')} label
+ */
+export default {
+  /**
+   * @deprecated Use `log` or `testomat.log`
+   */
+  testomatioLogger: services.logger,
+
+  artifact: reporterFunctions.artifact,
+  log: reporterFunctions.log,
+  logger: services.logger,
+  meta: reporterFunctions.keyValue,
+  step: reporterFunctions.step,
+  label: reporterFunctions.label,
+
+  // TestomatClient,
+  // TRConstants,
+};

package/src/services/artifacts.js

@@ -0,0 +1,59 @@
+import createDebugMessages from 'debug';
+import { dataStorage } from '../data-storage.js';
+
+const debug = createDebugMessages('@testomatio/reporter:services-artifacts');
+
+/**
+ * Artifact storage is supposed to store file paths
+ */
+class ArtifactStorage {
+  static #instance;
+
+  /**
+   * Singleton
+   * @returns {ArtifactStorage}
+   */
+  static getInstance() {
+    if (!this.#instance) {
+      this.#instance = new ArtifactStorage();
+    }
+    return this.#instance;
+  }
+
+  /**
+   * 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
+   * @param {*} context testId or test title
+   */
+  put(data, context = null) {
+    if (!data) return;
+    debug('Save artifact:', data);
+    dataStorage.putData('artifact', data, context);
+  }
+
+  /**
+   * Returns list of artifacts to upload
+   * @param {*} context testId or test context from test runner
+   * @returns {(string | {path: string, type: string, name: string})[]}
+   */
+  get(context) {
+    let artifacts = dataStorage.getData('artifact', context);
+    if (!artifacts || !artifacts.length) return [];
+
+    artifacts = artifacts.map(artifactData => {
+      // artifact could be an object ({type, path, name} props) or string (just path)
+      let artifact;
+      try {
+        artifact = JSON.parse(artifactData);
+      } catch (e) {
+        artifact = artifactData;
+      }
+      return artifact;
+    });
+    artifacts = artifacts.filter(artifact => !!artifact);
+    debug(`Artifacts for test ${context}:`, artifacts);
+    return artifacts.length ? artifacts : [];
+  }
+}
+
+export const artifactStorage = ArtifactStorage.getInstance();

package/src/services/index.js

@@ -0,0 +1,15 @@
+import { logger } from './logger.js';
+import { artifactStorage } from './artifacts.js';
+import { keyValueStorage } from './key-values.js';
+import { labelStorage } from './labels.js';
+import { dataStorage } from '../data-storage.js';
+
+export const services = {
+  logger,
+  artifacts: artifactStorage,
+  keyValues: keyValueStorage,
+  labels: labelStorage,
+  setContext: context => {
+    dataStorage.setContext(context);
+  },
+};

package/src/services/key-values.js

@@ -0,0 +1,59 @@
+import createDebugMessages from 'debug';
+import { dataStorage } from '../data-storage.js';
+
+const debug = createDebugMessages('@testomatio/reporter:services-key-value');
+class KeyValueStorage {
+  static #instance;
+
+  /**
+   *
+   * @returns {KeyValueStorage}
+   */
+  static getInstance() {
+    if (!this.#instance) {
+      this.#instance = new KeyValueStorage();
+    }
+    return this.#instance;
+  }
+
+  /**
+   * Stores key-value pair and passes it to reporter
+   * @param {{[key: string]: string}} keyValue - key-value pair(s) as object
+   * @param {*} context - full test title
+   */
+  put(keyValue, context = null) {
+    if (!keyValue) return;
+    dataStorage.putData('keyvalue', keyValue, context);
+  }
+
+  #isKeyValueObject(smth) {
+    return smth && typeof smth === 'object' && !Array.isArray(smth) && smth !== null;
+  }
+
+  /**
+   * Returns key-values pairs for the test as object
+   * @param {*} context testId or test context from test runner
+   * @returns {{[key: string]: string} | {}} key-values pairs as object, e.g. {priority: 'high', browser: 'chrome'}
+   */
+  get(context = null) {
+    const keyValuesList = dataStorage.getData('keyvalue', context);
+    if (!keyValuesList || !keyValuesList?.length) return {};
+
+    const keyValues = {};
+    for (const keyValue of keyValuesList) {
+      if (this.#isKeyValueObject(keyValue)) {
+        Object.assign(keyValues, keyValue);
+      } else if (typeof keyValue === 'string') {
+        try {
+          Object.assign(keyValues, JSON.parse(keyValue));
+        } catch (e) {
+          debug(`Error parsing key-values for test ${context}`, keyValue);
+        }
+      }
+    }
+
+    return keyValues;
+  }
+}
+
+export const keyValueStorage = KeyValueStorage.getInstance();

package/src/services/labels.js

@@ -0,0 +1,59 @@
+import createDebugMessages from 'debug';
+import { dataStorage } from '../data-storage.js';
+
+const debug = createDebugMessages('@testomatio/reporter:services-labels');
+class LabelStorage {
+  static #instance;
+
+  /**
+   *
+   * @returns {LabelStorage}
+   */
+  static getInstance() {
+    if (!this.#instance) {
+      this.#instance = new LabelStorage();
+    }
+    return this.#instance;
+  }
+
+  /**
+   * Stores labels array and passes it to reporter
+   * @param {string[]} labels - array of label strings
+   * @param {*} context - full test title
+   */
+  put(labels, context = null) {
+    if (!labels || !Array.isArray(labels)) return;
+    dataStorage.putData('labels', labels, context);
+  }
+
+  /**
+   * Returns labels array for the test
+   * @param {*} context testId or test context from test runner
+   * @returns {string[]} labels array, e.g. ['smoke', 'severity:high', 'feature:user_account']
+   */
+  get(context = null) {
+    const labelsList = dataStorage.getData('labels', context);
+    if (!labelsList || !labelsList?.length) return [];
+
+    const allLabels = [];
+    for (const labels of labelsList) {
+      if (Array.isArray(labels)) {
+        allLabels.push(...labels);
+      } else if (typeof labels === 'string') {
+        try {
+          const parsedLabels = JSON.parse(labels);
+          if (Array.isArray(parsedLabels)) {
+            allLabels.push(...parsedLabels);
+          }
+        } catch (e) {
+          debug(`Error parsing labels for test ${context}`, labels);
+        }
+      }
+    }
+
+    // Remove duplicates
+    return [...new Set(allLabels)];
+  }
+}
+
+export const labelStorage = LabelStorage.getInstance();