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

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

@@ -1,5 +1,6 @@
 import createDebugMessages from 'debug';
 import { STATUS } from '../constants.js';
+import { fetchFilesFromStackTrace } from '../utils/utils.js';
 
 const debug = createDebugMessages('@testomatio/reporter:nunit-parser');
 
@@ -85,7 +86,8 @@ export class NUnitXmlParser {
       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];
+        // Avoid adding duplicate suite names to the path
+        const newPath = parentPath[parentPath.length - 1] === suiteName ? [...parentPath] : [...parentPath, suiteName];
         this.processChildren(testSuite, newPath);
         break;
 
@@ -96,6 +98,13 @@ export class NUnitXmlParser {
         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];
@@ -110,15 +119,15 @@ export class NUnitXmlParser {
    * @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);
     }
-
-    // Process test-cases
-    if (testSuite['test-case']) {
-      this.parseTestCases(testSuite['test-case'], currentPath, testSuite);
-    }
   }
 
   /**
@@ -156,12 +165,26 @@ export class NUnitXmlParser {
       return null;
     }
 
-    const testName = testCase.name;
+    // 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);
@@ -192,17 +215,31 @@ export class NUnitXmlParser {
     let message = '';
     let stack = '';
 
+    const files = [];
+
     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();
+    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 from properties
+    // 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
@@ -215,28 +252,62 @@ export class NUnitXmlParser {
         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 {
-      title: isParameterized ? testName : methodName || testName,
+      // 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,
+      parameters: parameters, // Keep original array for reference
       baseMethodName: baseMethodName,
     };
   }

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 ? false : true),
+        isEnabled: this.params.isBatchEnabled ?? !process.env.TESTOMATIO_DISABLE_BATCH_UPLOAD ?? true,
         intervalFunction: null,
         intervalTime: 5000,
         tests: [],
@@ -93,7 +93,8 @@ 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 ? false : true),
+      isEnabled: params?.isBatchEnabled ?? !process.env.TESTOMATIO_DISABLE_BATCH_UPLOAD ?? 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,6 +104,7 @@ 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;
     }
@@ -119,6 +120,7 @@ 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.
@@ -213,7 +215,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;
@@ -226,7 +228,7 @@ class TestomatioPipe {
         url: '/api/reporter',
         data: runParams,
         maxContentLength: Infinity,
-        responseType: 'json',
+        responseType: 'json'
       });
 
       this.runId = resp.data.uid;
@@ -285,44 +287,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: '' };
-            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;
-          }
+    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: ${data?.title || ''} (${err.response?.status})`),
-            `Report couldn't be processed: ${err?.response?.data?.message}`,
+            pc.yellow(`Warning: ${responseData.message} (${err.response.status})`),
+            pc.gray(data?.title || ''),
           );
-          printCreateIssue(err);
-        } else {
-          console.log(APP_PREFIX, pc.blue(data?.title || ''), "Report couldn't be processed", err);
+          if (err.response?.data?.message?.includes('could not be matched')) {
+            this.hasUnmatchedTests = true;
+          }
+          return;
         }
-      });
+        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
    */
@@ -347,42 +349,43 @@ 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: '' };
-            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;
-          }
+    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: (${err.response?.status})`),
-            `Report couldn't be processed: ${err?.response?.data?.message}`,
+            pc.yellow(`Warning: ${responseData.message} (${err.response.status})`),
           );
-          printCreateIssue(err);
-        } else {
-          console.log(APP_PREFIX, "Report couldn't be processed", err);
+          if (err.response?.data?.message?.includes('could not be matched')) {
+            this.hasUnmatchedTests = true;
+          }
+          return;
         }
-      });
+        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);
+      }
+    });
   };
 
   /**
@@ -405,9 +408,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;
   }
 
@@ -456,11 +459,9 @@ 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));
         }
@@ -471,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) {
@@ -524,6 +525,9 @@ function printCreateIssue(err) {
     console.log({ body: body?.replace(/"(tstmt_[^"]+)"/g, 'tstmt_*'), url, baseURL, method, time });
     console.log('```');
   });
+
 }
 
+
+
 export default TestomatioPipe;

package/src/reporter.js

@@ -1,8 +1,10 @@
-// import TestomatClient from './client.js';
-// import * as TRConstants from './constants.js';
+import Client from './client.js';
+import * as TestomatioConstants   from './constants.js';
 import { services } from './services/index.js';
 import reporterFunctions from './reporter-functions.js';
 
+export { Client };
+export const STATUS = TestomatioConstants.STATUS;
 export const artifact = reporterFunctions.artifact;
 export const log = reporterFunctions.log;
 export const logger = services.logger;
@@ -35,6 +37,7 @@ export default {
   linkTest: reporterFunctions.linkTest,
   linkJira: reporterFunctions.linkJira,
 
-  // TestomatClient,
-  // TRConstants,
+  TestomatioClient: Client,
+  STATUS,
+
 };