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

package/src/pipe/testomatio.js

@@ -1,12 +1,6 @@
 import createDebugMessages from 'debug';
 import pc from 'picocolors';
-
-// Retry interceptor function
-import axiosRetry from 'axios-retry';
-
-// Default axios instance
-import axios from 'axios';
-
+import { Gaxios } from 'gaxios';
 import JsonCycle from 'json-cycle';
 import { APP_PREFIX, STATUS, AXIOS_TIMEOUT, REPORTER_REQUEST_RETRIES } from '../constants.js';
 import { isValidUrl, foundedTestLog } from '../utils/utils.js';
@@ -15,9 +9,7 @@ import { config } from '../config.js';
 
 const debug = createDebugMessages('@testomatio/reporter:pipe:testomatio');
 
-if (process.env.TESTOMATIO_RUN) {
-  // process.env.runId = process.env.TESTOMATIO_RUN;
-}
+if (process.env.TESTOMATIO_RUN) process.env.runId = process.env.TESTOMATIO_RUN;
 
 /**
  * @typedef {import('../../types/types.js').Pipe} Pipe
@@ -59,50 +51,38 @@ class TestomatioPipe {
     this.groupTitle = params.groupTitle || process.env.TESTOMATIO_RUNGROUP_TITLE;
     this.env = process.env.TESTOMATIO_ENV;
     this.label = process.env.TESTOMATIO_LABEL;
-    // Create a new instance of axios with a custom config
-    this.axios = axios.create({
+
+    // Create a new instance of gaxios with a custom config
+    this.client = new Gaxios({
       baseURL: `${this.url.trim()}`,
       timeout: AXIOS_TIMEOUT,
-      proxy: proxy
-        ? {
-            host: proxy.hostname,
-            port: parseInt(proxy.port, 10),
-            protocol: proxy.protocol,
+      proxy: proxy ? proxy.toString() : undefined,
+      retry: true,
+      retryConfig: {
+        retry: REPORTER_REQUEST_RETRIES.retriesPerRequest,
+        retryDelay: REPORTER_REQUEST_RETRIES.retryTimeout,
+        httpMethodsToRetry: ['GET','PUT','HEAD','OPTIONS','DELETE','POST'],
+        shouldRetry: (error) => {
+          if (!error.response) return false;
+          switch (error.response?.status) {
+            case 400: // Bad request (probably wrong API key)
+            case 404: // Test not matched
+            case 429: // Rate limit exceeded
+            case 500: // Internal server error
+              return false;
+            default:
+              break;
           }
-        : false,
-    });
-
-    // Pass the axios instance to the retry function
-    axiosRetry(this.axios, {
-      // do not use retries for unit tests
-      retries: REPORTER_REQUEST_RETRIES.retriesPerRequest, // Number of retries
-      shouldResetTimeout: true,
-      retryCondition: error => {
-        if (!error.response) return false;
-        switch (error.response?.status) {
-          case 400: // Bad request (probably wrong API key)
-          case 404: // Test not matched
-          case 429: // Rate limit exceeded
-          case 500: // Internal server error
-            return false;
-          default:
-            break;
+          return error.response?.status >= 401; // Retry on 401+ and 5xx
         }
-        return error.response?.status >= 401; // Retry on 401+ and 5xx
-      },
-      retryDelay: () => REPORTER_REQUEST_RETRIES.retryTimeout, // sum = 15sec
-      onRetry: async (retryCount, error) => {
-        this.retriesTimestamps.push(Date.now());
-
-        debug(`${error.message || `Request failed ${error.status}`}. Retry #${retryCount} ...`);
-      },
+      }
     });
 
     this.isEnabled = true;
     // do not finish this run (for parallel testing)
     this.proceed = process.env.TESTOMATIO_PROCEED;
     this.jiraId = process.env.TESTOMATIO_JIRA_ID;
-    this.runId = params.runId || process.env.runId;
+    this.runId = params.runId || process.env.TESTOMATIO_RUN;
     this.createNewTests = params.createNewTests ?? !!process.env.TESTOMATIO_CREATE;
     this.hasUnmatchedTests = false;
     this.requestFailures = 0;
@@ -136,12 +116,15 @@ class TestomatioPipe {
         return;
       }
 
-      const resp = await this.axios.get('/api/test_grep', q);
-      const { data } = resp;
+      const resp = await this.client.request({
+        method: 'GET',
+        url: '/api/test_grep',
+        params: q
+      });
 
-      if (Array.isArray(data?.tests) && data?.tests?.length > 0) {
-        foundedTestLog(APP_PREFIX, data.tests);
-        return data.tests;
+      if (Array.isArray(resp.data?.tests) && resp.data?.tests?.length > 0) {
+        foundedTestLog(APP_PREFIX, resp.data.tests);
+        return resp.data.tests;
       }
 
       console.log(APP_PREFIX, `⛔  No tests found for your --filter --> ${type}=${id}`);
@@ -201,16 +184,23 @@ class TestomatioPipe {
     if (this.runId) {
       this.store.runId = this.runId;
       debug(`Run with id ${this.runId} already created, updating...`);
-      const resp = await this.axios.put(`/api/reporter/${this.runId}`, runParams);
+      const resp = await this.client.request({
+        method: 'PUT',
+        url: `/api/reporter/${this.runId}`,
+        data: runParams
+      });
       if (resp.data.artifacts) setS3Credentials(resp.data.artifacts);
       return;
     }
 
     debug('Creating run...');
     try {
-      const resp = await this.axios.post(`/api/reporter`, runParams, {
+      const resp = await this.client.request({
+        method: 'POST',
+        url: '/api/reporter',
+        data: runParams,
         maxContentLength: Infinity,
-        maxBodyLength: Infinity,
+        responseType: 'json'
       });
 
       this.runId = resp.data.uid;
@@ -227,6 +217,7 @@ class TestomatioPipe {
       debug('Run created', this.runId);
     } catch (err) {
       const errorText = err.response?.data?.message || err.message;
+      debug('Error creating run', err);
       console.log(errorText || err);
       if (!this.apiKey) console.error('Testomat.io API key is not set');
       if (!this.apiKey?.startsWith('tstmt')) console.error('Testomat.io API key is invalid');
@@ -273,7 +264,15 @@ class TestomatioPipe {
 
     debug('Adding test', json);
 
-    return this.axios.post(`/api/reporter/${this.runId}/testrun`, json, axiosAddTestrunRequestConfig).catch(err => {
+    return this.client.request({
+      method: 'POST',
+      url: `/api/reporter/${this.runId}/testrun`,
+      data: json,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      maxContentLength: Infinity
+    }).catch(err => {
       this.requestFailures++;
       this.notReportedTestsCount++;
       if (err.response) {
@@ -325,44 +324,51 @@ class TestomatioPipe {
     const testsToSend = this.batch.tests.splice(0);
     debug('📨 Batch upload', testsToSend.length, 'tests');
 
-    return this.axios
-      .post(
-        `/api/reporter/${this.runId}/testrun`,
-        { api_key: this.apiKey, tests: testsToSend, batch_index: this.batch.batchIndex },
-        axiosAddTestrunRequestConfig,
-      )
-      .catch(err => {
-        this.requestFailures++;
-        this.notReportedTestsCount += testsToSend.length;
-        if (err.response) {
-          if (err.response.status >= 400) {
-            const responseData = err.response.data || { message: '' };
-            console.log(
-              APP_PREFIX,
-              pc.yellow(`Warning: ${responseData.message} (${err.response.status})`),
-              // pc.grey(data?.title || ''),
-            );
-            if (err.response?.data?.message?.includes('could not be matched')) {
-              this.hasUnmatchedTests = true;
-            }
-            return;
-          }
+    return this.client.request({
+      method: 'POST',
+      url: `/api/reporter/${this.runId}/testrun`,
+      data: { 
+        api_key: this.apiKey, 
+        tests: testsToSend, 
+        batch_index: this.batch.batchIndex 
+      },
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      maxContentLength: Infinity
+    }).catch(err => {
+      this.requestFailures++;
+      this.notReportedTestsCount += testsToSend.length;
+      if (err.response) {
+        if (err.response.status >= 400) {
+          const responseData = err.response.data || { message: '' };
           console.log(
             APP_PREFIX,
-            pc.yellow(`Warning: (${err.response?.status})`),
-            `Report couldn't be processed: ${err?.response?.data?.message}`,
+            pc.yellow(`Warning: ${responseData.message} (${err.response.status})`),
           );
-          printCreateIssue(err);
-        } else {
-          console.log(APP_PREFIX, "Report couldn't be processed", err);
+          if (err.response?.data?.message?.includes('could not be matched')) {
+            this.hasUnmatchedTests = true;
+          }
+          return;
         }
-      });
+        console.log(
+          APP_PREFIX,
+          pc.yellow(`Warning: (${err.response?.status})`),
+          `Report couldn't be processed: ${err?.response?.data?.message}`,
+        );
+        printCreateIssue(err);
+      } else {
+        console.log(APP_PREFIX, "Report couldn't be processed", err);
+      }
+    });
   };
 
   /**
    * 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;
 
@@ -371,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;
   }
 
   /**
@@ -415,12 +425,16 @@ class TestomatioPipe {
 
     try {
       if (this.runId && !this.proceed) {
-        await this.axios.put(`/api/reporter/${this.runId}`, {
-          api_key: this.apiKey,
-          duration: params.duration,
-          status_event,
-          detach: params.detach,
-          tests: params.tests,
+        await this.client.request({
+          method: 'PUT',
+          url: `/api/reporter/${this.runId}`,
+          data: {
+            api_key: this.apiKey,
+            duration: params.duration,
+            status_event,
+            detach: params.detach,
+            tests: params.tests,
+          }
         });
         if (this.runUrl) {
           console.log(APP_PREFIX, '📊 Report Saved. Report URL:', pc.magenta(this.runUrl));
@@ -437,14 +451,11 @@ class TestomatioPipe {
 
       if (this.hasUnmatchedTests) {
         console.log('');
-        // eslint-disable-next-line max-len
         console.log(APP_PREFIX, pc.yellow(pc.bold('⚠️ Some reported tests were not found in Testomat.io project')));
-        // eslint-disable-next-line max-len
         console.log(
           APP_PREFIX,
           `If you use Testomat.io as a reporter only, please re-run tests using ${pc.bold('TESTOMATIO_CREATE=1')}`,
         );
-        // eslint-disable-next-line max-len
         console.log(
           APP_PREFIX,
           `But to keep your tests consistent it is recommended to ${pc.bold('import tests first')}`,
@@ -453,7 +464,6 @@ class TestomatioPipe {
         console.log(APP_PREFIX, 'You can do that automatically via command line tools:');
         console.log(APP_PREFIX, pc.bold('npx check-tests ... --update-ids'), 'See: https://bit.ly/js-update-ids');
         console.log(APP_PREFIX, 'or for Cucumber:');
-        // eslint-disable-next-line max-len
         console.log(APP_PREFIX, pc.bold('npx check-cucumber ... --update-ids'), 'See: https://bit.ly/bdd-update-ids');
       }
     } catch (err) {
@@ -478,26 +488,17 @@ function printCreateIssue(err) {
     console.log(
       APP_PREFIX,
       'If you think this is a bug please create an issue: https://github.com/testomatio/reporter/issues/new',
-    ); // eslint-disable-line max-len
+    );
     console.log(APP_PREFIX, 'Provide this information:');
     console.log('Error:', err.message || err.code);
     if (!err.config) return;
 
     const time = new Date().toUTCString();
-    const { data, url, baseURL, method } = err?.config || {};
+    const { body, url, baseURL, method } = err?.config || {};
     console.log('```js');
-    console.log({ data: data?.replace(/"(tstmt_[^"]+)"/g, 'tstmt_*'), url, baseURL, method, time });
+    console.log({ body: body?.replace(/"(tstmt_[^"]+)"/g, 'tstmt_*'), url, baseURL, method, time });
     console.log('```');
   });
 }
 
-const axiosAddTestrunRequestConfig = {
-  maxContentLength: Infinity,
-  maxBodyLength: Infinity,
-  headers: {
-    // Overwrite Axios's automatically set Content-Type
-    'Content-Type': 'application/json',
-  },
-};
-
 export default TestomatioPipe;

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

@@ -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);
   },