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

package/lib/utils/utils.d.ts

@@ -2,6 +2,7 @@ export function getPackageVersion(): any;
 export const TEST_ID_REGEX: RegExp;
 export const SUITE_ID_REGEX: RegExp;
 export function ansiRegExp(): RegExp;
+export function truncate(s: any, size?: number): any;
 export function cleanLatestRunId(): any;
 export function isSameTest(test: any, t: any): boolean;
 export function fetchSourceCode(contents: any, opts?: {}): string;

package/lib/utils/utils.js

@@ -38,6 +38,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateSuiteId = exports.testRunnerHelper = exports.specificTestInfo = exports.parseSuite = exports.isValidUrl = exports.humanize = exports.getTestomatIdFromTestTitle = exports.getCurrentDateTime = exports.foundedTestLog = exports.fileSystem = exports.fetchFilesFromStackTrace = exports.fetchIdFromOutput = exports.fetchIdFromCode = exports.fetchSourceCodeFromStackTrace = exports.fetchSourceCode = exports.isSameTest = exports.ansiRegExp = exports.SUITE_ID_REGEX = exports.TEST_ID_REGEX = void 0;
 exports.getPackageVersion = getPackageVersion;
+exports.truncate = truncate;
 exports.cleanLatestRunId = cleanLatestRunId;
 exports.formatStep = formatStep;
 exports.readLatestRunId = readLatestRunId;
@@ -213,27 +214,56 @@ const fetchSourceCode = (contents, opts = {}) => {
                 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}(`));
-            if (lineIndex === -1) {
-                lineIndex = lines.findIndex(l => l.includes(`public async Task ${title}(`));
+            // Find the method declaration line
+            let methodLineIndex = lines.findIndex(l => l.includes(`public void ${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;
                 }
             }
         }
@@ -246,9 +276,26 @@ 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) {
+                    result.push(lines[i]);
+                    break;
+                }
+            }
             if (i > lineIndex + 2 && !opts.prepend) {
                 // annotation
                 if (opts.lang === 'php' && lines[i].trim().startsWith('#['))
@@ -287,14 +334,22 @@ 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;
+                // 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
+                    if (trimmed.match(/^\[(Test|TestCase|Theory|Fact)/))
+                        break;
+                    // Stop at XML documentation comments that belong to next method
+                    if (trimmed.startsWith('///'))
+                        break;
+                    // Stop at another method declaration
+                    if (trimmed.match(/^\s*(public|private|protected|internal)\s+(\w+|async\s+\w+)\s+\w+\s*\(/))
+                        break;
+                    // Stop at class declaration
+                    if (trimmed.includes(' class ') && trimmed.includes('public'))
+                        break;
+                }
             }
             result.push(lines[i]);
         }
@@ -494,9 +549,17 @@ function transformEnvVarToBoolean(value) {
     // if not recognized, return truthy if any value is set
     return Boolean(value);
 }
+function truncate(s, size = 255) {
+    if (s.toString().trim().length < size) {
+        return s.toString();
+    }
+    return `${s.toString().substring(0, size)}...`;
+}
 
 module.exports.getPackageVersion = getPackageVersion;
 
+module.exports.truncate = truncate;
+
 module.exports.cleanLatestRunId = cleanLatestRunId;
 
 module.exports.formatStep = formatStep;

package/lib/xmlReader.d.ts

@@ -52,6 +52,27 @@ declare class XmlReader {
         failed_count: number;
         tests: any;
     };
+    _parseTRXTestDefinition(td: any): {
+        title: any;
+        example: any;
+        file: string;
+        description: any;
+        suite_title: any;
+        id: any;
+    };
+    _parseTRXTestResult(td: any, tests: any): {
+        suite_title: any;
+        title: any;
+        file: any;
+        description: any;
+        code: any;
+        run_time: number;
+        stack: any;
+        files: any;
+        create: boolean;
+        overwrite: boolean;
+    };
+    _mapTRXStatus(outcome: any): string;
     processXUnit(assemblies: any): {
         status: string;
         create_tests: boolean;

package/lib/xmlReader.js

@@ -195,61 +195,17 @@ 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 = constants_js_1.STATUS.PASSED;
-            if (r.status === 'Failed')
-                r.status = constants_js_1.STATUS.FAILED;
-            if (r.status === 'Skipped')
-                r.status = constants_js_1.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 = constants_js_1.STATUS.PASSED.toString();
-        if (failed_count > 0)
-            status = constants_js_1.STATUS.FAILED;
+        const status = failed_count > 0 ? constants_js_1.STATUS.FAILED : constants_js_1.STATUS.PASSED.toString();
         this.tests = results.filter(t => !!t.title);
         return {
             status,
@@ -261,6 +217,57 @@ class XmlReader {
             tests: results,
         };
     }
+    _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 constants_js_1.STATUS.PASSED;
+            case 'Failed':
+                return constants_js_1.STATUS.FAILED;
+            case 'Skipped':
+                return constants_js_1.STATUS.SKIPPED;
+            default:
+                return constants_js_1.STATUS.PASSED;
+        }
+    }
     processXUnit(assemblies) {
         const tests = [];
         assemblies = Array.isArray(assemblies.assembly) ? assemblies.assembly : [assemblies.assembly];

package/package.json

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

package/src/adapter/codecept.js

@@ -2,7 +2,7 @@ import createDebugMessages from 'debug';
 import pc from 'picocolors';
 import TestomatClient from '../client.js';
 import { STATUS, APP_PREFIX, TESTOMAT_TMP_STORAGE_DIR } from '../constants.js';
-import { getTestomatIdFromTestTitle, fileSystem } from '../utils/utils.js';
+import { getTestomatIdFromTestTitle, truncate, fileSystem } from '../utils/utils.js';
 import { services } from '../services/index.js';
 import { dataStorage } from '../data-storage.js';
 import codeceptjs from 'codeceptjs';
@@ -127,6 +127,28 @@ function CodeceptReporter(config) {
   });
 
 
+  // mark as failed all tests inside the failed hook
+  event.dispatcher.on(event.hook.failed, hook => {
+    if (hook.name !== 'BeforeSuiteHook') return;
+    const suite = hook.runnable.parent;
+
+    if (!suite) return;
+
+    const error = hook?.ctx?.currentTest?.err;
+
+    for (const test of suite.tests) {
+      client.addTestRun('failed', {
+        ...stripExampleFromTitle(test.title),
+        rid: test.uid,
+        test_id: getTestomatIdFromTestTitle(test.title),
+        suite_title: stripTagsFromTitle(suite.title),
+        error,
+        time: hook?.runnable?.duration,
+      });
+    }
+  });
+
+
   event.dispatcher.on(event.suite.before, suite => {
     dataStorage.setContext(suite.fullTitle());
   });
@@ -441,7 +463,7 @@ function formatCodeceptStep(step) {
   if (!step) return null;
 
   const category = step.constructor.name === 'HelperStep' ? 'framework' : 'user';
-  const title = step.toString(); // Use built-in toString
+  const title = truncate(step); // Use built-in toString
   const duration = step.duration || 0; // Use built-in duration
 
   const formattedStep = {
@@ -469,10 +491,11 @@ function formatHookStep(step) {
   if (step.actor && step.name) {
     title = `${step.actor} ${step.name}`;
     if (step.args && step.args.length > 0) {
-      const argsStr = step.args.map(arg => JSON.stringify(arg)).join(', ');
+      const argsStr = step.args.map(arg => truncate(JSON.stringify(arg))).join(', ');
       title += ` ${argsStr}`;
     }
   }
+  title = truncate(title);
 
   return {
     category: 'hook',
@@ -481,5 +504,6 @@ function formatHookStep(step) {
   };
 }
 
+
 export { CodeceptReporter };
 export default CodeceptReporter;

package/src/bin/cli.js

@@ -158,7 +158,7 @@ program
   .option('--lang <lang>', 'Language used (python, ruby, java)')
   .option('--timelimit <time>', 'default time limit in seconds to kill a stuck process')
   .action(async (pattern, opts) => {
-    if (!pattern.endsWith('.xml')) {
+    if (!pattern.endsWith('.xml') && !pattern.includes('*')) {
       pattern += '.xml';
     }
     let { javaTests, lang } = opts;

package/src/bin/reportXml.js

@@ -23,7 +23,7 @@ program
   .option('--timelimit <time>', 'default time limit in seconds to kill a stuck process')
   .option('--env-file <envfile>', 'Load environment variables from env file')
   .action(async (pattern, opts) => {
-    if (!pattern.endsWith('.xml')) {
+    if (!pattern.endsWith('.xml') && !pattern.includes('*')) {
       pattern += '.xml';
     }
     let { javaTests, lang } = opts;

package/src/bin/startTest.js

@@ -18,7 +18,7 @@ const newArgs = ['run'];
 let i = 0;
 while (i < args.length) {
   const arg = args[i];
-  
+
   if (arg === '-c' || arg === '--command') {
     // Map -c/--command to positional argument for run command
     i++;
@@ -33,7 +33,7 @@ while (i < args.length) {
     // Map --launch to start command
     newArgs[0] = 'start';
   } else if (arg === '--finish') {
-    // Map --finish to finish command  
+    // Map --finish to finish command
     newArgs[0] = 'finish';
   } else {
     // Pass through other arguments
@@ -45,9 +45,9 @@ while (i < args.length) {
 // Execute the main CLI with mapped arguments
 
 const child = spawn(process.execPath, [cliPath, ...newArgs], {
-  stdio: 'inherit'
+  stdio: 'inherit',
 });
 
-child.on('exit', (code) => {
+child.on('exit', code => {
   process.exit(code);
-});
+});

package/src/client.js

@@ -10,7 +10,7 @@ import { glob } from 'glob';
 import path, { sep } from 'path';
 import { fileURLToPath } from 'node:url';
 import { S3Uploader } from './uploader.js';
-import { formatStep, readLatestRunId, storeRunId, validateSuiteId } from './utils/utils.js';
+import { formatStep, truncate, readLatestRunId, storeRunId, validateSuiteId } from './utils/utils.js';
 import { filesize as prettyBytes } from 'filesize';
 
 const debug = createDebugMessages('@testomatio/reporter:client');
@@ -37,9 +37,8 @@ class Client {
     this.runId = '';
     this.queue = Promise.resolve();
 
-    // @ts-ignore this line will be removed in compiled code, because __dirname is defined in commonjs
-    const __dirname = path.dirname(fileURLToPath(import.meta.url));
-    const pathToPackageJSON = path.join(__dirname, '../package.json');
+    // Get package.json path - use a simple approach that works in both environments
+    const pathToPackageJSON = path.join(process.cwd(), 'package.json');
     try {
       this.version = JSON.parse(fs.readFileSync(pathToPackageJSON).toString()).version;
       console.log(APP_PREFIX, `Testomatio Reporter v${this.version}`);
@@ -387,7 +386,11 @@ class Client {
    */
   formatLogs({ error, steps, logs }) {
     error = error?.trim();
-    logs = logs?.trim();
+    logs = logs
+      ?.trim()
+      .split('\n')
+      .map(l => truncate(l))
+      .join('\n');
 
     if (Array.isArray(steps)) {
       steps = steps

package/src/junit-adapter/csharp.js

@@ -3,18 +3,23 @@ import Adapter from './adapter.js';
 
 class CSharpAdapter extends Adapter {
   formatTest(t) {
-    // Don't override example if it already exists from NUnit XML processing
-    // The xmlReader.js already extracts parameters correctly from <arguments>
+    // Extract example from title if not already present
     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());
+        // Extract parameters as object with numeric keys for API
+        const params = exampleMatch[1].split(',').map(param => param.trim());
+        t.example = {};
+        params.forEach((param, index) => {
+          t.example[index] = param;
+        });
       }
-      t.title = title.trim();
     }
 
+    // For runs: keep full title with parameters for display
+    // The example field will be used for grouping on import
+    // Do NOT remove parameters from title
+
     const suite = t.suite_title.split('.');
     t.suite_title = suite.pop();
     t.file = namespaceToFileName(t.file);

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

@@ -220,8 +220,20 @@ export class NUnitXmlParser {
     // 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,
@@ -235,8 +247,9 @@ export class NUnitXmlParser {
       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/testomatio.js

@@ -459,8 +459,6 @@ class TestomatioPipe {
           },
         });
 
-        debug(APP_PREFIX, '✅ Testrun finished');
-
         if (this.runUrl) {
           console.log(APP_PREFIX, '📊 Report Saved. Report URL:', pc.magenta(this.runUrl));
         }
@@ -471,7 +469,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) {