@testomatio/reporter 2.3.7-beta.10-stack-artifacts → 2.3.7-beta.100

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@testomatio/reporter",
-  "version": "2.3.7-beta.10-stack-artifacts",
+  "version": "2.3.7-beta.100",
   "description": "Testomatio Reporter Client",
   "engines": {
     "node": ">=18"
   },
-  "typings": "typings/index.d.ts",
+  "main": "lib/reporter.js",
+  "module": "src/reporter.js",
+  "types": "types/types.d.ts",
   "repository": "git@github.com:testomatio/reporter.git",
   "author": "Michael Bodnarchuk <davert@testomat.io>,Koushik Mohan <koushikmohan1996@gmail.com>",
   "license": "MIT",
@@ -45,7 +47,8 @@
     "bin",
     "lib",
     "src",
-    "testcafe"
+    "testcafe",
+    "types"
   ],
   "scripts": {
     "clear-exportdir": "rm -rf export/",
@@ -57,7 +60,8 @@
     "test": "mocha 'tests/unit/**/*_test.js'",
     "test:playwright": "mocha tests/adapter/playwright.test.js",
     "test:codecept": "mocha tests/adapter/codecept.test.js tests/adapter/codecept_comprehensive.test.js tests/adapter/codecept_steps_sections.test.js",
-    "test:frameworks": "npm run test:playwright && npm run test:codecept",
+    "test:vitest": "mocha tests/adapter/vitest.test.js",
+    "test:frameworks": "npm run test:playwright && npm run test:codecept && npm run test:vitest",
     "test:all": "npm run test && npm run test:frameworks",
     "test:adapters": "mocha tests/adapter/*.test.js",
     "test:codecept:bug948": "mocha tests/adapter/codecept_aftersuite_failure.test.js",

package/src/bin/cli.js

@@ -158,7 +158,7 @@ program
   .option('--lang <lang>', 'Language used (python, ruby, java)')
   .option('--timelimit <time>', 'default time limit in seconds to kill a stuck process')
   .action(async (pattern, opts) => {
-    if (!pattern.endsWith('.xml')) {
+    if (!pattern.endsWith('.xml') && !pattern.includes('*')) {
       pattern += '.xml';
     }
     let { javaTests, lang } = opts;

package/src/bin/reportXml.js

@@ -23,7 +23,7 @@ program
   .option('--timelimit <time>', 'default time limit in seconds to kill a stuck process')
   .option('--env-file <envfile>', 'Load environment variables from env file')
   .action(async (pattern, opts) => {
-    if (!pattern.endsWith('.xml')) {
+    if (!pattern.endsWith('.xml') && !pattern.includes('*')) {
       pattern += '.xml';
     }
     let { javaTests, lang } = opts;
@@ -34,7 +34,10 @@ program
     }
     lang = lang?.toLowerCase();
     if (javaTests === true || (lang === 'java' && !javaTests)) javaTests = 'src/test/java';
-    const runReader = new XmlReader({ javaTests, lang });
+    const runReader = new XmlReader({
+      javaTests,
+      lang,
+    });
     const files = glob.sync(pattern, { cwd: opts.dir || process.cwd() });
     if (!files.length) {
       console.log(APP_PREFIX, `Report can't be created. No XML files found 😥`);

package/src/bin/startTest.js

@@ -18,7 +18,7 @@ const newArgs = ['run'];
 let i = 0;
 while (i < args.length) {
   const arg = args[i];
-  
+
   if (arg === '-c' || arg === '--command') {
     // Map -c/--command to positional argument for run command
     i++;
@@ -33,7 +33,7 @@ while (i < args.length) {
     // Map --launch to start command
     newArgs[0] = 'start';
   } else if (arg === '--finish') {
-    // Map --finish to finish command  
+    // Map --finish to finish command
     newArgs[0] = 'finish';
   } else {
     // Pass through other arguments
@@ -45,9 +45,9 @@ while (i < args.length) {
 // Execute the main CLI with mapped arguments
 
 const child = spawn(process.execPath, [cliPath, ...newArgs], {
-  stdio: 'inherit'
+  stdio: 'inherit',
 });
 
-child.on('exit', (code) => {
+child.on('exit', code => {
   process.exit(code);
-});
+});

package/src/client.js

@@ -170,12 +170,12 @@ class Client {
       title,
       suite_title,
     } = testData;
-    const steps = originalSteps;
+    let steps = originalSteps;
 
     const uploadedFiles = [];
     const stackArtifactsEnabled = transformEnvVarToBoolean(process.env.TESTOMATIO_STACK_ARTIFACTS);
 
-    
+
     const {
       time = 0,
       example = null,
@@ -210,20 +210,18 @@ class Client {
 
     let fullLogs = this.formatLogs({ error: errorFormatted, steps, logs: testData.logs });
 
-    if (stackArtifactsEnabled && status && (steps || testData.logs || error)) {
-      const timestamp = +new Date;
-      if (fullLogs && fullLogs.trim().length > 0) {
-        uploadedFiles.push(
-          this.uploader.uploadFileAsBuffer(
-            Buffer.from(stripColors(fullLogs), 'utf8'),
-            [this.runId, rid, `logs_${timestamp}.txt`]
-          )
-        );
-      }
+    if (stackArtifactsEnabled && fullLogs?.trim()?.length > 0) {
+      uploadedFiles.push(
+        this.uploader.uploadFileAsBuffer(
+          Buffer.from(stripColors(fullLogs), 'utf8'),
+          [this.runId, rid, `logs_${+new Date}.log`]
+        )
+      );
       fullLogs = '';
+      steps = null;
     }
 
-    
+
     if (!this.pipes || !this.pipes.length)
       this.pipes = await pipesFactory(this.paramsForPipesFactory || {}, this.pipeStore);
 

package/src/junit-adapter/csharp.js

@@ -3,18 +3,50 @@ import Adapter from './adapter.js';
 
 class CSharpAdapter extends Adapter {
   formatTest(t) {
-    const title = t.title.replace(/\(.*?\)/, '').trim();
-    const example = t.title.match(/\((.*?)\)/);
-    if (example) t.example = { ...example[1].split(',') };
+    // 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());
+        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);
-    t.title = title.trim();
     return t;
   }
 
   getFilePath(t) {
-    const fileName = namespaceToFileName(t.file);
+    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;
   }
 }
@@ -22,7 +54,14 @@ class CSharpAdapter extends Adapter {
 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(path.sep)}.cs`;
+  return `${fileParts.join('/')}.cs`;
 }

package/src/junit-adapter/nunit-parser.js

@@ -0,0 +1,462 @@
+import createDebugMessages from 'debug';
+import { STATUS } from '../constants.js';
+import { fetchFilesFromStackTrace } from '../utils/utils.js';
+
+const debug = createDebugMessages('@testomatio/reporter:nunit-parser');
+
+/**
+ * Enhanced NUnit XML Parser that properly handles test-suite hierarchy
+ * and parameterized tests
+ */
+export class NUnitXmlParser {
+  constructor(options = {}) {
+    this.options = options;
+    this.tests = [];
+    this.stats = {
+      total: 0,
+      passed: 0,
+      failed: 0,
+      skipped: 0,
+      inconclusive: 0,
+    };
+  }
+
+  /**
+   * Parse NUnit XML test-run structure
+   * @param {Object} testRun - Parsed XML test-run object
+   * @returns {Object} - Parsed test results
+   */
+  parseTestRun(testRun) {
+    debug('Parsing NUnit test-run');
+
+    // Extract run-level statistics
+    this.stats = {
+      total: parseInt(testRun.total || 0, 10),
+      passed: parseInt(testRun.passed || 0, 10),
+      failed: parseInt(testRun.failed || 0, 10),
+      skipped: parseInt(testRun.skipped || 0, 10),
+      inconclusive: parseInt(testRun.inconclusive || 0, 10),
+    };
+
+    // Process the root test-suite
+    if (testRun['test-suite']) {
+      this.parseTestSuite(testRun['test-suite'], []);
+    }
+
+    debug(`Parsed ${this.tests.length} tests from NUnit XML`);
+
+    return {
+      status: testRun.result?.toLowerCase() || 'unknown',
+      create_tests: true,
+      tests_count: this.tests.length,
+      passed_count: this.tests.filter(t => t.status === STATUS.PASSED).length,
+      failed_count: this.tests.filter(t => t.status === STATUS.FAILED).length,
+      skipped_count: this.tests.filter(t => t.status === STATUS.SKIPPED).length,
+      tests: this.tests,
+    };
+  }
+
+  /**
+   * Recursively parse test-suite elements based on their type
+   * @param {Object|Array} testSuite - Test suite object or array
+   * @param {Array} parentPath - Current path in the hierarchy
+   */
+  parseTestSuite(testSuite, parentPath = []) {
+    if (!testSuite) return;
+
+    // Handle arrays of test suites
+    if (Array.isArray(testSuite)) {
+      testSuite.forEach(suite => this.parseTestSuite(suite, parentPath));
+      return;
+    }
+
+    const suiteType = testSuite.type;
+    const suiteName = testSuite.name;
+    const fullName = testSuite.fullname;
+
+    debug(`Processing test-suite: type=${suiteType}, name=${suiteName}`);
+
+    switch (suiteType) {
+      case 'Assembly':
+        // Assembly level - ignore the name, just process children
+        debug('Processing Assembly level - ignoring name, processing children');
+        this.processChildren(testSuite, parentPath);
+        break;
+
+      case 'TestSuite':
+        // Namespace/grouping level - add to path but don't create test
+        debug(`Processing TestSuite level - adding '${suiteName}' to path`);
+        // Avoid adding duplicate suite names to the path
+        const newPath = parentPath[parentPath.length - 1] === suiteName ? [...parentPath] : [...parentPath, suiteName];
+        this.processChildren(testSuite, newPath);
+        break;
+
+      case 'TestFixture':
+        // Test class level - add to path and process test cases
+        debug(`Processing TestFixture level - test class '${suiteName}'`);
+        const testFixturePath = [...parentPath, suiteName];
+        this.processChildren(testSuite, testFixturePath);
+        break;
+
+      case 'ParameterizedMethod':
+        // Parameterized method level - process test cases directly
+        debug(`Processing ParameterizedMethod level - method '${suiteName}'`);
+        // Don't add to path, just process children directly
+        this.processChildren(testSuite, parentPath);
+        break;
+
+      default:
+        debug(`Unknown test-suite type: ${suiteType}, treating as TestSuite`);
+        const unknownPath = [...parentPath, suiteName];
+        this.processChildren(testSuite, unknownPath);
+        break;
+    }
+  }
+
+  /**
+   * Process child elements of a test suite
+   * @param {Object} testSuite - Test suite object
+   * @param {Array} currentPath - Current path in hierarchy
+   */
+  processChildren(testSuite, currentPath) {
+    // Process test-cases first (to maintain order)
+    if (testSuite['test-case']) {
+      this.parseTestCases(testSuite['test-case'], currentPath, testSuite);
+    }
+
+    // Process nested test-suites
+    if (testSuite['test-suite']) {
+      this.parseTestSuite(testSuite['test-suite'], currentPath);
+    }
+  }
+
+  /**
+   * Parse test-case elements (actual tests)
+   * @param {Object|Array} testCases - Test case object or array
+   * @param {Array} suitePath - Path to the test suite
+   * @param {Object} parentSuite - Parent test suite for context
+   */
+  parseTestCases(testCases, suitePath, parentSuite) {
+    if (!testCases) return;
+
+    // Handle arrays of test cases
+    if (!Array.isArray(testCases)) {
+      testCases = [testCases];
+    }
+
+    testCases.forEach(testCase => {
+      const parsedTest = this.parseTestCase(testCase, suitePath, parentSuite);
+      if (parsedTest) {
+        this.tests.push(parsedTest);
+      }
+    });
+  }
+
+  /**
+   * Parse individual test case
+   * @param {Object} testCase - Test case object
+   * @param {Array} suitePath - Path to the test suite
+   * @param {Object} parentSuite - Parent test suite for context
+   * @returns {Object|null} - Parsed test object
+   */
+  parseTestCase(testCase, suitePath, parentSuite) {
+    if (!testCase || !testCase.name) {
+      debug('Skipping test case without name');
+      return null;
+    }
+
+    // Use Description from properties if available (for SpecFlow tests), otherwise use name
+    let testName = testCase.name;
+    if (testCase.properties && testCase.properties.property) {
+      const properties = Array.isArray(testCase.properties.property)
+        ? testCase.properties.property
+        : [testCase.properties.property];
+
+      const descriptionProperty = properties.find(p => p.name === 'Description');
+      if (descriptionProperty && descriptionProperty.value) {
+        // Clean up SpecFlow description format: [C211256] Allow mobile print behavior -> Allow mobile print behavior
+        testName = descriptionProperty.value.replace(/^\[[^\]]+\]\s*/, '');
+      }
+    }
+
+    const fullName = testCase.fullname;
+    const methodName = testCase.methodname || this.extractMethodName(testName);
+    const className = testCase.classname || parentSuite?.name;
+
+    debug(`Parsing test case: ${testName}`);
+    debug(`Test case structure:`, JSON.stringify(testCase, null, 2));
+
+    // Extract parameters if this is a parameterized test
+    const { baseMethodName, parameters, isParameterized } = this.extractParameters(testName);
+
+    // Determine test status
+    let status = STATUS.PASSED;
+    if (testCase.result) {
+      switch (testCase.result.toLowerCase()) {
+        case 'passed':
+          status = STATUS.PASSED;
+          break;
+        case 'failed':
+          status = STATUS.FAILED;
+          break;
+        case 'skipped':
+        case 'ignored':
+          status = STATUS.SKIPPED;
+          break;
+        case 'inconclusive':
+          status = STATUS.SKIPPED; // Treat inconclusive as skipped
+          break;
+        default:
+          status = STATUS.PASSED;
+      }
+    }
+
+    // Extract error information
+    let message = '';
+    let stack = '';
+
+    const files = [];
+
+    if (testCase.failure) {
+      message = testCase.failure.message || '';
+      stack = testCase.failure['stack-trace'] || testCase.failure['#text'] || '';
+    }
+
+    if (testCase.output) {
+      const outputText = typeof testCase.output === 'string' ? testCase.output : testCase.output['#text'];
+      const stackFiles = fetchFilesFromStackTrace(outputText);
+      files.push(...stackFiles);
+
+      if (outputText) {
+        debug(`Found output in test case: ${outputText.substring(0, 100)}...`);
+        stack = `${stack}\n\n${outputText}`.trim();
+      } else {
+        debug('No output text found in test case');
+      }
+    } else {
+      debug('No output found in test case');
+    }
+
+    // Extract test ID and tags from properties
+    let testId = null;
+    let tags = [];
+    if (testCase.properties && testCase.properties.property) {
+      const properties = Array.isArray(testCase.properties.property)
+        ? testCase.properties.property
+        : [testCase.properties.property];
+
+      const idProperty = properties.find(p => p.name === 'ID');
+      if (idProperty) {
+        testId = idProperty.value;
+        // Remove @ and T prefixes if present
+        if (testId.startsWith('@')) testId = testId.slice(1);
+        if (testId.startsWith('T')) testId = testId.slice(1);
+      }
+
+      // Extract Category properties as tags
+      const categoryProperties = properties.filter(p => p.name === 'Category');
+      tags = categoryProperties.map(p => p.value);
+    }
+
+    // If no test ID found in properties, try to extract from output
+    if (!testId && testCase.output) {
+      const outputText = typeof testCase.output === 'string' ? testCase.output : testCase.output['#text'];
+      if (outputText) {
+        debug(`Looking for test ID in output: ${outputText.substring(0, 200)}...`);
+        const idMatch = outputText.match(/\[ID\]\s+tid:\/\/@T([a-f0-9]{8})/i);
+        if (idMatch) {
+          testId = idMatch[1];
+          debug(`Found test ID in output: ${testId}`);
+        } else {
+          debug('No test ID found in output');
+        }
+      }
+    }
+
+    // Build file path from suite path and class name
+    const filePath = this.buildFilePath(suitePath, className, parentSuite);
+
+    // For parameterized tests, format example as expected by Testomatio API
+    // Convert array of parameters to object with numeric keys
+    let example = null;
+    if (isParameterized && parameters.length > 0) {
+      example = {};
+      parameters.forEach((param, index) => {
+        example[index] = param;
+      });
+    }
+
+    return {
+      // For runs: use full test name with parameters (TestBooleanValue(true))
+      // For import: API will group by base name using the example field
+      title: testName, // Full name with parameters for run display
+      methodName: baseMethodName || methodName || testName,
+      fullName: fullName,
+      suitePath: suitePath,
+      suite_title: className || suitePath[suitePath.length - 1] || 'Unknown',
+      file: filePath,
+      files: files, // Array of files that will be attached
+      status: status,
+      message: message,
+      stack: stack,
+      run_time: parseFloat(testCase.duration || testCase.time || 0) * 1000,
+      test_id: testId,
+      tags: tags, // Array of category tags from properties
+      create: true,
+      retry: false,
+      // Parameterized test metadata
+      example: example, // Parameters as object for API grouping
+      isParameterized: isParameterized,
+      parameters: parameters, // Keep original array for reference
+      baseMethodName: baseMethodName,
+    };
+  }
+
+  /**
+   * Extract method name and parameters from test name
+   * @param {string} testName - Full test name
+   * @returns {Object} - Extracted information
+   */
+  extractParameters(testName) {
+    const paramMatch = testName.match(/^(.+?)\((.+)\)$/);
+
+    if (paramMatch) {
+      const baseMethodName = paramMatch[1].trim();
+      const paramString = paramMatch[2];
+
+      // Parse parameters - handle quoted strings and nested structures
+      const parameters = this.parseParameterString(paramString);
+
+      return {
+        baseMethodName: baseMethodName,
+        parameters: parameters,
+        isParameterized: true,
+      };
+    }
+
+    return {
+      baseMethodName: testName,
+      parameters: [],
+      isParameterized: false,
+    };
+  }
+
+  /**
+   * Parse parameter string into array of parameters
+   * @param {string} paramString - Parameter string
+   * @returns {Array} - Array of parameters
+   */
+  parseParameterString(paramString) {
+    const parameters = [];
+    let current = '';
+    let inQuotes = false;
+    let quoteChar = null;
+    let depth = 0;
+
+    for (let i = 0; i < paramString.length; i++) {
+      const char = paramString[i];
+
+      if (!inQuotes && (char === '"' || char === "'")) {
+        inQuotes = true;
+        quoteChar = char;
+        current += char;
+      } else if (inQuotes && char === quoteChar) {
+        inQuotes = false;
+        quoteChar = null;
+        current += char;
+      } else if (!inQuotes && char === '(') {
+        depth++;
+        current += char;
+      } else if (!inQuotes && char === ')') {
+        depth--;
+        current += char;
+      } else if (!inQuotes && char === ',' && depth === 0) {
+        parameters.push(current.trim());
+        current = '';
+      } else {
+        current += char;
+      }
+    }
+
+    if (current.trim()) {
+      parameters.push(current.trim());
+    }
+
+    // Clean up parameters - remove quotes if they wrap the entire parameter
+    return parameters.map(param => {
+      param = param.trim();
+      if ((param.startsWith('"') && param.endsWith('"')) || (param.startsWith("'") && param.endsWith("'"))) {
+        return param.slice(1, -1);
+      }
+      return param;
+    });
+  }
+
+  /**
+   * Extract method name from test name (fallback)
+   * @param {string} testName - Test name
+   * @returns {string} - Method name
+   */
+  extractMethodName(testName) {
+    // Remove parameters if present
+    const paramMatch = testName.match(/^(.+?)\(/);
+    return paramMatch ? paramMatch[1].trim() : testName;
+  }
+
+  /**
+   * Build file path from suite path and class name
+   * @param {Array} suitePath - Suite path array
+   * @param {string} className - Class name
+   * @param {Object} parentSuite - Parent suite for context
+   * @returns {string} - File path
+   */
+  buildFilePath(suitePath, className, parentSuite) {
+    // Try to get file path from parent suite
+    if (parentSuite && parentSuite.filepath) {
+      return parentSuite.filepath;
+    }
+
+    // Build path from suite hierarchy
+    const pathParts = [...suitePath];
+    if (className && !pathParts.includes(className)) {
+      pathParts.push(className);
+    }
+
+    // Convert to file path format
+    return pathParts.join('/') + '.cs'; // Assume C# for NUnit
+  }
+
+  /**
+   * Group parameterized tests by base method name
+   * @param {Array} tests - Array of parsed tests
+   * @returns {Object} - Grouped tests
+   */
+  groupParameterizedTests(tests) {
+    const grouped = {};
+
+    tests.forEach(test => {
+      const key = test.isParameterized
+        ? `${test.suitePath.join('.')}.${test.baseMethodName}`
+        : `${test.suitePath.join('.')}.${test.title}`;
+
+      if (!grouped[key]) {
+        grouped[key] = {
+          baseTest: {
+            name: test.baseMethodName || test.title,
+            suitePath: test.suitePath,
+            suite_title: test.suite_title,
+            file: test.file,
+            isParameterized: test.isParameterized,
+          },
+          variations: [],
+        };
+      }
+
+      grouped[key].variations.push(test);
+    });
+
+    return grouped;
+  }
+}
+
+export default NUnitXmlParser;

package/src/pipe/testomatio.js

@@ -472,7 +472,7 @@ class TestomatioPipe {
       if (this.runUrl && this.proceed) {
         const notFinishedMessage = pc.yellow(pc.bold('Run was not finished because of $TESTOMATIO_PROCEED'));
         console.log(APP_PREFIX, `📊 ${notFinishedMessage}. Report URL: ${pc.magenta(this.runUrl)}`);
-        console.log(APP_PREFIX, `🛬 Run to finish it: TESTOMATIO_RUN=${this.runId} npx start-test-run --finish`);
+        console.log(APP_PREFIX, `🛬 Run to finish it: TESTOMATIO_RUN=${this.runId} npx @testomatio/reporter finish`);
       }
 
       if (this.hasUnmatchedTests) {