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

package/lib/utils/pipe_utils.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/{util.js → utils/utils.js}

@@ -11,7 +11,10 @@ const debug = require('debug')('@testomatio/reporter:util');
  * @returns {String|null} testId
  */
 const parseTest = testTitle => {
+  if (!testTitle) return null;
+
   const captures = testTitle.match(/@T([\w\d]+)/);
+
   if (captures) {
     return captures[1];
   }
@@ -52,11 +55,21 @@ const isValidUrl = s => {
   }
 };
 
+const fileMatchRegex = /file:(\/\/?[^:\s]+?\.(png|avi|webm|jpg|html|txt))/ig;
+
 const fetchFilesFromStackTrace = (stack = '') => {
-  const files = stack.matchAll(/file:?\/(\/.*?\.(png|avi|webm|jpg|html|txt))/g);
-  return Array.from(files)
-    .map(f => f[1])
-    .filter(f => fs.existsSync(f));
+
+  const files = Array.from(stack.matchAll(fileMatchRegex))
+  .map(f => f[1].trim())
+  .map(f => f.startsWith('//') ? f.substring(1) : f )
+  
+  debug('Found files in stack trace: ', files);
+
+  return files.filter(f => {
+      const isFile = fs.existsSync(f);
+      if (!isFile) debug('File %s could not be found and uploaded as artifact', f);
+      return isFile;
+    });
 };
 
 const fetchSourceCodeFromStackTrace = (stack = '') => {
@@ -84,13 +97,38 @@ const fetchSourceCodeFromStackTrace = (stack = '') => {
 
   if (!source) return '';
 
-  return source.split('\n')
+  return source
+    .split('\n')
     .map((l, i) => {
       if (i === prepend) return `${line} > ${chalk.bold(l)}`;
-      return `${line - prepend + i} | ${l}`
-    }).join('\n');
+      return `${line - prepend + i} | ${l}`;
+    })
+    .join('\n');
 };
 
+const TEST_ID_REGEX = /@T([\w\d]{8})/;
+
+const fetchIdFromCode = (code, opts = {}) => {
+  const comments = code.split('\n').map(l => l.trim()).filter(l => {
+    switch (opts.lang) {
+      case 'ruby':
+      case 'python':
+        return l.startsWith('# ');
+      default:
+        return l.startsWith('// ');
+    }
+  });
+
+  return comments.find(c => c.match(TEST_ID_REGEX))?.match(TEST_ID_REGEX)?.[1];
+}
+
+
+const fetchIdFromOutput = (output) => {
+  const lines = output.split('\n').map(l => l.trim()).filter(l => l.startsWith('tid://'));
+
+  return lines.find(c => c.match(TEST_ID_REGEX))?.match(TEST_ID_REGEX)?.[1];
+}
+
 const fetchSourceCode = (contents, opts = {}) => {
   if (!opts.title && !opts.line) return '';
 
@@ -112,7 +150,7 @@ const fetchSourceCode = (contents, opts = {}) => {
 
   if (lineIndex) {
     const result = [];
-    for (let i = lineIndex; i < (lineIndex + limit); i++) {
+    for (let i = lineIndex; i < lineIndex + limit; i++) {
       if (lines[i] === undefined) continue;
 
       if (i > lineIndex + 2 && !opts.prepend) {
@@ -186,13 +224,78 @@ const fileSystem = {
     } else {
       debug(`Trying to delete ${dirPath} but it doesn't exist`);
     }
-  }
+  },
 };
 
+
+const foundedTestLog = (app, tests) => {
+  const n = tests.length;
+
+  return (n === 1)
+    ? console.log(app, `✅ We found 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(),
+  );
+};
+
+/**
+ * Used to remove color codes
+ * @param {*} input
+ * @returns
+ */
+function removeColorCodes(input) {
+  // eslint-disable-next-line no-control-regex
+  return input.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
 module.exports = {
   isSameTest,
   fetchSourceCode,
   fetchSourceCodeFromStackTrace,
+  fetchIdFromCode,
+  fetchIdFromOutput,
   fetchFilesFromStackTrace,
   fileSystem,
   getCurrentDateTime,
@@ -201,4 +304,7 @@ module.exports = {
   ansiRegExp,
   parseTest,
   parseSuite,
-};
+  humanize,
+  removeColorCodes,
+  foundedTestLog
+};

package/lib/xmlReader.js

@@ -4,12 +4,17 @@ const chalk = require('chalk');
 const fs = require("fs");
 const { XMLParser } = require("fast-xml-parser");
 const { APP_PREFIX, STATUS } = require('./constants');
-const { fetchFilesFromStackTrace, fetchSourceCode, fetchSourceCodeFromStackTrace } = require('./util');
+const { fetchFilesFromStackTrace, 
+        fetchIdFromOutput, 
+        fetchSourceCode, 
+        fetchSourceCodeFromStackTrace, 
+        fetchIdFromCode,
+        humanize
+      } = require('./utils/utils');
 const upload = require('./fileUploader');
 const pipesFactory = require('./pipe');
 const adapterFactory = require('./junit-adapter');
 
-
 const TESTOMATIO_URL = process.env.TESTOMATIO_URL || "https://app.testomat.io";
 const TESTOMATIO = process.env.TESTOMATIO; // key?
 const { TESTOMATIO_RUNGROUP_TITLE, TESTOMATIO_TITLE, TESTOMATIO_ENV, TESTOMATIO_RUN } = process.env;
@@ -25,7 +30,7 @@ const options = {
 const reduceOptions = {};
 
 class XmlReader {
-  
+
   constructor(opts = {}) {
     this.requestParams = {
       apiKey: opts.apiKey || TESTOMATIO,
@@ -35,12 +40,12 @@ 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 || {};
-    const store = {}
-    this.pipes = pipesFactory(opts, store);
+    this.store = {}
+    this.pipes = pipesFactory(opts, this.store);
 
     this.parser = new XMLParser(options);
     this.tests = []
@@ -49,27 +54,33 @@ class XmlReader {
     this.filesToUpload = {}
 
     this.version = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json')).toString()).version;
-    console.log(APP_PREFIX, `Testomatio Reporter v${this.version}`);    
+    console.log(APP_PREFIX, `Testomatio Reporter v${this.version}`);
   }
 
   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) {       
+  parse(fileName) {
     const xmlData = fs.readFileSync(path.resolve(fileName));
     const jsonResult = this.parser.parse(xmlData);
     let jsonSuite;
-    
+
     if (jsonResult.testsuites) {
       jsonSuite = jsonResult.testsuites;
     } else if (jsonResult.testsuite) {
       jsonSuite = jsonResult;
     } else if (jsonResult.TestRun) {
-      return this.processTRX(jsonResult);      
+      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")
@@ -83,9 +94,9 @@ class XmlReader {
 
     reduceOptions.preferClassname = this.stats.language === 'python';
     const resultTests = processTestSuite(testsuite);
-    
+
     const hasFailures = resultTests.filter(t => t.status === 'failed').length > 0;
-    const status = ( failures > 0 || errors > 0 || hasFailures) ? 'failed' : 'passed';
+    const status = (failures > 0 || errors > 0 || hasFailures) ? 'failed' : 'passed';
 
     this.tests = this.tests.concat(resultTests);
 
@@ -118,7 +129,7 @@ class XmlReader {
       skipped_count: parseInt(inconclusive + skipped, 10),
       tests: resultTests,
     };
-  }  
+  }
 
   processTRX(jsonSuite) {
     let defs = jsonSuite?.TestRun?.TestDefinitions?.UnitTest;
@@ -127,10 +138,10 @@ class XmlReader {
     const tests = defs.map(td => {
       const title = td.name.replace(/\(.*?\)/, '').trim();
       let example = td.name.match(/\((.*?)\)/);
-      if (example) example = { ...example[1].split(',')};
+      if (example) example = { ...example[1].split(',') };
       const suite = td.TestMethod.className.split(', ')[0].split('.');
       const suite_title = suite.pop();
-      return { 
+      return {
         title,
         example,
         file: suite.join('/'),
@@ -143,18 +154,18 @@ class XmlReader {
     let result = jsonSuite?.TestRun?.Results?.UnitTestResult;
     if (!Array.isArray(result)) result = [result].filter(d => !!d);
 
-    const results = result.map(td => ({ 
+    const results = result.map(td => ({
       id: td.executionId,
       // seconds are used in junit reports, but ms are used by testomatio
       run_time: parseFloat(td.duration) * 1000,
-      status: td.outcome, 
+      status: td.outcome,
       stack: td.Output.StdOut,
       files: td?.ResultFiles?.ResultFile?.map(rf => rf.path)
     }));
 
-    
+
     results.forEach(r => {
-      const test = tests.find(t => t.id === r.id) || { };
+      const test = tests.find(t => t.id === r.id) || {};
       r.suite_title = test.suite_title;
       r.title = test.title?.trim();
       if (test.code) r.code = test.code;
@@ -169,7 +180,7 @@ class XmlReader {
     });
 
     debug(results);
-    
+
     const counters = jsonSuite?.TestRun?.ResultSummary?.Counters || {};
 
     const failed_count = parseInt(counters.failed, 10) + parseInt(counters.error, 10);
@@ -187,7 +198,80 @@ class XmlReader {
       skipped_count: parseInt(counters.notExecuted, 10),
       failed_count,
       tests: results,
-    };    
+    };
+  }
+
+  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() {
@@ -221,12 +305,19 @@ class XmlReader {
           if (file.endsWith('.py')) this.stats.language = 'python';
           if (file.endsWith('.java')) this.stats.language = 'java';
           if (file.endsWith('.rb')) this.stats.language = 'ruby';
-          if (file.endsWith('.js')) this.stats.language  = 'js';
+          if (file.endsWith('.js')) this.stats.language = 'js';
           if (file.endsWith('.ts')) this.stats.language = 'ts';
         }
 
+        if (!fs.existsSync(file)) {
+          debug('Failed to open file with the source code', file)
+          return;
+        }
         const contents = fs.readFileSync(file).toString();
         t.code = fetchSourceCode(contents, { ...t, lang: this.stats.language })
+        if (t.code) debug('Fetched code for test %s', t.title);
+        t.test_id = fetchIdFromCode(t.code, { lang: this.stats.language })
+        if (t.test_id) debug('Fetched test id %s for test %s', t.test_id, t.title);
       } catch (err) {
         debug(err)
       }
@@ -241,18 +332,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);
     });
   }
 
@@ -281,8 +361,12 @@ class XmlReader {
       let files = [];
       if (test.files?.length) files = test.files.map(f => path.join(process.cwd(), f))
       files = [...files, ...fetchFilesFromStackTrace(test.stack)];
-      debug('Uploading files', files)
-      test.artifacts = await Promise.all(files.map(f => upload.uploadFileByPath(f, this.runId)));
+
+      if (!files.length) continue;
+
+      const runId = this.runId || this.store.runId || Date.now().toString();
+      test.artifacts = await Promise.all(files.map(f => upload.uploadFileByPath(f, runId)));
+      console.log(APP_PREFIX, `🗄️ Uploaded ${chalk.bold(`${files.length} artifacts`)} for test ${test.title}`);
     }
   }
 
@@ -292,7 +376,7 @@ class XmlReader {
       title: this.requestParams.title,
       env: this.requestParams.env,
       group_title: this.requestParams.group_title,
-    };    
+    };
 
     debug("Run", runParams);
 
@@ -310,9 +394,9 @@ class XmlReader {
     debug(
       'Uploading data',
       {
-      ...this.stats,
-      tests: this.tests,
-    })
+        ...this.stats,
+        tests: this.tests,
+      })
 
     const dataString = {
       ...this.stats,
@@ -334,6 +418,8 @@ function reduceTestCases(prev, item) {
   if (!Array.isArray(testCases)) {
     testCases = [testCases]
   }
+  const suiteOutput = item['system-out'] || item.output || item.log || '';
+  const suiteErr = item['system-err'] || item.output || item.log || '';
   testCases.filter(t => !!t).forEach(testCaseItem => {
     const file = testCaseItem.file || item.filepath || '';
 
@@ -349,8 +435,9 @@ function reduceTestCases(prev, item) {
     if (testCaseItem.error && testCaseItem.error['#text']) stack = testCaseItem.error['#text'];
     if (!message) message = stack.trim().split('\n')[0];
 
-    // prepend system output
-    stack = `${testCaseItem['system-out'] || testCaseItem.output || testCaseItem.log || ''}\n\n${stack}`.trim()
+    // eslint-disable-next-line
+    stack = `${testCaseItem['system-out'] || testCaseItem.output || testCaseItem.log || ''}\n\n${stack}\n\n${suiteOutput}\n\n${suiteErr}`.trim()
+    const testId = fetchIdFromOutput(stack);
 
     let status = STATUS.PASSED.toString();
     if ('failure' in testCaseItem || 'error' in testCaseItem) status = STATUS.FAILED;
@@ -360,6 +447,7 @@ function reduceTestCases(prev, item) {
       create: true,
       file,
       stack,
+      test_id: testId,
       message,
       line: testCaseItem.lineno,
       // seconds are used in junit reports, but ms are used by testomatio