@testomatio/reporter 1.0.0-beta.4 → 1.0.1

package/lib/logger.js

@@ -0,0 +1,278 @@
+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;
+    }
+  }
+
+  /**
+   * 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: 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
+

package/lib/pipe/github.js

@@ -39,8 +39,8 @@ class GitHubPipe {
   async createRun() {}
 
   addTest(test) {
-    debug('Adding test:', test);
     if (!this.isEnabled) return;
+    debug('Adding test:', test);
 
     const index = this.tests.findIndex(t => isSameTest(t, test));
     // update if they were already added
@@ -200,7 +200,7 @@ function fullName(t) {
 }
 
 async function deletePreviousReport(octokit, owner, repo, issue, hiddenCommentData) {
-  if (process.env.GITHUB_KEEP_OUTDATED_REPORTS) return;
+  if (process.env.GH_KEEP_OUTDATED_REPORTS) return;
 
   // get comments
   let comments = [];

package/lib/pipe/testomatio.js

@@ -169,6 +169,7 @@ class TestomatioPipe {
 
 module.exports = TestomatioPipe;
 
+
 function setS3Credentials(artifacts) {  
   if (!Object.keys(artifacts).length) return;
 
@@ -181,4 +182,4 @@ function setS3Credentials(artifacts) {
   if (artifacts.ENDPOINT) process.env.S3_ENDPOINT = artifacts.ENDPOINT; 
   if (artifacts.presign) process.env.TESTOMATIO_PRIVATE_ARTIFACTS = '1'; 
   resetConfig();
-}
+}

package/lib/reporter.js

@@ -1,9 +1,17 @@
+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
+  TRArtifacts,
+  addArtifact: TRArtifacts.artifact,
 };

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
@@ -10,6 +11,7 @@ const isValid = require('is-valid-path');
  * @returns {String|null} testId
  */
 const parseTest = testTitle => {
+  if (!testTitle) return null;
   const captures = testTitle.match(/@T([\w\d]+)/);
   if (captures) {
     return captures[1];
@@ -32,7 +34,6 @@ const parseSuite = suiteTitle => {
   return null;
 };
 
-
 const ansiRegExp = () => {
   const pattern = [
     '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
@@ -54,11 +55,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 +71,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 +89,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 +137,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-beta.4",
+  "version": "1.0.1",
   "description": "Testomatio Reporter Client",
   "main": "./lib/reporter.js",
   "typings": "typings/index.d.ts",