@testomatio/reporter 1.2.0-beta → 1.2.0-beta-1

package/lib/logger.js

@@ -14,93 +14,56 @@ 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(params = {}) {
-    // 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', params);
-    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';
 
-    this.intercept(this._loggerToIntercept);
+  constructor() {
+    // intercept console by default
+    this.intercept(console);
 
     // 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);
+    // add beforeEach hook for mocha. it does not override existing hook, just add new one
+    try {
+      // @ts-ignore
+      if (!beforeEach) return;
+      // @ts-ignore-next-line
+      beforeEach(function () {
+        if (this.currentTest?.__mocha_id__) {
+          global.testTitle = this.currentTest.fullTitle();
+        }
+      });
+    } catch (e) {
+      // ignore
     }
-    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 
+   * @param {*} strings
+   * @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];
@@ -109,7 +72,7 @@ class Logger {
       }
     }
     logs = chalk.blue(`> ${logs}`);
-    this.dataStorage.putData(logs);
+    this.#dataStorage.putData(logs, context);
   }
 
   /**
@@ -118,15 +81,20 @@ class Logger {
    * @returns
    */
   getLogs(context) {
-    return this.dataStorage.getData(context);
+    const logs = this.#dataStorage.getData(context);
+    return logs || '';
   }
 
-  _strinfifyLogs(...args) {
+  #stringifyLogs(...args) {
     const logs = [];
     // stringify everything except strings
     for (const arg of args) {
+      // ignore empty strings
+      if (arg === '') continue;
       if (typeof arg === 'string') {
         logs.push(arg);
+      } else if (Array.isArray(arg)) {
+        logs.push(arg.join(' '));
       } else {
         try {
           // eslint-disable-next-line no-unused-expressions
@@ -140,137 +108,148 @@ class Logger {
     return logs.join(' ');
   }
 
-  assert(...args) {
-    const level = 'ERROR';
-    const severity = LEVELS[level].severity;
-    if (severity < LEVELS[this.logLevel]?.severity) return;
+  /**
+   * Tagget template literal. Allows to use different syntaxes:
+   * 1. Tagget template: log`text ${someVar}`
+   * 2. Standard: log(`text ${someVar}`)
+   * 3. Standard with multiple arguments: log('text', someVar)
+   */
+  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;
 
-    const logs = this._strinfifyLogs(...args);
-    this.dataStorage.putData(logs);
-    try {
-      this._originalUserLogger.log(`Assertion result: `, ...args);
-    } catch (e) {
-      // method could be unexisting, ignore error
+    // get testId for mocha
+    context = global.testTitle ?? null;
+
+    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.#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);
     }
+    this.#originalUserLogger.log(logs);
+    this.#dataStorage.putData(logs, context);
   }
 
-  debug(...args) {
-    const level = 'DEBUG';
+  /**
+   * 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) {
+    if (!argsArray.length) return;
+
+    // entity which is used to define testId
+    let context = null;
+
+    // get context for mocha
+    context = global.testTitle ?? null;
+
     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 logs = this.#stringifyLogs(...argsArray);
     const colorizedLogs = chalk[LEVELS[level].color](logs);
-    this.dataStorage.putData(colorizedLogs);
+    this.#dataStorage.putData(colorizedLogs, context);
     try {
-      this._originalUserLogger.debug(...args);
+      // level.toLowerCase() represents method name (log, warn, error, etc)
+      this.#originalUserLogger[level.toLowerCase()](colorizedLogs);
     } 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;
+  assert(...args) {
+    this.#logWrapper(args, 'ERROR');
+  }
 
-    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
-    }
+  debug(...args) {
+    this.#logWrapper(args, 'DEBUG');
   }
 
-  info(...args) {
-    const level = 'INFO';
-    const severity = LEVELS[level].severity;
-    if (severity < LEVELS[this.logLevel]?.severity) return;
+  error(...args) {
+    this.#logWrapper(args, 'ERROR');
+  }
 
-    const logs = this._strinfifyLogs(...args);
-    this.dataStorage.putData(logs);
-    try {
-      this._originalUserLogger.info(...args);
-    } catch (e) {
-      // method could be unexisting, ignore error
-    }
+  info(...args) {
+    this.#logWrapper(args, 'INFO');
   }
 
   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
-    }
+    this.#logWrapper(args, 'LOG');
   }
 
   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
-    }
+    this.#logWrapper(args, 'TRACE');
   }
 
   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
-    }
+    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 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).
+   * When call this method, Logger start to control the user logger
    * @param {*} userLogger
    */
   intercept(userLogger) {
-    if (!userLogger) return;
-    debug(`Intercepting user logger`);
+    /* 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;
+    }
 
-    // save original user logger to use it for logging (last intercepted will be used for console output)
-    this._originalUserLogger = { ...userLogger };
-    this._loggerToIntercept = userLogger;
+    process.env.TESTOMATIO_LOGGER_CONSOLE_INTERCEPTED = 'true';
+    debug(isUserLoggerConsole ? 'console intercepted' : 'User logger intercepted');
 
-    /* 
-    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
+    */
   }
 
   /**
@@ -283,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();
   }
 }
@@ -291,11 +270,50 @@ class Logger {
 Logger.instance = null;
 
 // module.exports.Logger = Logger;
-module.exports = new Logger();
+const logger = new Logger();
+
+module.exports = 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
+/* 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/pipe/csv.js

@@ -4,7 +4,7 @@ const fs = require('fs');
 const csvWriter = require('csv-writer');
 const chalk = require('chalk');
 const merge = require('lodash.merge');
-const { isSameTest, getCurrentDateTime } = require('../util');
+const { isSameTest, getCurrentDateTime } = require('../utils/utils');
 const { CSV_HEADERS } = require('../constants');
 
 /**
@@ -40,6 +40,9 @@ class CsvPipe {
     }
   }
 
+  // TODO: to using SET opts as argument => prepareRun(opts)
+  async prepareRun() {}
+  
   async createRun() {
     // empty
   }

package/lib/pipe/github.js

@@ -5,7 +5,8 @@ const humanizeDuration = require('humanize-duration');
 const merge = require('lodash.merge');
 const { Octokit } = require('@octokit/rest');
 const { APP_PREFIX } = require('../constants');
-const { ansiRegExp, isSameTest } = require('../util');
+const { ansiRegExp, isSameTest } = require('../utils/utils');
+const { statusEmoji, fullName } = require('../utils/pipe_utils');
 
 /**
  * @typedef {import('../../types').Pipe} Pipe
@@ -21,7 +22,8 @@ class GitHubPipe {
     this.token = params.GH_PAT || process.env.GH_PAT;
     this.ref = process.env.GITHUB_REF;
     this.repo = process.env.GITHUB_REPOSITORY;
-    this.hiddenCommentData = `<!--- testomat.io report ${process.env.GITHUB_WORKFLOW || ''} -->`;
+    this.jobKey = `${process.env.GITHUB_WORKFLOW || ''} / ${process.env.GITHUB_JOB || ''}`;
+    this.hiddenCommentData = `<!--- testomat.io report ${this.jobKey} -->`;
 
     debug('GitHub Pipe: ', this.token ? 'TOKEN' : '*no token*', 'Ref:', this.ref, 'Repo:', this.repo);
 
@@ -36,6 +38,9 @@ class GitHubPipe {
     debug('GitHub Pipe: Enabled');
   }
 
+  // TODO: to using SET opts as argument => prepareRun(opts)
+  async prepareRun() {}
+
   async createRun() {}
 
   addTest(test) {
@@ -73,35 +78,32 @@ class GitHubPipe {
     let summary = `${this.hiddenCommentData}
 
 | [![Testomat.io Report](https://avatars.githubusercontent.com/u/59105116?s=36&v=4)](https://testomat.io)  | ${
-  statusEmoji(runParams.status,)} ${runParams.status.toUpperCase()} ${statusEmoji(runParams.status)} |
+  statusEmoji(runParams.status,)} ${`${process.env.GITHUB_JOB} ${runParams.status}`.toUpperCase()} |
 | --- | --- |        
 | Tests | ✔️  **${this.tests.length}** tests run  |
-| Summary | ${statusEmoji('failed')} **${failedCount}** failed; ${statusEmoji(
+| Summary | ${failedCount ? `${statusEmoji('failed')} **${failedCount}** failed; ` : ''} ${statusEmoji(
       'passed',
     )} **${passedCount}** passed; **${statusEmoji('skipped')}** ${skippedCount} skipped |
-| Duration | 🕐  **${humanizeDuration(parseInt(this.tests.reduce((a, t) => a + (t.run_time || 0), 0), 10), {
-      maxDecimalPoints: 0,
-    })}** |
-`;
+| Duration | 🕐  **${humanizeDuration(
+      parseInt(
+        this.tests.reduce((a, t) => a + (t.run_time || 0), 0),
+        10,
+      ),
+      {
+        maxDecimalPoints: 0,
+      },
+    )}** |`;
+
     if (this.store.runUrl) {
-      summary += `| Testomat.io Report | 📊 [Run #${this.store.runId}](${this.store.runUrl})  | `;
+      summary += `\n| Testomat.io Report | 📊 [Run #${this.store.runId}](${this.store.runUrl})  | `;
     }
     if (process.env.GITHUB_WORKFLOW) {
-      summary += `| Workflow | 🗂️  ${process.env.GITHUB_WORKFLOW} | `;
+      summary += `\n| Job | 🗂️  [${this.jobKey}](${process.env.GITHUB_SERVER_URL || 'https://github.com'}/${
+        this.repo
+      }/actions/runs/${process.env.GITHUB_RUN_ID}) | `;
     }
     if (process.env.RUNNER_OS) {
-      summary += `| Operating System | 🖥️ \`${process.env.RUNNER_OS}\` ${process.env.RUNNER_ARCH || ''} | `;
-    }
-    if (process.env.GITHUB_HEAD_REF) {
-      summary += `| Branch | 🌳  \`${process.env.GITHUB_HEAD_REF}\` | `;
-    }
-    if (process.env.GITHUB_RUN_ATTEMPT) {
-      summary += `| Run Attempt | 🌒  \`${process.env.GITHUB_RUN_ATTEMPT}\` | `;
-    }
-    if (process.env.GITHUB_RUN_ID) {
-      summary += `| Build Log | ✒️  ${process.env.GITHUB_SERVER_URL || 'https://github.com'}/${
-        this.repo
-      }/actions/runs/${process.env.GITHUB_RUN_ID} | `;
+      summary += `\n| Operating System | 🖥️ \`${process.env.RUNNER_OS}\` ${process.env.RUNNER_ARCH || ''} | `;
     }
 
     const failures = this.tests
@@ -184,21 +186,6 @@ class GitHubPipe {
   }
 }
 
-function statusEmoji(status) {
-  if (status === 'passed') return '🟢';
-  if (status === 'failed') return '🔴';
-  if (status === 'skipped') return '🟡';
-  return '';
-}
-
-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;
-}
-
 async function deletePreviousReport(octokit, owner, repo, issue, hiddenCommentData) {
   if (process.env.GH_KEEP_OUTDATED_REPORTS) return;
 

package/lib/pipe/gitlab.js

@@ -5,7 +5,8 @@ const humanizeDuration = require('humanize-duration');
 const merge = require('lodash.merge');
 const path = require('path');
 const { APP_PREFIX } = require('../constants');
-const { ansiRegExp, isSameTest } = require('../util');
+const { ansiRegExp, isSameTest } = require('../utils/utils');
+const { statusEmoji, fullName } = require('../utils/pipe_utils');
 
 //! GITLAB_PAT environment variable is required for this functionality to work
 //! and your pipeline trigger should be merge_request
@@ -46,6 +47,9 @@ class GitLabPipe {
     debug('GitLab Pipe: Enabled');
   }
 
+  // TODO: to using SET opts as argument => prepareRun(opts)
+  async prepareRun() {}
+
   async createRun() {}
 
   addTest(test) {
@@ -179,21 +183,6 @@ class GitLabPipe {
   updateRun() {}
 }
 
-function statusEmoji(status) {
-  if (status === 'passed') return '🟢';
-  if (status === 'failed') return '🔴';
-  if (status === 'skipped') return '🟡';
-  return '';
-}
-
-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;
-}
-
 async function deletePreviousReport(axiosInstance, commentsRequestURL, hiddenCommentData, token) {
   if (process.env.GITLAB_KEEP_OUTDATED_REPORTS) return;