@testomatio/reporter 2.0.1-beta.5-timestamp → 2.0.1

package/src/services/logger.js

@@ -0,0 +1,315 @@
+import pc from 'picocolors';
+import createDebugMessages from 'debug';
+import { dataStorage } from '../data-storage.js';
+
+const debug = createDebugMessages('@testomatio/reporter:services-logger');
+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' },
+};
+
+// ! DON'T use console.log, console.warn, etc in this file, because it will lead to infinite loop
+// use debug() instead
+
+/**
+ * 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 {
+  // set default logger to be used in log, warn, error, etc methods
+  #originalUserLogger = { ...console };
+
+  #userLoggerWithOverridenMethods;
+
+  static #instance;
+
+  /**
+   *
+   * @returns {Logger}
+   */
+  static getInstance() {
+    if (!this.#instance) {
+      this.#instance = new Logger();
+    }
+    return this.#instance;
+  }
+
+  logLevel = process?.env?.LOG_LEVEL?.toUpperCase() || 'ALL';
+
+  constructor() {
+    if (
+      !dataStorage.isFileStorage ||
+      (process.env.TESTOMATIO_INTERCEPT_CONSOLE_LOGS && process.env.TESTOMATIO_INTERCEPT_CONSOLE_LOGS !== 'false')
+    )
+      this.intercept(console);
+  }
+
+  /**
+   * 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 = pc.blue(`> ${logs}`);
+    dataStorage.putData('log', logs);
+  }
+
+  /**
+   *
+   * @param {string} context testId or test context from test runner
+   * @returns {string[]}
+   */
+  getLogs(context) {
+    const logs = dataStorage.getData('log', context);
+    if (!logs) return [];
+    return logs;
+  }
+
+  #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 {
+          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(' ');
+  }
+
+  /**
+   * 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 !== '');
+
+    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
+            ? 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);
+    dataStorage.putData('log', logs);
+  }
+
+  /**
+   * 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;
+
+    const severity = LEVELS[level].severity;
+    if (severity < LEVELS[this.logLevel]?.severity) return;
+
+    const logs = this.#stringifyLogs(...argsArray);
+
+    const colorizedLogs = pc[LEVELS[level].color](logs);
+    // do not attach logs from testomatio reporter itself
+    if (!logs.includes('[TESTOMATIO]')) {
+      dataStorage.putData('log', colorizedLogs);
+    }
+
+    try {
+      // level.toLowerCase() represents method name (log, warn, error, etc)
+      this.#originalUserLogger[level.toLowerCase()](colorizedLogs);
+    } catch (e) {
+      // method could be unexisting, ignore error
+    }
+  }
+
+  assert(...args) {
+    this.#logWrapper(args, 'ERROR');
+  }
+
+  debug(...args) {
+    this.#logWrapper(args, 'DEBUG');
+  }
+
+  error(...args) {
+    this.#logWrapper(args, 'ERROR');
+  }
+
+  info(...args) {
+    this.#logWrapper(args, 'INFO');
+  }
+
+  log(...args) {
+    this.#logWrapper(args, 'LOG');
+  }
+
+  trace(...args) {
+    this.#logWrapper(args, 'TRACE');
+  }
+
+  warn(...args) {
+    this.#logWrapper(args, 'WARN');
+  }
+
+  /**
+   * Intercepts user logger messages.
+   * When call this method, Logger start to control the user logger
+   * @param {*} userLogger
+   */
+  intercept(userLogger) {
+    // STEP 1: reset previously intercepted logger methods to original
+    if (this.#userLoggerWithOverridenMethods) {
+      for (const method of LOG_METHODS) {
+        this.#userLoggerWithOverridenMethods[method] = this.#originalUserLogger[method];
+      }
+    }
+
+    // STEP 2: intercept new logger
+    this.#originalUserLogger = { ...userLogger };
+
+    const isUserLoggerConsole = userLogger.toString?.().toLowerCase() === '[object console]';
+    debug(`Intercepting ${isUserLoggerConsole ? 'console' : 'some user'} logger}`);
+
+    // override user logger (any, e.g. console) methods to intercept log messages
+    for (const method of LOG_METHODS) {
+      /*
+      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;
+      userLogger[method] = (...args) => this[method](...args);
+    }
+
+    this.#userLoggerWithOverridenMethods = userLogger;
+
+    /*
+    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 always provided by console.
+    TODO: try to implement the providing output to terminal by user logger
+    */
+  }
+
+  stopInterception() {
+    debug('Stop ntercepting logs');
+
+    // restore original user logger
+    if (this.#userLoggerWithOverridenMethods) {
+      for (const method of LOG_METHODS) {
+        this.#userLoggerWithOverridenMethods[method] = this.#originalUserLogger[method];
+      }
+    }
+  }
+
+  /**
+   * 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 === false || config.prettyObjects === true) this.prettyObjects = config.prettyObjects;
+    if (config.logLevel) this.logLevel = config.logLevel.toUpperCase();
+  }
+}
+
+export const logger = Logger.getInstance();
+
+// TODO: parse passed arguments as {level: 'str', message: 'str'} because some loggers use such syntax;
+// upd: did not face such loggers, but still could be useful
+
+/* Cypress
+There is no listener like "after:test" in cypress, only "after:spec" is available.
+Thus, cannot separate logs even when I gather them (because I don't know when the test is done, just know about suite).
+Also there is no easy way to access the message from cy.log() function.
+(Using testomatio logger – logger.log() is not convenient because Cypress chains its commands,
+thus such command will interrupt the chain.)
+
+(Could not implement intercepting of cy.log('message'));
+I found the only ability to get any logs using .task('log', 'message') (this is custom, not default cypress command)
+and then intercept it with:
+  on('task', {
+    log (message) {
+      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??
+*/
+
+// TODO: add time to logs
+// TODO: add logger name to logs?

package/src/template/emptyData.svg

@@ -0,0 +1,23 @@
+<svg width="185" height="185" viewBox="0 0 370 370" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <g clip-path="url(#clip0_215_375)">
+        <path opacity="0.1" d="M185 369.998C287.173 369.998 370.001 287.171 370.001 184.999C370.001 82.8268 287.173 0 185 0C82.8274 0 0 82.8268 0 184.999C0 287.171 82.8274 369.998 185 369.998Z" fill="#A9C7FF"/>
+        <path d="M104.96 129.507C105.629 128.757 106.439 128.147 107.344 127.71C108.249 127.273 109.231 127.019 110.234 126.961C111.237 126.904 112.242 127.045 113.191 127.376C114.14 127.707 115.014 128.221 115.764 128.89L140.183 150.67L129.997 162.091L105.577 140.311C104.827 139.642 104.216 138.832 103.779 137.927C103.342 137.022 103.088 136.04 103.031 135.037C102.974 134.034 103.114 133.029 103.446 132.08C103.777 131.132 104.291 130.257 104.96 129.507Z" fill="white"/>
+        <path d="M130.056 163.157L105.074 140.874C104.25 140.139 103.579 139.249 103.099 138.255C102.619 137.261 102.34 136.182 102.277 135.079C102.214 133.977 102.368 132.873 102.732 131.831C103.096 130.788 103.661 129.828 104.396 129.004C105.131 128.18 106.021 127.508 107.015 127.028C108.009 126.548 109.088 126.269 110.191 126.206C111.293 126.143 112.397 126.298 113.439 126.661C114.482 127.025 115.443 127.59 116.267 128.325L141.251 150.608L130.056 163.157ZM110.677 127.703C110.544 127.703 110.409 127.707 110.275 127.714C108.913 127.792 107.605 128.273 106.516 129.094C105.427 129.916 104.607 131.042 104.158 132.329C103.709 133.617 103.652 135.01 103.994 136.33C104.336 137.65 105.062 138.84 106.08 139.747L129.936 161.024L139.117 150.731L115.261 129.454C114.002 128.325 112.371 127.701 110.68 127.703H110.677Z" fill="#474646"/>
+        <path d="M240 162.09L229.814 150.669L254.234 128.89C255.748 127.539 257.737 126.845 259.763 126.961C261.789 127.076 263.686 127.992 265.037 129.507C266.388 131.021 267.082 133.01 266.966 135.036C266.85 137.062 265.935 138.96 264.42 140.31L240 162.09Z" fill="white"/>
+        <path d="M239.942 163.157L228.749 150.608L253.733 128.325C255.397 126.841 257.583 126.079 259.809 126.206C262.035 126.333 264.12 127.34 265.604 129.004C267.088 130.668 267.851 132.853 267.723 135.079C267.596 137.306 266.59 139.39 264.926 140.874L239.942 163.157ZM230.883 150.73L240.064 161.023L263.92 139.747C264.596 139.144 265.146 138.414 265.54 137.599C265.934 136.783 266.163 135.898 266.214 134.994C266.266 134.09 266.139 133.185 265.841 132.329C265.543 131.474 265.079 130.686 264.476 130.011C263.873 129.335 263.143 128.784 262.328 128.391C261.512 127.997 260.627 127.768 259.723 127.716C258.819 127.664 257.913 127.791 257.058 128.09C256.203 128.388 255.415 128.852 254.739 129.454L230.883 150.73Z" fill="#474646"/>
+        <path d="M250.171 176.257C255.618 200.379 263.075 215.898 259.362 224.811C257.41 229.495 253.403 233.424 246.771 233.424C236.433 233.424 236.433 221.232 226.095 221.232C215.756 221.232 215.758 233.424 205.42 233.424C195.083 233.424 195.084 221.232 184.748 221.232C174.411 221.232 174.411 233.424 164.074 233.424C153.737 233.424 153.738 221.232 143.401 221.232C133.065 221.232 133.066 233.424 122.731 233.424C116.595 233.424 113.126 229.81 110.926 225.633C105.639 215.6 117.96 193.521 122.731 174.051C128.002 152.536 127.558 125.739 128.265 109.576C129.629 78.4083 153.554 53.0876 184.755 53.0876C215.955 53.0876 238.971 78.4613 241.244 109.576C242.469 126.351 245.184 154.176 250.171 176.257Z" fill="white"/>
+        <path d="M246.771 234.186C241.249 234.186 238.506 230.95 235.852 227.818C233.311 224.822 230.911 221.992 226.095 221.992C221.278 221.992 218.882 224.822 216.339 227.818C213.685 230.948 210.942 234.186 205.42 234.186C199.899 234.186 197.156 230.95 194.503 227.818C191.962 224.822 189.562 221.992 184.748 221.992C179.933 221.992 177.535 224.822 174.992 227.818C172.339 230.948 169.596 234.186 164.074 234.186C158.552 234.186 155.808 230.95 153.16 227.822C150.619 224.825 148.219 221.995 143.404 221.995C138.589 221.995 136.191 224.825 133.65 227.822C130.998 230.951 128.255 234.189 122.734 234.189C117.243 234.189 113.161 231.508 110.254 225.992C106.568 218.996 110.995 206.627 115.683 193.534C118.011 187.03 120.416 180.305 121.994 173.874C126.21 156.668 126.743 136.45 127.172 120.204C127.272 116.362 127.368 112.732 127.51 109.548C128.186 94.1198 134.32 79.7607 144.785 69.1146C149.986 63.7845 156.204 59.5527 163.071 56.6697C169.937 53.7867 177.313 52.3113 184.76 52.3308C192.159 52.3133 199.486 53.7933 206.298 56.6817C213.11 59.5701 219.267 63.8071 224.399 69.1377C234.622 79.6633 240.876 94.0076 242.01 109.526C243.102 124.489 245.712 153.033 250.92 176.094C252.686 183.916 254.663 190.825 256.407 196.921C260.048 209.651 262.679 218.848 260.069 225.109C258.652 228.498 255.046 234.186 246.771 234.186ZM226.095 220.47C231.617 220.47 234.361 223.705 237.014 226.837C239.556 229.834 241.956 232.664 246.771 232.664C254.162 232.664 257.391 227.561 258.658 224.519C261.062 218.751 258.489 209.769 254.935 197.338C253.188 191.222 251.203 184.292 249.428 176.428C244.198 153.268 241.58 124.639 240.484 109.635C238.161 77.833 214.203 53.8517 184.754 53.8517C154.874 53.8517 130.395 78.3441 129.024 109.612C128.885 112.782 128.789 116.406 128.686 120.241C128.278 135.699 127.72 156.869 123.465 174.234C121.871 180.742 119.45 187.505 117.109 194.046C112.538 206.815 108.22 218.877 111.594 225.28C114.212 230.248 117.853 232.662 122.725 232.662C127.54 232.662 129.938 229.832 132.48 226.836C135.132 223.706 137.875 220.468 143.396 220.468C148.916 220.468 151.661 223.704 154.313 226.836C156.854 229.832 159.253 232.662 164.068 232.662C168.884 232.662 171.284 229.832 173.824 226.836C176.478 223.706 179.221 220.468 184.742 220.468C190.263 220.468 193.007 223.704 195.659 226.836C198.2 229.832 200.599 232.662 205.415 232.662C210.23 232.662 212.63 229.832 215.171 226.836C217.83 223.708 220.573 220.47 226.095 220.47Z" fill="#474646"/>
+        <path d="M163.527 113.221C166.986 113.221 169.789 110.418 169.789 106.96C169.789 103.501 166.986 100.698 163.527 100.698C160.069 100.698 157.266 103.501 157.266 106.96C157.266 110.418 160.069 113.221 163.527 113.221Z" fill="#474646"/>
+        <path d="M206.465 113.221C209.923 113.221 212.726 110.418 212.726 106.96C212.726 103.501 209.923 100.698 206.465 100.698C203.006 100.698 200.203 103.501 200.203 106.96C200.203 110.418 203.006 113.221 206.465 113.221Z" fill="#474646"/>
+        <path d="M196.211 123.859C196.573 123.859 196.93 123.938 197.256 124.093C197.583 124.247 197.871 124.473 198.1 124.752C198.329 125.032 198.492 125.36 198.578 125.71C198.665 126.061 198.672 126.427 198.599 126.781C197.256 133.059 191.677 137.005 184.998 137.005C178.319 137.005 172.74 133.061 171.397 126.781C171.324 126.427 171.331 126.061 171.418 125.71C171.504 125.359 171.668 125.032 171.896 124.752C172.125 124.472 172.413 124.247 172.74 124.093C173.067 123.938 173.424 123.858 173.785 123.859H196.211Z" fill="white"/>
+        <path d="M184.997 137.767C177.802 137.767 172.037 133.416 170.652 126.94C170.553 126.479 170.559 126.002 170.67 125.543C170.78 125.085 170.992 124.657 171.29 124.292C171.59 123.919 171.97 123.618 172.402 123.412C172.834 123.206 173.306 123.099 173.785 123.1H196.212C196.691 123.099 197.164 123.206 197.595 123.412C198.027 123.618 198.407 123.919 198.707 124.292C199.005 124.657 199.217 125.085 199.327 125.543C199.438 126.002 199.444 126.479 199.345 126.94C197.958 133.416 192.192 137.767 184.997 137.767ZM173.784 124.621C173.532 124.621 173.284 124.677 173.057 124.786C172.83 124.894 172.631 125.052 172.473 125.248C172.318 125.437 172.208 125.659 172.151 125.897C172.093 126.135 172.09 126.382 172.141 126.622C173.371 132.377 178.537 136.243 184.996 136.243C191.455 136.243 196.621 132.377 197.852 126.622C197.903 126.382 197.899 126.135 197.842 125.897C197.784 125.659 197.674 125.437 197.519 125.248C197.361 125.052 197.162 124.894 196.935 124.786C196.708 124.677 196.46 124.621 196.209 124.621H173.784Z" fill="#474646"/>
+        <path d="M332.184 297.095C298.385 341.408 245.033 370 185.003 370C124.973 370 71.6211 341.408 37.8223 297.095C76.4052 282.579 128.135 273.704 185.003 273.704C241.872 273.704 293.598 282.579 332.184 297.095Z" fill="#A9C7FF"/>
+        <path d="M347.711 96.8905L252.766 96.4848C252.766 80.628 261.697 77.5062 271.192 74.931C280.687 72.3558 284.959 54.9269 301.458 53.9351C311.202 53.3491 316.312 55.8566 320.544 59.0855C320.549 59.0911 320.549 59.0967 320.555 59.0967C331.158 70.5047 340.281 83.2025 347.711 96.8905Z" fill="white"/>
+        <path d="M76.8801 214.712L2.43035 215.033C1.15867 207.26 0.386967 199.413 0.119995 191.541C16.4277 189.231 14.7598 176.27 34.2344 177.448C48.6825 178.316 52.4355 193.581 60.7471 195.835C69.0587 198.089 76.8801 200.83 76.8801 214.712Z" fill="white"/>
+    </g>
+    <defs>
+        <clipPath id="clip0_215_375">
+            <rect width="370" height="370" fill="white"/>
+        </clipPath>
+    </defs>
+</svg>