@testomatio/reporter 1.0.8 → 1.0.9-beta.2

package/lib/adapter/mocha.js

@@ -3,15 +3,18 @@ const Mocha = require('mocha');
 const debug = require('debug')('@testomatio/reporter:adapter:mocha');
 const chalk = require('chalk');
 const TestomatClient = require('../client');
-const { STATUS } = require('../constants');
-const { parseTest, specificTestInfo } = require('../util');
+const { STATUS, TESTOMAT_TMP_STORAGE } = require('../constants');
+const { parseTest, specificTestInfo, fileSystem } = require('../util');
 const ArtifactStorage = require('../_ArtifactStorageOld');
 
-const { EVENT_RUN_BEGIN, EVENT_RUN_END, EVENT_TEST_FAIL, EVENT_TEST_PASS, EVENT_TEST_PENDING } = Mocha.Runner.constants;
+const { EVENT_RUN_BEGIN, EVENT_RUN_END, EVENT_TEST_FAIL, EVENT_TEST_PASS, EVENT_TEST_PENDING } =
+  Mocha.Runner.constants;
 
 function MochaReporter(runner, opts) {
   Mocha.reporters.Base.call(this, runner);
-  let passes = 0; let failures = 0; let skipped = 0;
+  let passes = 0;
+  let failures = 0;
+  let skipped = 0;
   let artifactStore;
 
   const apiKey = opts?.reporterOptions?.apiKey || process.env.TESTOMATIO;
@@ -25,33 +28,33 @@ function MochaReporter(runner, opts) {
   runner.on(EVENT_RUN_BEGIN, () => {
     client.createRun();
 
-    const params = { 
-      toFile: true
+    const params = {
+      toFile: true,
     };
-    
-    artifactStore = runner._workerReporter !== undefined
-      ? new ArtifactStorage(params)
-      : new ArtifactStorage();
+
+    artifactStore = runner._workerReporter !== undefined ? new ArtifactStorage(params) : new ArtifactStorage();
+
+    fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
   });
 
-  runner.on(EVENT_TEST_PASS, async(test) => {
+  runner.on(EVENT_TEST_PASS, async test => {
     passes += 1;
     console.log(chalk.bold.green('✔'), test.fullTitle());
     const testId = parseTest(test.title);
 
-    const specificTest =  specificTestInfo(test);
+    const specificTest = specificTestInfo(test);
     const content = await artifactStore.artifactByTestName(specificTest);
 
     debug(`test=${specificTest} content = `, content);
 
     client.addTestRun(
-      STATUS.PASSED, 
+      STATUS.PASSED,
       {
         test_id: testId,
         title: test.title,
         time: test.duration,
       },
-      content
+      content,
     );
   });
 
@@ -66,24 +69,25 @@ function MochaReporter(runner, opts) {
     });
   });
 
-  runner.on(EVENT_TEST_FAIL, async(test, err) => {
+  runner.on(EVENT_TEST_FAIL, async (test, err) => {
     failures += 1;
     console.log(chalk.bold.red('✖'), test.fullTitle(), chalk.gray(err.message));
     const testId = parseTest(test.title);
 
-    const specificTest =  specificTestInfo(test);
+    const specificTest = specificTestInfo(test);
     const content = await artifactStore.artifactByTestName(specificTest);
 
     debug(`fail test=${specificTest} content = `, content);
 
     client.addTestRun(
-      STATUS.FAILED, {
+      STATUS.FAILED,
+      {
         error: err,
         test_id: testId,
         title: test.title,
         time: test.duration,
-      }, 
-      content
+      },
+      content,
     );
   });
 

package/lib/bin/startTest.js

@@ -13,9 +13,11 @@ program
   .option('--launch', 'Start a new run and return its ID')
   .option('--finish', 'Finish Run by its ID')
   .option("--env-file <envfile>", "Load environment variables from env file")
-  .action(opts => {
+  .option("--filter <filter>", "Additional execution filter")
+  .action(async (opts) => {
+    const { launch, finish, filter } = opts;
+    let { command } = opts;
 
-    const { command, launch, finish } = opts;
     if (opts.envFile) require('dotenv').config(opts.envFile); // eslint-disable-line
 
     const apiKey = process.env['INPUT_TESTOMATIO-KEY'] || process.env.TESTOMATIO;
@@ -51,6 +53,27 @@ program
 
     let exitCode = 0;
 
+    const client = new TestomatClient({ apiKey, title, parallel: true });
+
+    if(filter) {
+      const [pipe, ...optsArray] = filter.split(":");
+      const opts = optsArray.join(":");
+
+      try { 
+        const tests = await client.prepareRun({pipe, opts});
+
+        if(!tests || tests.length === 0) {
+          return;
+        }
+
+        const grep = ` --grep (${tests.join('|')})`;
+        command += grep;
+      }
+      catch(err) {
+        console.log(APP_PREFIX, err);
+      }
+    }
+
     if (!command.split) {
       process.exitCode = 255;
       console.log(APP_PREFIX, `No command provided. Use -c option to launch a test runner.`);
@@ -73,8 +96,6 @@ program
       return;
     }
 
-    const client = new TestomatClient({ apiKey, title, parallel: true });
-
     client.createRun().then(() => {
       const cmd = spawn(testCmds[0], testCmds.slice(1), { stdio: 'inherit' });
 

package/lib/client.js

@@ -27,9 +27,60 @@ class Client {
     this.queue = Promise.resolve();
     this.totalUploaded = 0;
     this.version = JSON.parse(fs.readFileSync(join(__dirname, '..', 'package.json')).toString()).version;
+    this.executionList = Promise.resolve();
+
     console.log(APP_PREFIX, `Testomatio Reporter v${this.version}`);
   }
 
+  /**
+   * Asynchronously prepares the execution list for running tests through various pipes.
+   * Each pipe in the client is checked for enablement, 
+   * and if all pipes are disabled, the function returns a resolved Promise.
+   * Otherwise, it executes the `prepareRun` method for each enabled pipe and collects the results.
+   * The results are then filtered to remove any undefined values.
+   * If no valid results are found, the function returns undefined.
+   * Otherwise, it returns the first non-empty array from the filtered results.
+   *
+   * @param {Object} params - The options for preparing the test execution list.
+   * @param {string} params.pipe - Name of the executed pipe.
+   * @param {string} params.opts - Filter option.
+   * @returns {Promise<any>} - A Promise that resolves to an 
+   * array containing the prepared execution list,
+   * or resolves to undefined if no valid results are found or if all pipes are disabled.
+   */
+  async prepareRun(params) {
+    const { pipe, opts } = params;
+    // all pipes disabled, skipping
+    if (!this.pipes.some(p => p.isEnabled)) {
+      return Promise.resolve();
+    }
+
+    try {
+      if (pipe.toLowerCase() !== "testomatio") {
+        //TODO: for the future for the another pipes
+        console.warn(APP_PREFIX, `At the moment processing is available only for the "testomatio" key. Example: "testomatio:tag-name=xxx"`)
+        return;
+      }
+
+      const results = await Promise.all(this.pipes.map(async p => {
+        return { pipe: p.toString(), result: await p.prepareRun(opts) };
+      }));
+    
+      const result = results.filter(p => p.pipe.includes('Testomatio'))[0]?.result;
+
+      if (!result || result.length === 0) {
+        return;
+      } 
+  
+      debug('Execution tests list', result);
+
+      return result;
+    } catch (err) {
+      console.error(APP_PREFIX, err);
+      return;
+    }
+  }
+
   /**
    * Used to create a new Test run
    *

package/lib/dataStorage.js

@@ -11,7 +11,8 @@ const getTestIdFromTestTitle = require('./util').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.
+   * Stores data to global variable or to file depending on what is applicable for current test runner
+   * (running environment).
    * dataType: 'log' | 'artifact' | ...
    * @param {*} dataType storage type (like 'log', 'artifact'); could be any string, used only to define file path
    */
@@ -19,7 +20,7 @@ class DataStorage {
     // if (!dataType) throw new Error('Data type is required when creating data storage');
     this.dataType = dataType || 'data';
     this.dataDirName = this.dataType;
-
+    this.isFileStorage = true;
     this._refreshStorageType();
 
     // dir is created in any case (not to recheck its existence every time)
@@ -37,14 +38,6 @@ class DataStorage {
     // jest
     if (process.env.JEST_WORKER_ID) return 'jest';
 
-    // mocha
-    try {
-      // @ts-expect-error mocha is defined only in mocha environment
-      if (typeof mocha !== 'undefined') return 'mocha';
-    } catch (e) {
-      // ignore
-    }
-
     // codeceptjs
     // @ts-expect-error codeceptjs is defined only in codeceptjs environment
     if (global.codeceptjs) return 'codeceptjs';
@@ -55,6 +48,8 @@ class DataStorage {
 
     if (process.env.PLAYWRIGHT_TEST_BASE_URL) return 'playwright';
 
+    // mocha - can't detect
+
     return null;
   }
 
@@ -69,15 +64,24 @@ class DataStorage {
 
     let testId = this._tryToRetrieveTestId(context) || null;
 
-    if (this.runningEnvironment === 'codeceptjs') testId = testId ?? global.testomatioDataStore?.currentlyRunningTestId;
-    if (this.runningEnvironment === 'jest') testId = testId ?? JestReporter.getIdOfCurrentlyRunningTest();
-    // logs in playwright are gathered by pw framwork itself
+    if (this.runningEnvironment === 'codeceptjs') {
+      this.isFileStorage = false;
+      testId = testId ?? global.testomatioDataStore?.currentlyRunningTestId;
+    }
+    if (this.runningEnvironment === 'jest') {
+      testId = testId ?? JestReporter.getIdOfCurrentlyRunningTest();
+      this.isFileStorage = true;
+    }
+    // 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) {
       debug(`No test id provided for ${this.dataType} data: ${data}`);
@@ -116,17 +120,26 @@ class DataStorage {
       return null;
     }
 
-    let testData = null;
+    let testData = '';
 
     if (global?.testomatioDataStore) {
       testData = this._getDataFromGlobalVar(testId);
-      if (testData) return testData;
+      // these frameworks use global variable storage
+      if (testData && ['cucumber', 'codeceptjs'].includes(this.runningEnvironment)) return testData;
     }
 
-    if (this.isFileStorage || !testData) {
-      testData = this._getDataFromFile(testId);
-      if (testData) 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 || '';
+
+    if (testData) return testData;
 
     debug(`No ${this.dataType} data for test id ${testId} in both file and global variable`);
     return testData;
@@ -162,7 +175,6 @@ class DataStorage {
    * Because storage instance is created before the test runner is started. And storage type could be changed
    */
   _refreshStorageType() {
-    this.isFileStorage = !global.testomatioDataStore;
     /*
         FYI:
         If this storage instance is used within test runner, it works fine.
@@ -174,8 +186,8 @@ class DataStorage {
       */
     this.runningEnvironment = this.getRunningEnviroment();
 
-    // some test frameworks do not persist global variables, thus file storage is used for them
-    if (this.runningEnvironment === 'jest') this.isFileStorage = true;
+    // 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) {
@@ -186,7 +198,7 @@ class DataStorage {
         return testData;
       }
       debug(`No ${this.dataType} data for test id ${testId} in <global> storage`);
-      return null;
+      return '';
     } catch (e) {
       // there could be no data, ignore
     }
@@ -201,11 +213,11 @@ class DataStorage {
         return testData;
       }
       debug(`No ${this.dataType} data for test id ${testId} in <file> storage`);
-      return null;
+      return '';
     } catch (e) {
       // there could be no data, ignore
     }
-    return null;
+    return '';
   }
 
   _putDataToGlobalVar(data, testId) {
@@ -238,7 +250,6 @@ module.exports.DataStorage = DataStorage;
 // TODO: use .env
 // TODO: ability to intercept multiple loggers (upd: no need)
 
-
 /* Cypress
 Parallelization is only available if using Cypress Dashboard??
 */

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) {

package/lib/logger.js

@@ -53,6 +53,20 @@ class Logger {
         }
       },
     };
+
+    // add beforeEach hook for mocha. it does not override existing hook, just add new one
+    try {
+      // @ts-ignore
+      if (!beforeEach) return;
+      // @ts-ignore
+      beforeEach(function () {
+        if (this.currentTest?.__mocha_id__) {
+          global.testTitle = this.currentTest.fullTitle();
+        }
+      });
+    } catch (e) {
+      // ignore
+    }
   }
 
   /**
@@ -115,6 +129,10 @@ class Logger {
   _log(strings, ...args) {
     // entity which is used to define testId
     let context = null;
+
+    // get testId for mocha
+    context = global.testTitle ?? null;
+
     // last argument could contain testId
     const testId = this._helpers.parseLastArgToGetTestId(...args);
     if (testId) {
@@ -152,7 +170,7 @@ class Logger {
   }
 
   /**
-   * This function is a wrapper for all logging methods (not to repeat the same code)
+   * This function is a wrapper for each logging methods (log, warn, error etc) (not to repeat the same code)
    * @param {*} argsArray
    * @param {*} level
    * @returns
@@ -162,6 +180,10 @@ class Logger {
 
     // entity which is used to define testId
     let context = null;
+
+    // get context for mocha
+    context = global.testTitle ?? null;
+
     // last argument could contain testId
     const testId = this._helpers.parseLastArgToGetTestId(...argsArray);
     if (testId) {
@@ -299,3 +321,41 @@ module.exports = logger;
 
 // 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) {
+      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()
+*/

package/lib/pipe/csv.js

@@ -40,6 +40,8 @@ class CsvPipe {
     }
   }
 
+  async prepareRun(opts) {}
+  
   async createRun() {
     // empty
   }

package/lib/pipe/github.js

@@ -6,6 +6,7 @@ const merge = require('lodash.merge');
 const { Octokit } = require('@octokit/rest');
 const { APP_PREFIX } = require('../constants');
 const { ansiRegExp, isSameTest } = require('../util');
+const { statusEmoji, fullName } = require('./misc');
 
 /**
  * @typedef {import('../../types').Pipe} Pipe
@@ -37,6 +38,8 @@ class GitHubPipe {
     debug('GitHub Pipe: Enabled');
   }
 
+  async prepareRun(opts) {}
+
   async createRun() {}
 
   addTest(test) {
@@ -182,21 +185,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

@@ -6,6 +6,7 @@ const merge = require('lodash.merge');
 const path = require('path');
 const { APP_PREFIX } = require('../constants');
 const { ansiRegExp, isSameTest } = require('../util');
+const { statusEmoji, fullName } = require('./misc');
 
 //! GITLAB_PAT environment variable is required for this functionality to work
 //! and your pipeline trigger should be merge_request
@@ -46,6 +47,8 @@ class GitLabPipe {
     debug('GitLab Pipe: Enabled');
   }
 
+  async prepareRun(opts) {}
+
   async createRun() {}
 
   addTest(test) {
@@ -179,21 +182,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;
 

package/lib/pipe/misc.js

@@ -0,0 +1,135 @@
+const { resetConfig } = require('../fileUploader');
+const { APP_PREFIX } = require('../constants');
+
+/**
+ * Set S3 credentials from the provided artifacts object.
+ * @param {Object} artifacts - The artifacts object containing S3 credentials.
+ */
+function setS3Credentials(artifacts) {
+    if (!Object.keys(artifacts).length) return;
+
+    console.log(APP_PREFIX, 'S3 were credentials obtained from Testomat.io...');
+
+    if (artifacts.ACCESS_KEY_ID) process.env.S3_ACCESS_KEY_ID = artifacts.ACCESS_KEY_ID;
+    if (artifacts.SECRET_ACCESS_KEY) process.env.S3_SECRET_ACCESS_KEY = artifacts.SECRET_ACCESS_KEY;
+    if (artifacts.REGION) process.env.S3_REGION = artifacts.REGION;
+    if (artifacts.BUCKET) process.env.S3_BUCKET = artifacts.BUCKET;
+    if (artifacts.ENDPOINT) process.env.S3_ENDPOINT = artifacts.ENDPOINT;
+    if (artifacts.presign) process.env.TESTOMATIO_PRIVATE_ARTIFACTS = '1';
+    resetConfig();
+}
+/**
+ * Generates mode request parameters based on the input params.
+ * @param {Object} params - The input parameters for the request.
+ * @param {string} params.type - The type of the request (e.g., "tag").
+ * @param {string} params.id - The ID associated with the request.
+ * @param {string} params.apiKey - The API key for authentication.
+ * @returns {Object|null} - An object containing the generated request parameters, or null if the type is invalid.
+ */
+function generateFilterRequestParams(params) {
+    const { type, id, apiKey } = params;
+
+    if (!type) {
+        return;
+    }
+
+    if (!id) {
+        console.error(APP_PREFIX, `Please make sure your settings "${type.toUpperCase()}"= "${id}" is correct!`);
+        return;
+    }
+
+    return {
+        params: {
+            type,
+            id: encodeURIComponent(id),
+            api_key: apiKey
+        },
+        responseType: "json"
+    }
+}
+
+/**
+ * Parse filter parameters from a string in the format "type=id".
+ * @param {string} opts - The input string containing the filter parameters.
+ * @returns {Object} An object containing the parsed filter parameters.
+ *                   The object has properties "type" and "id".
+ */
+function parseFilterParams(opts) {
+    const [type, id] = opts.split("=");
+    const validType = updateFilterType(type);
+
+    return {
+        type: validType,
+        id
+    };
+}
+
+/**
+ * Update and validate the filter type.
+ * @param {string} type - The original filter type.
+ * @returns {string|undefined} The updated and validated filter type.
+ *                            Returns undefined if the type is not valid.
+ */
+function updateFilterType(type) {
+    const typeLowerCase = type.toLowerCase();
+
+    const filterTypes = [
+        "tag-name",
+        "plan-id",
+        "label",
+        "jira-ticket",
+    ];
+
+    const filterApi = [
+        "tag",
+        "plan",
+        "label",
+        "jira",
+        // "ims-issue", //TODO: WIP
+    ];
+
+    if (!filterTypes.includes(typeLowerCase)) {
+        console.log(APP_PREFIX, `❗❗❗ Invalid "filter=${type}" start settings! Available option list: ${filterTypes}`);
+        return;
+    }
+
+    const index = filterTypes.indexOf(typeLowerCase);
+
+    return (index !== -1)
+        ? filterApi[index]
+        : undefined
+}
+
+/**
+ * Return an emoji based on the provided status.
+ * @param {string} status - The status value ('passed', 'failed', or 'skipped').
+ * @returns {string} - An emoji corresponding to the provided status.
+ */
+function statusEmoji(status) {
+    if (status === 'passed') return '🟢';
+    if (status === 'failed') return '🔴';
+    if (status === 'skipped') return '🟡';
+    return '';
+}
+
+/**
+ * Generate a full name string based on the provided test object.
+ * @param {object} t - The test object.
+ * @returns {string} - A formatted full name string for the test object.
+ */
+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;
+}
+
+module.exports = {
+    updateFilterType,
+    parseFilterParams,
+    generateFilterRequestParams,
+    setS3Credentials,
+    statusEmoji,
+    fullName
+};

package/lib/pipe/testomatio.js

@@ -3,8 +3,8 @@ const chalk = require('chalk');
 const axios = require('axios');
 const JsonCycle = require('json-cycle');
 const { APP_PREFIX, STATUS } = require('../constants');
-const { isValidUrl } = require('../util');
-const { resetConfig } = require('../fileUploader');
+const { isValidUrl, foundedTestLog } = require('../util');
+const { parseFilterParams, generateFilterRequestParams, setS3Credentials, } = require('./misc');
 
 const { TESTOMATIO_RUN } = process.env;
 if (TESTOMATIO_RUN) {
@@ -33,7 +33,12 @@ class TestomatioPipe {
     this.sharedRun = !!process.env.TESTOMATIO_SHARED_RUN;
     this.groupTitle = params.groupTitle || process.env.TESTOMATIO_RUNGROUP_TITLE;
     this.env = process.env.TESTOMATIO_ENV;
-    this.axios = axios.create();
+
+    this.axios = axios.create({
+      baseURL: `${this.url.trim()}`,
+      timeout: 20000
+    });
+
     this.isEnabled = true;
     // do not finish this run (for parallel testing)
     this.proceed = process.env.TESTOMATIO_PROCEED;
@@ -47,6 +52,50 @@ class TestomatioPipe {
     }
   }
 
+  /**
+   * Asynchronously prepares and retrieves the Testomat.io test grepList based on the provided options.
+   * @param {Object} opts - The options for preparing the test grepList.
+   * @returns {Promise<string[]>} - An array containing the retrieved 
+   * test grepList, or an empty array if no tests are found or the request is disabled.
+   * @throws {Error} - Throws an error if there was a problem while making the request.
+   */
+  async prepareRun(opts) {
+    if (!this.isEnabled) return [];
+
+    const { type, id } = parseFilterParams(opts);
+
+    try {
+      const q = generateFilterRequestParams({
+        type,
+        id,
+        apiKey: this.apiKey.trim()
+      });
+
+      if (!q) {
+        return;
+      }
+
+      const resp = await this.axios.get('/api/test_grep', q);
+      const { data } = resp;
+
+      if (Array.isArray(data?.tests) && data?.tests?.length > 0) {
+        foundedTestLog(APP_PREFIX, data.tests);
+        return data.tests;
+      }
+      else {
+        console.log(APP_PREFIX, `⛔  No tests found for your --filter --> ${type}=${id}`);
+        return;
+      }
+    }
+    catch (err) {
+      console.error(
+        APP_PREFIX,
+        `🚩 Error getting Testomat.io test grepList: ${err}`,
+      );
+      return;
+    }
+  }
+
   /**
    * @returns Promise<void>
    */
@@ -84,13 +133,13 @@ class TestomatioPipe {
     );
 
     if (this.runId) {
-      const resp = await this.axios.put(`${this.url.trim()}/api/reporter/${this.runId}`, runParams);
+      const resp = await this.axios.put(`/api/reporter/${this.runId}`, runParams);
       if (resp.data.artifacts) setS3Credentials(resp.data.artifacts);
       return;
     }
 
     try {
-      const resp = await this.axios.post(`${this.url.trim()}/api/reporter`, runParams, {
+      const resp = await this.axios.post(`/api/reporter`, runParams, {
         maxContentLength: Infinity,
         maxBodyLength: Infinity,
       });
@@ -121,7 +170,7 @@ class TestomatioPipe {
     data.create = this.createNewTests;
     const json = JsonCycle.stringify(data);
 
-    return this.axios.post(`${this.url}/api/reporter/${this.runId}/testrun`, json, {
+    return this.axios.post(`/api/reporter/${this.runId}/testrun`, json, {
       maxContentLength: Infinity,
       maxBodyLength: Infinity,
       headers: {
@@ -169,7 +218,7 @@ class TestomatioPipe {
 
     try {
       if (this.runId && !this.proceed) {
-        await this.axios.put(`${this.url}/api/reporter/${this.runId}`, {
+        await this.axios.put(`/api/reporter/${this.runId}`, {
           api_key: this.apiKey,
           status_event,
           tests: params.tests,
@@ -209,18 +258,3 @@ class TestomatioPipe {
 }
 
 module.exports = TestomatioPipe;
-
-
-function setS3Credentials(artifacts) {  
-  if (!Object.keys(artifacts).length) return;
-
-  console.log(APP_PREFIX, 'S3 were credentials obtained from Testomat.io...');
-
-  if (artifacts.ACCESS_KEY_ID) process.env.S3_ACCESS_KEY_ID = artifacts.ACCESS_KEY_ID; 
-  if (artifacts.SECRET_ACCESS_KEY) process.env.S3_SECRET_ACCESS_KEY = artifacts.SECRET_ACCESS_KEY; 
-  if (artifacts.REGION) process.env.S3_REGION = artifacts.REGION; 
-  if (artifacts.BUCKET) process.env.S3_BUCKET = artifacts.BUCKET; 
-  if (artifacts.ENDPOINT) process.env.S3_ENDPOINT = artifacts.ENDPOINT; 
-  if (artifacts.presign) process.env.TESTOMATIO_PRIVATE_ARTIFACTS = '1'; 
-  resetConfig();
-}

package/lib/util.js

@@ -192,6 +192,60 @@ const fileSystem = {
   }
 };
 
+
+const foundedTestLog = (app, tests) => {
+  const n = tests.length;
+
+  return (n === 1)
+    ? console.log(app, `✅ We found only one test!`)
+    : console.log(app, `✅ We found ${n} tests!`);
+}
+
+const humanize = (text) => {  
+  text = decamelize(text);
+  return text.replace(/_./g, match => ` ${  match.charAt(1).toUpperCase()}`)
+      .trim()
+      .replace(/^(.)|\s(.)/g, ($1) => $1.toUpperCase()).trim()
+      .replace(/\sA\s/g, ' a ') // replace a|the
+      .replace(/\sThe\s/g, ' the ') // replace a|the
+      .replace(/^Test\s/, '')
+      .replace(/^Should\s/, '')
+}
+
+/**
+ * From https://github.com/sindresorhus/decamelize/blob/main/index.js
+ * @param {*} text 
+ * @returns 
+ */
+const decamelize = (text) => {
+  const separator = '_';
+	const replacement = `$1${separator}$2`;
+
+	// Split lowercase sequences followed by uppercase character.
+	// `dataForUSACounties` → `data_For_USACounties`
+	// `myURLstring → `my_URLstring`
+	let decamelized = text.replace(
+		/([\p{Lowercase_Letter}\d])(\p{Uppercase_Letter})/gu,
+		replacement,
+	);
+
+	// Lowercase all single uppercase characters. As we
+	// want to preserve uppercase sequences, we cannot
+	// simply lowercase the separated string at the end.
+	// `data_For_USACounties` → `data_for_USACounties`
+	decamelized = decamelized.replace(
+		/((?<![\p{Uppercase_Letter}\d])[\p{Uppercase_Letter}\d](?![\p{Uppercase_Letter}\d]))/gu,
+		$0 => $0.toLowerCase(),
+	);
+
+	// Remaining uppercase sequences will be separated from lowercase sequences.
+	// `data_For_USACounties` → `data_for_USA_counties`
+	return decamelized.replace(
+		/(\p{Uppercase_Letter}+)(\p{Uppercase_Letter}\p{Lowercase_Letter}+)/gu,
+		(_, $1, $2) => $1 + separator + $2.toLowerCase(),
+	);
+};
+
 module.exports = {
   isSameTest,
   fetchSourceCode,
@@ -204,4 +258,6 @@ module.exports = {
   ansiRegExp,
   parseTest,
   parseSuite,
-};
+  humanize,
+  foundedTestLog
+}

package/lib/xmlReader.js

@@ -8,7 +8,7 @@ const { fetchFilesFromStackTrace, fetchSourceCode, fetchSourceCodeFromStackTrace
 const upload = require('./fileUploader');
 const pipesFactory = require('./pipe');
 const adapterFactory = require('./junit-adapter');
-
+const { humanize } = require('./util')
 
 const TESTOMATIO_URL = process.env.TESTOMATIO_URL || "https://app.testomat.io";
 const TESTOMATIO = process.env.TESTOMATIO; // key?
@@ -35,7 +35,7 @@ class XmlReader {
       group_title: TESTOMATIO_RUNGROUP_TITLE,
     };
     this.runId = opts.runId || TESTOMATIO_RUN;
-    this.adapter = adapterFactory(null, opts)
+    this.adapter = adapterFactory(opts.lang?.toLowerCase(), opts)
     if (!this.adapter) throw new Error('XML adapter for this format not found');
 
     this.opts = opts || {};
@@ -53,8 +53,12 @@ class XmlReader {
   }
 
   connectAdapter() {
-    if (this.opts.javaTests) return adapterFactory('java', this.opts);
-    return adapterFactory(this.stats.language, this.opts);
+    if (this.opts.javaTests) {
+      this.adapter = adapterFactory('java', this.opts);
+      return this.adapter;
+    }
+    this.adapter = adapterFactory(this.stats.language, this.opts);
+    return this.adapter;
   }
 
   parse(fileName) {       
@@ -70,6 +74,8 @@ class XmlReader {
       return this.processTRX(jsonResult);      
     } else if (jsonResult['test-run']) {
       return this.processNUnit(jsonResult['test-run']);
+    } else if (jsonResult.assemblies) {
+      return this.processXUnit(jsonResult.assemblies);      
     } else {
       console.log(jsonResult)
       throw new Error("Format can't be parsed")
@@ -190,6 +196,79 @@ class XmlReader {
     };    
   }
 
+  processXUnit(assemblies) {
+    const tests = [];
+
+    assemblies = Array.isArray(assemblies.assembly) ? assemblies.assembly : [assemblies.assembly];
+
+    assemblies.forEach(assembly => {
+      const { collection } = assembly;
+
+      const suites = Array.isArray(collection) ? collection : [collection];
+
+      suites.forEach(suite => {
+        const { test } = suite;
+        if (!test) return;
+        const cases = Array.isArray(test) ? test : [test];
+        cases.forEach(testCase => {
+          const { type, time, result } = testCase;
+
+          let message = '';
+          let stack = '';
+
+          if (testCase.failure) {
+            message = testCase.failure.message;
+            stack = testCase.failure['stack-trace']
+          }
+          if (testCase.reason) {
+            message = testCase.reason.message;
+          }
+
+          let status = STATUS.PASSED;
+          if (result === 'Pass') status = STATUS.PASSED;
+          if (result === 'Fail') status = STATUS.FAILED;
+          if (result === 'Skip') status = STATUS.SKIPPED;          
+
+          const pathParts = type.split('.');
+          const suite_title = pathParts[pathParts.length - 1];
+          const file = pathParts.slice(0, -1).join('/');
+          const title = testCase.method || testCase.name.split('.').pop();
+          const run_time = parseFloat(time) * 1000;
+
+          tests.push({
+            create: true,
+            stack,
+            message,
+            file,
+            status,
+            title,
+            suite_title,
+            run_time,
+          });
+
+        });
+      });
+    });
+
+    const hasFailures = tests.filter(t => t.status === STATUS.FAILED).length > 0;
+    const status = hasFailures ? STATUS.FAILED : STATUS.PASSED;
+
+    this.tests = tests;
+
+    debug(tests);
+
+    return {
+      status,
+      create_tests: true,
+      name: 'xUnit',
+      tests_count: tests.length,
+      passed_count: tests.filter(t => t.status === STATUS.PASSED).length,
+      failed_count: tests.filter(t => t.status === STATUS.FAILED).length,
+      skipped_count: tests.filter(t => t.status === STATUS.SKIPPED).length,
+      tests,
+    };
+  }
+
   calculateStats() {
     this.stats = {
       ...this.stats,
@@ -241,18 +320,7 @@ class XmlReader {
 
       this.adapter.formatTest(t)
 
-      t.title = t.title
-      // insert a space before all caps
-        .replace(/([A-Z])/g, ' $1')
-      // _ chars to spaces
-        .replace(/_/g, ' ')
-      // uppercase the first character
-        .replace(/^(.)|\s(.)/g, $1 => $1.toLowerCase())
-
-        // remove standard prefixes
-        .replace(/^test\s/, '')
-        .replace(/^should\s/, '')
-        .trim();
+      t.title = humanize(t.title);
     });
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testomatio/reporter",
-  "version": "1.0.8",
+  "version": "1.0.9-beta.2",
   "description": "Testomatio Reporter Client",
   "main": "./lib/reporter.js",
   "typings": "typings/index.d.ts",