@testomatio/reporter 2.3.1-beta.1-dependency → 2.3.2-beta.3-xml-import

package/lib/xmlReader.js

@@ -131,7 +131,18 @@ class XmlReader {
         const { result, total, passed, failed, inconclusive, skipped } = jsonSuite;
         reduceOptions.preferClassname = this.stats.language === 'python';
         const resultTests = processTestSuite(jsonSuite['test-suite']);
-        this.tests = this.tests.concat(resultTests);
+        debug('Raw tests extracted from NUnit XML:', resultTests.length);
+        debug('Raw tests:', resultTests.map(t => ({ title: t.title, example: t.example, file: t.file })));
+        // Deduplicate tests based on FQN (Assembly + Namespace + Class + Method)
+        const deduplicatedTests = this.deduplicateTestsByFQN(resultTests);
+        debug('Tests after deduplication:', deduplicatedTests.length);
+        debug('Deduplicated tests:', deduplicatedTests.map(t => ({
+            title: t.title,
+            examples: t.examples,
+            example: t.example,
+            file: t.file,
+        })));
+        this.tests = this.tests.concat(deduplicatedTests);
         return {
             status: result?.toLowerCase(),
             create_tests: true,
@@ -139,7 +150,7 @@ class XmlReader {
             passed_count: parseInt(passed, 10),
             failed_count: parseInt(failed, 10),
             skipped_count: parseInt(inconclusive + skipped, 10),
-            tests: resultTests,
+            tests: deduplicatedTests,
         };
     }
     processTRX(jsonSuite) {
@@ -275,6 +286,171 @@ class XmlReader {
             tests,
         };
     }
+    deduplicateTestsByFQN(tests) {
+        const fqnMap = new Map();
+        tests.forEach(test => {
+            const fqn = this.generateNormalizedFQN(test);
+            if (fqnMap.has(fqn)) {
+                const existingTest = fqnMap.get(fqn);
+                // For parameterized tests, merge as Examples
+                if (test.example && Array.isArray(test.example) && test.example.length > 0) {
+                    // Initialize examples array if it doesn't exist
+                    if (!existingTest.examples) {
+                        existingTest.examples = [];
+                        // Add the existing test's example as the first item if it has parameters
+                        if (existingTest.example && Array.isArray(existingTest.example) && existingTest.example.length > 0) {
+                            existingTest.examples.push({
+                                parameters: existingTest.example,
+                                status: existingTest.status,
+                                run_time: existingTest.run_time,
+                                message: existingTest.message,
+                                stack: existingTest.stack,
+                            });
+                            // Clear the main test's example since it's now in examples array
+                            delete existingTest.example;
+                        }
+                    }
+                    // Add this test's execution as an example
+                    existingTest.examples.push({
+                        parameters: test.example,
+                        status: test.status,
+                        run_time: test.run_time,
+                        message: test.message,
+                        stack: test.stack,
+                    });
+                    // Update the main test status to reflect the worst status
+                    if (test.status === 'failed' || existingTest.status === 'failed') {
+                        existingTest.status = 'failed';
+                    }
+                    else if (test.status === 'skipped' && existingTest.status !== 'failed') {
+                        existingTest.status = 'skipped';
+                    }
+                    // Update total run time
+                    existingTest.run_time = (existingTest.run_time || 0) + (test.run_time || 0);
+                }
+                else {
+                    // Merge test properties for non-parameterized tests, prioritizing Test Explorer structure
+                    if (test.test_id && !existingTest.test_id) {
+                        existingTest.test_id = test.test_id;
+                    }
+                    // Keep the most complete test data
+                    if (test.stack && !existingTest.stack) {
+                        existingTest.stack = test.stack;
+                    }
+                    if (test.message && !existingTest.message) {
+                        existingTest.message = test.message;
+                    }
+                }
+                // Prefer Test Explorer structure (longer, more complete suite_title)
+                if (test.suite_title && test.suite_title.length > existingTest.suite_title.length) {
+                    existingTest.suite_title = test.suite_title;
+                }
+                // Always use the source file path if available
+                if (test.file && test.file.endsWith('.cs')) {
+                    existingTest.file = test.file;
+                }
+                else if (!existingTest.file || !existingTest.file.endsWith('.cs')) {
+                    existingTest.file = this.extractCsFileFromPath(test);
+                }
+            }
+            else {
+                // Fix file path to use proper .cs file names from source paths
+                if (!test.file || !test.file.endsWith('.cs')) {
+                    test.file = this.extractCsFileFromPath(test);
+                }
+                fqnMap.set(fqn, test);
+            }
+        });
+        return Array.from(fqnMap.values());
+    }
+    generateFQN(test) {
+        // Generate Fully Qualified Name: Namespace + Class + Method (standard .NET FQN)
+        // Don't include assembly as it can vary between different test structures
+        const namespace = this.extractNamespace(test);
+        const className = this.extractClassName(test);
+        const methodName = test.title;
+        // Use the most complete namespace.class structure available
+        if (test.suite_title && test.suite_title.includes('.')) {
+            return `${test.suite_title}.${methodName}`;
+        }
+        return `${namespace}.${className}.${methodName}`;
+    }
+    generateNormalizedFQN(test) {
+        // Generate normalized FQN for deduplication by extracting the core namespace.class.method
+        // For parameterized tests, we want the SAME FQN so they merge into one test with multiple Examples
+        const fullClassName = test.suite_title || '';
+        const methodName = test.title;
+        // Extract the most specific namespace.class pattern
+        if (fullClassName.includes('.')) {
+            const parts = fullClassName.split('.');
+            if (parts.length >= 2) {
+                const className = parts[parts.length - 1];
+                // Look for common .NET namespace patterns and normalize them:
+                // TestProject.Tests.MyClass -> Tests.MyClass
+                // Tests.MyClass -> Tests.MyClass
+                // MyProject.SubNamespace.Tests.MyClass -> Tests.MyClass
+                let normalizedNamespace = '';
+                for (let i = parts.length - 2; i >= 0; i--) {
+                    const part = parts[i];
+                    // Build namespace from right to left, excluding project names
+                    if (part === 'Tests' || part.endsWith('Tests') || part.includes('Test')) {
+                        // Found a test namespace, use it as the normalized namespace
+                        normalizedNamespace = part;
+                        break;
+                    }
+                    else if (i === parts.length - 2) {
+                        // If no test namespace found, use the immediate parent as namespace
+                        normalizedNamespace = part;
+                    }
+                }
+                return `${normalizedNamespace}.${className}.${methodName}`;
+            }
+        }
+        // Fallback for simple class names
+        return `${fullClassName}.${methodName}`;
+    }
+    extractAssemblyName(test) {
+        // Extract assembly name from file path or use default
+        if (test.file) {
+            const parts = test.file.split(/[/\\]/);
+            return parts[0] || 'DefaultAssembly';
+        }
+        return 'DefaultAssembly';
+    }
+    extractNamespace(test) {
+        // Extract namespace from suite_title or classname
+        if (test.suite_title && test.suite_title.includes('.')) {
+            const parts = test.suite_title.split('.');
+            return parts.slice(0, -1).join('.');
+        }
+        return test.suite_title || 'DefaultNamespace';
+    }
+    extractClassName(test) {
+        // Extract class name from suite_title
+        if (test.suite_title && test.suite_title.includes('.')) {
+            const parts = test.suite_title.split('.');
+            return parts[parts.length - 1];
+        }
+        return test.suite_title || 'DefaultClass';
+    }
+    extractCsFileFromPath(test) {
+        // Extract .cs file name from source file path, not namespace
+        if (test.file) {
+            // Look for actual .cs file path patterns
+            const csFileMatch = test.file.match(/([^/\\]+\.cs)$/);
+            if (csFileMatch) {
+                return test.file;
+            }
+            // If no .cs extension, assume it's a namespace path and convert to likely file name
+            const className = this.extractClassName(test);
+            const pathParts = test.file.split(/[/\\]/);
+            pathParts[pathParts.length - 1] = `${className}.cs`;
+            return pathParts.join('/');
+        }
+        // Fallback to class name
+        const className = this.extractClassName(test);
+        return `${className}.cs`;
+    }
     calculateStats() {
         this.stats = {
             ...this.stats,
@@ -320,11 +496,13 @@ class XmlReader {
                         this.stats.language = 'csharp';
                 }
                 if (!fs_1.default.existsSync(file)) {
-                    debug('Failed to open file with the source code', file);
+                    debug('Failed to open file with the source code: %s', file);
                     return;
                 }
                 const contents = fs_1.default.readFileSync(file).toString();
-                t.code = (0, utils_js_1.fetchSourceCode)(contents, { ...t, lang: this.stats.language });
+                // Use original test name for source code lookup, not humanized title
+                const originalTitle = t.originalTestName ? t.originalTestName.replace(/\(.*?\)/, '').trim() : t.title;
+                t.code = (0, utils_js_1.fetchSourceCode)(contents, { ...t, title: originalTitle, lang: this.stats.language });
                 if (t.code)
                     debug('Fetched code for test %s', t.title);
                 t.test_id = (0, utils_js_1.fetchIdFromCode)(t.code, { lang: this.stats.language });
@@ -430,7 +608,8 @@ function reduceTestCases(prev, item) {
     testCases
         .filter(t => !!t)
         .forEach(testCaseItem => {
-        const file = testCaseItem.file || item.filepath || item.fullname || item.package || '';
+        // Use consistent Test Explorer structure: prioritize fullname for file path
+        const file = extractSourceFilePath(testCaseItem, item);
         let stack = '';
         let message = '';
         if (testCaseItem.error)
@@ -450,17 +629,33 @@ function reduceTestCases(prev, item) {
         if (!message)
             message = stack.trim().split('\n')[0];
         const isParametrized = item.type === 'ParameterizedMethod';
-        const preferClassname = reduceOptions.preferClassname || isParametrized;
         // SpecFlow config
         let { title, tags, testId } = fetchProperties(isParametrized ? item : testCaseItem);
         let example = null;
-        const suiteTitle = preferClassname ? testCaseItem.classname : item.name || testCaseItem.classname;
+        // Use consistent Test Explorer structure for suite title
+        const suiteTitle = extractTestExplorerSuiteTitle(testCaseItem, item);
         title ||= testCaseItem.name || testCaseItem.methodname || testCaseItem.classname;
         tags ||= [];
-        const exampleMatches = testCaseItem.name?.match(/\S\((.*?)\)/);
-        if (exampleMatches) {
-            example = { ...exampleMatches[1].split(',').map(v => v.trim().replace(/[^\w\s-]/g, '')) };
-            title = title.replace(/\(.*?\)/, '').trim();
+        // Store original test name for parameter extraction
+        const originalTestName = testCaseItem.name || testCaseItem.methodname;
+        // Handle NUnit-style arguments from <arguments> element
+        if (testCaseItem.arguments && testCaseItem.arguments.arg) {
+            const args = Array.isArray(testCaseItem.arguments.arg)
+                ? testCaseItem.arguments.arg
+                : [testCaseItem.arguments.arg];
+            example = args; // Store as array instead of object
+            // Remove parameters from title for NUnit tests
+            title = (testCaseItem.methodname || title).replace(/\(.*?\)/, '').trim();
+        }
+        else {
+            // Fallback to parsing parameters from test name (SpecFlow, etc.)
+            const exampleMatches = originalTestName?.match(/\((.*?)\)$/);
+            if (exampleMatches) {
+                // Extract and store parameters as Examples
+                const parameterValues = exampleMatches[1].split(',').map(v => v.trim().replace(/['"]/g, ''));
+                example = parameterValues;
+                title = title.replace(/\(.*?\)/, '').trim();
+            }
         }
         stack = `${testCaseItem['system-out'] || testCaseItem.output || testCaseItem.log || ''}\n\n${stack}\n\n${suiteOutput}\n\n${suiteErr}`.trim();
         if (!testId)
@@ -508,6 +703,7 @@ function reduceTestCases(prev, item) {
             run_time: parseFloat(testCaseItem.time || testCaseItem.duration) * 1000,
             status,
             title,
+            originalTestName, // Store original name for parameter-aware FQN generation
             root_suite_id: TESTOMATIO_SUITE,
             suite_title: suiteTitle,
             files,
@@ -516,6 +712,102 @@ function reduceTestCases(prev, item) {
     });
     return prev;
 }
+function extractSourceFilePath(testCaseItem, item) {
+    // Priority order for file path extraction to match Test Explorer structure:
+    // 1. filepath attribute (direct .cs file path from NUnit)
+    // 2. fullname (contains full project path)
+    // 3. file attribute from test case
+    // 4. package (fallback)
+    // NUnit provides filepath attribute with actual .cs file path - use this first
+    if (item.filepath) {
+        // Clean up Windows/Unix path separators and ensure proper format
+        let filePath = item.filepath.replace(/\\/g, '/');
+        // Make relative to current working directory if absolute
+        if (path_1.default.isAbsolute(item.filepath)) {
+            const cwd = process.cwd().replace(/\\/g, '/');
+            if (filePath.startsWith(cwd)) {
+                filePath = path_1.default.relative(cwd, item.filepath).replace(/\\/g, '/');
+            }
+            else {
+                // Try to extract relative path from common patterns
+                const commonPatterns = ['/Tests/', '/test/', '/src/', '/Test/'];
+                for (const pattern of commonPatterns) {
+                    const index = filePath.lastIndexOf(pattern);
+                    if (index !== -1) {
+                        filePath = filePath.substring(index + 1);
+                        break;
+                    }
+                }
+            }
+        }
+        return filePath;
+    }
+    if (testCaseItem.file) {
+        let filePath = testCaseItem.file.replace(/\\/g, '/');
+        // Make relative to current working directory if absolute
+        if (path_1.default.isAbsolute(testCaseItem.file)) {
+            const cwd = process.cwd().replace(/\\/g, '/');
+            if (filePath.startsWith(cwd)) {
+                filePath = path_1.default.relative(cwd, testCaseItem.file).replace(/\\/g, '/');
+            }
+            else {
+                // Try to extract relative path from common patterns
+                const commonPatterns = ['/Tests/', '/test/', '/src/', '/Test/'];
+                for (const pattern of commonPatterns) {
+                    const index = filePath.lastIndexOf(pattern);
+                    if (index !== -1) {
+                        filePath = filePath.substring(index + 1);
+                        break;
+                    }
+                }
+            }
+        }
+        return filePath;
+    }
+    if (item.fullname) {
+        // Extract actual file path from fullname if it contains path separators
+        const fullnameParts = item.fullname.split('.');
+        if (fullnameParts.length > 2) {
+            // For ParameterizedMethod, get the class name (not method name)
+            // Example: "NUnit_sample_test.Tests.SampleTests.TestBooleanValue" -> "Tests/SampleTests.cs"
+            let namespaceParts, className;
+            if (item.type === 'ParameterizedMethod') {
+                // For parameterized methods, the last part is the method name, second-to-last is class
+                namespaceParts = fullnameParts.slice(1, -2); // Skip project name and method name
+                className = fullnameParts[fullnameParts.length - 2]; // Get class name
+            }
+            else {
+                // For regular classes/fixtures
+                namespaceParts = fullnameParts.slice(1, -1); // Skip project name
+                className = fullnameParts[fullnameParts.length - 1];
+            }
+            return `${namespaceParts.join('/')}/${className}.cs`;
+        }
+    }
+    if (item.package)
+        return item.package.replace(/\\/g, '/');
+    // Fallback: construct from classname
+    if (testCaseItem.classname) {
+        const parts = testCaseItem.classname.split('.');
+        const className = parts[parts.length - 1];
+        const namespacePath = parts.slice(0, -1).join('/');
+        return `${namespacePath}/${className}.cs`;
+    }
+    return '';
+}
+function extractTestExplorerSuiteTitle(testCaseItem, item) {
+    // Extract suite title to match Test Explorer structure (Project/Namespace hierarchy)
+    // Priority: fullname > classname > name
+    if (item.fullname) {
+        // Use fullname to maintain Test Explorer structure
+        return item.fullname;
+    }
+    if (testCaseItem.classname) {
+        return testCaseItem.classname;
+    }
+    // Fallback to item name but prefer classname structure
+    return item.name || testCaseItem.classname || 'UnknownClass';
+}
 function processTestSuite(testsuite) {
     if (!testsuite)
         return [];
@@ -527,8 +819,20 @@ function processTestSuite(testsuite) {
     if (!Array.isArray(testsuite)) {
         suites = [testsuite];
     }
-    const subSuites = suites.filter(s => s['test-suite'] && !testsuite['test-case']);
-    return [...subSuites.map(s => processTestSuite(s['test-suite'])), ...suites.reduce(reduceTestCases, [])].flat();
+    let allResults = [];
+    for (const suite of suites) {
+        // Process child test suites recursively (TestFixture, ParameterizedMethod, etc.)
+        if (suite['test-suite']) {
+            const childResults = processTestSuite(suite['test-suite']);
+            allResults = allResults.concat(childResults);
+        }
+        // Process direct test cases in this suite
+        if (suite['test-case'] || suite.testcase) {
+            const leafResults = reduceTestCases([], suite);
+            allResults = allResults.concat(leafResults);
+        }
+    }
+    return allResults;
 }
 function fetchProperties(item) {
     const tags = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testomatio/reporter",
-  "version": "2.3.1-beta.1-dependency",
+  "version": "2.3.2-beta.3-xml-import",
   "description": "Testomatio Reporter Client",
   "engines": {
     "node": ">=18"
@@ -10,20 +10,13 @@
   "author": "Michael Bodnarchuk <davert@testomat.io>,Koushik Mohan <koushikmohan1996@gmail.com>",
   "license": "MIT",
   "type": "module",
-  "overrides": {
-    "tmp": "0.2.4",
-    "external-editor": {
-      "tmp": "0.2.4"
-    },
-    "follow-redirects": "1.15.6",
-    "axios": "^1.7.0"
-  },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.279.0",
     "@aws-sdk/lib-storage": "^3.279.0",
-    "@cucumber/cucumber": "^12.2.0",
+    "@cucumber/cucumber": "^10.9.0",
     "@octokit/rest": "^21.1.1",
     "aws-sdk": "^2.1072.0",
+    "gaxios": ">=6.0 || >=7.0.0-rc.4 || <8",
     "callsite-record": "^4.1.4",
     "commander": "^12",
     "cross-spawn": "^7.0.3",
@@ -33,7 +26,6 @@
     "fast-xml-parser": "^4.4.1",
     "file-url": "3.0.0",
     "filesize": "^10.1.6",
-    "gaxios": ">=6.0 || >=7.0.0-rc.4 || <8",
     "glob": "^10.3",
     "handlebars": "^4.7.8",
     "has-flag": "^5.0.1",
@@ -93,7 +85,7 @@
     "@types/mocha": "^10.0.7",
     "@wdio/reporter": "^7.16.13",
     "chai": "^4.3.6",
-    "codeceptjs": "^3.7.4",
+    "codeceptjs": "^3.6.5",
     "cucumber": "^6.0.7",
     "eslint": "^9.24.0",
     "eslint-config-prettier": "^8.3.0",
@@ -101,13 +93,13 @@
     "jasmine": "^5.2.0",
     "jest": "^27.4.7",
     "jsdom": "^22.1.0",
-    "mocha": "^11.7.2",
+    "mocha": "^9.2.0",
     "mock-http-server": "^1.4.5",
     "pino": "^8.15.0",
     "prettier": "^3.2.5",
     "puppeteer": "^22.15.0",
     "typescript": "^5.5.4",
-    "vitest": "^3.2.4"
+    "vitest": "^1.6.0"
   },
   "bin": {
     "@testomatio/reporter": "./lib/bin/cli.js",
@@ -121,28 +113,27 @@
       "require": "./lib/reporter.js",
       "types": "./types/types.d.ts"
     },
-    "exports": {
-      ".": {
-        "import": "./src/reporter.js",
-        "require": "./lib/reporter.js",
-        "types": "./types/types.d.ts"
-      },
-      "./cypress-plugin": "./lib/adapter/cypress-plugin/index.js",
-      "./cypress": "./lib/adapter/cypress-plugin/index.js",
-      "./lib/adapter/jasmine.js": "./lib/adapter/jasmine.js",
-      "./jasmine": "./lib/adapter/jasmine.js",
-      "./lib/adapter/jest.js": "./lib/adapter/jest.js",
-      "./jest": "./lib/adapter/jest.js",
-      "./lib/adapter/mocha/mocha.js": "./lib/adapter/mocha.js",
-      "./mocha": "./lib/adapter/mocha.js",
-      "./lib/adapter/playwright.js": "./lib/adapter/playwright.js",
-      "./nightwatch": "./lib/adapter/nightwatch.js",
-      "./playwright": "./lib/adapter/playwright.js",
-      "./vitest": "./lib/adapter/vitest.js",
-      "./lib/adapter/webdriver.js": "./lib/adapter/webdriver.js",
-      "./lib/adapter/webdriver": "./lib/adapter/webdriver.js",
-      "./webdriver": "./lib/adapter/webdriver.js",
-      "./wdio": "./lib/adapter/webdriver.js"
-    }
+    "./lib/adapter/codecept/codecept.js": "./lib/adapter/codecept.js",
+    "./lib/adapter/codecept": "./lib/adapter/codecept.js",
+    "./codecept": "./lib/adapter/codecept.js",
+    "./lib/adapter/cucumber/cucumber.js": "./lib/adapter/cucumber/current.js",
+    "./cucumber": "./lib/adapter/cucumber/current.js",
+    "./lib/adapter/cypress-plugin": "./lib/adapter/cypress-plugin/index.js",
+    "./cypress-plugin": "./lib/adapter/cypress-plugin/index.js",
+    "./cypress": "./lib/adapter/cypress-plugin/index.js",
+    "./lib/adapter/jasmine.js": "./lib/adapter/jasmine.js",
+    "./jasmine": "./lib/adapter/jasmine.js",
+    "./lib/adapter/jest.js": "./lib/adapter/jest.js",
+    "./jest": "./lib/adapter/jest.js",
+    "./lib/adapter/mocha/mocha.js": "./lib/adapter/mocha.js",
+    "./mocha": "./lib/adapter/mocha.js",
+    "./lib/adapter/playwright.js": "./lib/adapter/playwright.js",
+    "./nightwatch": "./lib/adapter/nightwatch.js",
+    "./playwright": "./lib/adapter/playwright.js",
+    "./vitest": "./lib/adapter/vitest.js",
+    "./lib/adapter/webdriver.js": "./lib/adapter/webdriver.js",
+    "./lib/adapter/webdriver": "./lib/adapter/webdriver.js",
+    "./webdriver": "./lib/adapter/webdriver.js",
+    "./wdio": "./lib/adapter/webdriver.js"
   }
 }

package/src/junit-adapter/csharp.js

@@ -3,18 +3,45 @@ import Adapter from './adapter.js';
 
 class CSharpAdapter extends Adapter {
   formatTest(t) {
-    const title = t.title.replace(/\(.*?\)/, '').trim();
-    const example = t.title.match(/\((.*?)\)/);
-    if (example) t.example = { ...example[1].split(',') };
+    // Don't override example if it already exists from NUnit XML processing
+    // The xmlReader.js already extracts parameters correctly from <arguments>
+    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());
+      }
+      t.title = title.trim();
+    }
+
     const suite = t.suite_title.split('.');
     t.suite_title = suite.pop();
     t.file = namespaceToFileName(t.file);
-    t.title = title.trim();
     return t;
   }
 
   getFilePath(t) {
-    const fileName = namespaceToFileName(t.file);
+    if (!t.file) return null;
+
+    // Normalize path separators for cross-platform compatibility
+    let filePath = t.file.replace(/\\/g, '/');
+
+    // If file already has .cs extension, use it directly
+    if (filePath.endsWith('.cs')) {
+      // Make relative path if it's absolute
+      if (path.isAbsolute(filePath)) {
+        // Try to find project-relative path
+        const cwd = process.cwd().replace(/\\/g, '/');
+        if (filePath.startsWith(cwd)) {
+          filePath = path.relative(cwd, filePath).replace(/\\/g, '/');
+        }
+      }
+      return filePath;
+    }
+
+    // Convert namespace path to file path
+    const fileName = namespaceToFileName(filePath);
     return fileName;
   }
 }
@@ -22,7 +49,14 @@ class CSharpAdapter extends Adapter {
 export default CSharpAdapter;
 
 function namespaceToFileName(fileName) {
+  if (!fileName) return '';
+
+  // If already a .cs file path, clean it up
+  if (fileName.endsWith('.cs')) {
+    return fileName.replace(/\\/g, '/');
+  }
+
   const fileParts = fileName.split('.');
   fileParts[fileParts.length - 1] = fileParts[fileParts.length - 1]?.replace(/\$.*/, '');
-  return `${fileParts.join(path.sep)}.cs`;
+  return `${fileParts.join('/')}.cs`;
 }

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,
+        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();
   }