@testomatio/reporter 2.3.7-beta.1-xml-import → 2.3.7-beta.100

package/src/utils/utils.js

@@ -76,17 +76,29 @@ const isValidUrl = s => {
   }
 };
 
-const fileMatchRegex = /file:(\/+(?:[A-Za-z]:[\\/]|\/)?[^\s]*?\.(png|avi|webm|jpg|html|txt))/gi;
+const fileMatchRegex = /file:(\/*)([A-Za-z]:[\\/].*?|\/.*?)\.(png|avi|webm|jpg|html|txt)/gi;
 
 const fetchFilesFromStackTrace = (stack = '', checkExists = true) => {
-  const files = Array.from(stack.matchAll(fileMatchRegex))
-    .map(f => f[1].trim())
+  let files = Array.from(stack.matchAll(fileMatchRegex))
+    .map(match => {
+      // match[0] is full match, match[1] is slashes, match[2] is path, match[3] is extension
+      const slashes = match[1] || '';
+      const path = match[2];
+      const extension = match[3];
+      return `${slashes}${path}.${extension}`;
+    })
+    .map(f => f.trim())
     .map(f => f.replace(/^\/+/, '/').replace(/^\/([A-Za-z]:)/, '$1')) // Remove extra slashes, handle Windows paths
     .map(f => {
       // Normalize path separators for cross-platform compatibility
       return f.replace(/\\/g, '/');
     });
 
+  // If we're not checking file existence, remove Windows drive letters for consistency
+  if (!checkExists) {
+    files = files.map(f => f.replace(/^([A-Za-z]):/, ''));
+  }
+
   debug('Found files in stack trace: ', files);
 
   return files.filter(f => {
@@ -101,21 +113,92 @@ const fetchSourceCodeFromStackTrace = (stack = '') => {
   const stackLines = stack
     .split('\n')
     .filter(l => l.includes(':'))
-    // .map(l => l.match(/\[(.*?)\]/)?.[1] || l) // minitest format
-    // .map(l => l.split(':')[0])
     .map(l => l.trim())
-    .map(l => l.split(' ').find(p => p.includes(':')) || '')
-    .filter(l => isValid(l?.split(':')[0]))
+    .map(l => {
+      // Remove 'at ' prefix if present
+      if (l.startsWith('at ')) {
+        return l.substring(3).trim();
+      }
+      // Find the part that looks like a file path with line number
+      const parts = l.split(' ');
+      for (const part of parts) {
+        // Check if this part has a colon
+        if (part.includes(':')) {
+          // For Windows paths, we need to handle drive letters (C:, D:, etc.)
+          // Split by colon but keep drive letter with the path
+          const colonParts = part.split(':');
+          let filePath;
+
+          // Check if first part is a Windows drive letter (single letter)
+          if (colonParts.length >= 2 && colonParts[0].length === 1 && /[A-Za-z]/.test(colonParts[0])) {
+            // Windows path like D:\path\file.php:24
+            // Reconstruct as D:\path\file.php
+            filePath = colonParts[0] + ':' + colonParts[1];
+          } else {
+            // Unix path like /path/file.php:24
+            filePath = colonParts[0];
+          }
+
+          // Only consider it valid if the file exists
+          if (fs.existsSync(filePath)) {
+            return part;
+          }
+        }
+      }
+      // If no valid file path found in parts, return the whole line
+      // It will be filtered out later if it's not a valid file path
+      return parts.find(p => p.includes(':')) || l;
+    })
+    .filter(l => {
+      // Extract file path from line (accounting for Windows drive letters)
+      if (!l) return false;
+      const colonParts = l.split(':');
+      let filePath;
+
+      if (colonParts.length >= 2 && colonParts[0].length === 1 && /[A-Za-z]/.test(colonParts[0])) {
+        // Windows path
+        filePath = colonParts[0] + ':' + colonParts[1];
+      } else {
+        // Unix path
+        filePath = colonParts[0];
+      }
+
+      return filePath && fs.existsSync(filePath);
+    })
 
     // // filter out 3rd party libs
     .filter(l => !l?.includes(`vendor${sep}`))
     .filter(l => !l?.includes(`node_modules${sep}`))
-    .filter(l => fs.existsSync(l.split(':')[0]))
-    .filter(l => fs.lstatSync(l.split(':')[0]).isFile());
+    .filter(l => {
+      // Extract file path for final check (accounting for Windows drive letters)
+      const colonParts = l.split(':');
+      let filePath;
+
+      if (colonParts.length >= 2 && colonParts[0].length === 1 && /[A-Za-z]/.test(colonParts[0])) {
+        filePath = colonParts[0] + ':' + colonParts[1];
+      } else {
+        filePath = colonParts[0];
+      }
+
+      return fs.lstatSync(filePath).isFile();
+    });
 
   if (!stackLines.length) return '';
 
-  const [file, line] = stackLines[0].split(':');
+  // Extract file and line number (accounting for Windows drive letters)
+  const firstLine = stackLines[0];
+  const colonParts = firstLine.split(':');
+  let file, line;
+
+  if (colonParts.length >= 3 && colonParts[0].length === 1 && /[A-Za-z]/.test(colonParts[0])) {
+    // Windows path like D:\path\file.php:24
+    file = colonParts[0] + ':' + colonParts[1];
+    line = colonParts[2];
+  } else {
+    // Unix path like /path/file.php:24
+    file = colonParts[0];
+    line = colonParts[1];
+  }
 
   const prepend = 3;
   const source = fetchSourceCode(fs.readFileSync(file).toString(), { line, prepend, limit: 7 });
@@ -178,30 +261,63 @@ const fetchSourceCode = (contents, opts = {}) => {
       if (lineIndex === -1) lineIndex = lines.findIndex(l => l.includes(`public void ${title}`));
       if (lineIndex === -1) lineIndex = lines.findIndex(l => l.includes(`${title}(`));
     } else if (opts.lang === 'csharp') {
-      // Enhanced C# method detection for NUnit tests
-      lineIndex = lines.findIndex(l => l.includes(`public void ${title}(`));
+      // Find the method declaration line
+      let methodLineIndex = lines.findIndex(l => l.includes(`public void ${title}(`));
 
-      if (lineIndex === -1) {
-        lineIndex = lines.findIndex(l => l.includes(`public async Task ${title}(`));
+      if (methodLineIndex === -1) {
+        methodLineIndex = lines.findIndex(l => l.includes(`public async Task ${title}(`));
       }
 
-      if (lineIndex === -1) {
-        lineIndex = lines.findIndex(l => l.includes(`${title}(`));
+      if (methodLineIndex === -1) {
+        methodLineIndex = 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;
+      // If found, scan upwards to find [TestCase], [Test] attributes and XML comments
+      if (methodLineIndex !== -1) {
+        lineIndex = methodLineIndex;
+
+        // Scan upwards to find the start of attributes and comments
+        for (let i = methodLineIndex - 1; i >= 0; i--) {
+          const trimmedLine = lines[i].trim();
+
+          // Include [TestCase], [Test], and other attributes
+          if (trimmedLine.startsWith('[')) {
+            lineIndex = i;
+            continue;
+          }
+
+          // Include XML documentation comments
+          if (trimmedLine.startsWith('///')) {
+            lineIndex = i;
+            continue;
+          }
+
+          // Stop at empty lines (with some tolerance)
+          if (trimmedLine === '') {
+            // Check if next non-empty line is an attribute or comment
+            let hasMoreAttributes = false;
+            for (let j = i - 1; j >= 0; j--) {
+              const nextTrimmed = lines[j].trim();
+              if (nextTrimmed === '') continue;
+              if (nextTrimmed.startsWith('[') || nextTrimmed.startsWith('///')) {
+                hasMoreAttributes = true;
+                lineIndex = j;
+              }
+              break;
+            }
+            if (!hasMoreAttributes) break;
+            continue;
+          }
+
+          // Stop at other method declarations or class-level elements
+          if (
+            trimmedLine.includes('public ') ||
+            trimmedLine.includes('private ') ||
+            trimmedLine.includes('protected ') ||
+            trimmedLine.includes('internal ')
+          ) {
+            if (!trimmedLine.startsWith('[')) break;
           }
-          return false;
-        });
-        if (testAttributeIndex !== -1) {
-          lineIndex = testAttributeIndex;
         }
       }
     } else {
@@ -215,9 +331,29 @@ const fetchSourceCode = (contents, opts = {}) => {
 
   if (lineIndex !== -1 && lineIndex !== undefined) {
     const result = [];
+    let braceDepth = 0; // Track brace depth for C# methods
+    let methodStartFound = false; // Flag to indicate we've found the method opening brace
+
     for (let i = lineIndex; i < lineIndex + limit; i++) {
       if (lines[i] === undefined) continue;
 
+      // Track brace depth for C# to stop after method closes
+      if (opts.lang === 'csharp') {
+        const line = lines[i];
+        // Count opening and closing braces
+        const openBraces = (line.match(/\{/g) || []).length;
+        const closeBraces = (line.match(/\}/g) || []).length;
+
+        if (openBraces > 0) methodStartFound = true;
+        braceDepth += openBraces - closeBraces;
+
+        // If we've started the method and depth returns to 0, method is complete
+        if (methodStartFound && braceDepth === 0 && closeBraces > 0) {
+          // Don't include the closing brace - just break
+          break;
+        }
+      }
+
       if (i > lineIndex + 2 && !opts.prepend) {
         // annotation
         if (opts.lang === 'php' && lines[i].trim().startsWith('#[')) break;
@@ -238,11 +374,36 @@ const fetchSourceCode = (contents, opts = {}) => {
         if (opts.lang === 'java' && lines[i].trim().match(/^@\w+/)) break;
         if (opts.lang === 'java' && lines[i].includes(' public void ')) 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;
+        // For C#, additional checks if brace tracking didn't stop us
+        if (opts.lang === 'csharp') {
+          const trimmed = lines[i].trim();
+          // Stop at attribute that marks beginning of next test (but not if we're still in the current method)
+          if (trimmed.match(/^\[(Test|TestCase|Theory|Fact)/) && methodStartFound && braceDepth === 0) break;
+          // Stop at XML documentation comments that belong to next method
+          if (trimmed.startsWith('///') && methodStartFound && braceDepth === 0) break;
+          // Stop at another method declaration (but not if we're still in the current method)
+          if (
+            trimmed.match(/^\s*(public|private|protected|internal)\s+(\w+|async\s+\w+)\s+\w+\s*\(/) &&
+            methodStartFound &&
+            braceDepth === 0
+          )
+            break;
+          // Stop at class declaration
+          if (trimmed.includes(' class ') && trimmed.includes('public')) break;
+          // Stop at helper method calls (like ProcessBooleanValue, AddNumbers) - these are private methods
+          if (methodStartFound && trimmed.match(/^\s*\/\/\s*Helper methods for testing/)) break;
+        }
+      }
+
+      // For C# tests, stop if we encounter helper method calls in the method body
+      if (opts.lang === 'csharp' && methodStartFound && braceDepth > 0) {
+        const trimmed = lines[i].trim();
+        // Stop at comment indicating helper methods section
+        if (trimmed.match(/^\s*\/\/\s*Helper methods for testing/)) {
+          break;
+        }
       }
+
       result.push(lines[i]);
     }
     return result.join('\n');
@@ -454,8 +615,20 @@ function transformEnvVarToBoolean(value) {
   return Boolean(value);
 }
 
+function truncate(s, size = 255) {
+  if (s === undefined || s === null) {
+    return '';
+  }
+  const str = s.toString();
+  if (str.trim().length < size) {
+    return str;
+  }
+  return `${str.substring(0, size)}...`;
+}
+
 export {
   ansiRegExp,
+  truncate,
   cleanLatestRunId,
   isSameTest,
   fetchSourceCode,

package/src/xmlReader.js

@@ -15,6 +15,7 @@ import {
   fetchIdFromCode,
   humanize,
   TEST_ID_REGEX,
+  transformEnvVarToBoolean,
 } from './utils/utils.js';
 import { pipesFactory } from './pipe/index.js';
 import adapterFactory from './junit-adapter/index.js';
@@ -36,6 +37,7 @@ const {
   TESTOMATIO_ENV,
   TESTOMATIO_RUN,
   TESTOMATIO_MARK_DETACHED,
+  TESTOMATIO_LEGACY_NUNIT,
 } = process.env;
 
 const options = {
@@ -77,7 +79,8 @@ class XmlReader {
     this.uploader = new S3Uploader();
 
     // Enhanced NUnit parsing - enabled by default for NUnit XML
-    this.enhancedNunit = opts.enhancedNunit !== false; // Default true, can be disabled
+    // Can be disabled via opts.enhancedNunit = false or TESTOMATIO_LEGACY_NUNIT=1
+    this.enhancedNunit = opts.enhancedNunit !== false && !transformEnvVarToBoolean(TESTOMATIO_LEGACY_NUNIT); // Default true, can be disabled
     this.groupParameterized = opts.groupParameterized !== false; // Default true, can be disabled
 
     // @ts-ignore
@@ -240,59 +243,20 @@ class XmlReader {
     let defs = jsonSuite?.TestRun?.TestDefinitions?.UnitTest;
     if (!Array.isArray(defs)) defs = [defs].filter(d => !!d);
 
-    const tests =
-      defs.map(td => {
-        const title = td.name.replace(/\(.*?\)/, '').trim();
-        let example = td.name.match(/\((.*?)\)/);
-        if (example) example = { ...example[1].split(',') };
-        const suite = td.TestMethod.className.split(', ')[0].split('.');
-        const suite_title = suite.pop();
-        return {
-          title,
-          example,
-          file: suite.join('/'),
-          description: td.Description,
-          suite_title,
-          id: td.Execution.id,
-        };
-      }) || [];
+    // Parse test definitions
+    const tests = defs.map(td => this._parseTRXTestDefinition(td));
 
+    // Parse test results
     let result = jsonSuite?.TestRun?.Results?.UnitTestResult;
     if (!Array.isArray(result)) result = [result].filter(d => !!d);
 
-    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,
-      stack: td.Output.StdOut,
-      files: td?.ResultFiles?.ResultFile?.map(rf => rf.path),
-    }));
-
-    results.forEach(r => {
-      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;
-      if (test.description) r.description = test.description;
-      if (test.example) r.example = test.example;
-      if (test.file) r.file = test.file;
-      r.create = true;
-      r.overwrite = true;
-      if (r.status === 'Passed') r.status = STATUS.PASSED;
-      if (r.status === 'Failed') r.status = STATUS.FAILED;
-      if (r.status === 'Skipped') r.status = STATUS.SKIPPED;
-      delete r.id;
-    });
+    const results = result.map(td => this._parseTRXTestResult(td, tests));
 
     debug(results);
 
     const counters = jsonSuite?.TestRun?.ResultSummary?.Counters || {};
-
     const failed_count = parseInt(counters.failed, 10) + parseInt(counters.error, 10);
-
-    let status = STATUS.PASSED.toString();
-    if (failed_count > 0) status = STATUS.FAILED;
+    const status = failed_count > 0 ? STATUS.FAILED : STATUS.PASSED.toString();
 
     this.tests = results.filter(t => !!t.title);
 
@@ -307,6 +271,67 @@ class XmlReader {
     };
   }
 
+  _parseTRXTestDefinition(td) {
+    const title = td.name.replace(/\(.*?\)/, '').trim();
+    const exampleMatch = td.name.match(/\((.*?)\)/);
+    const example = exampleMatch ? { ...exampleMatch[1].split(',') } : null;
+
+    const suite = td.TestMethod.className.split(', ')[0].split('.');
+    const suite_title = suite.pop();
+
+    // Convert namespace to file path for C#
+    const file = `${suite.join('/')}.cs`;
+
+    return {
+      title, // Base name without parameters for test import
+      example, // Parameters object for parameterized tests
+      file, // File path with .cs extension
+      description: td.Description,
+      suite_title,
+      id: td.Execution.id,
+    };
+  }
+
+  _parseTRXTestResult(td, tests) {
+    const test = tests.find(t => t.id === td.executionId) || {};
+
+    const result = {
+      suite_title: test.suite_title,
+      title: test.title?.trim(),
+      file: test.file,
+      description: test.description,
+      code: test.code,
+      run_time: parseFloat(td.duration) * 1000,
+      stack: td.Output?.StdOut || '',
+      files: td?.ResultFiles?.ResultFile?.map(rf => rf.path),
+      create: true,
+      overwrite: true,
+    };
+
+    // Add example for parameterized tests
+    if (test.example) {
+      result.example = test.example;
+    }
+
+    // Map TRX status to Testomat.io status
+    result.status = this._mapTRXStatus(td.outcome);
+
+    return result;
+  }
+
+  _mapTRXStatus(outcome) {
+    switch (outcome) {
+      case 'Passed':
+        return STATUS.PASSED;
+      case 'Failed':
+        return STATUS.FAILED;
+      case 'Skipped':
+        return STATUS.SKIPPED;
+      default:
+        return STATUS.PASSED;
+    }
+  }
+
   processXUnit(assemblies) {
     const tests = [];