@testomatio/reporter 1.0.0 → 1.2.0-beta

package/README.md

@@ -16,7 +16,8 @@ Testomat.io Reporter (this npm package) supports:
 * 🚅 Realtime reports
 * 🗃️ Other test frameworks supported via [JUNit XML](./docs/junit.md)
 * 🚶‍♀️ Steps *(work in progress)*
-* ☁️  Custom properties and metadata *(work in progress)*
+* 📄 Logger *(work in progress, supports Jest for now)*
+* ☁️ Custom properties and metadata *(work in progress)*
 * 💯 Free & open-source.
 * 📊 Public and private Run reports on cloud via [Testomat.io App](https://testomat.io) 👇
 
@@ -64,7 +65,7 @@ yarn add @testomatio/reporter --dev
 
 ### 1️⃣ Attach Reporter to the Test Runner
 
-* ####  [Playwright](./docs/frameworks.md#playwright)
+* #### [Playwright](./docs/frameworks.md#playwright)
 * #### [CodeceptJS](./docs/frameworks.md#CodeceptJS)
 * #### [Cypress](./docs/frameworks.md#Cypress)
 * #### [Jest](./docs/frameworks.md#Jest)
@@ -99,7 +100,11 @@ GitHub report published as a comment to Pull Request:
 1. Create bucket on AWS, Google Cloud, or any other cloud storage provider supporting S3 protocol. 
 2. [Pass S3 credentials](./docs/artifacts.md) to reporter to enable artifacts uploading.
 
-### 4️⃣ Add to CI Pipeline
+### 4️⃣ Use Logger
+
+Intercept your logger messages or log anything with our [Logger](./docs/logger.md) (_work in progress_).
+
+### 5️⃣ Add to CI Pipeline
 
 After you tested reporter locally add it to your CI pipeline.
 
@@ -119,6 +124,7 @@ Bring this reporter on CI and never lose test results again!
 * 📓 [JUnit](./docs/junit.md)
 * 🗄️ [Artifacts](./docs/artifacts.md)
 * 🔂 [Workflows](./docs/workflows.md)
+* 🔂 [Logger](./docs/logger.md)
 
 ## Development
 

package/lib/{ArtifactStorage.js → _ArtifactStorageOld.js}

@@ -7,24 +7,29 @@ const { TESTOMAT_ARTIFACT_SUFFIX } = require('./constants');
 const { specificTestInfo } = require('./util');
 
 class ArtifactStorage {
-
+  
   constructor(params) {
-    this._tmpPrefix = "tsmt_reporter";
     this.isFile = false;
     this.isMemory = true;
     this.storage = params?.toFile;
 
     if (this.storage) {
+      // this is fine to use when you start saving artifacts;
+      // but when you need to retrieve them, you will not know if there is "isFile" param,
+      // because you need to create a new instance of ArtifactStorage inside client
+      // so the solution is make it opposite to isMemory (which will be retrieved from global)
       this.isFile = true;
       this.isMemory = false;
-      this.tmpDirFullpath = this.createTestomatTmpDir(this._tmpPrefix);
+      this.tmpDirFullpath = this.createTestomatTmpDir(ArtifactStorage._tmpPrefix);
       debug('SAVE to tmp folder mode enabled!');
     }
   }
 
   static async storeToFile(tmpDirName, artifact, testSuffix = "test") {
+    // this assumes to use multiple files for each test. do we really want this?
     const suffix = TESTOMAT_ARTIFACT_SUFFIX + uuid.v4() + testSuffix;
     const dirpath = join(os.tmpdir(), tmpDirName);
+    // why json?
     const filepath = resolve(dirpath, `${suffix}.json`);
 
     return fs.promises.appendFile(filepath, JSON.stringify(artifact));
@@ -34,6 +39,7 @@ class ArtifactStorage {
     // TODO: mode for different pre-hooks. As variant - "all-tests" || "only_fail"
     // const mode = process.env.TESTOMAT_ARTIFACTS || "only_fail";
 
+    // you save the artifact without specifying its source - test id
     if (Array.isArray(global.testomatioArtifacts)) {
       debug("Saving artifacts to global storage");
 
@@ -71,6 +77,7 @@ class ArtifactStorage {
     return list;
   }
 
+  // returns all the content from all files; do we really need it?
   async tmpContents() {
     const contents = [];
 
@@ -103,8 +110,9 @@ class ArtifactStorage {
     }
   }
 
+  // no need to use multiple dirs; we can implement it later if required
   static tmpTestomatDirNames() {
-    const subname = this._tmpPrefix || "tsmt_reporter";
+    const subname = ArtifactStorage._tmpPrefix || "tsmt_reporter";
 
     return fs.readdirSync(os.tmpdir(), { withFileTypes: true })
       .filter((item) => item.isDirectory())
@@ -113,6 +121,7 @@ class ArtifactStorage {
   }
 
   cleanup() {
+    // when you do a cleanup, I know nothing about isFile param
     if (this.isFile && this.tmpDirFullpath) {
       const tmpDirNames = ArtifactStorage.tmpTestomatDirNames();
 
@@ -128,4 +137,6 @@ class ArtifactStorage {
   }
 }
 
+ArtifactStorage._tmpPrefix = "tsmt_reporter";
+
 module.exports = ArtifactStorage;

package/lib/adapter/jest.js

@@ -1,6 +1,6 @@
 const TestomatClient = require('../client');
-const { STATUS } = require('../constants');
-const { parseTest, ansiRegExp } = require('../util');
+const { STATUS, TESTOMAT_TMP_STORAGE } = require('../constants');
+const { parseTest, ansiRegExp, fileSystem } = require('../util');
 
 class JestReporter {
   constructor(globalConfig, options) {
@@ -11,6 +11,16 @@ class JestReporter {
     this.client.createRun();
   }
 
+  static getIdOfCurrentlyRunningTest() {
+    // @ts-expect-error "expect" could only be defined inside Jest environement (forbidden to import it outside)
+    return parseTest(expect?.getState()?.currentTestName) || null; // eslint-disable-line
+  }
+
+  onRunStart() {
+    // clear tmp dir
+    fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
+  }
+
   onTestResult(test, testResult) {
     if (!this.client) return;
 
@@ -47,6 +57,9 @@ class JestReporter {
     const { numFailedTests } = results;
     const status = numFailedTests === 0 ? STATUS.PASSED : STATUS.FAILED;
     this.client.updateRunStatus(status);
+
+    // clear tmp dir
+    fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
   }
 }
 

package/lib/adapter/mocha.js

@@ -5,7 +5,7 @@ const chalk = require('chalk');
 const TestomatClient = require('../client');
 const { STATUS } = require('../constants');
 const { parseTest, specificTestInfo } = require('../util');
-const ArtifactStorage = require('../ArtifactStorage');
+const ArtifactStorage = require('../_ArtifactStorageOld');
 
 const { EVENT_RUN_BEGIN, EVENT_RUN_END, EVENT_TEST_FAIL, EVENT_TEST_PASS, EVENT_TEST_PENDING } = Mocha.Runner.constants;
 

package/lib/artifactStorage.js

@@ -0,0 +1,25 @@
+// const debug = require('debug')('@testomatio/reporter:logger');
+const { DataStorage } = require('./dataStorage');
+
+class ArtifactStorage {
+  constructor(params = {}) {
+    this.dataStorage = new DataStorage('artifact', params);
+
+    // singleton
+    if (!ArtifactStorage.instance) {
+      ArtifactStorage.instance = this;
+    }
+  }
+
+  save(data, context = null) {
+    this.dataStorage.putData(data, context);
+  }
+
+  get(context) {
+    this.dataStorage.getData(context);
+  }
+}
+
+ArtifactStorage.instance = null;
+
+module.exports = new ArtifactStorage();

package/lib/client.js

@@ -7,6 +7,7 @@ const { randomUUID } = require('crypto');
 const upload = require('./fileUploader');
 const { APP_PREFIX } = require('./constants');
 const pipesFactory = require('./pipe');
+const logger = require('./logger');
 
 /**
  * @typedef {import('../types').TestData} TestData
@@ -47,6 +48,7 @@ class Client {
     };
 
     global.testomatioArtifacts = [];
+    // TODO: create global storage
 
     this.queue = this.queue
       .then(() => Promise.all(this.pipes.map(p => p.createRun(runParams))))
@@ -58,7 +60,7 @@ class Client {
 
   /**
    * Updates test status and its data
-   * 
+   *
    * @param {string|undefined} status
    * @param {TestData} [testData]
    * @param {string[]} [storeArtifacts]
@@ -68,10 +70,11 @@ class Client {
     // all pipes disabled, skipping
     if (!this.pipes.filter(p => p.isEnabled).length) return;
 
-    if (!testData) testData = {
-      title: 'Unknown test',
-      suite_title: 'Unknown suite',
-    }
+    if (!testData)
+      testData = {
+        title: 'Unknown test',
+        suite_title: 'Unknown suite',
+      };
 
     const {
       error = null,
@@ -100,13 +103,17 @@ class Client {
       stack = this.formatSteps(stack, steps);
     }
 
+    const testLogs = logger.getLogs(test_id);
+    debug(`Test logs for ${test_id}:\n`, testLogs);
+    stack += testLogs;
+
     if (Array.isArray(storeArtifacts) && storeArtifacts.length) {
-      debug("CLIENT storeArtifact", storeArtifacts);
+      debug('CLIENT storeArtifact', storeArtifacts);
       files.push(...storeArtifacts);
     }
 
     if (Array.isArray(global.testomatioArtifacts)) {
-      debug("CLIENT global[testomatioArtifacts]", global.testomatioArtifacts);
+      debug('CLIENT global[testomatioArtifacts]', global.testomatioArtifacts);
       files.push(...global.testomatioArtifacts);
       global.testomatioArtifacts = [];
     }
@@ -172,8 +179,8 @@ class Client {
     this.queue = this.queue
       .then(() => Promise.all(this.pipes.map(p => p.finishRun(runParams))))
       .then(() => {
-        debug("TOTAL uploaded files", this.totalUploaded);
-        
+        debug('TOTAL uploaded files', this.totalUploaded);
+
         if (upload.isArtifactsEnabled() && this.totalUploaded > 0) {
           console.log(
             APP_PREFIX,

package/lib/constants.js

@@ -3,6 +3,10 @@ const chalk = require('chalk');
 const APP_PREFIX = chalk.gray('[TESTOMATIO]');
 const TESTOMAT_ARTIFACT_SUFFIX = "testomatio_artifact_";
 
+const TESTOMAT_TMP_STORAGE = {
+  mainDir: "testomatio_tmp",
+}
+
 const CSV_HEADERS = [
   { id: 'suite_title', title: 'Suite_title' },
   { id: 'title', title: 'Title' },
@@ -21,6 +25,7 @@ const STATUS = {
 module.exports = {
   APP_PREFIX,
   TESTOMAT_ARTIFACT_SUFFIX,
+  TESTOMAT_TMP_STORAGE,
   CSV_HEADERS,
   STATUS,
 }

package/lib/dataStorage.js

@@ -0,0 +1,172 @@
+const debug = require('debug')('@testomatio/reporter:storage');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { join } = require('path');
+const JestReporter = require('./adapter/jest');
+const { TESTOMAT_TMP_STORAGE } = require('./constants');
+const { fileSystem } = require('./util');
+
+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.
+   * dataType: 'log' | 'artifact' | ...
+   * @param {*} dataType storage type (like 'log', 'artifact'); could be any string, used only to define file path
+   * @param {*} params
+   */
+  constructor(dataType, params = {}) {
+    if (!dataType) throw new Error('Data type is required when creating data storage');
+    this.dataType = dataType || 'data';
+    this.dataDirName = `${dataType}s`;
+    this.isFileStorage = params?.isFileStorage ?? !global.testomatioDataStore;
+
+    /*
+      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 be different (not already a test runner env).
+      Thus, checking environment is only reasonable when you put data to starage 
+      and potentially useless when get data from storage
+    */
+    const runningEnvironment = this.getRunningEnviroment();
+    if (runningEnvironment === 'jest') this.isFileStorage = true;
+
+    if (this.isFileStorage) {
+      this.dataDirPath = path.join(TESTOMAT_TMP_STORAGE.mainDir, this.dataDirName);
+      fileSystem.createDir(this.dataDirPath);
+    }
+
+    debug(`Data storage mode: ${this.isFileStorage ? 'file' : 'memory'}`);
+  }
+
+  // TODO: implement
+  getTestIdFromContext(context) { // eslint-disable-line
+    // eslint-disable-line
+    // return testId;
+  }
+
+  /**
+   * Try to define the running environment. Not 100% reliable and used as additional check
+   * @returns jest | mocha | ...
+   */
+  getRunningEnviroment() {
+    if (process.env.JEST_WORKER_ID) return 'jest';
+    // @ts-expect-error mocha could be undefined, its ok
+    if (typeof mocha !== 'undefined') return 'mocha';
+    return undefined;
+  }
+
+  /**
+   * Puts any data to storage (file or global variable)
+   * @param {*} data anything you want to store
+   * @param {*} context could be testId or any context (test, suite, etc) which is used to define testId
+   * @returns
+   */
+  putData(data, context = null) {
+    let testId = null;
+    if (typeof context === 'string') {
+      testId = context;
+    } else {
+      // TODO: derive testId from context
+      // testId = context...
+    }
+
+    // try to get testId for Jest
+    testId = testId ?? JestReporter.getIdOfCurrentlyRunningTest();
+
+    // if testId is not provided, data is be saved to `{dataType}_other` file;
+    if (!testId) testId = 'other';
+
+    if (this.isFileStorage) {
+      this._putDataToFile(data, testId);
+    } else {
+      this._putDataToGlobalVar(data, testId);
+    }
+  }
+
+  /**
+   * Returns data, stored for specific testId (or data which was stored without test id specified)
+   *
+   * (Don't try to guess the execution environment (e.g. test runner) inside this method, it could be any)
+   * @param {*} context could be testId or any context (test, suite, etc) which is used to define testId
+   * @returns
+   */
+  getData(context) {
+    let testId = null;
+    if (typeof context === 'string') {
+      testId = context;
+    } else {
+      // TODO: derive testId from context
+      // testId = context...
+    }
+
+    if (!testId) testId = 'other';
+
+    if (this.isFileStorage) {
+      return this._getDataFromFile(testId);
+    }
+    if (global?.testomatioDataStore) {
+      return this._getDataFromGlobalVar(testId);
+    }
+    debug(`No ${this.dataType} data for test id ${testId} in both file and global variable`);
+    return null;
+  }
+
+  _getDataFromGlobalVar(testId) {
+    try {
+      if (global?.testomatioDataStore[this.dataDirName]) {
+        const testData = global.testomatioDataStore[this.dataDirName][testId];
+        debug(`Data for test id ${testId}:\n${testData}`);
+        return testData;
+      }
+      debug(`No ${this.dataType} data for test id ${testId}`);
+      return null;
+    } catch (e) {
+      // there could be no data, ignore
+    }
+  }
+
+  _getDataFromFile(testId) {
+    try {
+      const filepath = join(TESTOMAT_TMP_STORAGE.mainDir, `${this.dataType}_${testId}`);
+      if (fs.existsSync(filepath)) {
+        const testData = fs.readFileSync(filepath, 'utf-8');
+        debug(`Data for test id ${testId}:\n${testData}`);
+        return testData;
+      }
+      debug(`No ${this.dataType} data for test id ${testId}`);
+      return null;
+    } catch (e) {
+      // there could be no data, ignore
+    }
+    return null;
+  }
+
+  _putDataToGlobalVar(data, testId) {
+    debug('Saving data to global variable for test', testId, ':\n', data, '\n');
+    global.testomatioDataStore[this.dataDirName] = {};
+    global.testomatioDataStore[this.dataDirName][testId] = data;
+  }
+
+  _putDataToFile(data, testId) {
+    if (typeof data !== 'string') data = JSON.stringify(data);
+    const filename = `${this.dataType}_${testId}`;
+    const filepath = join(TESTOMAT_TMP_STORAGE.mainDir, filename);
+    debug('Saving data to file for test', testId, 'to', filepath, ':\n', data, '\n');
+
+    // TODO: handle multiple invocations of JSON.stringify.
+    // UPD: not actual because decided not to use it - it created extra wrapping quotes "" and // (escaped slashes)
+    fs.appendFileSync(filepath, data + os.EOL, 'utf-8');
+  }
+}
+
+module.exports.DataStorage = DataStorage;
+
+// TODO: consider using fs promises instead of writeSync/appendFileSync to
+// prevent blocking and improve performance (probably queue usage will be required)
+
+// TODO: rewrite client - everything regarding storing artifacts
+// TODO: try to define adapter inside client
+// TODO: use .env
+// TODO: ability to intercept multiple loggers

package/lib/logger.js

@@ -0,0 +1,301 @@
+const chalk = require('chalk');
+const debug = require('debug')('@testomatio/reporter:logger');
+const { DataStorage } = require('./dataStorage');
+
+const LOG_METHODS = ['assert', 'debug', 'error', 'info', 'log', 'trace', 'warn'];
+const LEVELS = {
+  ALL: { severity: 1, color: '' },
+  VERBOSE: { severity: 3, color: 'grey' },
+  TRACE: { severity: 5, color: 'grey' },
+  DEBUG: { severity: 7, color: 'cyan' },
+  INFO: { severity: 9, color: 'black' },
+  LOG: { severity: 11, color: 'black' },
+  WARN: { severity: 13, color: 'yellow' },
+  ERROR: { severity: 15, color: 'red' },
+};
+
+/**
+ * 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.
+ */
+class Logger {
+  // _originalUserLogger used to output logs to console by the user logger
+  // _loggerToIntercept intercepted and reassigned immediately when added
+
+  constructor(params = {}) {
+    // set default logger to be used in log, warn, error, etc methods
+    this._originalUserLogger = { ...console };
+
+    this.dataStorage = new DataStorage('log', params);
+    this.logLevel = process?.env?.LOG_LEVEL?.toUpperCase() || 'ALL';
+
+    // commented because prefer to use "intercept" method
+    // if (params?.logger) this._loggerToIntercept = params.logger;
+
+    this.intercept(this._loggerToIntercept);
+
+    // singleton
+    if (!Logger.instance) {
+      Logger.instance = this;
+    }
+  }
+
+  /**
+   * Returns the string (logs) and the context
+   * This is required because loggers take multiple arguments
+   * @param  {...any} args
+   */
+  /*
+    TODO: its difficult to distinguish context from log artument if its not a string,
+    e.g. user can use something like console.log('some log', { key: 'value' });
+    consider not to use this method at all and don't expect context from user inside default log methods;
+    instead, use custom method like $`some log` and parse it
+  */
+  // _getLogStringAndContextFromArgs(...args) {
+  //   let context = '';
+  //   if (args.length > 1 && typeof args[args.length - 1] !== 'string') {
+  //     context = args.pop();
+  //   }
+  //   const logs = args.join(' ');
+  //   return { logs, context };
+  // }
+
+  /**
+   * Tagget template literal. Allows to use different syntaxes:
+   * 1. Tagget template: $`text ${someVar}`
+   * 2. Standard: $(`text ${someVar}`)
+   * 3. Standard with multiple arguments: $('text', someVar)
+   */
+  _log(strings, ...args) {
+    let logs;
+    // this block means tagged template is used (syntax like $`text ${someVar}`)
+    if (Array.isArray(strings) && strings.length === args.length + 1) {
+      logs = 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 // eslint-disable-line no-nested-ternary
+            ? typeof args[index] === 'string'
+              ? args[index] // add arg as it is
+              : this._strinfifyLogs(args[index]) // stringify arg
+            : ' '), // add space if no arg after string
+        // 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._strinfifyLogs(strings, ...args);
+    }
+    this.dataStorage.putData(logs);
+  }
+
+  /**
+   * Allows you to define a step inside a test. Step name is attached to the report and
+   * helps to understand the test flow.
+   * @param {*} strings 
+   * @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 = chalk.blue(`> ${logs}`);
+    this.dataStorage.putData(logs);
+  }
+
+  /**
+   *
+   * @param {*} context testId or test context from test runner
+   * @returns
+   */
+  getLogs(context) {
+    return this.dataStorage.getData(context);
+  }
+
+  _strinfifyLogs(...args) {
+    const logs = [];
+    // stringify everything except strings
+    for (const arg of args) {
+      if (typeof arg === 'string') {
+        logs.push(arg);
+      } else {
+        try {
+          // eslint-disable-next-line no-unused-expressions
+          this.prettyObjects ? logs.push(JSON.stringify(arg, null, 2)) : logs.push(JSON.stringify(arg));
+        } catch (e) {
+          debug('Error while stringify object', e);
+          logs.push(arg);
+        }
+      }
+    }
+    return logs.join(' ');
+  }
+
+  assert(...args) {
+    const level = 'ERROR';
+    const severity = LEVELS[level].severity;
+    if (severity < LEVELS[this.logLevel]?.severity) return;
+
+    const logs = this._strinfifyLogs(...args);
+    this.dataStorage.putData(logs);
+    try {
+      this._originalUserLogger.log(`Assertion result: `, ...args);
+    } catch (e) {
+      // method could be unexisting, ignore error
+    }
+  }
+
+  debug(...args) {
+    const level = 'DEBUG';
+    const severity = LEVELS[level].severity;
+    if (severity < LEVELS[this.logLevel]?.severity) return;
+
+    if (this.logLevel === 'error' || this.logLevel === 'warn') return;
+    const logs = this._strinfifyLogs(...args);
+    const colorizedLogs = chalk[LEVELS[level].color](logs);
+    this.dataStorage.putData(colorizedLogs);
+    try {
+      this._originalUserLogger.debug(...args);
+    } catch (e) {
+      // method could be unexisting, ignore error
+    }
+  }
+
+  error(...args) {
+    const level = 'ERROR';
+    const severity = LEVELS[level].severity;
+    if (severity < LEVELS[this.logLevel]?.severity) return;
+
+    const logs = this._strinfifyLogs(...args);
+    const colorizedLogs = chalk[LEVELS[level].color](logs);
+    this.dataStorage.putData(colorizedLogs);
+    try {
+      this._originalUserLogger.error(...args);
+    } catch (e) {
+      // method could be unexisting, ignore error
+    }
+  }
+
+  info(...args) {
+    const level = 'INFO';
+    const severity = LEVELS[level].severity;
+    if (severity < LEVELS[this.logLevel]?.severity) return;
+
+    const logs = this._strinfifyLogs(...args);
+    this.dataStorage.putData(logs);
+    try {
+      this._originalUserLogger.info(...args);
+    } catch (e) {
+      // method could be unexisting, ignore error
+    }
+  }
+
+  log(...args) {
+    const level = 'INFO';
+    const severity = LEVELS[level].severity;
+    if (severity < LEVELS[this.logLevel]?.severity) return;
+
+    const logs = this._strinfifyLogs(...args);
+    this.dataStorage.putData(logs);
+    try {
+      this._originalUserLogger.log(...args);
+    } catch (e) {
+      // method could be unexisting, ignore error
+    }
+  }
+
+  trace(...args) {
+    const level = 'TRACE';
+    const severity = LEVELS[level].severity;
+    if (severity < LEVELS[this.logLevel]?.severity) return;
+
+    const logs = this._strinfifyLogs(...args);
+    const colorizedLogs = chalk[LEVELS[level].color](logs);
+    this.dataStorage.putData(colorizedLogs);
+    try {
+      this._originalUserLogger.trace(...args);
+    } catch (e) {
+      // method could be unexisting, ignore error
+    }
+  }
+
+  warn(...args) {
+    const level = 'WARN';
+    const severity = LEVELS[level].severity;
+    if (severity < LEVELS[this.logLevel]?.severity) return;
+
+    const logs = this._strinfifyLogs(...args);
+    const colorizedLogs = chalk[LEVELS[level].color](logs);
+    this.dataStorage.putData(colorizedLogs);
+    try {
+      this._originalUserLogger.warn(...args);
+    } catch (e) {
+      // method could be unexisting, ignore error
+    }
+  }
+
+  /**
+   * Intercepts user logger messages.
+   * When call this method, Logger start to control the user logger,
+   * but almost nothing is changed for user ragarding 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).
+   * @param {*} userLogger
+   */
+  intercept(userLogger) {
+    if (!userLogger) return;
+    debug(`Intercepting user logger`);
+
+    // save original user logger to use it for logging (last intercepted will be used for console 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
+    */
+    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;
+      on method invocation, we will store the data anyway and catch block will prevent potential errors
+      */
+      // if (!this._loggerToIntercept[method]) continue;
+      this._loggerToIntercept[method] = (...args) => this[method](...args);
+    }
+  }
+
+  /**
+   * Allows to configure logger. Make sure you do it before the logger usage in your code.
+   *
+   * @param {Object} [config={}] - The configuration object.
+   * @param {string} [config.logLevel] - The desired log level. Valid values are 'DEBUG', 'INFO', 'WARN', and 'ERROR'.
+   * @param {boolean} [config.prettyObjects] - Specifies whether to enable pretty printing of objects.
+   * @returns {void}
+   */
+  configure(config = {}) {
+    if (!config) return;
+    if (config.prettyObjects) this.prettyObjects = config.prettyObjects;
+    if (config.logLevel) this.logLevel = config.logLevel.toUpperCase();
+  }
+}
+
+Logger.instance = null;
+
+// module.exports.Logger = Logger;
+module.exports = new Logger();
+
+// TODO: consider using fs promises instead of writeSync/appendFileSync to prevent blocking and improve performance
+// 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
+
+// TODO: in case of unset _originalUserLogger, logger.{method} will not provide console output,
+// need to add some logger by default

package/lib/reporter.js

@@ -1,8 +1,15 @@
+const logger = require('./logger');
 const TestomatClient = require('./client');
 const TRConstants = require('./constants');
-const TRArtifacts = require('./ArtifactStorage');
+const TRArtifacts = require('./_ArtifactStorageOld');
+
+const log = logger._log.bind(logger);
+const step = logger.step.bind(logger);
 
 module.exports = {
+  logger,
+  log,
+  step,
   TestomatClient,
   TRConstants,
   TRArtifacts,

package/lib/util.js

@@ -3,6 +3,7 @@ const { sep, basename } = require('path');
 const chalk = require('chalk');
 const fs = require('fs');
 const isValid = require('is-valid-path');
+const debug = require('debug')('@testomatio/reporter:util');
 
 /**
  * @param {String} testTitle - Test title
@@ -32,7 +33,6 @@ const parseSuite = suiteTitle => {
   return null;
 };
 
-
 const ansiRegExp = () => {
   const pattern = [
     '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
@@ -54,11 +54,14 @@ const isValidUrl = s => {
 
 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));
-}
+  return Array.from(files)
+    .map(f => f[1])
+    .filter(f => fs.existsSync(f));
+};
 
 const fetchSourceCodeFromStackTrace = (stack = '') => {
-  const stackLines = stack.split('\n')
+  const stackLines = stack
+    .split('\n')
     .filter(l => l.includes(':'))
     // .map(l => l.match(/\[(.*?)\]/)?.[1] || l) // minitest format
     // .map(l => l.split(':')[0])
@@ -67,17 +70,17 @@ const fetchSourceCodeFromStackTrace = (stack = '') => {
     .filter(l => isValid(l?.split(':')[0]))
 
     // // filter out 3rd party libs
-    .filter(l => !l?.includes(`vendor${  sep}`))
-    .filter(l => !l?.includes(`node_modules${  sep}`))
+    .filter(l => !l?.includes(`vendor${sep}`))
+    .filter(l => !l?.includes(`node_modules${sep}`))
     .filter(l => fs.existsSync(l.split(':')[0]))
-    .filter(l => fs.lstatSync(l.split(':')[0]).isFile())
+    .filter(l => fs.lstatSync(l.split(':')[0]).isFile());
 
   if (!stackLines.length) return '';
 
   const [file, line] = stackLines[0].split(':');
 
   const prepend = 3;
-  const source = fetchSourceCode(fs.readFileSync(file).toString(), { line, prepend, limit: 7 })
+  const source = fetchSourceCode(fs.readFileSync(file).toString(), { line, prepend, limit: 7 });
 
   if (!source) return '';
 
@@ -85,22 +88,22 @@ const fetchSourceCodeFromStackTrace = (stack = '') => {
     .map((l, i) => {
       if (i === prepend) return `${line} > ${chalk.bold(l)}`;
       return `${line - prepend + i} | ${l}`
-    }).join('\n')
-}
+    }).join('\n');
+};
 
 const fetchSourceCode = (contents, opts = {}) => {
   if (!opts.title && !opts.line) return '';
 
-    // code fragment is 20 lines
+  // code fragment is 20 lines
   const limit = opts.limit || 50;
   let lineIndex;
   if (opts.line) lineIndex = opts.line - 1;
-  const lines = contents.split('\n')
+  const lines = contents.split('\n');
 
   // remove special chars from title
   if (!lineIndex && opts.title) {
-    const title = opts.title.replace(/[([@].*/g, '')
-    lineIndex = lines.findIndex(l => l.includes(title))
+    const title = opts.title.replace(/[([@].*/g, '');
+    lineIndex = lines.findIndex(l => l.includes(title));
   }
 
   if (opts.prepend) {
@@ -133,52 +136,69 @@ const fetchSourceCode = (contents, opts = {}) => {
         if (opts.lang === 'java' && lines[i].includes(' public void ')) break;
         if (opts.lang === 'java' && lines[i].includes(' class ')) break;
       }
-      result.push(lines[i])
+      result.push(lines[i]);
     }
     return result.join('\n');
   }
-}
+};
 
-const isSameTest = (test, t) => (typeof t === 'object') 
-    && (typeof test === 'object') 
-    && t.title === test.title 
-    && t.suite_title === test.suite_title 
-    && Object.values(t.example || {}) === Object.values(test.example || {})
-    && t.test_id === test.test_id;
+const isSameTest = (test, t) =>
+  typeof t === 'object' &&
+  typeof test === 'object' &&
+  t.title === test.title &&
+  t.suite_title === test.suite_title &&
+  Object.values(t.example || {}) === Object.values(test.example || {}) &&
+  t.test_id === test.test_id;
 
 const getCurrentDateTime = () => {
   const today = new Date();
-  
-  return `${today.getFullYear()  }_${  today.getMonth() + 1  }_${  today.getDate()  }_${ 
-         today.getHours()  }_${  today.getMinutes()  }_${  today.getSeconds()}`;
-}
+
+  return `${today.getFullYear()}_${
+    today.getMonth() + 1
+  }_${today.getDate()}_${today.getHours()}_${today.getMinutes()}_${today.getSeconds()}`;
+};
 
 /**
  * @param {Object} test - Test adapter object
  *
- * @returns {String|null} testInfo as one string 
+ * @returns {String|null} testInfo as one string
  */
 const specificTestInfo = test => {
   // TODO: afterEach has another context.... need to add specific handler, maybe...
   if (test?.title && test?.file) {
-
-    return `${basename(test.file).split(".").join("#")
-              }#${ 
-              test.title.split(" ").join("#")}`;
+    return `${basename(test.file).split('.').join('#')}#${test.title.split(' ').join('#')}`;
   }
 
   return null;
 };
 
+const fileSystem = {
+  createDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+      debug('Created dir: ', dirPath);
+    }
+  },
+  clearDir(dirPath) {
+    if (fs.existsSync(dirPath)) {
+      fs.rmSync(dirPath, { recursive: true });
+      debug(`Dir ${dirPath} was deleted`);
+    } else {
+      debug(`Trying to delete ${dirPath} but it doesn't exist`);
+    }
+  }
+};
+
 module.exports = {
   isSameTest,
   fetchSourceCode,
   fetchSourceCodeFromStackTrace,
   fetchFilesFromStackTrace,
+  fileSystem,
   getCurrentDateTime,
   specificTestInfo,
   isValidUrl,
   ansiRegExp,
   parseTest,
-  parseSuite 
-}
+  parseSuite,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testomatio/reporter",
-  "version": "1.0.0",
+  "version": "1.2.0-beta",
   "description": "Testomatio Reporter Client",
   "main": "./lib/reporter.js",
   "typings": "typings/index.d.ts",

package/Changelog.md

@@ -1,264 +0,0 @@
-# 1.0.0
-
-<!-- pending release updates -->
-
-* Added [`TESTOMATIO_SHARED_RUN` option](https://github.com/testomatio/reporter/blob/master/docs/pipes.md#reporting-parallel-execution-to-to-same-run) to use a shared run for parallel executions
-* Reworked [documentation](https://github.com/testomatio/reporter/tree/master#readme).
-* Added an option to obtain [S3 configuration](https://github.com/testomatio/reporter/blob/master/docs/artifacts.md#configuration) from Testomat.io
-* Introduced [pipes](https://github.com/testomatio/reporter/blob/master/docs/pipes.md):
-  * GitHub
-  * GitLab
-  * CSV Pipe
-
-
-# 0.7.6
-
-* Updated to use AWS S3 3.0 SDK for uploading
-
-# 0.7.5
-
-* Fixed reporting skipped tests in mocha
-
-# 0.7.4
-
-* Fixed parsing source code in JUnit files
-
-# 0.7.3
-
-* CodeceptJS: Upload all traces and videos from artifacts
-* Fixed reporting skipped test in XML
-* added `--timelimit` option to `report-xml` command line
-
-# 0.7.2
-
-* Fixed uploading non-existing file
-
-# 0.7.1
-
-* Support for NUnit XML v3 format
-
-# 0.7.0
-
-* Support for `@cucumber/cucumber` (>= 7.0) added
-* Initial support for C# and NUnit  
-
-# 0.6.10
-
-* Fixed uploading multilpe artifacts in Playwright
-
-# 0.6.9
-
-* Fixed pending tests reports for Cypress
-
-# 0.6.8
-# 0.6.7
-
-* Pytest: fixed creating suites from reports
-
-# 0.6.6
-
-* JUnit reporter: prefer suite title over testcase classname in a report
-
-# 0.6.5
-
-* Fixed test statuses for runs in JUnit reporter
-
-# 0.6.4
-
-* Added `TESTOMATIO_PROCEED=1` param to not close current run
-* Fixed priority of commands from `npx @testomatio/reporter`
-
-# 0.6.3
-
-* Fixed `npx start-test-run` to launch commands
-
-# 0.6.2
-
-* Added `--env-file` option to load env variables from env file
-
-# 0.6.1
-
-* Fixed creating RunGroup with JUnit reporter
-
-# 0.6.0
-
-* JUnit reporter support
-
-# 0.5.10
-
-* Fixed reporting Scenario Outline in Cypress-Cucumber
-* Fixed error reports for Cypress when running in Chrome
-
-# 0.5.9
-
-* Added environment on Cypress report
-
-# 0.5.8
-
-* Fixed Cypress.io reporting
-
-# 0.5.7
-
-* Fixed webdriverio artifacts
-
-# 0.5.6
-
-* Unmark failed CodeceptJS tests as skipped
-
-# 0.5.5
-
-* Fixed `BeforeSuite` failures in CodeceptJS
-
-# 0.5.4
-
-Added `TESTOMATIO_CREATE=1` option to create unmatched tests on report
-
-```
-TESTOMATIO_CREATE=1 TESTOMATIO=apiKey npx codeceptjs run
-```
-
-# 0.5.3
-
-* Fixed parsing suites
-
-# 0.5.2
-
-* Fixed multiple upload of artifacts in Cypress.io
-
-# 0.5.1
-
-* Fixed Cypress.io to report tests inside nested suites
-
-# 0.5.0
-
-* Added Cypress.io plugin
-* Added artifacts upload to webdriverio
-
-# 0.4.6
-
-- Fixed CodeceptJS reporter to report tests failed in hooks
-
-# 0.4.5
-
-- Fixed "Total XX artifacts publicly uploaded to S3 bucket" when no S3 bucket is configured
-- Improved S3 connection error messages
-
-# 0.4.4
-
-- Fixed returning 0 exit code when a process fails when running tests in parallel via `start-test-run`. Previously was using the last exit code returned by a process. Currently prefers the highest exit code that was returned by a process.
-
-# 0.4.3
-
-- Added `TESTOMATIO_DISABLE_ARTIFACTS` env variable to disable publishing artifacts.
-
-# 0.4.2
-
-- print version of reporter
-- print number of uploaded artifacts
-- print access mode for uploaded artifacts
-
-# 0.4.1
-
-Added `global.testomatioArtifacts = []` array which can be used to add arbitrary artifacts to a report.
-
-```js
-// inside a running test:
-global.testomatioArtifacts.push('file/to/upload.png');
-```
-
-# 0.4.0
-
-- Playwright: Introduced playwright/test support with screenshots and video artifacts
-
-> Known issues: reporting using projects configured in Playwright does not work yet
-
-- CodeceptJS: added video uploads
-
-# 0.3.16
-
-- CodeceptJS: fixed reporting tests with empty steps (on retry)
-
-# 0.3.15
-
-- Finish Run via API:
-
-```
-TESTOMATIO={apiKey} TESTOMATIO_RUN={runId} npx @testomatio/reporter@latest --finish
-```
-
-# 0.3.14
-
-- Create an empty Run via API:
-
-```
-TESTOMATIO={apiKey} npx @testomatio/reporter@latest --launch
-```
-
-# 0.3.13
-
-- Checking for a valid report URL
-- Sending unlimited data on test report
-
-# 0.3.12
-
-- Fixed submitting arbitrary data on a test run
-- Jest: fixed sending errors with stack traces
-- Cypress: fixed sending reports
-
-# 0.3.11
-
-- Fixed circular JSON reference when submitting data to Testomatio
-
-# 0.3.10
-
-- Minor fixes
-
-# 0.3.9
-
-- Making all reporters to run without API key
-
-# 0.3.8
-
-- Fixed `npx start-test-run` to work with empty API keys
-
-# 0.3.7
-
-- Fixed release
-
-# 0.3.6
-
-- Update title and rungroup on start for scheduled runs.
-
-# 0.3.5
-
-- Added `TESTOMATIO_RUN` environment variable to pass id of a specific run to report
-
-# 0.3.4
-
-- Minor fixes
-
-# 0.3.3
-
-- [CodeceptJS] Fixed stack trace reporting
-- [CodeceptJS] Fixed displaying of nested steps
-- [CodeceptJS][mocha] Added assertion diff to report
-
-# 0.3.2
-
-- Fixed error message for S3 uploading
-
-# 0.3.1
-
-- [CodeceptJS] Better formatter for nested structures and BDD tests
-
-# 0.3.0
-
-- Added `TESTOMATIO_TITLE` env variable to set a name for Run
-- Added `TESTOMATIO_RUNGROUP_TITLE` env variable to attach Run to RunGroup
-- Added `TESTOMATIO_ENV` env variable to attach additional env values to report
-- [CodeceptJS] **CodeceptJS v3 support**
-- [CodeceptJS] Dropped support for CodeceptJS 2
-- [CodeceptJS] Added support for before hooks
-- [CodeceptJS] Log of steps
-- [CodeceptJS] Upload screenshots of failed tests to S3
-- [CodeceptJS] Updated to use with parallel execution