@testomatio/reporter 2.3.9 → 2.5.0

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,20 +19,24 @@ 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);
 }
 
 /**
  * Similar to "log" function but marks message in report as a step
  * @param {string} message - step message
+ * @param {{[key: string]: any}} [logs] optional key-value object with additional info, e.g. logs
  * @returns {void}
+ *
+ * Example:
+ * step('Get response', { logs: {status: 'success'} });
  */
-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);
+function addStep(message, logs) {
+  // 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) services.logger._templateLiteralLog(message, logs);
+  // all other frameworks
+  else services.logger.step(message, logs);
 }
 
 /**
@@ -43,8 +46,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,6 +61,7 @@ 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));
   }
@@ -87,6 +90,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/services/logger.js

@@ -59,14 +59,10 @@ class Logger {
    * @param  {...any} values
    */
   step(strings, ...values) {
-    let logs = '';
-    for (let i = 0; i < strings.length; i++) {
-      logs += strings[i];
-      if (i < values.length) {
-        logs += values[i];
-      }
-    }
-    logs = pc.blue(`> ${logs}`);
+    // Filter trailing undefined from optional params (e.g., step('message') called without second arg)
+    const filteredValues = values.filter(v => v !== undefined);
+    const message = this.#formatMessage(strings, ...filteredValues);
+    const logs = pc.blue(`> ${message}`);
     dataStorage.putData('log', logs);
   }
 
@@ -87,7 +83,11 @@ class Logger {
     for (const arg of args) {
       // ignore empty strings
       if (arg === '') continue;
-      if (typeof arg === 'string') {
+      if (arg === undefined) {
+        logs.push('undefined');
+      } else if (arg === null) {
+        logs.push('null');
+      } else if (typeof arg === 'string') {
         logs.push(arg);
       } else if (Array.isArray(arg)) {
         logs.push(arg.join(' '));
@@ -104,37 +104,42 @@ class Logger {
   }
 
   /**
-   * Tagget template literal. Allows to use different syntaxes:
-   * 1. Tagget template: log`text ${someVar}`
-   * 2. Standard: log(`text ${someVar}`)
-   * 3. Standard with multiple arguments: log('text', someVar)
+   * Formats a message from either tagged template literal or standard function call.
+   * @param {*} strings - Template strings array or first argument
+   * @param {...any} args - Template values or additional arguments
+   * @returns {string} Formatted message
    */
-  _templateLiteralLog(strings, ...args) {
-    if (Array.isArray(strings)) strings = strings.filter(item => item !== '').map(item => item.trim());
+  #formatMessage(strings, ...args) {
     if (Array.isArray(args)) args = args.filter(item => item !== '');
 
-    let logs;
-    // this block means tagged template is used (syntax like $`text ${someVar}`)
+    // Tagged template syntax: func`text ${someVar}`
     if (Array.isArray(strings) && strings.length === args.length + 1) {
-      logs = strings.reduce(
+      return strings.reduce(
         (result, current, index) =>
           result +
           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
-            ? typeof args[index] === 'string'
-              ? args[index] // add arg as it is
-              : this.#stringifyLogs(args[index]) // stringify arg
+          (index < args.length
+            ? args[index] === undefined
+              ? 'undefined'
+              : typeof args[index] === 'string'
+                ? args[index]
+                : this.#stringifyLogs(args[index])
             : ''),
-        // initial accumulator value
         '',
       );
-    } else {
-      // this block means arguments syntax is used (syntax like $('text', someVar))
-      // in this case strings represents just a first argument
-      logs = this.#stringifyLogs(strings, ...args);
     }
+    // Standard function call: func('text', someVar)
+    return this.#stringifyLogs(strings, ...args);
+  }
+
+  /**
+   * Tagged template literal. Allows to use different syntaxes:
+   * 1. Tagged template: log`text ${someVar}`
+   * 2. Standard: log(`text ${someVar}`)
+   * 3. Standard with multiple arguments: log('text', someVar)
+   */
+  _templateLiteralLog(strings, ...args) {
+    const logs = this.#formatMessage(strings, ...args);
     this.#originalUserLogger.log(logs);
     dataStorage.putData('log', logs);
   }

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
+};

package/src/utils/utils.js

@@ -6,6 +6,7 @@ import isValid from 'is-valid-path';
 import createDebugMessages from 'debug';
 import os from 'os';
 import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
 
 const debug = createDebugMessages('@testomatio/reporter:util');
 
@@ -58,6 +59,21 @@ const validateSuiteId = suiteId => {
   return match ? match[0] : null;
 };
 
+/**
+ * Gets current git commit SHA
+ * @returns {String|null} git commit SHA or null if not available
+ */
+const getGitCommitSha = () => {
+  try {
+    const sha = execSync('git rev-parse --short HEAD', {
+      stdio: ['ignore', 'pipe', 'ignore']
+    }).toString().trim();
+    return sha || null;
+  } catch (error) {
+    return null;
+  }
+};
+
 const ansiRegExp = () => {
   const pattern = [
     '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
@@ -615,6 +631,63 @@ function truncate(s, size = 255) {
   return `${str.substring(0, size)}...`;
 }
 
+function applyFilter(command, tests) {
+  if (!tests || !tests.length) return command;
+
+  const lower = (command || '').toLowerCase();
+  const regexPattern = `(${tests.join('|')})`;
+
+  if (lower.includes('jest')) {
+    return `${command} --testNamePattern ${regexPattern}`;
+  }
+
+  if (lower.includes('cypress')) {
+    const grepValue = tests.join(',');
+    const baseEnv = {
+      grep: grepValue,
+      grepFilterSpecs: true,
+      grepOmitFiltered: true,
+    };
+
+    if (command.includes('--env')) {
+      return command.replace(
+        /--env\s+(['"]?)([^\s'"]+)\1/,
+        (match, quote, envVal) => {
+          const existingEnv = {};
+
+          if (envVal.startsWith('{') && envVal.endsWith('}')) {
+            try {
+              Object.assign(existingEnv, JSON.parse(envVal));
+            } catch (e) {
+            }
+          }
+
+          if (!Object.keys(existingEnv).length) {
+            envVal.split(',').forEach((pair) => {
+              const [k, v] = pair.split('=');
+              if (!k) return;
+
+              if (v === 'true') existingEnv[k] = true;
+              else if (v === 'false') existingEnv[k] = false;
+              else existingEnv[k] = v;
+            });
+          }
+
+          const merged = { ...existingEnv, ...baseEnv };
+          const json = JSON.stringify(merged);
+
+          return `--env ${json}`;
+        },
+      );
+    }
+
+    const json = JSON.stringify(baseEnv);
+    return `${command} --env ${json}`;
+  }
+
+  return `${command} --grep ${regexPattern}`;
+}
+
 export {
   ansiRegExp,
   truncate,
@@ -629,6 +702,7 @@ export {
   foundedTestLog,
   formatStep,
   getCurrentDateTime,
+  getGitCommitSha,
   getTestomatIdFromTestTitle,
   humanize,
   isValidUrl,
@@ -640,4 +714,5 @@ export {
   testRunnerHelper,
   transformEnvVarToBoolean,
   validateSuiteId,
+  applyFilter
 };

package/types/types.d.ts

@@ -15,8 +15,9 @@ declare module '@testomatio/reporter' {
   /**
    * Similar to "log" function but marks message in report as a step
    * @param message - step message
+   * @param logs - optional key-value object with additional info (e.g. logs)
    */
-  export function step(message: string): void;
+  export function step(message: string, logs?: {[key: string]: any}): void;
 
   /**
    * Add key-value pair(s) to the test report