@testomatio/reporter 2.3.9-beta-bin-fix → 2.4.0

package/src/pipe/testomatio.js

@@ -3,7 +3,12 @@ import pc from 'picocolors';
 import { Gaxios } from 'gaxios';
 import JsonCycle from 'json-cycle';
 import { APP_PREFIX, STATUS, AXIOS_TIMEOUT, REPORTER_REQUEST_RETRIES } from '../constants.js';
-import { isValidUrl, foundedTestLog, readLatestRunId, transformEnvVarToBoolean } from '../utils/utils.js';
+import { isValidUrl, 
+  foundedTestLog, 
+  readLatestRunId, 
+  transformEnvVarToBoolean, 
+  getGitCommitSha 
+} from '../utils/utils.js';
 import { parseFilterParams, generateFilterRequestParams, setS3Credentials } from '../utils/pipe_utils.js';
 import { config } from '../config.js';
 
@@ -46,7 +51,25 @@ class TestomatioPipe {
     this.store = store || {};
     this.title = params.title || process.env.TESTOMATIO_TITLE;
     this.sharedRun = !!process.env.TESTOMATIO_SHARED_RUN;
-    this.sharedRunTimeout = !!process.env.TESTOMATIO_SHARED_RUN_TIMEOUT;
+    this.sharedRunTimeout = process.env.TESTOMATIO_SHARED_RUN_TIMEOUT
+      ? parseInt(process.env.TESTOMATIO_SHARED_RUN_TIMEOUT, 10)
+      : undefined;
+
+    if (this.sharedRunTimeout && !this.sharedRun) {
+      debug('Auto-enabling sharedRun because sharedRunTimeout is set');
+      this.sharedRun = true;
+    }
+
+    if (!this.title && (this.sharedRun || this.sharedRunTimeout)) {
+      const sha = getGitCommitSha();
+      if (sha) {
+        this.title = `Shared Run - ${sha}`;
+        console.log(APP_PREFIX, `🔄 Auto-generated title for shared run: ${this.title}`);
+      } else {
+        console.log(APP_PREFIX, pc.red('Failed to resolve git commit SHA for shared run title.'));
+        console.log(APP_PREFIX, 'Please run the tests inside a Git repository or set TESTOMATIO_TITLE explicitly.');
+      }
+    }
     this.groupTitle = params.groupTitle || process.env.TESTOMATIO_RUNGROUP_TITLE;
     this.env = process.env.TESTOMATIO_ENV;
     this.label = process.env.TESTOMATIO_LABEL;
@@ -60,8 +83,8 @@ class TestomatioPipe {
       retryConfig: {
         retry: REPORTER_REQUEST_RETRIES.retriesPerRequest,
         retryDelay: REPORTER_REQUEST_RETRIES.retryTimeout,
-        httpMethodsToRetry: ['GET','PUT','HEAD','OPTIONS','DELETE','POST'],
-        shouldRetry: (error) => {
+        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)
@@ -73,8 +96,8 @@ class TestomatioPipe {
               break;
           }
           return error.response?.status >= 401; // Retry on 401+ and 5xx
-        }
-      }
+        },
+      },
     });
 
     this.isEnabled = true;
@@ -104,7 +127,6 @@ class TestomatioPipe {
     // add test ID + run ID
     if (data.rid) data.rid = `${this.runId}-${data.rid}`;
 
-
     if (!process.env.TESTOMATIO_STACK_PASSED && data.status === STATUS.PASSED) {
       data.stack = null;
     }
@@ -120,7 +142,6 @@ class TestomatioPipe {
     return data;
   }
 
-
   /**
    * Asynchronously prepares and retrieves the Testomat.io test grepList based on the provided options.
    * @param {Object} opts - The options for preparing the test grepList.
@@ -131,17 +152,23 @@ class TestomatioPipe {
   async prepareRun(opts) {
     if (!this.isEnabled) return [];
 
-    const { type, id } = parseFilterParams(opts);
+    const clearOptions = parseFilterParams(opts);
+
+    if (!clearOptions) {
+      return [];
+    }
+
+    const { type, id } = clearOptions;
 
     try {
       const q = generateFilterRequestParams({
         type,
         id,
-        apiKey: this.apiKey.trim(),
+        apiKey: this?.apiKey?.trim(),
       });
 
       if (!q) {
-        return;
+        return [];
       }
 
       const resp = await this.client.request({
@@ -163,7 +190,7 @@ class TestomatioPipe {
 
   /**
    * Creates a new run on Testomat.io
-   * @param {{isBatchEnabled?: boolean}} params
+   * @param {{isBatchEnabled?: boolean, kind?: string}} params
    * @returns Promise<void>
    */
   async createRun(params = {}) {
@@ -204,6 +231,7 @@ class TestomatioPipe {
         label: this.label,
         shared_run: this.sharedRun,
         shared_run_timeout: this.sharedRunTimeout,
+        kind: params.kind,
       }).filter(([, value]) => !!value),
     );
     debug(' >>>>>> Run params', JSON.stringify(runParams, null, 2));
@@ -215,7 +243,7 @@ class TestomatioPipe {
         method: 'PUT',
         url: `/api/reporter/${this.runId}`,
         data: runParams,
-        responseType: 'json'
+        responseType: 'json',
       });
       if (resp.data.artifacts) setS3Credentials(resp.data.artifacts);
       return;
@@ -228,7 +256,7 @@ class TestomatioPipe {
         url: '/api/reporter',
         data: runParams,
         maxContentLength: Infinity,
-        responseType: 'json'
+        responseType: 'json',
       });
 
       this.runId = resp.data.uid;
@@ -287,44 +315,44 @@ class TestomatioPipe {
 
     debug('Adding test', json);
 
-    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) {
-        if (err.response.status >= 400) {
-          const responseData = err.response.data || { message: '' };
+    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) {
+          if (err.response.status >= 400) {
+            const responseData = err.response.data || { message: '' };
+            console.log(
+              APP_PREFIX,
+              pc.yellow(`Warning: ${responseData.message} (${err.response.status})`),
+              pc.gray(data?.title || ''),
+            );
+            if (err.response?.data?.message?.includes('could not be matched')) {
+              this.hasUnmatchedTests = true;
+            }
+            return;
+          }
           console.log(
             APP_PREFIX,
-            pc.yellow(`Warning: ${responseData.message} (${err.response.status})`),
-            pc.gray(data?.title || ''),
+            pc.yellow(`Warning: ${data?.title || ''} (${err.response?.status})`),
+            `Report couldn't be processed: ${err?.response?.data?.message}`,
           );
-          if (err.response?.data?.message?.includes('could not be matched')) {
-            this.hasUnmatchedTests = true;
-          }
-          return;
+          printCreateIssue(err);
+        } else {
+          console.log(APP_PREFIX, pc.blue(data?.title || ''), "Report couldn't be processed", err);
         }
-        console.log(
-          APP_PREFIX,
-          pc.yellow(`Warning: ${data?.title || ''} (${err.response?.status})`),
-          `Report couldn't be processed: ${err?.response?.data?.message}`,
-        );
-        printCreateIssue(err);
-      } else {
-        console.log(APP_PREFIX, pc.blue(data?.title || ''), "Report couldn't be processed", err);
-      }
-    });
+      });
   };
 
-
-
   /**
    * Uploads tests as a batch (multiple tests at once). Intended to be used with a setInterval
    */
@@ -349,43 +377,42 @@ class TestomatioPipe {
     const testsToSend = this.batch.tests.splice(0);
     debug('📨 Batch upload', testsToSend.length, 'tests');
 
-    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: '' };
+    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: ${responseData.message} (${err.response.status})`));
+            if (err.response?.data?.message?.includes('could not be matched')) {
+              this.hasUnmatchedTests = true;
+            }
+            return;
+          }
           console.log(
             APP_PREFIX,
-            pc.yellow(`Warning: ${responseData.message} (${err.response.status})`),
+            pc.yellow(`Warning: (${err.response?.status})`),
+            `Report couldn't be processed: ${err?.response?.data?.message}`,
           );
-          if (err.response?.data?.message?.includes('could not be matched')) {
-            this.hasUnmatchedTests = true;
-          }
-          return;
+          printCreateIssue(err);
+        } else {
+          console.log(APP_PREFIX, "Report couldn't be processed", err);
         }
-        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);
-      }
-    });
+      });
   };
 
   /**
@@ -408,9 +435,9 @@ class TestomatioPipe {
     else this.batch.tests.push(data);
 
     // if test is added after run which is already finished
-     if (!this.batch.intervalFunction) uploading = this.#batchUpload();
+    if (!this.batch.intervalFunction) uploading = this.#batchUpload();
 
-     // return promise to be able to wait for it
+    // return promise to be able to wait for it
     return uploading;
   }
 
@@ -459,7 +486,7 @@ class TestomatioPipe {
             status_event,
             detach: params.detach,
             tests: params.tests,
-          }
+          },
         });
 
         if (this.runUrl) {
@@ -525,9 +552,6 @@ function printCreateIssue(err) {
     console.log({ body: body?.replace(/"(tstmt_[^"]+)"/g, 'tstmt_*'), url, baseURL, method, time });
     console.log('```');
   });
-
 }
 
-
-
 export default TestomatioPipe;

package/src/reporter-functions.js

@@ -1,3 +1,4 @@
+import { isPlaywright } from './helpers.js';
 import { services } from './services/index.js';
 
 /**
@@ -7,9 +8,7 @@ import { services } from './services/index.js';
  * @returns {void}
  */
 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`);
+  showPlaywrightWarning('artifact', 'Playwright supports artifacts out of the box.');
   if (!data) return;
   services.artifacts.put(data, context);
 }
@@ -20,7 +19,6 @@ function saveArtifact(data, context = null) {
  * @returns {void}
  */
 function logMessage(...args) {
-  if (process.env.IS_PLAYWRIGHT) throw new Error('This function is not available in Playwright framework');
   services.logger._templateLiteralLog(...args);
 }
 
@@ -30,10 +28,10 @@ function logMessage(...args) {
  * @returns {void}
  */
 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);
+  // this is done because Playwright reporter intercepts console logs and then we gather them and show on Testomat
+  // if not console.log, the step message will be lost from reporter
+  if (isPlaywright) console.log(`Step: ${message}`);
 }
 
 /**
@@ -43,8 +41,7 @@ function addStep(message) {
  * @returns {void}
  */
 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.');
+  showPlaywrightWarning('meta', 'Use test annotations instead.');
 
   if (typeof keyValue === 'string') {
     keyValue = { [keyValue]: value };
@@ -59,12 +56,12 @@ function setKeyValue(keyValue, value = null) {
  * @returns {void}
  */
 function setLabel(key, value = null) {
+  showPlaywrightWarning('label', 'Use test tag instead.');
   if (Array.isArray(value)) {
     return value.forEach(label => setLabel(key, label));
   }
-  const labelObject = value !== null && value !== undefined && value !== ''
-    ? { label: `${key}:${value}` }
-    : { label: key };
+  const labelObject =
+    value !== null && value !== undefined && value !== '' ? { label: `${key}:${value}` } : { label: key };
   services.links.put([labelObject]);
 }
 
@@ -88,6 +85,12 @@ function linkJira(...jiraIds) {
   services.links.put(links);
 }
 
+function showPlaywrightWarning(functionName, recommendation) {
+  if (isPlaywright) {
+    console.warn(`[TESTOMATIO] '${functionName}' function is not supported for Playwright. ${recommendation}`);
+  }
+}
+
 export default {
   artifact: saveArtifact,
   log: logMessage,

package/src/reporter.js

@@ -1,8 +1,10 @@
-// import TestomatClient from './client.js';
-// import * as TRConstants from './constants.js';
+import Client from './client.js';
+import * as TestomatioConstants from './constants.js';
 import { services } from './services/index.js';
 import reporterFunctions from './reporter-functions.js';
 
+export { Client };
+export const STATUS = TestomatioConstants.STATUS;
 export const artifact = reporterFunctions.artifact;
 export const log = reporterFunctions.log;
 export const logger = services.logger;
@@ -35,6 +37,6 @@ export default {
   linkTest: reporterFunctions.linkTest,
   linkJira: reporterFunctions.linkJira,
 
-  // TestomatClient,
-  // TRConstants,
+  TestomatioClient: Client,
+  STATUS,
 };

package/src/services/links.js

@@ -66,4 +66,4 @@ class LinkStorage {
   }
 }
 
-export const linkStorage = LinkStorage.getInstance();
+export const linkStorage = LinkStorage.getInstance();

package/src/uploader.js

@@ -194,6 +194,11 @@ export class S3Uploader {
       filePath = path.join(process.cwd(), filePath);
     }
 
+    // Normalize path separators for cross-platform compatibility
+    if (typeof filePath === 'string') {
+      filePath = filePath.replace(/\\/g, '/');
+    }
+
     const data = { rid, file: filePath, uploaded };
     const jsonLine = `${JSON.stringify(data)}\n`;
     fs.appendFileSync(tempFilePath, jsonLine);

package/src/utils/log-formatter.js

@@ -0,0 +1,113 @@
+import createCallsiteRecord from 'callsite-record';
+import { minimatch } from 'minimatch';
+import pc from 'picocolors';
+import { stripVTControlCharacters } from 'util';
+import { sep } from 'path';
+import { formatStep, truncate } from './utils.js';
+
+const stripColors = stripVTControlCharacters || (str => str?.replace(/\x1b\[[0-9;]*m/g, '') || '');
+
+/**
+ * Returns the formatted stack including the stack trace, steps, and logs.
+ * @param {Object} params - Parameters for formatting logs
+ * @param {string} params.error - Error message
+ * @param {Array|any} params.steps - Test steps (array or other types)
+ * @param {string} params.logs - Test logs
+ * @returns {string}
+ */
+export function formatLogs({ error, steps, logs }) {
+  error = error?.trim();
+  logs = logs
+    ?.trim()
+    .split('\n')
+    .map(l => truncate(l))
+    .join('\n');
+
+  if (Array.isArray(steps)) {
+    steps = steps
+      .map(step => formatStep(step))
+      .flat()
+      .join('\n');
+  } else {
+    steps = null;
+  }
+
+  let testLogs = '';
+  if (steps) testLogs += `${pc.bold(pc.blue('################[ Steps ]################'))}\n${steps}\n\n`;
+  if (logs) testLogs += `${pc.bold(pc.gray('################[ Logs ]################'))}\n${logs}\n\n`;
+  if (error) testLogs += `${pc.bold(pc.red('################[ Failure ]################'))}\n${error}`;
+  return testLogs;
+}
+
+/**
+ * Formats an error with stack trace and diff information
+ * @param {Error & {inspect?: () => string, operator?: string, diff?: string, actual?: any, expected?: any}} error
+ *   The error object to format
+ * @param {string} [message] - Optional error message override
+ * @returns {string}
+ */
+export function formatError(error, message) {
+  if (!message) message = error.message;
+  // @ts-ignore - inspect is a custom property added by some testing frameworks
+  if (error.inspect) message = error.inspect() || '';
+
+  let stack = '';
+  if (error.name) stack += `${pc.red(error.name)}`;
+  // @ts-ignore - operator is a custom property added by assertion libraries
+  if (error.operator) stack += ` (${pc.red(error.operator)})`;
+  // add new line if something was added to stack
+  if (stack) stack += ': ';
+
+  stack += `${message}\n`;
+
+  // @ts-ignore - diff is a custom property added by vitest
+  if (error.diff) {
+    // diff for vitest
+    stack += error.diff;
+    stack += '\n\n';
+  } else if (error.actual && error.expected && error.actual !== error.expected) {
+    // diffs for mocha, cypress, codeceptjs style
+    stack += `\n\n${pc.bold(pc.green('+ expected'))} ${pc.bold(pc.red('- actual'))}`;
+    stack += `\n${pc.green(`+ ${error.expected.toString().split('\n').join('\n+ ')}`)}`;
+    stack += `\n${pc.red(`- ${error.actual.toString().split('\n').join('\n- ')}`)}`;
+    stack += '\n\n';
+  }
+
+  const customFilter = process.env.TESTOMATIO_STACK_IGNORE;
+
+  try {
+    let hasFrame = false;
+    const record = createCallsiteRecord({
+      forError: error,
+      isCallsiteFrame: frame => {
+        if (customFilter && minimatch(frame.fileName, customFilter)) return false;
+        if (hasFrame) return false;
+        if (isNotInternalFrame(frame)) hasFrame = true;
+        return hasFrame;
+      },
+    });
+    // @ts-ignore
+    if (record && !record.filename.startsWith('http')) {
+      stack += record.renderSync({ stackFilter: isNotInternalFrame });
+    }
+    return stack;
+  } catch (e) {
+    console.log(e);
+  }
+}
+
+/**
+ * Checks if a stack frame is not an internal frame (node_modules or internal)
+ * @param {Object} frame - Stack frame object
+ * @returns {boolean}
+ */
+function isNotInternalFrame(frame) {
+  return (
+    frame.getFileName() &&
+    frame.getFileName().includes(sep) &&
+    !frame.getFileName().includes('node_modules') &&
+    !frame.getFileName().includes('internal')
+  );
+}
+
+export { stripColors };

package/src/utils/pipe_utils.js

@@ -15,6 +15,7 @@ function setS3Credentials(artifacts) {
   if (artifacts.BUCKET) process.env.S3_BUCKET = artifacts.BUCKET;
   if (artifacts.SESSION_TOKEN) process.env.S3_SESSION_TOKEN = artifacts.SESSION_TOKEN;
   if (artifacts.presign) process.env.TESTOMATIO_PRIVATE_ARTIFACTS = '1';
+  if (artifacts.stack_artifacts) process.env.TESTOMATIO_STACK_ARTIFACTS = '1';
   // endpoint is not received from the server; and shuld be empty if IAM used (credentails obtained from the testomat)
   process.env.S3_ENDPOINT = artifacts.ENDPOINT || '';
 }
@@ -25,6 +26,12 @@ function setS3Credentials(artifacts) {
  * @returns {Object|null} - An object containing the generated request parameters, or null if the type is invalid.
  */
 function generateFilterRequestParams(params) {
+  // Defensive check: ensure params is an object
+  if (!params || typeof params !== 'object') {
+    console.error(APP_PREFIX, `Invalid parameters provided. Expected an object, got: ${typeof params}`);
+    return;
+  }
+
   const { type, id, apiKey } = params;
 
   if (!type) {
@@ -53,9 +60,13 @@ function generateFilterRequestParams(params) {
  *                   The object has properties "type" and "id".
  */
 function parseFilterParams(opts) {
-  const [type, id] = opts.split('=');
+  const [type, ...idParts] = opts.split('=');
+  const id = idParts.join('=');
+  
   const validType = updateFilterType(type);
 
+  if (!validType) return undefined;
+
   return {
     type: validType,
     id,
@@ -69,6 +80,8 @@ function parseFilterParams(opts) {
  *                            Returns undefined if the type is not valid.
  */
 function updateFilterType(type) {
+  if (!type || typeof type !== 'string') return;
+
   let typeLowerCase = type.toLowerCase();
 
   const filterTypes = ['tag-name', 'plan', 'label', 'jira-ticket'];
@@ -86,7 +99,7 @@ function updateFilterType(type) {
   ];
 
   if (!filterTypes.includes(typeLowerCase)) {
-    console.log(APP_PREFIX, `❗❗❗ Invalid "filter=${type}" start settings! Available option list: ${filterTypes}`);
+    console.log(APP_PREFIX, `❗❗❗ Invalid filter: "${type}" start settings! Available option list: ${filterTypes}`);
     return;
   }
 
@@ -120,4 +133,40 @@ function fullName(t) {
   return line;
 }
 
-export { updateFilterType, parseFilterParams, generateFilterRequestParams, setS3Credentials, statusEmoji, fullName };
+/**
+ * Parses a comma-separated list of key-value pairs into an options object.
+ *
+ * The input string should be formatted as `"key1=value1,key2=value2,..."`.
+ * Whitespace around keys and values is trimmed. If the input is empty or undefined,
+ * an empty object is returned.
+ *
+ * @param {string} [optionsStr] - A comma-separated string of key=value pairs.
+ * @returns {Object} An object mapping option keys to their string values.
+ *
+ * @example
+ * parsePipeOptions('foo=bar,baz=qux');
+ * => Returns: { foo: 'bar', baz: 'qux' }
+ */
+function parsePipeOptions(optionsStr) {
+  const options = {};
+  if (!optionsStr) return options;
+
+  const pairs = optionsStr.split(',');
+  for (const pair of pairs) {
+    const [key, value] = pair.split('=');
+    if (key && value) {
+      options[key.trim()] = value.trim();
+    }
+  }
+  return options;
+}
+
+export { 
+  updateFilterType, 
+  parseFilterParams, 
+  generateFilterRequestParams, 
+  setS3Credentials, 
+  statusEmoji, 
+  fullName,
+  parsePipeOptions
+};