@testomatio/reporter 1.0.11 → 1.0.12

package/lib/artifactStorage.js

@@ -2,8 +2,8 @@
 const { DataStorage } = require('./dataStorage');
 
 class ArtifactStorage {
-  constructor(params = {}) {
-    this.dataStorage = new DataStorage('artifact', params);
+  constructor() {
+    this.dataStorage = new DataStorage('artifact');
 
     // singleton
     if (!ArtifactStorage.instance) {

package/lib/dataStorage.js

@@ -13,21 +13,15 @@ class DataStorage {
    * Creates data storage instance for specific data type.
    * Stores data to global variable or to file depending on what is applicable for current test runner
    * (running environment).
-   * dataType: 'log' | 'artifact' | ...
    * @param {*} dataType storage type (like 'log', 'artifact'); could be any string, used only to define file path
    */
   constructor(dataType) {
-    // if (!dataType) throw new Error('Data type is required when creating data storage');
     this.dataType = dataType || 'data';
-    this.dataDirName = this.dataType;
     this.isFileStorage = true;
-    this._refreshStorageType();
+    this.#refreshStorageType();
 
-    // dir is created in any case (not to recheck its existence every time)
-    this.dataDirPath = path.join(TESTOMAT_TMP_STORAGE.mainDir, this.dataDirName);
+    this.dataDirPath = path.join(TESTOMAT_TMP_STORAGE.mainDir, this.dataType);
     fileSystem.createDir(this.dataDirPath);
-
-    debug(`Data storage mode: ${this.isFileStorage ? 'file' : 'memory'}`);
   }
 
   /**
@@ -38,18 +32,14 @@ class DataStorage {
     // jest
     if (process.env.JEST_WORKER_ID) return 'jest';
 
-    // codeceptjs
-    // @ts-expect-error codeceptjs is defined only in codeceptjs environment
     if (global.codeceptjs) return 'codeceptjs';
 
-    // others
     // 'cucumber:current', 'cucumber:legacy'
     if (global.testomatioRunningEnvironment) return global.testomatioRunningEnvironment;
 
-    if (process.env.PLAYWRIGHT_TEST_BASE_URL) return 'playwright';
+    if (process.env.PLAYWRIGHT_TEST_BASE_URL || process.env.TEST_WORKER_INDEX) return 'playwright';
 
     // mocha - can't detect
-
     return null;
   }
 
@@ -60,18 +50,19 @@ class DataStorage {
    * @returns
    */
   putData(data, context = null) {
-    this._refreshStorageType();
+    this.#refreshStorageType();
 
-    let testId = this._tryToRetrieveTestId(context) || null;
+    let testId = this.#tryToRetrieveTestId(context) || null;
 
     if (this.runningEnvironment === 'codeceptjs') {
       this.isFileStorage = false;
       testId = testId ?? global.testomatioDataStore?.currentlyRunningTestId;
     }
+
     if (this.runningEnvironment === 'jest') {
       testId = testId ?? JestReporter.getIdOfCurrentlyRunningTest();
-      this.isFileStorage = true;
     }
+
     // logs in playwright are gathered by pw framework itself
     if (this.runningEnvironment === 'playwright' && this.dataType === 'log') return;
 
@@ -80,18 +71,17 @@ class DataStorage {
       testId = testId ?? global.testomatioDataStore?.currentlyRunningTestId;
 
     if (!testId && global?.currentlyRunningTestTitle)
-      testId = this._tryToRetrieveTestId(global.currentlyRunningTestTitle);
+      testId = this.#tryToRetrieveTestId(global.currentlyRunningTestTitle);
 
-    // if testId is not provided, data is be saved to `{dataType}_other` file;
     if (!testId) {
       debug(`No test id provided for ${this.dataType} data: ${data}`);
       return;
     }
 
     if (this.isFileStorage) {
-      this._putDataToFile(data, testId);
+      this.#putDataToFile(data, testId);
     } else {
-      this._putDataToGlobalVar(data, testId);
+      this.#putDataToGlobalVar(data, testId);
     }
   }
 
@@ -105,25 +95,25 @@ class DataStorage {
    * @returns
    */
   getData(context) {
-    this._refreshStorageType();
+    this.#refreshStorageType();
 
     let testId = null;
     if (typeof context === 'string') {
-      testId = context;
+      testId = this.#tryToRetrieveTestId(context) || context;
     } else {
       // TODO: derive testId from context
       // testId = context...
     }
 
     if (!testId) {
-      debug(`Cannot get test id from passed context:\n}`, context);
+      debug(`Cannot get test id from passed context:`, context);
       return null;
     }
 
     let testData = '';
 
     if (global?.testomatioDataStore) {
-      testData = this._getDataFromGlobalVar(testId);
+      testData = this.#getDataFromGlobalVar(testId);
       // these frameworks use global variable storage
       if (testData && ['cucumber', 'codeceptjs'].includes(this.runningEnvironment)) return testData;
     }
@@ -132,17 +122,15 @@ class DataStorage {
     mocha has created a global storage, but just in some cases, generally it is not available
     */
     // if (this.isFileStorage || !testData) {
-    //   testData = this._getDataFromFile(testId);
+    //   testData = this.#getDataFromFile(testId);
     //   if (testData) return testData;
     // }
 
-    const testDataFromFile = this._getDataFromFile(testId);
+    const testDataFromFile = this.#getDataFromFile(testId);
     testData += testDataFromFile || '';
 
-    if (testData) return testData;
-
     debug(`No ${this.dataType} data for test id ${testId} in both file and global variable`);
-    return testData;
+    return testData || '';
   }
 
   /**
@@ -151,9 +139,9 @@ class DataStorage {
    * Or it could represent any other entity (which does not contain test id).
    * @param {*} context
    */
-  _tryToRetrieveTestId(context) {
+  #tryToRetrieveTestId(context) {
     if (!context) return null;
-    this._refreshStorageType();
+    this.#refreshStorageType();
 
     if (this.runningEnvironment === 'playwright' || context?.title) {
       // context is testInfo
@@ -174,28 +162,19 @@ class DataStorage {
    * This method should be run on each attempt to put or get data from/to storage
    * Because storage instance is created before the test runner is started. And storage type could be changed
    */
-  _refreshStorageType() {
-    /*
-        FYI:
-        If this storage instance is used within test runner, it works fine.
-        But if, for example, we create storage instance inside the testomatio client (to get stored data),
-        the environment could differs (not already a test runner environment).
-        Thus, checking environment is only reasonable when you put data to starage
-        (to define where to put data - to global variable or to file)
-        and potentially useless when getting data from storage
-      */
+  #refreshStorageType() {
     this.runningEnvironment = this.getRunningEnviroment();
 
     // some test frameworks do not persist global variables, thus file storage is used for them (by default)
     if (['playwright', 'codeceptjs'].includes(this.runningEnvironment)) this.isFileStorage = false;
   }
 
-  _getDataFromGlobalVar(testId) {
+  #getDataFromGlobalVar(testId) {
     try {
-      if (global?.testomatioDataStore[this.dataDirName]) {
-        const testData = global.testomatioDataStore[this.dataDirName][testId];
+      if (global?.testomatioDataStore[this.dataType]) {
+        const testData = global.testomatioDataStore[this.dataType][testId];
         debug(`Data for test id ${testId}:\n${testData}`);
-        return testData;
+        return testData || '';
       }
       debug(`No ${this.dataType} data for test id ${testId} in <global> storage`);
       return '';
@@ -204,13 +183,13 @@ class DataStorage {
     }
   }
 
-  _getDataFromFile(testId) {
+  #getDataFromFile(testId) {
     try {
       const filepath = join(this.dataDirPath, `${this.dataType}_${testId}`);
       if (fs.existsSync(filepath)) {
         const testData = fs.readFileSync(filepath, 'utf-8');
         debug(`Data for test id ${testId}:\n${testData}`);
-        return testData;
+        return testData || '';
       }
       debug(`No ${this.dataType} data for test id ${testId} in <file> storage`);
       return '';
@@ -220,18 +199,20 @@ class DataStorage {
     return '';
   }
 
-  _putDataToGlobalVar(data, testId) {
+  #putDataToGlobalVar(data, testId) {
     debug('Saving data to global variable for test', testId, ':\n', data, '\n');
-    if (!global.testomatioDataStore[this.dataDirName]) global.testomatioDataStore[this.dataDirName] = {};
-    global.testomatioDataStore[this.dataDirName][testId] // eslint-disable-line no-unused-expressions
-      ? (global.testomatioDataStore[this.dataDirName][testId] += `\n${data}`)
-      : (global.testomatioDataStore[this.dataDirName][testId] = data);
+    if (!global.testomatioDataStore) global.testomatioDataStore = {};
+    if (!global.testomatioDataStore?.[this.dataType]) global.testomatioDataStore[this.dataType] = {};
+    global.testomatioDataStore?.[this.dataType][testId] // eslint-disable-line no-unused-expressions
+      ? (global.testomatioDataStore[this.dataType][testId] += `\n${data}`)
+      : (global.testomatioDataStore[this.dataType][testId] = data);
   }
 
-  _putDataToFile(data, testId) {
+  #putDataToFile(data, testId) {
     if (typeof data !== 'string') data = JSON.stringify(data);
     const filename = `${this.dataType}_${testId}`;
     const filepath = join(this.dataDirPath, filename);
+    if (!fs.existsSync(this.dataDirPath)) fileSystem.createDir(this.dataDirPath);
     debug('Saving data to file for test', testId, 'to', filepath, ':\n', data, '\n');
 
     // TODO: handle multiple invocations of JSON.stringify.
@@ -249,7 +230,3 @@ module.exports.DataStorage = DataStorage;
 // TODO: try to define adapter inside client
 // TODO: use .env
 // TODO: ability to intercept multiple loggers (upd: no need)
-
-/* Cypress
-Parallelization is only available if using Cypress Dashboard??
-*/

package/lib/logger.js

@@ -1,6 +1,5 @@
 const chalk = require('chalk');
 const debug = require('debug')('@testomatio/reporter:logger');
-const _ = require('lodash');
 const { DataStorage } = require('./dataStorage');
 
 const LOG_METHODS = ['assert', 'debug', 'error', 'info', 'log', 'trace', 'warn'];
@@ -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);
 
@@ -43,22 +39,11 @@ class Logger {
       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]);
-        }
-      },
-    };
-
     // add beforeEach hook for mocha. it does not override existing hook, just add new one
     try {
       // @ts-ignore
       if (!beforeEach) return;
-      // @ts-ignore
+      // @ts-ignore-next-line
       beforeEach(function () {
         if (this.currentTest?.__mocha_id__) {
           global.testTitle = this.currentTest.fullTitle();
@@ -76,6 +61,9 @@ class Logger {
    * @param  {...any} values
    */
   step(strings, ...values) {
+    // get testId for mocha
+    const context = global.testTitle ?? null;
+
     let logs = '';
     for (let i = 0; i < strings.length; i++) {
       logs += strings[i];
@@ -84,7 +72,7 @@ class Logger {
       }
     }
     logs = chalk.blue(`> ${logs}`);
-    this.dataStorage.putData(logs);
+    this.#dataStorage.putData(logs, context);
   }
 
   /**
@@ -93,11 +81,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) {
@@ -122,27 +110,19 @@ 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) {
+  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 !== '');
     // entity which is used to define testId
     let context = null;
 
     // get testId for mocha
     context = global.testTitle ?? 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 !== '');
-
     let logs;
     // this block means tagged template is used (syntax like $`text ${someVar}`)
     if (Array.isArray(strings) && strings.length === args.length + 1) {
@@ -155,18 +135,18 @@ 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, context);
   }
 
   /**
@@ -175,7 +155,7 @@ class Logger {
    * @param {*} level
    * @returns
    */
-  _logWrapper(argsArray, level) {
+  #logWrapper(argsArray, level) {
     if (!argsArray.length) return;
 
     // entity which is used to define testId
@@ -184,117 +164,92 @@ class Logger {
     // get context for mocha
     context = global.testTitle ?? 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, context);
     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
+    */
   }
 
   /**
@@ -307,7 +262,7 @@ 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();
   }
 }
@@ -358,4 +313,7 @@ Finally, in the test it will look like:
       .get('element)
       .type('text')
       .click()
+
+
+Parallelization in Cypress is only available if using Cypress Dashboard??
 */

package/lib/reporter.js

@@ -3,11 +3,12 @@ const TestomatClient = require('./client');
 const TRConstants = require('./constants');
 const TRArtifacts = require('./_ArtifactStorageOld');
 
-const log = logger._log.bind(logger);
+const log = logger.templateLiteralLog.bind(logger);
 const step = logger.step.bind(logger);
 
 module.exports = {
   logger,
+  testomatioLogger: logger,
   log,
   step,
   TestomatClient,

package/lib/util.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];
   }
@@ -87,11 +87,13 @@ 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 fetchSourceCode = (contents, opts = {}) => {
@@ -115,7 +117,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,54 +191,63 @@ const fileSystem = {
     } else {
       debug(`Trying to delete ${dirPath} but it doesn't exist`);
     }
-  }
+  },
 };
 
-const humanize = (text) => {  
+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/, '')
-}
+  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 
+ * @param {*} text
+ * @returns
  */
-const decamelize = (text) => {
+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(),
-	);
+  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, '');
+}
+
 module.exports = {
   isSameTest,
   fetchSourceCode,
@@ -250,4 +261,5 @@ module.exports = {
   parseTest,
   parseSuite,
   humanize,
+  removeColorCodes,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testomatio/reporter",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "description": "Testomatio Reporter Client",
   "main": "./lib/reporter.js",
   "typings": "typings/index.d.ts",
@@ -25,7 +25,6 @@
     "humanize-duration": "^3.27.3",
     "is-valid-path": "^0.1.1",
     "json-cycle": "^1.3.0",
-    "lodash": "^4.17.21",
     "lodash.memoize": "^4.1.2",
     "lodash.merge": "^4.6.2",
     "uuid": "^9.0.0"
@@ -42,14 +41,14 @@
     "lint:fix": "eslint lib --fix",
     "test": "mocha tests/**",
     "init": "cd ./tests/adapter/examples/cucumber && npm i",
-    "test:unit": "mocha tests",
     "test:adapter": "mocha './tests/adapter/index.test.js'",
     "test:pipes": "mocha './tests/pipes/*_test.js'",
     "test:adapter:jest:example": "jest './tests/adapter/examples/jest/index.test.js' --config='./tests/adapter/examples/jest/jest.config.js'",
     "test:adapter:mocha:example": "mocha './tests/adapter/examples/mocha/index.test.js' --config='./tests/adapter/examples/mocha/mocha.config.js'",
     "test:adapter:jasmine:example": "./tests/adapter/examples/jasmine/passReporterOpts.sh && jasmine './tests/adapter/examples/jasmine/index.test.js' --reporter=./../../../lib/adapter/jasmine.js",
     "test:adapter:codecept:example": "codeceptjs run --config='./tests/adapter/examples/codecept/codecept.conf.js'",
-    "test:adapter:cucumber:example": "cd ./tests/adapter/examples/cucumber && npx cucumber-js"
+    "test:adapter:cucumber:example": "cd ./tests/adapter/examples/cucumber && npx cucumber-js",
+    "test:storage": "npx mocha ./tests-storage/**"
   },
   "devDependencies": {
     "@cucumber/cucumber": "^9.3.0",
@@ -66,6 +65,7 @@
     "jest": "^27.4.7",
     "mocha": "^9.2.0",
     "mock-http-server": "^1.4.5",
+    "pino": "^8.15.0",
     "prettier": "2.5.1",
     "puppeteer": "^13.1.2"
   },