@testomatio/reporter 1.3.6-beta → 1.4.1-beta-1

package/lib/{logger.js → storages/logger.js}

@@ -1,7 +1,6 @@
 const chalk = require('chalk');
 const debug = require('debug')('@testomatio/reporter:logger');
-const _ = require('lodash');
-const { DataStorage } = require('./dataStorage');
+const DataStorage = require('./data-storage');
 
 const LOG_METHODS = ['assert', 'debug', 'error', 'info', 'log', 'trace', 'warn'];
 const LEVELS = {
@@ -15,26 +14,23 @@ const LEVELS = {
   ERROR: { severity: 15, color: 'red' },
 };
 
+// ! DON'T use console.log, console.warn, etc in this file, because it will lead to infinite loop
+// use debug() instead
+
 /**
- * Logger allows to:
- * 1. Intercept logs from user logger (console.log, etc) and store them.
- * 2. Output logs to console (actually, logger functionality).
- * 3. Varied syntax.
+ * Logger allows to intercept logs from any logger (console.log, tracer, pino, etc)
+ * and save in the testomatio reporter.
+ * Supports different syntaxes to satisfy any user preferences.
  */
 class Logger {
-  // _originalUserLogger used to output logs to console by the user logger
-  // _loggerToIntercept intercepted and reassigned immediately when added
-
-  constructor() {
-    // set default logger to be used in log, warn, error, etc methods
-    this._originalUserLogger = { ...console };
+  // set default logger to be used in log, warn, error, etc methods
+  #originalUserLogger = { ...console };
 
-    this.dataStorage = new DataStorage('log');
-    this.logLevel = process?.env?.LOG_LEVEL?.toUpperCase() || 'ALL';
+  #dataStorage = new DataStorage('log');
 
-    // commented because prefer to use "intercept" method
-    // if (params?.logger) this._loggerToIntercept = params.logger;
+  logLevel = process?.env?.LOG_LEVEL?.toUpperCase() || 'ALL';
 
+  constructor() {
     // intercept console by default
     this.intercept(console);
 
@@ -42,17 +38,6 @@ class Logger {
     if (!Logger.instance) {
       Logger.instance = this;
     }
-
-    this._helpers = {
-      parseLastArgToGetTestId: (...args) => {
-        try {
-          return this.dataStorage._tryToRetrieveTestId(args.at(-1));
-        } catch (e) {
-          // node 14 support
-          return this.dataStorage._tryToRetrieveTestId(args[args.length - 1]);
-        }
-      },
-    };
   }
 
   /**
@@ -70,7 +55,7 @@ class Logger {
       }
     }
     logs = chalk.blue(`> ${logs}`);
-    this.dataStorage.putData(logs);
+    this.#dataStorage.putData(logs);
   }
 
   /**
@@ -79,11 +64,11 @@ class Logger {
    * @returns
    */
   getLogs(context) {
-    const logs = this.dataStorage.getData(context);
+    const logs = this.#dataStorage.getData(context);
     return logs || '';
   }
 
-  _stringifyLogs(...args) {
+  #stringifyLogs(...args) {
     const logs = [];
     // stringify everything except strings
     for (const arg of args) {
@@ -108,22 +93,13 @@ class Logger {
 
   /**
    * Tagget template literal. Allows to use different syntaxes:
-   * 1. Tagget template: $`text ${someVar}`
-   * 2. Standard: $(`text ${someVar}`)
-   * 3. Standard with multiple arguments: $('text', someVar)
+   * 1. Tagget template: log`text ${someVar}`
+   * 2. Standard: log(`text ${someVar}`)
+   * 3. Standard with multiple arguments: log('text', someVar)
    */
-  _log(strings, ...args) {
-    // entity which is used to define testId
-    let context = null;
-    // last argument could contain testId
-    const testId = this._helpers.parseLastArgToGetTestId(...args);
-    if (testId) {
-      // last arg is test id, do not log it
-      context = args.pop();
-    }
-
-    // filter empty strings
-    strings = strings.filter(item => item !== '');
+  templateLiteralLog(strings, ...args) {
+    if (Array.isArray(strings)) strings = strings.filter(item => item !== '').map(item => item.trim());
+    if (Array.isArray(args)) args = args.filter(item => item !== '');
 
     let logs;
     // this block means tagged template is used (syntax like $`text ${someVar}`)
@@ -137,142 +113,115 @@ class Logger {
           (args[index] !== undefined // eslint-disable-line no-nested-ternary
             ? typeof args[index] === 'string'
               ? args[index] // add arg as it is
-              : this._stringifyLogs(args[index]) // stringify arg
-            : ' '), // add space if no arg after string
+              : this.#stringifyLogs(args[index]) // stringify arg
+            : ''),
         // 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);
+      logs = this.#stringifyLogs(strings, ...args);
     }
-    this._originalUserLogger.log(logs);
-    this.dataStorage.putData(logs, context);
+    this.#originalUserLogger.log(logs);
+    this.#dataStorage.putData(logs);
   }
 
   /**
-   * This function is a wrapper for all logging methods (not to repeat the same code)
+   * This function is a wrapper for each logging methods (log, warn, error etc) (not to repeat the same code)
    * @param {*} argsArray
    * @param {*} level
    * @returns
    */
-  _logWrapper(argsArray, level) {
+  #logWrapper(argsArray, level) {
     if (!argsArray.length) return;
 
-    // entity which is used to define testId
-    let context = null;
-    // last argument could contain testId
-    const testId = this._helpers.parseLastArgToGetTestId(...argsArray);
-    if (testId) {
-      // last arg is test id, do not log it
-      context = argsArray.pop();
-    }
-
     const severity = LEVELS[level].severity;
     if (severity < LEVELS[this.logLevel]?.severity) return;
 
-    const logs = this._stringifyLogs(...argsArray);
+    const logs = this.#stringifyLogs(...argsArray);
     const colorizedLogs = chalk[LEVELS[level].color](logs);
-    this.dataStorage.putData(colorizedLogs, context);
+    this.#dataStorage.putData(colorizedLogs);
     try {
       // level.toLowerCase() represents method name (log, warn, error, etc)
-      this._originalUserLogger[level.toLowerCase()](colorizedLogs);
+      this.#originalUserLogger[level.toLowerCase()](colorizedLogs);
     } catch (e) {
       // method could be unexisting, ignore error
     }
   }
 
   assert(...args) {
-    // sometimes user invokes logger without any arguments passed
-    if (!args.length) return;
-
-    const level = 'ERROR';
-    const severity = LEVELS[level].severity;
-    if (severity < LEVELS[this.logLevel]?.severity) return;
-
-    const logs = this._stringifyLogs(...args);
-    this.dataStorage.putData(logs);
-    try {
-      this._originalUserLogger.log(`Assertion result: `, ...args);
-    } catch (e) {
-      // method could be unexisting, ignore error
-    }
+    this.#logWrapper(args, 'ERROR');
   }
 
   debug(...args) {
-    this._logWrapper(args, 'DEBUG');
+    this.#logWrapper(args, 'DEBUG');
   }
 
   error(...args) {
-    this._logWrapper(args, 'ERROR');
+    this.#logWrapper(args, 'ERROR');
   }
 
   info(...args) {
-    this._logWrapper(args, 'INFO');
+    this.#logWrapper(args, 'INFO');
   }
 
   log(...args) {
-    this._logWrapper(args, 'LOG');
+    this.#logWrapper(args, 'LOG');
   }
 
   trace(...args) {
-    this._logWrapper(args, 'TRACE');
+    this.#logWrapper(args, 'TRACE');
   }
 
   warn(...args) {
-    this._logWrapper(args, 'WARN');
+    this.#logWrapper(args, 'WARN');
   }
 
   /**
    * Intercepts user logger messages.
-   * When call this method, Logger start to control the user logger,
-   * but almost nothing is changed for user regarding the console output (like log level set by user)
-   * (until multiple loggers are intercepted,
-   * in this case only the last intercepted logger will be used as user console output).
+   * When call this method, Logger start to control the user logger
    * @param {*} userLogger
    */
   intercept(userLogger) {
-    if (!userLogger) return;
-
-    /* prevent multiple console interceptions (cause infinite loop)
+    /* prevent multiple console interceptions (cause of infinite loop)
     actual only for "console", because its used as default output and is intercepted by default */
     const isUserLoggerConsole = userLogger.toString?.().toLowerCase() === '[object console]';
     if (isUserLoggerConsole && process.env.TESTOMATIO_LOGGER_CONSOLE_INTERCEPTED) {
       debug(`Try to intercept console, but it is already intercepted`);
       return;
     }
-    // prevent other loggers multiple interceptions
-    if (_.isEqual(userLogger, this._originalUserLogger)) {
-      debug(`Try to intercept user logger, but it is already intercepted`);
-      return;
-    }
 
     process.env.TESTOMATIO_LOGGER_CONSOLE_INTERCEPTED = 'true';
     debug(isUserLoggerConsole ? 'console intercepted' : 'User logger intercepted');
 
-    /* logs could be intercepted for playwright only if console provides output, thus adding this exception.
-    it means default _originalUserLogger (console by default) will be used to provide output
-    (for other frameworks user logger will be passed for output) */
-    if (this.dataStorage.runningEnvironment !== 'playwright') {
-      // save original user logger to use it for logging (last intercepted will be used for console output)
-      //! TODO: temporary don't oeverride user logger to prevent recursion; console will be used for output
-      // this._originalUserLogger = { ...userLogger };
-    }
-    this._loggerToIntercept = userLogger;
-
-    /* 
-    override user logger (any, e.g. console) methods to intercept log messages
-    this._loggerToIntercept = this; could be used, but decided to override only output methods
-    */
+    // override user logger (any, e.g. console) methods to intercept log messages
     for (const method of LOG_METHODS) {
       /*
-      decided to comment next code line because its better to create method even if it does not exist in user logger;
+      its better to create method even if it does not exist in user logger;
       on method invocation, we will store the data anyway and catch block will prevent potential errors
+      while trying to output the message to terminal
       */
       // if (!this._loggerToIntercept[method]) continue;
-      this._loggerToIntercept[method] = (...args) => this[method](...args);
+      userLogger[method] = (...args) => this[method](...args);
     }
+
+    /* Playwright
+    Playwright intercepts console messages by default. Thus when we intercept any logger and provide output by console,
+    messages are intercepted by Playwright.
+    */
+
+    /*
+    Initial idea was to intercept any logger (tracer, pino, etc),
+    intercept message and provide output by the same logger.
+    But reality brings some problems: the same messages are intercepted multiple times
+    (because of multiple loggers are created at the same terminal process).
+    Also its difficult to understand (actually did not find the way to do it) if logger was already intercepted or not.
+    Thus, decided to intercept only console by default and provide output by default console.
+    It means, if user uses his own logger, its messages will be intercepted,
+    but the output will be provided by console.
+    TODO: try to implement the providing output to terminal by user logger
+    */
   }
 
   /**
@@ -285,17 +234,57 @@ class Logger {
    */
   configure(config = {}) {
     if (!config) return;
-    if (config.prettyObjects) this.prettyObjects = config.prettyObjects;
+    if (config.prettyObjects === false || config.prettyObjects === true) this.prettyObjects = config.prettyObjects;
     if (config.logLevel) this.logLevel = config.logLevel.toUpperCase();
   }
 }
 
 Logger.instance = null;
 
-// module.exports.Logger = Logger;
 const logger = new Logger();
 
 module.exports = logger;
 
 // TODO: parse passed arguments as {level: 'str', message: 'str'} because some loggers use such syntax;
 // upd: did not face such loggers, but still could be useful
+
+/* Cypress
+There is no listener like "after:test" in cypress, only "after:spec" is available.
+Thus, cannot separate logs even when I gather them (because I don't know when the test is done, just know about suite).
+Also there is no easy way to access the message from cy.log() function.
+(Using testomatio logger – logger.log() is not convenient because Cypress chains its commands,
+thus such command will interrupt the chain.)
+
+(Could not implement intercepting of cy.log('message'));
+I found the only ability to get any logs using .task('log', 'message') (this is custom, not default cypress command)
+and then intercept it with:
+  on('task', {
+    log (message) {
+      console.log(message)
+      return null
+    }
+  })
+
+but:
+1) it does not solve problem with getting current running testId;
+2) leads to warning "Warning: Multiple attempts to register the following task(s):".)
+
+My way to get test id:
+add cypress command to save test title to file)):
+  Cypress.Commands.add('writeTestTitleToFile', () => {
+    const testTitle = cy.state('runnable').title;
+    cy.writeFile('testomatio_test_title', testTitle);
+  });
+
+Finally, in the test it will look like:
+    cy
+      .writeTestTitleToFile() // <<<
+      .task('log', 'This is a log message from the test') // <<<
+
+      .get('element)
+      .type('text')
+      .click()
+
+
+Parallelization in Cypress is only available if using Cypress Dashboard??
+*/

package/lib/utils/pipe_utils.js

@@ -0,0 +1,135 @@
+const { resetConfig } = require('../fileUploader');
+const { APP_PREFIX } = require('../constants');
+
+/**
+ * Set S3 credentials from the provided artifacts object.
+ * @param {Object} artifacts - The artifacts object containing S3 credentials.
+ */
+function setS3Credentials(artifacts) {
+    if (!Object.keys(artifacts).length) return;
+
+    console.log(APP_PREFIX, 'S3 were credentials obtained from Testomat.io...');
+
+    if (artifacts.ACCESS_KEY_ID) process.env.S3_ACCESS_KEY_ID = artifacts.ACCESS_KEY_ID;
+    if (artifacts.SECRET_ACCESS_KEY) process.env.S3_SECRET_ACCESS_KEY = artifacts.SECRET_ACCESS_KEY;
+    if (artifacts.REGION) process.env.S3_REGION = artifacts.REGION;
+    if (artifacts.BUCKET) process.env.S3_BUCKET = artifacts.BUCKET;
+    if (artifacts.ENDPOINT) process.env.S3_ENDPOINT = artifacts.ENDPOINT;
+    if (artifacts.presign) process.env.TESTOMATIO_PRIVATE_ARTIFACTS = '1';
+    resetConfig();
+}
+/**
+ * Generates mode request parameters based on the input params.
+ * @param {Object} params - The input parameters for the request.
+ * @param {string} params.type - The type of the request (e.g., "tag").
+ * @param {string} params.id - The ID associated with the request.
+ * @param {string} params.apiKey - The API key for authentication.
+ * @returns {Object|null} - An object containing the generated request parameters, or null if the type is invalid.
+ */
+function generateFilterRequestParams(params) {
+    const { type, id, apiKey } = params;
+
+    if (!type) {
+        return;
+    }
+
+    if (!id) {
+        console.error(APP_PREFIX, `Please make sure your settings "${type.toUpperCase()}"= "${id}" is correct!`);
+        return;
+    }
+
+    return {
+        params: {
+            type,
+            id: encodeURIComponent(id),
+            api_key: apiKey
+        },
+        responseType: "json"
+    }
+}
+
+/**
+ * Parse filter parameters from a string in the format "type=id".
+ * @param {string} opts - The input string containing the filter parameters.
+ * @returns {Object} An object containing the parsed filter parameters.
+ *                   The object has properties "type" and "id".
+ */
+function parseFilterParams(opts) {
+    const [type, id] = opts.split("=");
+    const validType = updateFilterType(type);
+
+    return {
+        type: validType,
+        id
+    };
+}
+
+/**
+ * Update and validate the filter type.
+ * @param {string} type - The original filter type.
+ * @returns {string|undefined} The updated and validated filter type.
+ *                            Returns undefined if the type is not valid.
+ */
+function updateFilterType(type) {
+    const typeLowerCase = type.toLowerCase();
+
+    const filterTypes = [
+        "tag-name",
+        "plan-id",
+        "label",
+        "jira-ticket",
+    ];
+
+    const filterApi = [
+        "tag",
+        "plan",
+        "label",
+        "jira",
+        // "ims-issue", //TODO: WIP
+    ];
+
+    if (!filterTypes.includes(typeLowerCase)) {
+        console.log(APP_PREFIX, `❗❗❗ Invalid "filter=${type}" start settings! Available option list: ${filterTypes}`);
+        return;
+    }
+
+    const index = filterTypes.indexOf(typeLowerCase);
+
+    return (index !== -1)
+        ? filterApi[index]
+        : undefined
+}
+
+/**
+ * Return an emoji based on the provided status.
+ * @param {string} status - The status value ('passed', 'failed', or 'skipped').
+ * @returns {string} - An emoji corresponding to the provided status.
+ */
+function statusEmoji(status) {
+    if (status === 'passed') return '🟢';
+    if (status === 'failed') return '🔴';
+    if (status === 'skipped') return '🟡';
+    return '';
+}
+
+/**
+ * Generate a full name string based on the provided test object.
+ * @param {object} t - The test object.
+ * @returns {string} - A formatted full name string for the test object.
+ */
+function fullName(t) {
+    let line = '';
+    if (t.suite_title) line = `${t.suite_title}: `;
+    line += `**${t.title}**`;
+    if (t.example) line += ` \`[${Object.values(t.example)}]\``;
+    return line;
+}
+
+module.exports = {
+    updateFilterType,
+    parseFilterParams,
+    generateFilterRequestParams,
+    setS3Credentials,
+    statusEmoji,
+    fullName
+};

package/lib/{util.js → utils/utils.js}

@@ -12,9 +12,9 @@ const debug = require('debug')('@testomatio/reporter:util');
  */
 const parseTest = testTitle => {
   if (!testTitle) return null;
-  
+
   const captures = testTitle.match(/@T([\w\d]+)/);
-  
+
   if (captures) {
     return captures[1];
   }
@@ -55,11 +55,21 @@ const isValidUrl = s => {
   }
 };
 
+const fileMatchRegex = /file:(\/\/?[^:\s]+?\.(png|avi|webm|jpg|html|txt))/ig;
+
 const fetchFilesFromStackTrace = (stack = '') => {
-  const files = stack.matchAll(/file:?\/(\/.*?\.(png|avi|webm|jpg|html|txt))/g);
-  return Array.from(files)
-    .map(f => f[1])
-    .filter(f => fs.existsSync(f));
+
+  const files = Array.from(stack.matchAll(fileMatchRegex))
+  .map(f => f[1].trim())
+  .map(f => f.startsWith('//') ? f.substring(1) : f )
+  
+  debug('Found files in stack trace: ', files);
+
+  return files.filter(f => {
+      const isFile = fs.existsSync(f);
+      if (!isFile) debug('File %s could not be found and uploaded as artifact', f);
+      return isFile;
+    });
 };
 
 const fetchSourceCodeFromStackTrace = (stack = '') => {
@@ -87,13 +97,38 @@ const fetchSourceCodeFromStackTrace = (stack = '') => {
 
   if (!source) return '';
 
-  return source.split('\n')
+  return source
+    .split('\n')
     .map((l, i) => {
       if (i === prepend) return `${line} > ${chalk.bold(l)}`;
-      return `${line - prepend + i} | ${l}`
-    }).join('\n');
+      return `${line - prepend + i} | ${l}`;
+    })
+    .join('\n');
 };
 
+const TEST_ID_REGEX = /@T([\w\d]{8})/;
+
+const fetchIdFromCode = (code, opts = {}) => {
+  const comments = code.split('\n').map(l => l.trim()).filter(l => {
+    switch (opts.lang) {
+      case 'ruby':
+      case 'python':
+        return l.startsWith('# ');
+      default:
+        return l.startsWith('// ');
+    }
+  });
+
+  return comments.find(c => c.match(TEST_ID_REGEX))?.match(TEST_ID_REGEX)?.[1];
+}
+
+
+const fetchIdFromOutput = (output) => {
+  const lines = output.split('\n').map(l => l.trim()).filter(l => l.startsWith('tid://'));
+
+  return lines.find(c => c.match(TEST_ID_REGEX))?.match(TEST_ID_REGEX)?.[1];
+}
+
 const fetchSourceCode = (contents, opts = {}) => {
   if (!opts.title && !opts.line) return '';
 
@@ -115,7 +150,7 @@ const fetchSourceCode = (contents, opts = {}) => {
 
   if (lineIndex) {
     const result = [];
-    for (let i = lineIndex; i < (lineIndex + limit); i++) {
+    for (let i = lineIndex; i < lineIndex + limit; i++) {
       if (lines[i] === undefined) continue;
 
       if (i > lineIndex + 2 && !opts.prepend) {
@@ -189,19 +224,101 @@ const fileSystem = {
     } else {
       debug(`Trying to delete ${dirPath} but it doesn't exist`);
     }
-  }
+  },
+};
+
+
+const foundedTestLog = (app, tests) => {
+  const n = tests.length;
+
+  return (n === 1)
+    ? console.log(app, `✅ We found one test!`)
+    : console.log(app, `✅ We found ${n} tests!`);
+}
+
+const humanize = text => {
+  text = decamelize(text);
+  return text
+    .replace(/_./g, match => ` ${match.charAt(1).toUpperCase()}`)
+    .trim()
+    .replace(/^(.)|\s(.)/g, $1 => $1.toUpperCase())
+    .trim()
+    .replace(/\sA\s/g, ' a ') // replace a|the
+    .replace(/\sThe\s/g, ' the ') // replace a|the
+    .replace(/^Test\s/, '')
+    .replace(/^Should\s/, '');
+};
+
+/**
+ * From https://github.com/sindresorhus/decamelize/blob/main/index.js
+ * @param {*} text
+ * @returns
+ */
+const decamelize = text => {
+  const separator = '_';
+  const replacement = `$1${separator}$2`;
+
+  // Split lowercase sequences followed by uppercase character.
+  // `dataForUSACounties` → `data_For_USACounties`
+  // `myURLstring → `my_URLstring`
+  let decamelized = text.replace(/([\p{Lowercase_Letter}\d])(\p{Uppercase_Letter})/gu, replacement);
+
+  // Lowercase all single uppercase characters. As we
+  // want to preserve uppercase sequences, we cannot
+  // simply lowercase the separated string at the end.
+  // `data_For_USACounties` → `data_for_USACounties`
+  decamelized = decamelized.replace(
+    /((?<![\p{Uppercase_Letter}\d])[\p{Uppercase_Letter}\d](?![\p{Uppercase_Letter}\d]))/gu,
+    $0 => $0.toLowerCase(),
+  );
+
+  // Remaining uppercase sequences will be separated from lowercase sequences.
+  // `data_For_USACounties` → `data_for_USA_counties`
+  return decamelized.replace(
+    /(\p{Uppercase_Letter}+)(\p{Uppercase_Letter}\p{Lowercase_Letter}+)/gu,
+    (_, $1, $2) => $1 + separator + $2.toLowerCase(),
+  );
+};
+
+/**
+ * Used to remove color codes
+ * @param {*} input
+ * @returns
+ */
+function removeColorCodes(input) {
+  // eslint-disable-next-line no-control-regex
+  return input.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+const jestHelpers = {
+  getIdOfCurrentlyRunningTest: () => {
+    if (!process.env.JEST_WORKER_ID) return null;
+    try {
+      // @ts-expect-error "expect" could only be defined inside Jest environement (forbidden to import it outside)
+      // eslint-disable-next-line no-undef
+      if (expect && expect?.getState()?.currentTestName) return parseTest(expect?.getState()?.currentTestName);
+    } catch (e) {
+      return null;
+    }
+  },
 };
 
 module.exports = {
   isSameTest,
   fetchSourceCode,
   fetchSourceCodeFromStackTrace,
+  fetchIdFromCode,
+  fetchIdFromOutput,
   fetchFilesFromStackTrace,
   fileSystem,
   getCurrentDateTime,
+  jestHelpers,
   specificTestInfo,
   isValidUrl,
   ansiRegExp,
   parseTest,
   parseSuite,
-};
+  humanize,
+  removeColorCodes,
+  foundedTestLog
+};