@testomatio/reporter 2.3.9-beta-bin-fix → 2.3.9

package/lib/reporter.d.ts

@@ -1,3 +1,10 @@
+export { Client };
+export const STATUS: {
+    PASSED: string;
+    FAILED: string;
+    SKIPPED: string;
+    FINISHED: string;
+};
 export const artifact: (data: string | {
     path: string;
     type: string;
@@ -80,7 +87,7 @@ export const label: (key: string, value?: string | null) => void;
 export const linkTest: (...testIds: string[]) => void;
 export const linkJira: (...jiraIds: string[]) => void;
 declare namespace _default {
-    let testomatioLogger: {
+    export let testomatioLogger: {
         "__#13@#originalUserLogger": {
             assert(condition?: boolean, ...data: any[]): void;
             assert(value: any, message?: string, ...optionalParams: any[]): void;
@@ -148,13 +155,13 @@ declare namespace _default {
         }): void;
         prettyObjects: boolean;
     };
-    let artifact: (data: string | {
+    export let artifact: (data: string | {
         path: string;
         type: string;
         name: string;
     }, context?: any) => void;
-    let log: (...args: any[]) => void;
-    let logger: {
+    export let log: (...args: any[]) => void;
+    export let logger: {
         "__#13@#originalUserLogger": {
             assert(condition?: boolean, ...data: any[]): void;
             assert(value: any, message?: string, ...optionalParams: any[]): void;
@@ -222,13 +229,15 @@ declare namespace _default {
         }): void;
         prettyObjects: boolean;
     };
-    let meta: (keyValue: {
+    export let meta: (keyValue: {
         [key: string]: string;
     } | string, value?: string | null) => void;
-    let step: (message: string) => void;
-    let label: (key: string, value?: string | null) => void;
-    let linkTest: (...testIds: string[]) => void;
-    let linkJira: (...jiraIds: string[]) => void;
+    export let step: (message: string) => void;
+    export let label: (key: string, value?: string | null) => void;
+    export let linkTest: (...testIds: string[]) => void;
+    export let linkJira: (...jiraIds: string[]) => void;
+    export { Client as TestomatioClient };
+    export { STATUS };
 }
 export default _default;
 export type ArtifactFunction = typeof import("./reporter-functions.js").default.artifact;
@@ -237,3 +246,4 @@ export type LoggerService = typeof import("./services/index.js").services.logger
 export type MetaFunction = typeof import("./reporter-functions.js").default.keyValue;
 export type StepFunction = typeof import("./reporter-functions.js").default.step;
 export type LabelFunction = typeof import("./reporter-functions.js").default.label;
+import Client from './client.js';

package/lib/reporter.js

@@ -1,13 +1,48 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.linkJira = exports.linkTest = exports.label = exports.step = exports.meta = exports.logger = exports.log = exports.artifact = void 0;
-// import TestomatClient from './client.js';
-// import * as TRConstants from './constants.js';
+exports.linkJira = exports.linkTest = exports.label = exports.step = exports.meta = exports.logger = exports.log = exports.artifact = exports.STATUS = exports.Client = void 0;
+const client_js_1 = __importDefault(require("./client.js"));
+exports.Client = client_js_1.default;
+const TestomatioConstants = __importStar(require("./constants.js"));
 const index_js_1 = require("./services/index.js");
 const reporter_functions_js_1 = __importDefault(require("./reporter-functions.js"));
+exports.STATUS = TestomatioConstants.STATUS;
 exports.artifact = reporter_functions_js_1.default.artifact;
 exports.log = reporter_functions_js_1.default.log;
 exports.logger = index_js_1.services.logger;
@@ -37,6 +72,6 @@ module.exports = {
     label: reporter_functions_js_1.default.label,
     linkTest: reporter_functions_js_1.default.linkTest,
     linkJira: reporter_functions_js_1.default.linkJira,
-    // TestomatClient,
-    // TRConstants,
+    TestomatioClient: client_js_1.default,
+    STATUS: exports.STATUS,
 };

package/lib/uploader.js

@@ -170,6 +170,10 @@ class S3Uploader {
         if (typeof filePath === 'string' && !path_1.default.isAbsolute(filePath)) {
             filePath = path_1.default.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_1.default.appendFileSync(tempFilePath, jsonLine);

package/lib/utils/log-formatter.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Returns the formatted stack including the stack trace, steps, and logs.
+ * @param {Object} params - Parameters for formatting logs
+ * @param {string} params.error - Error message
+ * @param {Array|any} params.steps - Test steps (array or other types)
+ * @param {string} params.logs - Test logs
+ * @returns {string}
+ */
+export function formatLogs({ error, steps, logs }: {
+    error: string;
+    steps: any[] | any;
+    logs: string;
+}): string;
+/**
+ * Formats an error with stack trace and diff information
+ * @param {Error & {inspect?: () => string, operator?: string, diff?: string, actual?: any, expected?: any}} error
+ *   The error object to format
+ * @param {string} [message] - Optional error message override
+ * @returns {string}
+ */
+export function formatError(error: Error & {
+    inspect?: () => string;
+    operator?: string;
+    diff?: string;
+    actual?: any;
+    expected?: any;
+}, message?: string): string;
+export function stripColors(str: string): string;

package/lib/utils/log-formatter.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripColors = void 0;
+exports.formatLogs = formatLogs;
+exports.formatError = formatError;
+const callsite_record_1 = __importDefault(require("callsite-record"));
+const minimatch_1 = require("minimatch");
+const picocolors_1 = __importDefault(require("picocolors"));
+const util_1 = require("util");
+const path_1 = require("path");
+const utils_js_1 = require("./utils.js");
+const stripColors = util_1.stripVTControlCharacters || (str => str?.replace(/\x1b\[[0-9;]*m/g, '') || '');
+exports.stripColors = stripColors;
+/**
+ * Returns the formatted stack including the stack trace, steps, and logs.
+ * @param {Object} params - Parameters for formatting logs
+ * @param {string} params.error - Error message
+ * @param {Array|any} params.steps - Test steps (array or other types)
+ * @param {string} params.logs - Test logs
+ * @returns {string}
+ */
+function formatLogs({ error, steps, logs }) {
+    error = error?.trim();
+    logs = logs
+        ?.trim()
+        .split('\n')
+        .map(l => (0, utils_js_1.truncate)(l))
+        .join('\n');
+    if (Array.isArray(steps)) {
+        steps = steps
+            .map(step => (0, utils_js_1.formatStep)(step))
+            .flat()
+            .join('\n');
+    }
+    else {
+        steps = null;
+    }
+    let testLogs = '';
+    if (steps)
+        testLogs += `${picocolors_1.default.bold(picocolors_1.default.blue('################[ Steps ]################'))}\n${steps}\n\n`;
+    if (logs)
+        testLogs += `${picocolors_1.default.bold(picocolors_1.default.gray('################[ Logs ]################'))}\n${logs}\n\n`;
+    if (error)
+        testLogs += `${picocolors_1.default.bold(picocolors_1.default.red('################[ Failure ]################'))}\n${error}`;
+    return testLogs;
+}
+/**
+ * Formats an error with stack trace and diff information
+ * @param {Error & {inspect?: () => string, operator?: string, diff?: string, actual?: any, expected?: any}} error
+ *   The error object to format
+ * @param {string} [message] - Optional error message override
+ * @returns {string}
+ */
+function formatError(error, message) {
+    if (!message)
+        message = error.message;
+    // @ts-ignore - inspect is a custom property added by some testing frameworks
+    if (error.inspect)
+        message = error.inspect() || '';
+    let stack = '';
+    if (error.name)
+        stack += `${picocolors_1.default.red(error.name)}`;
+    // @ts-ignore - operator is a custom property added by assertion libraries
+    if (error.operator)
+        stack += ` (${picocolors_1.default.red(error.operator)})`;
+    // add new line if something was added to stack
+    if (stack)
+        stack += ': ';
+    stack += `${message}\n`;
+    // @ts-ignore - diff is a custom property added by vitest
+    if (error.diff) {
+        // diff for vitest
+        stack += error.diff;
+        stack += '\n\n';
+    }
+    else if (error.actual && error.expected && error.actual !== error.expected) {
+        // diffs for mocha, cypress, codeceptjs style
+        stack += `\n\n${picocolors_1.default.bold(picocolors_1.default.green('+ expected'))} ${picocolors_1.default.bold(picocolors_1.default.red('- actual'))}`;
+        stack += `\n${picocolors_1.default.green(`+ ${error.expected.toString().split('\n').join('\n+ ')}`)}`;
+        stack += `\n${picocolors_1.default.red(`- ${error.actual.toString().split('\n').join('\n- ')}`)}`;
+        stack += '\n\n';
+    }
+    const customFilter = process.env.TESTOMATIO_STACK_IGNORE;
+    try {
+        let hasFrame = false;
+        const record = (0, callsite_record_1.default)({
+            forError: error,
+            isCallsiteFrame: frame => {
+                if (customFilter && (0, minimatch_1.minimatch)(frame.fileName, customFilter))
+                    return false;
+                if (hasFrame)
+                    return false;
+                if (isNotInternalFrame(frame))
+                    hasFrame = true;
+                return hasFrame;
+            },
+        });
+        // @ts-ignore
+        if (record && !record.filename.startsWith('http')) {
+            stack += record.renderSync({ stackFilter: isNotInternalFrame });
+        }
+        return stack;
+    }
+    catch (e) {
+        console.log(e);
+    }
+}
+/**
+ * Checks if a stack frame is not an internal frame (node_modules or internal)
+ * @param {Object} frame - Stack frame object
+ * @returns {boolean}
+ */
+function isNotInternalFrame(frame) {
+    return (frame.getFileName() &&
+        frame.getFileName().includes(path_1.sep) &&
+        !frame.getFileName().includes('node_modules') &&
+        !frame.getFileName().includes('internal'));
+}
+
+module.exports.formatLogs = formatLogs;
+
+module.exports.formatError = formatError;
+
+module.exports.stripColors = stripColors;

package/lib/utils/utils.js

@@ -116,19 +116,26 @@ const isValidUrl = s => {
     }
 };
 exports.isValidUrl = isValidUrl;
-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 => {
-        // Convert Windows paths to Linux paths for testing purposes
-        if (f.match(/^[A-Za-z]:[\\\/]/)) {
-            // Convert Windows path to Linux equivalent for test scenarios
-            return f.replace(/^[A-Za-z]:[\\\/]/, '/').replace(/\\/g, '/');
-        }
-        return 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 => {
         if (!checkExists)
@@ -144,19 +151,88 @@ 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 => (0, is_valid_path_1.default)(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_1.default.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_1.default.existsSync(filePath);
+    })
         // // filter out 3rd party libs
         .filter(l => !l?.includes(`vendor${path_1.sep}`))
         .filter(l => !l?.includes(`node_modules${path_1.sep}`))
-        .filter(l => fs_1.default.existsSync(l.split(':')[0]))
-        .filter(l => fs_1.default.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_1.default.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_1.default.readFileSync(file).toString(), { line, prepend, limit: 7 });
     if (!source)
@@ -174,6 +250,8 @@ exports.fetchSourceCodeFromStackTrace = fetchSourceCodeFromStackTrace;
 exports.TEST_ID_REGEX = /@T([\w\d]{8})/;
 exports.SUITE_ID_REGEX = /@S([\w\d]{8})/;
 const fetchIdFromCode = (code, opts = {}) => {
+    if (!code)
+        return null;
     const comments = code
         .split('\n')
         .map(l => l.trim())
@@ -216,10 +294,58 @@ const fetchSourceCode = (contents, opts = {}) => {
                 lineIndex = lines.findIndex(l => l.includes(`${title}(`));
         }
         else if (opts.lang === 'csharp') {
-            if (lineIndex === -1)
-                lineIndex = lines.findIndex(l => l.includes(`public void ${title}`));
-            if (lineIndex === -1)
-                lineIndex = lines.findIndex(l => l.includes(`${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 (methodLineIndex === -1) {
+                methodLineIndex = lines.findIndex(l => l.includes(`${title}(`));
+            }
+            // 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;
+                    }
+                }
+            }
         }
         else {
             lineIndex = lines.findIndex(l => l.includes(title));
@@ -228,11 +354,28 @@ const fetchSourceCode = (contents, opts = {}) => {
     if (opts.prepend) {
         lineIndex -= opts.prepend;
     }
-    if (lineIndex) {
+    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('#['))
@@ -271,6 +414,24 @@ const fetchSourceCode = (contents, opts = {}) => {
                     break;
                 if (opts.lang === 'java' && lines[i].includes(' class '))
                     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;
+                }
             }
             result.push(lines[i]);
         }
@@ -471,10 +632,14 @@ function transformEnvVarToBoolean(value) {
     return Boolean(value);
 }
 function truncate(s, size = 255) {
-    if (s.toString().trim().length < size) {
-        return s.toString();
+    if (s === undefined || s === null) {
+        return '';
+    }
+    const str = s.toString();
+    if (str.trim().length < size) {
+        return str;
     }
-    return `${s.toString().substring(0, size)}...`;
+    return `${str.substring(0, size)}...`;
 }
 
 module.exports.getPackageVersion = getPackageVersion;

package/lib/xmlReader.d.ts

@@ -19,25 +19,11 @@ declare class XmlReader {
     tests: any[];
     stats: {};
     uploader: S3Uploader;
+    enhancedNunit: boolean;
+    groupParameterized: boolean;
     version: any;
     connectAdapter(): import("./junit-adapter/adapter.js").default;
-    parse(fileName: any): {
-        status: string;
-        create_tests: boolean;
-        tests_count: number;
-        passed_count: number;
-        skipped_count: number;
-        failed_count: number;
-        tests: any;
-    } | {
-        status: any;
-        create_tests: boolean;
-        tests_count: number;
-        passed_count: number;
-        failed_count: number;
-        skipped_count: number;
-        tests: any[];
-    };
+    parse(fileName: any): any;
     processJUnit(jsonSuite: any): {
         create_tests: boolean;
         duration: number;
@@ -49,15 +35,14 @@ declare class XmlReader {
         tests: any[];
         tests_count: number;
     };
-    processNUnit(jsonSuite: any): {
-        status: any;
-        create_tests: boolean;
-        tests_count: number;
-        passed_count: number;
-        failed_count: number;
-        skipped_count: number;
-        tests: any[];
-    };
+    processNUnit(jsonSuite: any): any;
+    /**
+     * Check if the XML is actually NUnit format (has test-suite hierarchy)
+     * @param {Object} jsonSuite - Parsed XML suite object
+     * @returns {boolean} - True if this is NUnit XML format
+     */
+    isNUnitXml(jsonSuite: any): boolean;
+    processNUnitEnhanced(jsonSuite: any): any;
     processTRX(jsonSuite: any): {
         status: string;
         create_tests: boolean;
@@ -67,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;