@testomatio/reporter 2.3.5-beta-5-xml-import → 2.3.5-beta.8-xml-import

package/src/xmlReader.js

@@ -162,29 +162,7 @@ class XmlReader {
     reduceOptions.preferClassname = this.stats.language === 'python';
     const resultTests = processTestSuite(jsonSuite['test-suite']);
 
-    debug('Raw tests extracted from NUnit XML:', resultTests.length);
-    debug(
-      'Raw tests:',
-      resultTests.map(t => ({ title: t.title, example: t.example, file: t.file })),
-    );
-
-    // Optional deduplication for complex NUnit scenarios - can be enabled via options
-    let finalTests = resultTests;
-    if (this.opts.enableNUnitDeduplication) {
-      finalTests = this.deduplicateTestsByFQN(resultTests);
-      debug('Tests after deduplication:', finalTests.length);
-      debug(
-        'Deduplicated tests:',
-        finalTests.map(t => ({
-          title: t.title,
-          examples: t.examples,
-          example: t.example,
-          file: t.file,
-        })),
-      );
-    }
-
-    this.tests = this.tests.concat(finalTests);
+    this.tests = this.tests.concat(resultTests);
 
     return {
       status: result?.toLowerCase(),
@@ -193,7 +171,7 @@ class XmlReader {
       passed_count: parseInt(passed, 10),
       failed_count: parseInt(failed, 10),
       skipped_count: parseInt(inconclusive + skipped, 10),
-      tests: finalTests,
+      tests: resultTests,
     };
   }
 
@@ -341,194 +319,6 @@ class XmlReader {
     };
   }
 
-  deduplicateTestsByFQN(tests) {
-    const fqnMap = new Map();
-
-    tests.forEach(test => {
-      const fqn = this.generateNormalizedFQN(test);
-
-      if (fqnMap.has(fqn)) {
-        const existingTest = fqnMap.get(fqn);
-
-        // For parameterized tests, merge as Examples
-        if (test.example && Array.isArray(test.example) && test.example.length > 0) {
-          // Initialize examples array if it doesn't exist
-          if (!existingTest.examples) {
-            existingTest.examples = [];
-            // Add the existing test's example as the first item if it has parameters
-            if (existingTest.example && Array.isArray(existingTest.example) && existingTest.example.length > 0) {
-              existingTest.examples.push({
-                parameters: existingTest.example,
-                status: existingTest.status,
-                run_time: existingTest.run_time,
-                message: existingTest.message,
-                stack: existingTest.stack,
-              });
-              // Clear the main test's example since it's now in examples array
-              delete existingTest.example;
-            }
-          }
-
-          // Add this test's execution as an example
-          existingTest.examples.push({
-            parameters: test.example,
-            status: test.status,
-            run_time: test.run_time,
-            message: test.message,
-            stack: test.stack,
-          });
-
-          // Update the main test status to reflect the worst status
-          if (test.status === 'failed' || existingTest.status === 'failed') {
-            existingTest.status = 'failed';
-          } else if (test.status === 'skipped' && existingTest.status !== 'failed') {
-            existingTest.status = 'skipped';
-          }
-
-          // Update total run time
-          existingTest.run_time = (existingTest.run_time || 0) + (test.run_time || 0);
-        } else {
-          // Merge test properties for non-parameterized tests, prioritizing Test Explorer structure
-          if (test.test_id && !existingTest.test_id) {
-            existingTest.test_id = test.test_id;
-          }
-          // Keep the most complete test data
-          if (test.stack && !existingTest.stack) {
-            existingTest.stack = test.stack;
-          }
-          if (test.message && !existingTest.message) {
-            existingTest.message = test.message;
-          }
-        }
-
-        // Prefer Test Explorer structure (longer, more complete suite_title)
-        if (test.suite_title && test.suite_title.length > existingTest.suite_title.length) {
-          existingTest.suite_title = test.suite_title;
-        }
-
-        // Always use the source file path if available
-        if (test.file && test.file.endsWith('.cs')) {
-          existingTest.file = test.file;
-        } else if (!existingTest.file || !existingTest.file.endsWith('.cs')) {
-          existingTest.file = this.extractCsFileFromPath(test);
-        }
-      } else {
-        // Fix file path to use proper .cs file names from source paths
-        if (!test.file || !test.file.endsWith('.cs')) {
-          test.file = this.extractCsFileFromPath(test);
-        }
-        fqnMap.set(fqn, test);
-      }
-    });
-
-    return Array.from(fqnMap.values());
-  }
-
-  generateFQN(test) {
-    // Generate Fully Qualified Name: Namespace + Class + Method (standard .NET FQN)
-    // Don't include assembly as it can vary between different test structures
-    const namespace = this.extractNamespace(test);
-    const className = this.extractClassName(test);
-    const methodName = test.title;
-
-    // Use the most complete namespace.class structure available
-    if (test.suite_title && test.suite_title.includes('.')) {
-      return `${test.suite_title}.${methodName}`;
-    }
-
-    return `${namespace}.${className}.${methodName}`;
-  }
-
-  generateNormalizedFQN(test) {
-    // Generate normalized FQN for deduplication by extracting the core namespace.class.method
-    // For parameterized tests, we want the SAME FQN so they merge into one test with multiple Examples
-
-    const fullClassName = test.suite_title || '';
-    const methodName = test.title;
-
-    // Extract the most specific namespace.class pattern
-    if (fullClassName.includes('.')) {
-      const parts = fullClassName.split('.');
-
-      if (parts.length >= 2) {
-        const className = parts[parts.length - 1];
-
-        // Look for common .NET namespace patterns and normalize them:
-        // TestProject.Tests.MyClass -> Tests.MyClass
-        // Tests.MyClass -> Tests.MyClass
-        // MyProject.SubNamespace.Tests.MyClass -> Tests.MyClass
-
-        let normalizedNamespace = '';
-        for (let i = parts.length - 2; i >= 0; i--) {
-          const part = parts[i];
-
-          // Build namespace from right to left, excluding project names
-          if (part === 'Tests' || part.endsWith('Tests') || part.includes('Test')) {
-            // Found a test namespace, use it as the normalized namespace
-            normalizedNamespace = part;
-            break;
-          } else if (i === parts.length - 2) {
-            // If no test namespace found, use the immediate parent as namespace
-            normalizedNamespace = part;
-          }
-        }
-
-        return `${normalizedNamespace}.${className}.${methodName}`;
-      }
-    }
-
-    // Fallback for simple class names
-    return `${fullClassName}.${methodName}`;
-  }
-
-  extractAssemblyName(test) {
-    // Extract assembly name from file path or use default
-    if (test.file) {
-      const parts = test.file.split(/[/\\]/);
-      return parts[0] || 'DefaultAssembly';
-    }
-    return 'DefaultAssembly';
-  }
-
-  extractNamespace(test) {
-    // Extract namespace from suite_title or classname
-    if (test.suite_title && test.suite_title.includes('.')) {
-      const parts = test.suite_title.split('.');
-      return parts.slice(0, -1).join('.');
-    }
-    return test.suite_title || 'DefaultNamespace';
-  }
-
-  extractClassName(test) {
-    // Extract class name from suite_title
-    if (test.suite_title && test.suite_title.includes('.')) {
-      const parts = test.suite_title.split('.');
-      return parts[parts.length - 1];
-    }
-    return test.suite_title || 'DefaultClass';
-  }
-
-  extractCsFileFromPath(test) {
-    // Extract .cs file name from source file path, not namespace
-    if (test.file) {
-      // Look for actual .cs file path patterns
-      const csFileMatch = test.file.match(/([^/\\]+\.cs)$/);
-      if (csFileMatch) {
-        return test.file;
-      }
-
-      // If no .cs extension, assume it's a namespace path and convert to likely file name
-      const className = this.extractClassName(test);
-      const pathParts = test.file.split(/[/\\]/);
-      pathParts[pathParts.length - 1] = `${className}.cs`;
-      return pathParts.join('/');
-    }
-
-    // Fallback to class name
-    const className = this.extractClassName(test);
-    return `${className}.cs`;
-  }
-
   calculateStats() {
     this.stats = {
       ...this.stats,
@@ -570,15 +360,9 @@ class XmlReader {
           debug('Failed to open file with the source code', file);
           return;
         }
-
         const contents = fs.readFileSync(file).toString();
-
-        // Try original test name first (for parameterized tests), fallback to regular title
-        const titleForLookup = t.originalTestName ? t.originalTestName.replace(/\(.*?\)/, '').trim() : t.title;
-
-        t.code = fetchSourceCode(contents, { ...t, title: titleForLookup, lang: this.stats.language });
+        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) {
@@ -701,13 +485,7 @@ function reduceTestCases(prev, item) {
   testCases
     .filter(t => !!t)
     .forEach(testCaseItem => {
-      // Simple file extraction (version 2.1.1 approach) with fallback to enhanced extraction
-      let file = testCaseItem.file || item.filepath || item.fullname || item.package || '';
-
-      // If no file found with simple approach and we have enhanced extraction enabled, use it
-      if (!file && item.filepath) {
-        file = extractSourceFilePath(testCaseItem, item);
-      }
+      const file = testCaseItem.file || item.filepath || item.fullname || item.package || '';
 
       let stack = '';
       let message = '';
@@ -727,34 +505,15 @@ function reduceTestCases(prev, item) {
       // SpecFlow config
       let { title, tags, testId } = fetchProperties(isParametrized ? item : testCaseItem);
       let example = null;
-
-      // Simple suite title extraction (version 2.1.1 approach) with fallback to enhanced
-      let suiteTitle = preferClassname ? testCaseItem.classname : item.name || testCaseItem.classname;
-      if (!suiteTitle && item.fullname) {
-        suiteTitle = extractTestExplorerSuiteTitle(testCaseItem, item);
-      }
+      const suiteTitle = preferClassname ? testCaseItem.classname : item.name || testCaseItem.classname;
 
       title ||= testCaseItem.name || testCaseItem.methodname || testCaseItem.classname;
       tags ||= [];
 
-      // Store original test name for enhanced parameter extraction
-      const originalTestName = testCaseItem.name || testCaseItem.methodname;
-
-      // Enhanced NUnit-style arguments from <arguments> element
-      if (testCaseItem.arguments && testCaseItem.arguments.arg) {
-        const args = Array.isArray(testCaseItem.arguments.arg)
-          ? testCaseItem.arguments.arg
-          : [testCaseItem.arguments.arg];
-        example = args; // Store as array instead of object
-        // Remove parameters from title for NUnit tests
-        title = (testCaseItem.methodname || title).replace(/\(.*?\)/, '').trim();
-      } else {
-        // Simple parameter extraction (version 2.1.1 approach)
-        const exampleMatches = testCaseItem.name?.match(/\S\((.*?)\)/);
-        if (exampleMatches) {
-          example = { ...exampleMatches[1].split(',').map(v => v.trim().replace(/[^\w\s-]/g, '')) };
-          title = title.replace(/\(.*?\)/, '').trim();
-        }
+      const exampleMatches = testCaseItem.name?.match(/\S\((.*?)\)/);
+      if (exampleMatches) {
+        example = { ...exampleMatches[1].split(',').map(v => v.trim().replace(/[^\w\s-]/g, '')) };
+        title = title.replace(/\(.*?\)/, '').trim();
       }
 
       stack = `${
@@ -809,7 +568,6 @@ function reduceTestCases(prev, item) {
         run_time: parseFloat(testCaseItem.time || testCaseItem.duration) * 1000,
         status,
         title,
-        originalTestName, // Store original name for enhanced features
         root_suite_id: TESTOMATIO_SUITE,
         suite_title: suiteTitle,
         files,
@@ -819,113 +577,6 @@ function reduceTestCases(prev, item) {
   return prev;
 }
 
-function extractSourceFilePath(testCaseItem, item) {
-  // Priority order for file path extraction to match Test Explorer structure:
-  // 1. filepath attribute (direct .cs file path from NUnit)
-  // 2. fullname (contains full project path)
-  // 3. file attribute from test case
-  // 4. package (fallback)
-
-  // NUnit provides filepath attribute with actual .cs file path - use this first
-  if (item.filepath) {
-    // Clean up Windows/Unix path separators and ensure proper format
-    let filePath = item.filepath.replace(/\\/g, '/');
-
-    // Make relative to current working directory if absolute
-    if (path.isAbsolute(item.filepath)) {
-      const cwd = process.cwd().replace(/\\/g, '/');
-      if (filePath.startsWith(cwd)) {
-        filePath = path.relative(cwd, item.filepath).replace(/\\/g, '/');
-      } else {
-        // Try to extract relative path from common patterns
-        const commonPatterns = ['/Tests/', '/test/', '/src/', '/Test/'];
-        for (const pattern of commonPatterns) {
-          const index = filePath.lastIndexOf(pattern);
-          if (index !== -1) {
-            filePath = filePath.substring(index + 1);
-            break;
-          }
-        }
-      }
-    }
-    return filePath;
-  }
-
-  if (testCaseItem.file) {
-    let filePath = testCaseItem.file.replace(/\\/g, '/');
-
-    // Make relative to current working directory if absolute
-    if (path.isAbsolute(testCaseItem.file)) {
-      const cwd = process.cwd().replace(/\\/g, '/');
-      if (filePath.startsWith(cwd)) {
-        filePath = path.relative(cwd, testCaseItem.file).replace(/\\/g, '/');
-      } else {
-        // Try to extract relative path from common patterns
-        const commonPatterns = ['/Tests/', '/test/', '/src/', '/Test/'];
-        for (const pattern of commonPatterns) {
-          const index = filePath.lastIndexOf(pattern);
-          if (index !== -1) {
-            filePath = filePath.substring(index + 1);
-            break;
-          }
-        }
-      }
-    }
-    return filePath;
-  }
-
-  if (item.fullname) {
-    // Extract actual file path from fullname if it contains path separators
-    const fullnameParts = item.fullname.split('.');
-    if (fullnameParts.length > 2) {
-      // For ParameterizedMethod, get the class name (not method name)
-      // Example: "NUnit_sample_test.Tests.SampleTests.TestBooleanValue" -> "Tests/SampleTests.cs"
-      let namespaceParts, className;
-
-      if (item.type === 'ParameterizedMethod') {
-        // For parameterized methods, the last part is the method name, second-to-last is class
-        namespaceParts = fullnameParts.slice(1, -2); // Skip project name and method name
-        className = fullnameParts[fullnameParts.length - 2]; // Get class name
-      } else {
-        // For regular classes/fixtures
-        namespaceParts = fullnameParts.slice(1, -1); // Skip project name
-        className = fullnameParts[fullnameParts.length - 1];
-      }
-
-      return `${namespaceParts.join('/')}/${className}.cs`;
-    }
-  }
-
-  if (item.package) return item.package.replace(/\\/g, '/');
-
-  // Fallback: construct from classname
-  if (testCaseItem.classname) {
-    const parts = testCaseItem.classname.split('.');
-    const className = parts[parts.length - 1];
-    const namespacePath = parts.slice(0, -1).join('/');
-    return `${namespacePath}/${className}.cs`;
-  }
-
-  return '';
-}
-
-function extractTestExplorerSuiteTitle(testCaseItem, item) {
-  // Extract suite title to match Test Explorer structure (Project/Namespace hierarchy)
-  // Priority: fullname > classname > name
-
-  if (item.fullname) {
-    // Use fullname to maintain Test Explorer structure
-    return item.fullname;
-  }
-
-  if (testCaseItem.classname) {
-    return testCaseItem.classname;
-  }
-
-  // Fallback to item name but prefer classname structure
-  return item.name || testCaseItem.classname || 'UnknownClass';
-}
-
 function processTestSuite(testsuite) {
   if (!testsuite) return [];
   if (testsuite.testsuite) return processTestSuite(testsuite.testsuite);
@@ -936,8 +587,7 @@ function processTestSuite(testsuite) {
     suites = [testsuite];
   }
 
-  // Simple approach from version 2.1.1 with enhanced processing for complex scenarios
-  const subSuites = suites.filter(s => s['test-suite'] && !s['test-case']);
+  const subSuites = suites.filter(s => s['test-suite'] && !testsuite['test-case']);
 
   return [...subSuites.map(s => processTestSuite(s['test-suite'])), ...suites.reduce(reduceTestCases, [])].flat();
 }