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

package/lib/dataStorage.js

@@ -5,45 +5,23 @@ const os = require('os');
 const { join } = require('path');
 const JestReporter = require('./adapter/jest');
 const { TESTOMAT_TMP_STORAGE } = require('./constants');
-const { fileSystem } = require('./util');
+const { fileSystem } = require('./utils/utils');
+const getTestIdFromTestTitle = require('./utils/utils').parseTest;
 
 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' | ...
+   * Stores data to global variable or to file depending on what is applicable for current test runner
+   * (running environment).
    * @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');
+  constructor(dataType) {
     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);
-    }
+    this.isFileStorage = true;
+    this.#refreshStorageType();
 
-    debug(`Data storage mode: ${this.isFileStorage ? 'file' : 'memory'}`);
-  }
-
-  // TODO: implement
-  getTestIdFromContext(context) { // eslint-disable-line
-    // eslint-disable-line
-    // return testId;
+    this.dataDirPath = path.join(TESTOMAT_TMP_STORAGE.mainDir, this.dataType);
+    fileSystem.createDir(this.dataDirPath);
   }
 
   /**
@@ -51,10 +29,18 @@ class DataStorage {
    * @returns jest | mocha | ...
    */
   getRunningEnviroment() {
+    // jest
     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;
+
+    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;
   }
 
   /**
@@ -64,95 +50,169 @@ class DataStorage {
    * @returns
    */
   putData(data, context = null) {
-    let testId = null;
-    if (typeof context === 'string') {
-      testId = context;
-    } else {
-      // TODO: derive testId from context
-      // testId = context...
+    this.#refreshStorageType();
+
+    let testId = this.#tryToRetrieveTestId(context) || null;
+
+    if (this.runningEnvironment === 'codeceptjs') {
+      this.isFileStorage = false;
+      testId = testId ?? global.testomatioDataStore?.currentlyRunningTestId;
+    }
+
+    if (this.runningEnvironment === 'jest') {
+      testId = testId ?? JestReporter.getIdOfCurrentlyRunningTest();
     }
 
-    // try to get testId for Jest
-    testId = testId ?? JestReporter.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 is not provided, data is be saved to `{dataType}_other` file;
-    if (!testId) testId = 'other';
+    if (!testId) {
+      debug(`No test id provided for ${this.dataType} data: ${data}`);
+      return;
+    }
 
     if (this.isFileStorage) {
-      this._putDataToFile(data, testId);
+      this.#putDataToFile(data, testId);
     } else {
-      this._putDataToGlobalVar(data, testId);
+      this.#putDataToGlobalVar(data, testId);
     }
   }
 
   /**
-   * Returns data, stored for specific testId (or data which was stored without test id specified)
+   * Returns data, stored for specific testId (or data which was stored without test id specified).
+   * This method will get data from global variable. But if it is not available, it will try to get data from file.
+   * Thus, good approach is to remove file storage folder before each test run (and after, for sure).
    *
-   * (Don't try to guess the execution environment (e.g. test runner) inside this method, it could be any)
+   * Defining the execution environment is not guaranteed! Is used only as additional check.
    * @param {*} context could be testId or any context (test, suite, etc) which is used to define testId
    * @returns
    */
   getData(context) {
+    this.#refreshStorageType();
+
     let testId = null;
     if (typeof context === 'string') {
-      testId = context;
+      testId = this.#tryToRetrieveTestId(context) || context;
     } else {
       // TODO: derive testId from context
       // testId = context...
     }
 
-    if (!testId) testId = 'other';
-
-    if (this.isFileStorage) {
-      return this._getDataFromFile(testId);
+    if (!testId) {
+      debug(`Cannot get test id from passed context:`, context);
+      return null;
     }
+
+    let testData = '';
+
     if (global?.testomatioDataStore) {
-      return this._getDataFromGlobalVar(testId);
+      testData = this.#getDataFromGlobalVar(testId);
+      // these frameworks use global variable storage
+      if (testData && ['cucumber', 'codeceptjs'].includes(this.runningEnvironment)) return testData;
     }
+
+    /* 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;
+    // }
+
+    const testDataFromFile = this.#getDataFromFile(testId);
+    testData += testDataFromFile || '';
+
     debug(`No ${this.dataType} data for test id ${testId} in both file and global variable`);
+    return testData || '';
+  }
+
+  /**
+   * 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;
   }
 
-  _getDataFromGlobalVar(testId) {
+  /**
+   * 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 (['playwright', 'codeceptjs'].includes(this.runningEnvironment)) this.isFileStorage = false;
+  }
+
+  #getDataFromGlobalVar(testId) {
     try {
-      if (global?.testomatioDataStore[this.dataDirName]) {
-        const testData = global.testomatioDataStore[this.dataDirName][testId];
+      if (global?.testomatioDataStore[this.dataType]) {
+        const testData = global.testomatioDataStore[this.dataType][testId];
         debug(`Data for test id ${testId}:\n${testData}`);
-        return testData;
+        return testData || '';
       }
-      debug(`No ${this.dataType} data for test id ${testId}`);
-      return null;
+      debug(`No ${this.dataType} data for test id ${testId} in <global> storage`);
+      return '';
     } catch (e) {
       // there could be no data, ignore
     }
   }
 
-  _getDataFromFile(testId) {
+  #getDataFromFile(testId) {
     try {
-      const filepath = join(TESTOMAT_TMP_STORAGE.mainDir, `${this.dataType}_${testId}`);
+      const filepath = join(this.dataDirPath, `${this.dataType}_${testId}`);
       if (fs.existsSync(filepath)) {
         const testData = fs.readFileSync(filepath, 'utf-8');
         debug(`Data for test id ${testId}:\n${testData}`);
-        return testData;
+        return testData || '';
       }
-      debug(`No ${this.dataType} data for test id ${testId}`);
-      return null;
+      debug(`No ${this.dataType} data for test id ${testId} in <file> storage`);
+      return '';
     } catch (e) {
       // there could be no data, ignore
     }
-    return null;
+    return '';
   }
 
-  _putDataToGlobalVar(data, testId) {
+  #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;
+    if (!global.testomatioDataStore) global.testomatioDataStore = {};
+    if (!global.testomatioDataStore?.[this.dataType]) global.testomatioDataStore[this.dataType] = {};
+    global.testomatioDataStore?.[this.dataType][testId] // eslint-disable-line no-unused-expressions
+      ? (global.testomatioDataStore[this.dataType][testId] += `\n${data}`)
+      : (global.testomatioDataStore[this.dataType][testId] = data);
   }
 
-  _putDataToFile(data, testId) {
+  #putDataToFile(data, testId) {
     if (typeof data !== 'string') data = JSON.stringify(data);
     const filename = `${this.dataType}_${testId}`;
-    const filepath = join(TESTOMAT_TMP_STORAGE.mainDir, filename);
+    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');
 
     // TODO: handle multiple invocations of JSON.stringify.
@@ -169,4 +229,4 @@ module.exports.DataStorage = DataStorage;
 // TODO: rewrite client - everything regarding storing artifacts
 // TODO: try to define adapter inside client
 // TODO: use .env
-// TODO: ability to intercept multiple loggers
+// TODO: ability to intercept multiple loggers (upd: no need)

package/lib/junit-adapter/java.js

@@ -10,24 +10,42 @@ class JavaAdapter extends Adapter {
 
   formatTest(t) {
     const fileParts = t.suite_title.split('.')
-    const example = t.title.match(/\[(.*)\]/)?.[1];
-    if (example) t.example = { "#": example }
 
     t.file = namespaceToFileName(t.suite_title);
     t.title = t.title.split('(')[0];
+
+    // detect params
+    const paramMatches = t.title.match(/\[(.*?)\]/g);
+
+    if (paramMatches) {
+      const params = paramMatches.map((_match, index) => `param${index + 1}`);
+      if (params.length === 1) params[0] = 'param';
+      let paramIndex = 0;
+    
+      t.title = t.title.replace(/: \[(.*?)\]/g, () => {
+        if (params.length < 2) return `\${param}`
+        const paramName = params[paramIndex] || `param${paramIndex + 1}`;
+        paramIndex++;
+        return `\${${paramName}}`;
+      });
+      const example = {};
+      paramMatches.forEach((match, index) => { example[params[index]] = match.replace(/[[\]]/g, '') });
+      t.example = example;
+    }
+
     t.suite_title = fileParts[fileParts.length - 1].replace(/\$/g, ' | ')
     return t;
   }
 
-  formatStack(t) {
-    const stack = super.formatStack(t);
+  // formatStack(t) {
+  //   const stack = super.formatStack(t);
 
-    const file = t.suite_title.split('.');
+  //   const file = t.suite_title.split('.');
 
-    const fileLine = `at .*${file[file.length - 1]}\.java:(\\d+)` // eslint-disable-line no-useless-escape
-    const regexp = new RegExp(fileLine,"g")
-    return stack.replace(regexp, `${this.opts.javaTests}${path.sep}${namespaceToFileName(t.suite_title)}:$1:`);
-  }
+  //   const fileLine = `at .*${file[file.length - 1]}\.java:(\\d+)` // eslint-disable-line no-useless-escape
+  //   const regexp = new RegExp(fileLine,"g")
+  //   return stack.replace(regexp, `${this.opts.javaTests}${path.sep}${namespaceToFileName(t.suite_title)}:$1:`);
+  // }
 }
 
 function namespaceToFileName(fileName) {