@testomatio/reporter 1.1.0-beta.mocha-create.8 → 1.1.1-beta-codecept-logger

package/lib/storages/data-storage.js

@@ -4,225 +4,108 @@ const path = require('path');
 const os = require('os');
 const { join } = require('path');
 const { TESTOMAT_TMP_STORAGE_DIR } = require('../constants');
-const { fileSystem, jestHelpers, parseTest } = require('../utils/utils');
-
-const getTestIdFromTestTitle = parseTest;
+const { fileSystem } = require('../utils/utils');
 
 class DataStorage {
   /**
    * Creates data storage instance for specific data type.
    * Stores data to global variable or to file depending on what is applicable for current test runner
-   * (running environment).
    * Recommend to use composition while using this class (instead of inheritance).
    * ! Also the class which will use data storage should be singleton (to avoid data loss).
-   * @param {*} dataType storage type (like 'log', 'artifact'); could be any string, used only to define file path
+   * But the data storage itself is not singleton. It will have an instance per data type.
+   * @param {'log' | 'artifact' | 'keyvalue'} dataType – type of data to store
    */
   constructor(dataType) {
     this.dataType = dataType || 'data';
+
+    // some frameworks use global variable to store data, some use file storage
     this.isFileStorage = true;
-    this.#refreshStorageType();
 
     this.dataDirPath = path.join(TESTOMAT_TMP_STORAGE_DIR, this.dataType);
-
-    // set test title for mocha (could not be moved to adapter)
-    // 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
-    }
-
-    // set test title for playwright
-    try {
-      // eslint-disable-next-line import/no-extraneous-dependencies, import/no-unresolved
-      const { test } = require('@playwright/test');
-      // eslint-disable-next-line no-empty-pattern
-      test.beforeEach(async ({}, testInfo) => {
-        global.testTitle = testInfo.title;
-        global.testomatioRunningEnvironment = 'playwright';
-      });
-    } catch (e) {
-      // ignore
-    }
   }
 
-  /**
-   * Try to define the running environment. Not 100% reliable and used as additional check
-   * @returns jest | mocha | ...
-   */
-  getRunningEnviroment() {
-    // jest
-    if (process.env.JEST_WORKER_ID) return 'jest';
-
-    if (global.codeceptjs) return 'codeceptjs';
-
-    // 'cucumber:current', 'cucumber:legacy'
-    if (global.testomatioRunningEnvironment) return global.testomatioRunningEnvironment;
-
-    if (process.env.PLAYWRIGHT_TEST_BASE_URL || process.env.TEST_WORKER_INDEX) return 'playwright';
-
-    // mocha - can't detect
-    return null;
+  #stringToFilename(str) {
+    // TODO: use md5 hash later
+    const validFilenameRegex = /[^a-zA-Z0-9_.-]/g;
+    // replace all characters not in the regex above with underscore, then duplicate underscores removed
+    let filename = str.replace(validFilenameRegex, '_').replace(/_{2,}/g, '_').substring(0, 255); // max filename length
+    // remove leading and trailing underscores
+    filename = filename.replace(/^_+|_+$/g, '');
+    return filename;
   }
 
   /**
    * Puts any data to storage (file or global variable).
    * If file: stores data as text, if global variable – stores as array of data.
    * @param {*} data anything you want to store (string, object, array, etc)
-   * @param {*} context could be testId or any context (test, suite, etc) which is used to define testId
+   * @param {*} context could be testId or any context (test name, suite name, including their IDs etc)
+   * suite name + test name is used by default
    * @returns
    */
   putData(data, context = null) {
     fileSystem.createDir(this.dataDirPath);
-
-    this.#refreshStorageType();
-    context = context ?? global.testTitle ?? null;
-    let testId = this.#tryToRetrieveTestId(context) || context || null;
-
-    if (this.runningEnvironment === 'codeceptjs') {
-      this.isFileStorage = false;
-      testId = testId ?? global.testomatioDataStore?.currentlyRunningTestId;
-    }
-
-    if (this.runningEnvironment === 'jest') {
-      testId = testId ?? jestHelpers.getIdOfCurrentlyRunningTest();
-    }
-
-    // logs in playwright are gathered by pw framework itself
-    if (this.runningEnvironment === 'playwright' && this.dataType === 'log') return;
-
-    // get id from global store
-    if (global.testomatioDataStore && global.testomatioDataStore.currentlyRunningTestId)
-      testId = testId ?? global.testomatioDataStore?.currentlyRunningTestId;
-
-    if (!testId && global?.currentlyRunningTestTitle)
-      testId = this.#tryToRetrieveTestId(global.currentlyRunningTestTitle);
-
-    if (!testId) {
-      debug(`No test id provided for "${this.dataType}" data:`, data);
+    if (!context) {
+      debug(`No context provided for "${this.dataType}" data:`, data);
       return;
     }
+    context = this.#stringToFilename(context);
 
     if (this.isFileStorage) {
-      this.#putDataToFile(data, testId);
+      this.#putDataToFile(data, context);
     } else {
-      this.#putDataToGlobalVar(data, testId);
+      this.#putDataToGlobalVar(data, context);
     }
   }
 
   /**
-   * Returns data, stored for specific testId (or data which was stored without test id specified).
+   * Returns data, stored for specific test/context (or data which was stored without test id specified).
    * This method will get data from global variable and/or from from file (previosly saved with put method).
    *
-   * @param {*} context could be testId or any context (test title, suite, etc) which is used to define testId
-   * @returns array of data (any type), null (if no data found for test) or string (if data type is log)
+   * @param {string} context
+   * @returns {any []} of data (any type), null (if no data found for test) or string (if data type is log)
    */
   getData(context) {
-    this.#refreshStorageType();
-
-    let testId = null;
-    if (typeof context === 'string') {
-      testId = this.#tryToRetrieveTestId(context) || context;
-    }
-
-    if (!testId) {
-      debug(`Cannot get test id from passed context:`, context);
+    if (!context) {
+      debug(`No context passed`, context);
       return null;
     }
 
+    context = this.#stringToFilename(context);
+
     let testDataFromFile = [];
     let testDataFromGlobalVar = [];
 
     if (global?.testomatioDataStore) {
-      testDataFromGlobalVar = this.#getDataFromGlobalVar(testId);
-      // these frameworks use global variable storage
-      // if (testDataFromGlobalVar && ['cucumber', 'codeceptjs'].includes(this.runningEnvironment)) {
+      testDataFromGlobalVar = this.#getDataFromGlobalVar(context);
       if (testDataFromGlobalVar) {
-        // return as string if its log data
-        if (this.dataType === 'log' && testDataFromGlobalVar.length) return testDataFromGlobalVar.join('\n');
-        // return as array for other data types
         if (testDataFromGlobalVar.length) return testDataFromGlobalVar;
       }
       // don't return nothing if no data in global variable
     }
 
-    /* condition is removed for mocha
-    mocha has created a global storage, but just in some cases, generally it is not available
-    */
-    // if (this.isFileStorage || !testData) {
-    //   testData = this.#getDataFromFile(testId);
-    //   if (testData) return testData;
-    // }
-
-    testDataFromFile = this.#getDataFromFile(testId);
+    testDataFromFile = this.#getDataFromFile(context);
 
     if (testDataFromFile.length) {
-      if (this.dataType === 'log') return testDataFromFile.join('\n');
       return testDataFromFile;
     }
-    debug(`No "${this.dataType}" data for test id ${testId} in both file and global variable`);
+    debug(`No "${this.dataType}" data for test id ${context} in both file and global variable`);
 
     // in case no data found for test
     return null;
   }
 
   /**
-   * This method is named as "try" because it does not guarantee that test id could be retrieved.
-   * Context could be anything (test, suite, string, etc) which is used to define testId.
-   * Or it could represent any other entity (which does not contain test id).
-   * @param {*} context
-   */
-  #tryToRetrieveTestId(context) {
-    if (!context) return null;
-    this.#refreshStorageType();
-
-    if (this.runningEnvironment === 'playwright' || context?.title) {
-      // context is testInfo
-      const testId = getTestIdFromTestTitle(context.title);
-      if (testId) return testId;
-    }
-
-    if (typeof context === 'string') {
-      const testId = getTestIdFromTestTitle(context);
-      if (testId) return testId;
-    }
-
-    return null;
-  }
-
-  /**
-   * Refreshes storage type (file or global variable) depending on current environment
-   * This method should be run on each attempt to put or get data from/to storage
-   * Because storage instance is created before the test runner is started. And storage type could be changed
-   */
-  #refreshStorageType() {
-    this.runningEnvironment = this.getRunningEnviroment();
-
-    // some test frameworks do not persist global variables, thus file storage is used for them (by default)
-    if (this.runningEnvironment === 'codeceptjs') this.isFileStorage = false;
-    // playwrigth stores logs by itself; but file storage is used for other data types for playwright
-    if (this.runningEnvironment === 'playwright' && this.dataType === 'log') this.isFileStorage = false;
-  }
-
-  /**
-   * @param {*} testId
+   * @param {string} context
    * @returns aray of data (any type)
    */
-  #getDataFromGlobalVar(testId) {
+  #getDataFromGlobalVar(context) {
     try {
       if (global?.testomatioDataStore[this.dataType]) {
-        const testData = global.testomatioDataStore[this.dataType][testId];
-        if (testData) debug(`"${this.dataType}" data for test id ${testId}:`, testData.join(', '));
+        const testData = global.testomatioDataStore[this.dataType][context];
+        if (testData) debug(`"${this.dataType}" data for test id ${context}:`, testData.join(', '));
         return testData || [];
       }
-      // debug(`No ${this.dataType} data for test id ${testId} in <global> storage`);
+      // debug(`No ${this.dataType} data for test context ${context} in <global> storage`);
       return [];
     } catch (e) {
       // there could be no data, ignore
@@ -231,19 +114,19 @@ class DataStorage {
 
   /**
    *
-   * @param {*} testId
+   * @param {*} context
    * @returns array of data (any type)
    */
-  #getDataFromFile(testId) {
+  #getDataFromFile(context) {
     try {
-      const filepath = join(this.dataDirPath, `${this.dataType}_${testId}`);
+      const filepath = join(this.dataDirPath, `${this.dataType}_${context}`);
       if (fs.existsSync(filepath)) {
         const testDataAsText = fs.readFileSync(filepath, 'utf-8');
-        if (testDataAsText) debug(`"${this.dataType}" data for test id ${testId}:`, testDataAsText);
+        if (testDataAsText) debug(`"${this.dataType}" data for test id ${context}:`, testDataAsText);
         const testDataArr = testDataAsText?.split(os.EOL) || [];
         return testDataArr;
       }
-      // debug(`No ${this.dataType} data for test id ${testId} in <file> storage`);
+      // debug(`No ${this.dataType} data for test ${context} in <file> storage`);
       return [];
     } catch (e) {
       // there could be no data, ignore
@@ -254,23 +137,23 @@ class DataStorage {
   /**
    * Puts data to global variable. Unlike the file storage, stores data in array (file storage just append as string).
    * @param {*} data
-   * @param {*} testId
+   * @param {*} context
    */
-  #putDataToGlobalVar(data, testId) {
-    debug(`Saving data to global variable for test ${testId}:`, data);
+  #putDataToGlobalVar(data, context) {
+    debug('Saving data to global variable for ', context, ':', data);
     if (!global.testomatioDataStore) global.testomatioDataStore = {};
     if (!global.testomatioDataStore?.[this.dataType]) global.testomatioDataStore[this.dataType] = {};
 
-    if (!global.testomatioDataStore?.[this.dataType][testId]) global.testomatioDataStore[this.dataType][testId] = [];
-    global.testomatioDataStore[this.dataType][testId].push(data);
+    if (!global.testomatioDataStore?.[this.dataType][context]) global.testomatioDataStore[this.dataType][context] = [];
+    global.testomatioDataStore[this.dataType][context].push(data);
   }
 
-  #putDataToFile(data, testId) {
+  #putDataToFile(data, context) {
     if (typeof data !== 'string') data = JSON.stringify(data);
-    const filename = `${this.dataType}_${testId}`;
+    const filename = `${this.dataType}_${context}`;
     const filepath = join(this.dataDirPath, filename);
     if (!fs.existsSync(this.dataDirPath)) fileSystem.createDir(this.dataDirPath);
-    debug('Saving data to file for test', testId, 'to', filepath, ':\n', data, '\n');
+    debug('Saving data to file for', context, 'to', filepath, ':\n', data, '\n');
 
     // append new line if file already exists (in this case its definitely includes some data)
     if (fs.existsSync(filepath)) {
@@ -285,23 +168,3 @@ module.exports = 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: ability to intercept multiple loggers (upd: no need)
-
-/* does not work for Playwright
-    try {
-      const { test } = require('@playwright/test');
-      test.beforeEach(async ({}, testInfo) => {
-        global.testTitle = testInfo.title;
-        global.testomatioRunningEnvironment = 'playwright';
-      });
-    } catch (e) {
-      // ignore
-    }
-// Playwright storage works fine only when running tests from a single file;
-// otherwise it is not possible to define test id/title, it is overwritten
- TODO: the only way implementation for Pw for now is to pass testInfo inside test
-//  (and process this testInfo inside "put" function)
-*/

package/lib/storages/key-value-storage.js

@@ -2,23 +2,39 @@ const debug = require('debug')('@testomatio/reporter:key-value-storage');
 const DataStorage = require('./data-storage');
 
 class KeyValueStorage {
+  static #instance;
+
+  #context;
+
   constructor() {
     this.dataStorage = new DataStorage('keyvalue');
+  }
 
-    // singleton
-    if (!KeyValueStorage.instance) {
-      KeyValueStorage.instance = this;
+  /**
+   * 
+   * @returns {KeyValueStorage}
+   */
+  static getInstance() {
+    if (!this.#instance) {
+      this.#instance = new KeyValueStorage();
     }
+    return this.#instance;
+  }
+
+  /**
+   * @param {string} context - suite title + test title
+   */
+  setContext(context) {
+    this.#context = context;
   }
 
   /**
    * Stores key-value pair and passes it to reporter
    * @param {{key: string}} keyValue - key-value pair(s) as object
-   * @param {*} context testId or test title
    */
-  put(keyValue, context = null) {
+  put(keyValue) {
     if (!keyValue) return;
-    this.dataStorage.putData(keyValue, context);
+    this.dataStorage.putData(keyValue, this.#context);
   }
 
   #isKeyValueObject(smth) {
@@ -30,7 +46,8 @@ class KeyValueStorage {
    * @param {*} context testId or test context from test runner
    * @returns {Object} key-values pairs as object, e.g. {priority: 'high', browser: 'chrome'}
    */
-  get(context) {
+  get(context = null) {
+    context = context || this.#context;
     if (!context) return null;
 
     const keyValuesList = this.dataStorage.getData(context);
@@ -53,6 +70,4 @@ class KeyValueStorage {
   }
 }
 
-KeyValueStorage.instance = null;
-
-module.exports = new KeyValueStorage();
+module.exports.keyValueStorage = KeyValueStorage.getInstance();

package/lib/storages/logger.js

@@ -26,18 +26,45 @@ class Logger {
   // set default logger to be used in log, warn, error, etc methods
   #originalUserLogger = { ...console };
 
-  #dataStorage = new DataStorage('log');
+  #dataStorage;
+
+  #context = null;
+
+  static #instance;
+
+  /**
+   *
+   * @returns {Logger}
+   */
+  static getInstance() {
+    if (!this.#instance) {
+      this.#instance = new Logger();
+    }
+    return this.#instance;
+  }
 
   logLevel = process?.env?.LOG_LEVEL?.toUpperCase() || 'ALL';
 
   constructor() {
+    this.#dataStorage = new DataStorage('log');
+
     // intercept console by default
     this.intercept(console);
+  }
 
-    // singleton
-    if (!Logger.instance) {
-      Logger.instance = this;
-    }
+  /**
+   * @param { 'file' | 'global' } storageType
+   */
+  setStorageType(storageType) {
+    this.isFileStorage = storageType === 'file';
+    this.#dataStorage.isFileStorage = this.isFileStorage;
+  }
+
+  /**
+   * @param {string} context - suite title + test title
+   */
+  setContext(context) {
+    this.#context = context;
   }
 
   /**
@@ -55,17 +82,17 @@ class Logger {
       }
     }
     logs = chalk.blue(`> ${logs}`);
-    this.#dataStorage.putData(logs);
+    this.#dataStorage.putData(logs, this.#context);
   }
 
   /**
    *
-   * @param {*} context testId or test context from test runner
-   * @returns
+   * @param {string} context testId or test context from test runner
+   * @returns {string[]}
    */
   getLogs(context) {
     const logs = this.#dataStorage.getData(context);
-    return logs || '';
+    return logs;
   }
 
   #stringifyLogs(...args) {
@@ -124,7 +151,7 @@ class Logger {
       logs = this.#stringifyLogs(strings, ...args);
     }
     this.#originalUserLogger.log(logs);
-    this.#dataStorage.putData(logs);
+    this.#dataStorage.putData(logs, this.#context);
   }
 
   /**
@@ -140,8 +167,12 @@ class Logger {
     if (severity < LEVELS[this.logLevel]?.severity) return;
 
     const logs = this.#stringifyLogs(...argsArray);
+
+    // skip logs from testomatio reporter itself
+    if (logs.includes('[TESTOMATIO]')) return;
+
     const colorizedLogs = chalk[LEVELS[level].color](logs);
-    this.#dataStorage.putData(colorizedLogs);
+    this.#dataStorage.putData(colorizedLogs, this.#context);
     try {
       // level.toLowerCase() represents method name (log, warn, error, etc)
       this.#originalUserLogger[level.toLowerCase()](colorizedLogs);
@@ -239,11 +270,7 @@ class Logger {
   }
 }
 
-Logger.instance = null;
-
-const logger = new Logger();
-
-module.exports = logger;
+module.exports.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
@@ -288,3 +315,6 @@ Finally, in the test it will look like:
 
 Parallelization in Cypress is only available if using Cypress Dashboard??
 */
+
+// TODO: add time to logs
+// TODO: add logger name to logs?

package/lib/utils/utils.js

@@ -290,19 +290,6 @@ function removeColorCodes(input) {
   return input.replace(/\x1b\[[0-9;]*m/g, '');
 }
 
-const jestHelpers = {
-  getIdOfCurrentlyRunningTest: () => {
-    if (!process.env.JEST_WORKER_ID) return null;
-    try {
-      // @ts-expect-error "expect" could only be defined inside Jest environement (forbidden to import it outside)
-      // eslint-disable-next-line no-undef
-      if (expect && expect?.getState()?.currentTestName) return parseTest(expect?.getState()?.currentTestName);
-    } catch (e) {
-      return null;
-    }
-  },
-};
-
 module.exports = {
   isSameTest,
   fetchSourceCode,
@@ -312,7 +299,6 @@ module.exports = {
   fetchFilesFromStackTrace,
   fileSystem,
   getCurrentDateTime,
-  jestHelpers,
   specificTestInfo,
   isValidUrl,
   ansiRegExp,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testomatio/reporter",
-  "version": "1.1.0-beta.mocha-create.8",
+  "version": "1.1.1-beta-codecept-logger",
   "description": "Testomatio Reporter Client",
   "main": "./lib/reporter.js",
   "typings": "typings/index.d.ts",