@testomatio/reporter 2.3.6-beta.1-truncate-steps → 2.3.7-beta.1-xml-import

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

@@ -0,0 +1,391 @@
+import createDebugMessages from 'debug';
+import { STATUS } from '../constants.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`);
+        const newPath = [...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;
+
+      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 nested test-suites
+    if (testSuite['test-suite']) {
+      this.parseTestSuite(testSuite['test-suite'], currentPath);
+    }
+
+    // Process test-cases
+    if (testSuite['test-case']) {
+      this.parseTestCases(testSuite['test-case'], currentPath, testSuite);
+    }
+  }
+
+  /**
+   * 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;
+    }
+
+    const testName = testCase.name;
+    const fullName = testCase.fullname;
+    const methodName = testCase.methodname || this.extractMethodName(testName);
+    const className = testCase.classname || parentSuite?.name;
+
+    debug(`Parsing test case: ${testName}`);
+
+    // 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 = '';
+
+    if (testCase.failure) {
+      message = testCase.failure.message || '';
+      stack = testCase.failure['stack-trace'] || testCase.failure['#text'] || '';
+    }
+
+    if (testCase.output && testCase.output['#text']) {
+      stack = `${stack}\n\n${testCase.output['#text']}`.trim();
+    }
+
+    // Extract test ID from properties
+    let testId = null;
+    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);
+      }
+    }
+
+    // Build file path from suite path and class name
+    const filePath = this.buildFilePath(suitePath, className, parentSuite);
+
+    return {
+      title: isParameterized ? testName : methodName || testName,
+      methodName: baseMethodName || methodName || testName,
+      fullName: fullName,
+      suitePath: suitePath,
+      suite_title: className || suitePath[suitePath.length - 1] || 'Unknown',
+      file: filePath,
+      status: status,
+      message: message,
+      stack: stack,
+      run_time: parseFloat(testCase.duration || testCase.time || 0) * 1000,
+      test_id: testId,
+      create: true,
+      retry: false,
+      // Parameterized test metadata
+      isParameterized: isParameterized,
+      parameters: parameters,
+      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/debug.js

@@ -15,7 +15,7 @@ export class DebugPipe {
     this.isEnabled = !!process.env.TESTOMATIO_DEBUG || !!process.env.DEBUG;
     if (this.isEnabled) {
       this.batch = {
-        isEnabled: this.params.isBatchEnabled ?? !process.env.TESTOMATIO_DISABLE_BATCH_UPLOAD ?? true,
+        isEnabled: this.params.isBatchEnabled ?? (process.env.TESTOMATIO_DISABLE_BATCH_UPLOAD ? false : true),
         intervalFunction: null,
         intervalTime: 5000,
         tests: [],
@@ -93,8 +93,7 @@ export class DebugPipe {
       const logData = { action: 'addTest', testId: data };
       if (this.store.runId) logData.runId = this.store.runId;
       this.logToFile(logData);
-    }
-    else this.batch.tests.push(data);
+    } else this.batch.tests.push(data);
 
     if (!this.batch.intervalFunction) await this.batchUpload();
   }

package/src/pipe/testomatio.js

@@ -20,7 +20,7 @@ if (process.env.TESTOMATIO_RUN) process.env.runId = process.env.TESTOMATIO_RUN;
 class TestomatioPipe {
   constructor(params, store) {
     this.batch = {
-      isEnabled: params?.isBatchEnabled ?? !process.env.TESTOMATIO_DISABLE_BATCH_UPLOAD ?? true,
+      isEnabled: params?.isBatchEnabled ?? (process.env.TESTOMATIO_DISABLE_BATCH_UPLOAD ? false : true),
       intervalFunction: null, // will be created in createRun by setInterval function
       intervalTime: 5000, // how often tests are sent
       tests: [], // array of tests in batch
@@ -60,8 +60,8 @@ class TestomatioPipe {
       retryConfig: {
         retry: REPORTER_REQUEST_RETRIES.retriesPerRequest,
         retryDelay: REPORTER_REQUEST_RETRIES.retryTimeout,
-        httpMethodsToRetry: ['GET','PUT','HEAD','OPTIONS','DELETE','POST'],
-        shouldRetry: (error) => {
+        httpMethodsToRetry: ['GET', 'PUT', 'HEAD', 'OPTIONS', 'DELETE', 'POST'],
+        shouldRetry: error => {
           if (!error.response) return false;
           switch (error.response?.status) {
             case 400: // Bad request (probably wrong API key)
@@ -73,8 +73,8 @@ class TestomatioPipe {
               break;
           }
           return error.response?.status >= 401; // Retry on 401+ and 5xx
-        }
-      }
+        },
+      },
     });
 
     this.isEnabled = true;
@@ -104,7 +104,6 @@ class TestomatioPipe {
     // add test ID + run ID
     if (data.rid) data.rid = `${this.runId}-${data.rid}`;
 
-
     if (!process.env.TESTOMATIO_STACK_PASSED && data.status === STATUS.PASSED) {
       data.stack = null;
     }
@@ -120,7 +119,6 @@ class TestomatioPipe {
     return data;
   }
 
-
   /**
    * Asynchronously prepares and retrieves the Testomat.io test grepList based on the provided options.
    * @param {Object} opts - The options for preparing the test grepList.
@@ -215,7 +213,7 @@ class TestomatioPipe {
         method: 'PUT',
         url: `/api/reporter/${this.runId}`,
         data: runParams,
-        responseType: 'json'
+        responseType: 'json',
       });
       if (resp.data.artifacts) setS3Credentials(resp.data.artifacts);
       return;
@@ -228,7 +226,7 @@ class TestomatioPipe {
         url: '/api/reporter',
         data: runParams,
         maxContentLength: Infinity,
-        responseType: 'json'
+        responseType: 'json',
       });
 
       this.runId = resp.data.uid;
@@ -287,44 +285,44 @@ class TestomatioPipe {
 
     debug('Adding test', json);
 
-    return this.client.request({
-      method: 'POST',
-      url: `/api/reporter/${this.runId}/testrun`,
-      data: json,
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      maxContentLength: Infinity
-    }).catch(err => {
-      this.requestFailures++;
-      this.notReportedTestsCount++;
-      if (err.response) {
-        if (err.response.status >= 400) {
-          const responseData = err.response.data || { message: '' };
+    return this.client
+      .request({
+        method: 'POST',
+        url: `/api/reporter/${this.runId}/testrun`,
+        data: json,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        maxContentLength: Infinity,
+      })
+      .catch(err => {
+        this.requestFailures++;
+        this.notReportedTestsCount++;
+        if (err.response) {
+          if (err.response.status >= 400) {
+            const responseData = err.response.data || { message: '' };
+            console.log(
+              APP_PREFIX,
+              pc.yellow(`Warning: ${responseData.message} (${err.response.status})`),
+              pc.gray(data?.title || ''),
+            );
+            if (err.response?.data?.message?.includes('could not be matched')) {
+              this.hasUnmatchedTests = true;
+            }
+            return;
+          }
           console.log(
             APP_PREFIX,
-            pc.yellow(`Warning: ${responseData.message} (${err.response.status})`),
-            pc.gray(data?.title || ''),
+            pc.yellow(`Warning: ${data?.title || ''} (${err.response?.status})`),
+            `Report couldn't be processed: ${err?.response?.data?.message}`,
           );
-          if (err.response?.data?.message?.includes('could not be matched')) {
-            this.hasUnmatchedTests = true;
-          }
-          return;
+          printCreateIssue(err);
+        } else {
+          console.log(APP_PREFIX, pc.blue(data?.title || ''), "Report couldn't be processed", err);
         }
-        console.log(
-          APP_PREFIX,
-          pc.yellow(`Warning: ${data?.title || ''} (${err.response?.status})`),
-          `Report couldn't be processed: ${err?.response?.data?.message}`,
-        );
-        printCreateIssue(err);
-      } else {
-        console.log(APP_PREFIX, pc.blue(data?.title || ''), "Report couldn't be processed", err);
-      }
-    });
+      });
   };
 
-
-
   /**
    * Uploads tests as a batch (multiple tests at once). Intended to be used with a setInterval
    */
@@ -349,43 +347,42 @@ class TestomatioPipe {
     const testsToSend = this.batch.tests.splice(0);
     debug('📨 Batch upload', testsToSend.length, 'tests');
 
-    return this.client.request({
-      method: 'POST',
-      url: `/api/reporter/${this.runId}/testrun`,
-      data: {
-        api_key: this.apiKey,
-        tests: testsToSend,
-        batch_index: this.batch.batchIndex
-      },
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      maxContentLength: Infinity
-    }).catch(err => {
-      this.requestFailures++;
-      this.notReportedTestsCount += testsToSend.length;
-      if (err.response) {
-        if (err.response.status >= 400) {
-          const responseData = err.response.data || { message: '' };
+    return this.client
+      .request({
+        method: 'POST',
+        url: `/api/reporter/${this.runId}/testrun`,
+        data: {
+          api_key: this.apiKey,
+          tests: testsToSend,
+          batch_index: this.batch.batchIndex,
+        },
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        maxContentLength: Infinity,
+      })
+      .catch(err => {
+        this.requestFailures++;
+        this.notReportedTestsCount += testsToSend.length;
+        if (err.response) {
+          if (err.response.status >= 400) {
+            const responseData = err.response.data || { message: '' };
+            console.log(APP_PREFIX, pc.yellow(`Warning: ${responseData.message} (${err.response.status})`));
+            if (err.response?.data?.message?.includes('could not be matched')) {
+              this.hasUnmatchedTests = true;
+            }
+            return;
+          }
           console.log(
             APP_PREFIX,
-            pc.yellow(`Warning: ${responseData.message} (${err.response.status})`),
+            pc.yellow(`Warning: (${err.response?.status})`),
+            `Report couldn't be processed: ${err?.response?.data?.message}`,
           );
-          if (err.response?.data?.message?.includes('could not be matched')) {
-            this.hasUnmatchedTests = true;
-          }
-          return;
+          printCreateIssue(err);
+        } else {
+          console.log(APP_PREFIX, "Report couldn't be processed", err);
         }
-        console.log(
-          APP_PREFIX,
-          pc.yellow(`Warning: (${err.response?.status})`),
-          `Report couldn't be processed: ${err?.response?.data?.message}`,
-        );
-        printCreateIssue(err);
-      } else {
-        console.log(APP_PREFIX, "Report couldn't be processed", err);
-      }
-    });
+      });
   };
 
   /**
@@ -408,9 +405,9 @@ class TestomatioPipe {
     else this.batch.tests.push(data);
 
     // if test is added after run which is already finished
-     if (!this.batch.intervalFunction) uploading = this.#batchUpload();
+    if (!this.batch.intervalFunction) uploading = this.#batchUpload();
 
-     // return promise to be able to wait for it
+    // return promise to be able to wait for it
     return uploading;
   }
 
@@ -459,9 +456,11 @@ class TestomatioPipe {
             status_event,
             detach: params.detach,
             tests: params.tests,
-          }
+          },
         });
 
+        debug(APP_PREFIX, '✅ Testrun finished');
+
         if (this.runUrl) {
           console.log(APP_PREFIX, '📊 Report Saved. Report URL:', pc.magenta(this.runUrl));
         }
@@ -525,9 +524,6 @@ function printCreateIssue(err) {
     console.log({ body: body?.replace(/"(tstmt_[^"]+)"/g, 'tstmt_*'), url, baseURL, method, time });
     console.log('```');
   });
-
 }
 
-
-
 export default TestomatioPipe;

package/src/uploader.js

@@ -194,6 +194,11 @@ export class S3Uploader {
       filePath = path.join(process.cwd(), filePath);
     }
 
+    // Normalize path separators for cross-platform compatibility
+    if (typeof filePath === 'string') {
+      filePath = filePath.replace(/\\/g, '/');
+    }
+
     const data = { rid, file: filePath, uploaded };
     const jsonLine = `${JSON.stringify(data)}\n`;
     fs.appendFileSync(tempFilePath, jsonLine);