@testomatio/reporter 2.3.6-beta.2-fix-beforesuite → 2.3.7-beta.1-xml-import

package/lib/utils/utils.js

@@ -121,12 +121,8 @@ const fetchFilesFromStackTrace = (stack = '', checkExists = true) => {
         .map(f => f[1].trim())
         .map(f => f.replace(/^\/+/, '/').replace(/^\/([A-Za-z]:)/, '$1')) // Remove extra slashes, handle Windows paths
         .map(f => {
-        // Convert Windows paths to Linux paths for testing purposes
-        if (f.match(/^[A-Za-z]:[\\\/]/)) {
-            // Convert Windows path to Linux equivalent for test scenarios
-            return f.replace(/^[A-Za-z]:[\\\/]/, '/').replace(/\\/g, '/');
-        }
-        return f;
+        // Normalize path separators for cross-platform compatibility
+        return f.replace(/\\/g, '/');
     });
     debug('Found files in stack trace: ', files);
     return files.filter(f => {
@@ -173,6 +169,8 @@ exports.fetchSourceCodeFromStackTrace = fetchSourceCodeFromStackTrace;
 exports.TEST_ID_REGEX = /@T([\w\d]{8})/;
 exports.SUITE_ID_REGEX = /@S([\w\d]{8})/;
 const fetchIdFromCode = (code, opts = {}) => {
+    if (!code)
+        return null;
     const comments = code
         .split('\n')
         .map(l => l.trim())
@@ -215,10 +213,29 @@ const fetchSourceCode = (contents, opts = {}) => {
                 lineIndex = lines.findIndex(l => l.includes(`${title}(`));
         }
         else if (opts.lang === 'csharp') {
-            if (lineIndex === -1)
-                lineIndex = lines.findIndex(l => l.includes(`public void ${title}`));
-            if (lineIndex === -1)
+            // Enhanced C# method detection for NUnit tests
+            lineIndex = lines.findIndex(l => l.includes(`public void ${title}(`));
+            if (lineIndex === -1) {
+                lineIndex = lines.findIndex(l => l.includes(`public async Task ${title}(`));
+            }
+            if (lineIndex === -1) {
                 lineIndex = lines.findIndex(l => l.includes(`${title}(`));
+            }
+            // Look for TestCase or Test attributes above the method
+            if (lineIndex === -1) {
+                const testAttributeIndex = lines.findIndex((l, index) => {
+                    if (l.includes('[TestCase') || l.includes('[Test')) {
+                        // Check next few lines for the method
+                        const nextLines = lines.slice(index, Math.min(lines.length, index + 5));
+                        const hasMethod = nextLines.some(nextLine => nextLine.includes(`${title}(`));
+                        return hasMethod;
+                    }
+                    return false;
+                });
+                if (testAttributeIndex !== -1) {
+                    lineIndex = testAttributeIndex;
+                }
+            }
         }
         else {
             lineIndex = lines.findIndex(l => l.includes(title));
@@ -227,7 +244,7 @@ const fetchSourceCode = (contents, opts = {}) => {
     if (opts.prepend) {
         lineIndex -= opts.prepend;
     }
-    if (lineIndex) {
+    if (lineIndex !== -1 && lineIndex !== undefined) {
         const result = [];
         for (let i = lineIndex; i < lineIndex + limit; i++) {
             if (lines[i] === undefined)
@@ -270,6 +287,14 @@ const fetchSourceCode = (contents, opts = {}) => {
                     break;
                 if (opts.lang === 'java' && lines[i].includes(' class '))
                     break;
+                if (opts.lang === 'csharp' && lines[i].trim().match(/^\[Test/))
+                    break;
+                if (opts.lang === 'csharp' && lines[i].includes(' public void '))
+                    break;
+                if (opts.lang === 'csharp' && lines[i].includes(' public async Task '))
+                    break;
+                if (opts.lang === 'csharp' && lines[i].includes(' class ') && lines[i].includes('public'))
+                    break;
             }
             result.push(lines[i]);
         }

package/lib/xmlReader.d.ts

@@ -19,25 +19,11 @@ declare class XmlReader {
     tests: any[];
     stats: {};
     uploader: S3Uploader;
+    enhancedNunit: boolean;
+    groupParameterized: boolean;
     version: any;
     connectAdapter(): import("./junit-adapter/adapter.js").default;
-    parse(fileName: any): {
-        status: string;
-        create_tests: boolean;
-        tests_count: number;
-        passed_count: number;
-        skipped_count: number;
-        failed_count: number;
-        tests: any;
-    } | {
-        status: any;
-        create_tests: boolean;
-        tests_count: number;
-        passed_count: number;
-        failed_count: number;
-        skipped_count: number;
-        tests: any[];
-    };
+    parse(fileName: any): any;
     processJUnit(jsonSuite: any): {
         create_tests: boolean;
         duration: number;
@@ -49,15 +35,14 @@ declare class XmlReader {
         tests: any[];
         tests_count: number;
     };
-    processNUnit(jsonSuite: any): {
-        status: any;
-        create_tests: boolean;
-        tests_count: number;
-        passed_count: number;
-        failed_count: number;
-        skipped_count: number;
-        tests: any[];
-    };
+    processNUnit(jsonSuite: any): any;
+    /**
+     * Check if the XML is actually NUnit format (has test-suite hierarchy)
+     * @param {Object} jsonSuite - Parsed XML suite object
+     * @returns {boolean} - True if this is NUnit XML format
+     */
+    isNUnitXml(jsonSuite: any): boolean;
+    processNUnitEnhanced(jsonSuite: any): any;
     processTRX(jsonSuite: any): {
         status: string;
         create_tests: boolean;

package/lib/xmlReader.js

@@ -11,6 +11,7 @@ const fast_xml_parser_1 = require("fast-xml-parser");
 const constants_js_1 = require("./constants.js");
 const crypto_1 = require("crypto");
 const url_1 = require("url");
+const nunit_parser_js_1 = require("./junit-adapter/nunit-parser.js");
 const utils_js_1 = require("./utils/utils.js");
 const index_js_1 = require("./pipe/index.js");
 const index_js_2 = __importDefault(require("./junit-adapter/index.js"));
@@ -54,6 +55,9 @@ class XmlReader {
         this.stats = {};
         this.stats.language = opts.lang?.toLowerCase();
         this.uploader = new uploader_js_1.S3Uploader();
+        // Enhanced NUnit parsing - enabled by default for NUnit XML
+        this.enhancedNunit = opts.enhancedNunit !== false; // Default true, can be disabled
+        this.groupParameterized = opts.groupParameterized !== false; // Default true, can be disabled
         // @ts-ignore
         const packageJsonPath = path_1.default.resolve(__dirname, '..', 'package.json');
         this.version = JSON.parse(fs_1.default.readFileSync(packageJsonPath).toString()).version;
@@ -102,7 +106,8 @@ class XmlReader {
         return this.processJUnit(jsonSuite);
     }
     processJUnit(jsonSuite) {
-        const { testsuite, name, tests, failures, errors } = jsonSuite;
+        const { testsuite, name, failures, errors } = jsonSuite;
+        const tests = testsuite?.tests || jsonSuite.tests;
         reduceOptions.preferClassname = this.stats.language === 'python';
         const resultTests = processTestSuite(testsuite);
         const hasFailures = resultTests.filter(t => t.status === 'failed').length > 0;
@@ -128,6 +133,13 @@ class XmlReader {
         };
     }
     processNUnit(jsonSuite) {
+        // Use enhanced NUnit parser if enabled and this is actually NUnit XML
+        if (this.enhancedNunit && this.isNUnitXml(jsonSuite)) {
+            debug('Using enhanced NUnit parser');
+            return this.processNUnitEnhanced(jsonSuite);
+        }
+        // Fallback to legacy parser for backward compatibility
+        debug('Using legacy NUnit parser');
         const { result, total, passed, failed, inconclusive, skipped } = jsonSuite;
         reduceOptions.preferClassname = this.stats.language === 'python';
         const resultTests = processTestSuite(jsonSuite['test-suite']);
@@ -142,6 +154,43 @@ class XmlReader {
             tests: resultTests,
         };
     }
+    /**
+     * Check if the XML is actually NUnit format (has test-suite hierarchy)
+     * @param {Object} jsonSuite - Parsed XML suite object
+     * @returns {boolean} - True if this is NUnit XML format
+     */
+    isNUnitXml(jsonSuite) {
+        // NUnit XML has test-suite elements with type attributes
+        if (jsonSuite['test-suite']) {
+            const testSuite = Array.isArray(jsonSuite['test-suite']) ? jsonSuite['test-suite'][0] : jsonSuite['test-suite'];
+            // Check for NUnit-specific test-suite types
+            return (testSuite &&
+                testSuite.type &&
+                ['Assembly', 'TestSuite', 'TestFixture', 'ParameterizedMethod'].includes(testSuite.type));
+        }
+        return false;
+    }
+    processNUnitEnhanced(jsonSuite) {
+        debug('Processing NUnit XML with enhanced parser');
+        try {
+            const nunitParser = new nunit_parser_js_1.NUnitXmlParser({
+                groupParameterized: this.groupParameterized,
+                ...this.opts,
+            });
+            const result = nunitParser.parseTestRun(jsonSuite);
+            // Add parsed tests to our collection
+            this.tests = this.tests.concat(result.tests);
+            debug(`Enhanced NUnit parser processed ${result.tests.length} tests`);
+            return result;
+        }
+        catch (error) {
+            debug('Enhanced NUnit parser failed, falling back to legacy parser:', error.message);
+            console.warn(`${constants_js_1.APP_PREFIX} Enhanced NUnit parsing failed, using legacy parser: ${error.message}`);
+            // Fallback to legacy parser
+            this.enhancedNunit = false;
+            return this.processNUnit(jsonSuite);
+        }
+    }
     processTRX(jsonSuite) {
         let defs = jsonSuite?.TestRun?.TestDefinitions?.UnitTest;
         if (!Array.isArray(defs))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testomatio/reporter",
-  "version": "2.3.6-beta.2-fix-beforesuite",
+  "version": "2.3.7-beta.1-xml-import",
   "description": "Testomatio Reporter Client",
   "engines": {
     "node": ">=18"

package/src/bin/reportXml.js

@@ -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/junit-adapter/csharp.js

@@ -3,18 +3,45 @@ 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(',') };
+    // Don't override example if it already exists from NUnit XML processing
+    // The xmlReader.js already extracts parameters correctly from <arguments>
+    if (!t.example) {
+      const title = t.title.replace(/\(.*?\)/, '').trim();
+      const exampleMatch = t.title.match(/\((.*?)\)/);
+      if (exampleMatch) {
+        // Keep as array for consistency with NUnit XML processing
+        t.example = exampleMatch[1].split(',').map(param => param.trim());
+      }
+      t.title = title.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 +49,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`;
 }