testomatio-reporter-cli 2.8.4 → 2.8.5-beta.2-yarn

package/src/constants.js

@@ -0,0 +1,72 @@
+import pc from 'picocolors';
+import os from 'os';
+import path from 'path';
+import { transformEnvVarToBoolean } from './utils/utils.js';
+
+const APP_PREFIX = pc.gray('[TESTOMATIO]');
+const TESTOMATIO_REQUEST_TIMEOUT = parseInt(process.env.TESTOMATIO_REQUEST_TIMEOUT, 10);
+if (TESTOMATIO_REQUEST_TIMEOUT) {
+  console.log(`${APP_PREFIX} Request timeout is set to ${TESTOMATIO_REQUEST_TIMEOUT / 1000}s`);
+}
+const REQUEST_TIMEOUT = TESTOMATIO_REQUEST_TIMEOUT || 20 * 1000;
+const SCREENSHOTS_ON_STEPS = process.env.TESTOMATIO_SCREENSHOTS_ON_STEPS == null
+  || transformEnvVarToBoolean(process.env.TESTOMATIO_SCREENSHOTS_ON_STEPS);
+
+const TESTOMAT_TMP_STORAGE_DIR = path.join(os.tmpdir(), 'testomatio_tmp');
+
+const CSV_HEADERS = [
+  { id: 'suite_title', title: 'Suite_title' },
+  { id: 'title', title: 'Title' },
+  { id: 'status', title: 'Status' },
+  { id: 'message', title: 'Message' },
+  { id: 'stack', title: 'Stack' },
+];
+
+const STATUS = {
+  PASSED: 'passed',
+  FAILED: 'failed',
+  SKIPPED: 'skipped',
+  FINISHED: 'finished',
+};
+// html pipe var
+const HTML_REPORT = {
+  FOLDER: 'html-report',
+  REPORT_DEFAULT_NAME: 'testomatio-report.html',
+  TEMPLATE_NAME: 'testomatio.hbs',
+};
+
+// markdown pipe var
+const MARKDOWN_REPORT = {
+  FOLDER: 'md-report',
+  REPORT_DEFAULT_NAME: 'testomatio-report.md',
+};
+
+const testomatLogoURL = 'https://avatars.githubusercontent.com/u/59105116?s=36&v=4';
+
+const REPORTER_REQUEST_RETRIES = {
+  retryTimeout: 5 * 1000, // sum = 5sec
+  retriesPerRequest: 2,
+  maxTotalRetries: Number(process.env.TESTOMATIO_MAX_REQUEST_FAILURES_COUNT) || 10,
+  withinTimeSeconds: Number(process.env.TESTOMATIO_MAX_REQUEST_RETRIES_WITHIN_TIME_SECONDS) || 60,
+};
+
+const DEBUG_FILE = 'testomatio.debug';
+
+function getCreateRunRequestTimeout() {
+  return Math.max(REQUEST_TIMEOUT, 80 * 1000);
+}
+
+export {
+  APP_PREFIX,
+  TESTOMAT_TMP_STORAGE_DIR,
+  CSV_HEADERS,
+  STATUS,
+  HTML_REPORT,
+  MARKDOWN_REPORT,
+  REQUEST_TIMEOUT,
+  getCreateRunRequestTimeout,
+  testomatLogoURL,
+  REPORTER_REQUEST_RETRIES,
+  SCREENSHOTS_ON_STEPS,
+  DEBUG_FILE,
+};

package/src/data-storage.js

@@ -0,0 +1,204 @@
+import createDebugMessages from 'debug';
+import fs from 'fs';
+import path, { join } from 'path';
+import os from 'os';
+import { TESTOMAT_TMP_STORAGE_DIR } from './constants.js';
+import { fileSystem, testRunnerHelper } from './utils/utils.js';
+import crypto from 'crypto';
+
+const debug = createDebugMessages('@testomatio/reporter:storage');
+class DataStorage {
+  static #instance;
+
+  context;
+
+  /**
+   *
+   * @returns {DataStorage}
+   */
+  static getInstance() {
+    if (!this.#instance) {
+      this.#instance = new DataStorage();
+    }
+    return this.#instance;
+  }
+
+  setContext(context) {
+    this.context = context;
+  }
+
+  /**
+   * Creates data storage instance as singleton
+   * Stores data to global variable or to file depending on what is applicable for current test runner (adapter)
+   * 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).
+   */
+  constructor() {
+    // some frameworks use global variable to store data, some use file storage
+    this.isFileStorage = true;
+  }
+
+  /**
+   * Puts any data to storage (file or global variable).
+   * If file: stores data as text, if global variable – stores as array of data.
+   * @param {'log' | 'artifact' | 'keyvalue' | 'links'} dataType
+   * @param {*} data anything you want to store (string, object, array, etc)
+   * @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(dataType, data, context = null) {
+    if (!dataType || !data) return;
+
+    context = context || this.context || testRunnerHelper.getNameOfCurrentlyRunningTest();
+    if (!context) {
+      // debug(`No context provided for "${dataType}" data:`, data);
+      return;
+    }
+    const contextHash = stringToMD5Hash(context);
+
+    if (this.isFileStorage) {
+      const dataDirPath = path.join(TESTOMAT_TMP_STORAGE_DIR, dataType);
+      fileSystem.createDir(dataDirPath);
+      this.#putDataToFile(dataType, data, contextHash);
+    } else {
+      this.#putDataToGlobalVar(dataType, data, contextHash);
+    }
+  }
+
+  /**
+   * 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 {'log' | 'artifact' | 'keyvalue' | 'links'} dataType
+   * @param {string} context
+   * @returns {any []} array of data (any type), null (if no data found for context) or string (if data type is log)
+   */
+  getData(dataType, context) {
+    // TODO: think if it could be useful
+    // context = context || this.context || testRunnerHelper.getNameOfCurrentlyRunningTest();
+
+    if (!context) {
+      debug(`Trying to get "${dataType}" data without context`);
+      return null;
+    }
+
+    const contextHash = stringToMD5Hash(context);
+
+    let testDataFromFile = [];
+    let testDataFromGlobalVar = [];
+
+    if (global?.testomatioDataStore) {
+      testDataFromGlobalVar = this.#getDataFromGlobalVar(dataType, contextHash);
+      if (testDataFromGlobalVar) {
+        if (testDataFromGlobalVar.length) return testDataFromGlobalVar;
+      }
+      // don't return nothing if no data in global variable
+    }
+
+    testDataFromFile = this.#getDataFromFile(dataType, contextHash);
+
+    if (testDataFromFile.length) {
+      return testDataFromFile;
+    }
+    // debug(`No "${dataType}" data for context "${contextHash}" in both file and global variable`);
+
+    // in case no data found for context
+    return null;
+  }
+
+  /**
+   * @param {'log' | 'artifact' | 'keyvalue' | 'links'} dataType
+   * @param {string} context
+   * @returns aray of data (any type)
+   */
+  #getDataFromGlobalVar(dataType, context) {
+    try {
+      if (global?.testomatioDataStore[dataType]) {
+        const testData = global.testomatioDataStore[dataType][context];
+        if (testData) debug('<=', dataType, 'global', context, testData);
+        return testData || [];
+      }
+      // debug(`No ${this.dataType} data for context ${context} in <global> storage`);
+      return [];
+    } catch (e) {
+      // there could be no data, ignore
+    }
+  }
+
+  /**
+   * @param {'log' | 'artifact' | 'keyvalue' | 'links'} dataType
+   * @param {*} context
+   * @returns array of data (any type)
+   */
+  #getDataFromFile(dataType, context) {
+    const dataDirPath = path.join(TESTOMAT_TMP_STORAGE_DIR, dataType);
+    try {
+      const filepath = join(dataDirPath, `${dataType}_${context}`);
+      if (fs.existsSync(filepath)) {
+        const testDataAsText = fs.readFileSync(filepath, 'utf-8');
+        if (testDataAsText) debug('<=', dataType, 'file', context, testDataAsText);
+        const testDataArr = testDataAsText?.split(os.EOL) || [];
+        debug('<=', dataType, 'file', context, testDataArr);
+        return testDataArr;
+      }
+      // debug(`No ${this.dataType} data for ${context} in <file> storage`);
+      return [];
+    } catch (e) {
+      // there could be no data, ignore
+    }
+    return [];
+  }
+
+  /**
+   * Puts data to global variable. Unlike the file storage, stores data in array (file storage just append as string).
+   * @param {'log' | 'artifact' | 'keyvalue' | 'links'} dataType
+   * @param {*} data
+   * @param {*} context
+   */
+  #putDataToGlobalVar(dataType, data, context) {
+    debug('=>', dataType, 'global', context, data);
+    if (!global.testomatioDataStore) global.testomatioDataStore = {};
+    if (!global.testomatioDataStore?.[dataType]) global.testomatioDataStore[dataType] = {};
+
+    if (!global.testomatioDataStore?.[dataType][context]) global.testomatioDataStore[dataType][context] = [];
+    global.testomatioDataStore[dataType][context].push(data);
+  }
+
+  /**
+   * Puts data to file. Unlike the global variable storage, stores data as string
+   * @param {'log' | 'artifact' | 'keyvalue' | 'links'} dataType
+   * @param {*} data
+   * @param {string} context
+   * @returns
+   */
+  #putDataToFile(dataType, data, context) {
+    const dataDirPath = path.join(TESTOMAT_TMP_STORAGE_DIR, dataType);
+    if (typeof data !== 'string') data = JSON.stringify(data);
+    const filename = `${dataType}_${context}`;
+    const filepath = join(dataDirPath, filename);
+    if (!fs.existsSync(dataDirPath)) fileSystem.createDir(dataDirPath);
+    debug('=>', dataType, 'file', context, data);
+
+    // append new line if file already exists (in this case its definitely includes some data)
+    if (fs.existsSync(filepath)) {
+      fs.appendFileSync(filepath, os.EOL + data, 'utf-8');
+    } else {
+      fs.writeFileSync(filepath, data, 'utf-8');
+    }
+  }
+}
+
+function stringToMD5Hash(str) {
+  const md5 = crypto.createHash('md5');
+  md5.update(str);
+  const hash = md5.digest('hex');
+  return `${process.env.runId || 'run'}_${hash}`;
+}
+
+export const dataStorage = DataStorage.getInstance();
+
+export { stringToMD5Hash };
+
+// TODO: consider using fs promises instead of writeSync/appendFileSync to
+// prevent blocking and improve performance (probably queue usage will be required)

package/src/helpers.js

@@ -0,0 +1 @@
+export const isPlaywright = Boolean(process.env.PLAYWRIGHT_TEST || process.env.PLAYWRIGHT);

package/src/junit-adapter/adapter.js

@@ -0,0 +1,23 @@
+class Adapter {
+  constructor(opts) {
+    this.opts = opts;
+  }
+
+  getFilePath(t) {
+    return t.file;
+  }
+
+  formatTest(t) {
+    return t;
+  }
+
+  formatStack(t) {
+    return t.stack || '';
+  }
+
+  formatMessage(t) {
+    return t.message;
+  }
+}
+
+export default Adapter;

package/src/junit-adapter/csharp.js

@@ -0,0 +1,70 @@
+import path from 'path';
+import Adapter from './adapter.js';
+
+class CSharpAdapter extends Adapter {
+  formatTest(t) {
+    // Extract example from title if not already present
+    if (!t.example) {
+      const exampleMatch = t.title.match(/\((.*?)\)/);
+      if (exampleMatch) {
+        // Extract parameters as object with numeric keys for API
+        const params = exampleMatch[1]
+          .split(',')
+          .map(param => param.trim())
+          .filter(param => param !== '');
+        t.example = {};
+        params.forEach((param, index) => {
+          t.example[index] = param;
+        });
+      }
+    }
+
+    // Remove parameters from title to avoid duplicates in Test Suite
+    // The example field will be used for grouping on import
+    t.title = t.title.replace(/\(.*?\)/, '').trim();
+
+    const suite = t.suite_title.split('.');
+    t.suite_title = suite.pop();
+    t.file = namespaceToFileName(t.file);
+    return t;
+  }
+
+  getFilePath(t) {
+    if (!t.file) return null;
+
+    // Normalize path separators for cross-platform compatibility
+    let filePath = t.file.replace(/\\/g, '/');
+
+    // If file already has .cs extension, use it directly
+    if (filePath.endsWith('.cs')) {
+      // Make relative path if it's absolute
+      if (path.isAbsolute(filePath)) {
+        // Try to find project-relative path
+        const cwd = process.cwd().replace(/\\/g, '/');
+        if (filePath.startsWith(cwd)) {
+          filePath = path.relative(cwd, filePath).replace(/\\/g, '/');
+        }
+      }
+      return filePath;
+    }
+
+    // Convert namespace path to file path
+    const fileName = namespaceToFileName(filePath);
+    return fileName;
+  }
+}
+
+export default CSharpAdapter;
+
+function namespaceToFileName(fileName) {
+  if (!fileName) return '';
+
+  // If already a .cs file path, clean it up
+  if (fileName.endsWith('.cs')) {
+    return fileName.replace(/\\/g, '/');
+  }
+
+  const fileParts = fileName.split('.');
+  fileParts[fileParts.length - 1] = fileParts[fileParts.length - 1]?.replace(/\$.*/, '');
+  return `${fileParts.join('/')}.cs`;
+}

package/src/junit-adapter/index.js

@@ -0,0 +1,28 @@
+import Adapter from './adapter.js';
+import JavaScriptAdapter from './javascript.js';
+import JavaAdapter from './java.js';
+import PythonAdapter from './python.js';
+import RubyAdapter from './ruby.js';
+import CSharpAdapter from './csharp.js';
+
+function AdapterFactory(lang, opts) {
+  if (lang === 'java') {
+    return new JavaAdapter(opts);
+  }
+  if (lang === 'js') {
+    return new JavaScriptAdapter(opts);
+  }
+  if (lang === 'python') {
+    return new PythonAdapter(opts);
+  }
+  if (lang === 'ruby') {
+    return new RubyAdapter(opts);
+  }
+  if (lang === 'c#' || lang === 'csharp') {
+    return new CSharpAdapter(opts);
+  }
+
+  return new Adapter(opts);
+}
+
+export default AdapterFactory;

package/src/junit-adapter/java.js

@@ -0,0 +1,58 @@
+import path from 'path';
+import Adapter from './adapter.js';
+
+class JavaAdapter extends Adapter {
+  getFilePath(t) {
+    const fileName = namespaceToFileName(t.suite_title);
+    return this.opts.javaTests + path.sep + fileName;
+  }
+
+  formatTest(t) {
+    const fileParts = t.suite_title.split('.');
+
+    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);
+
+  //   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:`);
+  // }
+}
+
+function namespaceToFileName(fileName) {
+  const fileParts = fileName.split('.');
+  fileParts[fileParts.length - 1] = fileParts[fileParts.length - 1]?.replace(/\$.*/, '');
+  return `${fileParts.join(path.sep)}.java`;
+}
+
+export default JavaAdapter;

package/src/junit-adapter/javascript.js

@@ -0,0 +1,31 @@
+import createCallsiteRecord from 'callsite-record';
+import path from 'path';
+import Adapter from './adapter.js';
+
+class JavaScriptAdapter extends Adapter {
+  formatStack(t) {
+    let stack = super.formatStack(t);
+
+    try {
+      const error = new Error(stack.split('\n')[0]);
+      error.stack = stack;
+      const record = createCallsiteRecord({
+        forError: error,
+      });
+      // @ts-ignore
+      if (record && !record.filename.startsWith('http')) {
+        stack += record.renderSync({
+          stackFilter: frame =>
+            frame.fileName?.indexOf(path.sep) > -1 &&
+            frame.fileName?.indexOf('node_modules') < 0 &&
+            frame.fileName?.indexOf('internal') < 0,
+        });
+      }
+      return stack;
+    } catch (err) {
+      return stack;
+    }
+  }
+}
+
+export default JavaScriptAdapter;