@testomatio/reporter 2.1.0-beta-nightwatch → 2.1.0-beta.2-codeceptjs

package/src/replay.js

@@ -0,0 +1,268 @@
+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, overwrite: true });
+        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

@@ -47,9 +47,50 @@ function setKeyValue(keyValue, value = null) {
   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.js

@@ -8,6 +8,7 @@ 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
@@ -15,6 +16,7 @@ export const step = reporterFunctions.step;
  * @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 {
   /**
@@ -27,6 +29,7 @@ export default {
   logger: services.logger,
   meta: reporterFunctions.keyValue,
   step: reporterFunctions.step,
+  label: reporterFunctions.label,
 
   // TestomatClient,
   // TRConstants,

package/src/services/index.js

@@ -1,12 +1,14 @@
 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/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();

package/src/services/logger.js

@@ -93,7 +93,6 @@ class Logger {
         logs.push(arg.join(' '));
       } 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) {
           debug('Error while stringify object', e);
@@ -123,7 +122,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