@testomatio/reporter 2.1.1 → 2.1.3-beta.1-xml-import

package/lib/services/links.d.ts

@@ -0,0 +1,22 @@
+export const linkStorage: LinkStorage;
+declare class LinkStorage {
+    static "__#13@#instance": any;
+    /**
+     *
+     * @returns {LinkStorage}
+     */
+    static getInstance(): LinkStorage;
+    /**
+     * Stores links array and passes it to reporter
+     * @param {object[]} links - array of link objects
+     * @param {*} context - full test title
+     */
+    put(links: object[], context?: any): void;
+    /**
+     * Returns links array for the test
+     * @param {*} context testId or test context from test runner
+     * @returns {object[]} links array, e.g. [{test: 'TEST-123'}, {jira: 'JIRA-456'}]
+     */
+    get(context?: any): object[];
+}
+export {};

package/lib/services/links.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linkStorage = void 0;
+const debug_1 = __importDefault(require("debug"));
+const data_storage_js_1 = require("../data-storage.js");
+const debug = (0, debug_1.default)('@testomatio/reporter:services-links');
+class LinkStorage {
+    static #instance;
+    /**
+     *
+     * @returns {LinkStorage}
+     */
+    static getInstance() {
+        if (!this.#instance) {
+            this.#instance = new LinkStorage();
+        }
+        return this.#instance;
+    }
+    /**
+     * Stores links array and passes it to reporter
+     * @param {object[]} links - array of link objects
+     * @param {*} context - full test title
+     */
+    put(links, context = null) {
+        if (!links || !Array.isArray(links))
+            return;
+        data_storage_js_1.dataStorage.putData('links', links, context);
+    }
+    /**
+     * Returns links array for the test
+     * @param {*} context testId or test context from test runner
+     * @returns {object[]} links array, e.g. [{test: 'TEST-123'}, {jira: 'JIRA-456'}]
+     */
+    get(context = null) {
+        const linksList = data_storage_js_1.dataStorage.getData('links', context);
+        if (!linksList || !linksList?.length)
+            return [];
+        const allLinks = [];
+        for (const links of linksList) {
+            if (Array.isArray(links)) {
+                allLinks.push(...links);
+            }
+            else if (typeof links === 'string') {
+                try {
+                    const parsedLinks = JSON.parse(links);
+                    if (Array.isArray(parsedLinks)) {
+                        allLinks.push(...parsedLinks);
+                    }
+                }
+                catch (e) {
+                    debug(`Error parsing links for test ${context}`, links);
+                }
+            }
+        }
+        // Remove duplicates based on JSON string comparison
+        const uniqueLinks = [];
+        const seen = new Set();
+        for (const link of allLinks) {
+            const key = JSON.stringify(link);
+            if (!seen.has(key)) {
+                seen.add(key);
+                uniqueLinks.push(link);
+            }
+        }
+        return uniqueLinks;
+    }
+}
+exports.linkStorage = LinkStorage.getInstance();

package/lib/services/logger.d.ts

@@ -5,7 +5,7 @@ export const logger: Logger;
  * Supports different syntaxes to satisfy any user preferences.
  */
 declare class Logger {
-    static "__#13@#instance": any;
+    static "__#14@#instance": any;
     /**
      *
      * @returns {Logger}

package/lib/xmlReader.d.ts

@@ -77,6 +77,13 @@ declare class XmlReader {
         skipped_count: number;
         tests: any[];
     };
+    deduplicateTestsByFQN(tests: any): any[];
+    generateFQN(test: any): string;
+    generateNormalizedFQN(test: any): string;
+    extractAssemblyName(test: any): any;
+    extractNamespace(test: any): any;
+    extractClassName(test: any): any;
+    extractCsFileFromPath(test: any): any;
     calculateStats(): {};
     fetchSourceCode(): void;
     formatTests(): void;

package/lib/xmlReader.js

@@ -131,7 +131,9 @@ 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);
+        // Deduplicate tests based on FQN (Assembly + Namespace + Class + Method)
+        const deduplicatedTests = this.deduplicateTestsByFQN(resultTests);
+        this.tests = this.tests.concat(deduplicatedTests);
         return {
             status: result?.toLowerCase(),
             create_tests: true,
@@ -139,7 +141,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 +277,125 @@ 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);
+                // Merge test properties, prioritizing Test Explorer structure but updating with IDs
+                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;
+                    existingTest.file = this.extractCsFileFromPath(test);
+                }
+            }
+            else {
+                // Fix file path to use proper .cs file names from source paths
+                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
+        // This normalizes different representations of the same test
+        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,
@@ -430,7 +551,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,11 +572,11 @@ 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\((.*?)\)/);
@@ -516,6 +638,51 @@ function reduceTestCases(prev, item) {
     });
     return prev;
 }
+function extractSourceFilePath(testCaseItem, item) {
+    // Priority order for file path extraction to match Test Explorer structure:
+    // 1. fullname (contains full project path)
+    // 2. filepath (direct file path)
+    // 3. file attribute from test case
+    // 4. package (fallback)
+    if (item.fullname) {
+        // Extract actual file path from fullname if it contains path separators
+        const fullnameParts = item.fullname.split('.');
+        if (fullnameParts.length > 2) {
+            // Reconstruct path from project.namespace.class structure
+            const projectName = fullnameParts[0];
+            const namespaceParts = fullnameParts.slice(1, -1);
+            const className = fullnameParts[fullnameParts.length - 1];
+            return `${projectName}/${namespaceParts.join('/')}/${className}.cs`;
+        }
+    }
+    if (item.filepath)
+        return item.filepath;
+    if (testCaseItem.file)
+        return testCaseItem.file;
+    if (item.package)
+        return item.package;
+    // 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 +694,14 @@ 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();
+    // Only process suites that have test cases OR child suites, but avoid double processing
+    const subSuites = suites.filter(s => s['test-suite'] && !s['test-case']);
+    const leafSuites = suites.filter(s => s['test-case'] || s.testcase);
+    // Process child suites recursively
+    const childResults = subSuites.map(s => processTestSuite(s['test-suite'])).flat();
+    // Process leaf suites with actual test cases
+    const leafResults = leafSuites.reduce(reduceTestCases, []);
+    return [...childResults, ...leafResults];
 }
 function fetchProperties(item) {
     const tags = [];

package/package.json

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

package/src/adapter/codecept.js

@@ -163,7 +163,7 @@ function CodeceptReporter(config) {
     const manuallyAttachedArtifacts = services.artifacts.get(test.fullTitle());
     const keyValues = services.keyValues.get(test.fullTitle());
     const stepHierarchy = buildUnifiedStepHierarchy(test.steps, hookSteps);
-    const labels = services.labels.get(test.fullTitle());
+    const links = services.links.get(test.fullTitle());
 
     services.setContext(null);
 
@@ -178,7 +178,7 @@ function CodeceptReporter(config) {
       files,
       steps: stepHierarchy, // Array of step objects per API schema
       logs,
-      labels,
+      links,
       manuallyAttachedArtifacts,
       meta: { ...keyValues, ...test.meta },
     });

package/src/adapter/mocha.js

@@ -61,6 +61,7 @@ function MochaReporter(runner, opts) {
     const logs = getTestLogs(test);
     const artifacts = services.artifacts.get(test.fullTitle());
     const keyValues = services.keyValues.get(test.fullTitle());
+    const links = services.links.get(test.fullTitle());
 
     client.addTestRun(STATUS.PASSED, {
       test_id: testId,
@@ -72,6 +73,7 @@ function MochaReporter(runner, opts) {
       logs,
       manuallyAttachedArtifacts: artifacts,
       meta: keyValues,
+      links,
     });
   });
 
@@ -79,6 +81,10 @@ function MochaReporter(runner, opts) {
     skipped += 1;
     console.log('skip: %s', test.fullTitle());
     const testId = getTestomatIdFromTestTitle(test.title);
+    const artifacts = services.artifacts.get(test.fullTitle());
+    const keyValues = services.keyValues.get(test.fullTitle());
+    const links = services.links.get(test.fullTitle());
+    
     client.addTestRun(STATUS.SKIPPED, {
       title: getTestName(test),
       suite_title: getSuiteTitle(test),
@@ -86,6 +92,9 @@ function MochaReporter(runner, opts) {
       file: getFile(test),
       test_id: testId,
       time: test.duration,
+      manuallyAttachedArtifacts: artifacts,
+      meta: keyValues,
+      links,
     });
   });
 
@@ -95,6 +104,9 @@ function MochaReporter(runner, opts) {
     const testId = getTestomatIdFromTestTitle(test.title);
 
     const logs = getTestLogs(test);
+    const artifacts = services.artifacts.get(test.fullTitle());
+    const keyValues = services.keyValues.get(test.fullTitle());
+    const links = services.links.get(test.fullTitle());
 
     client.addTestRun(STATUS.FAILED, {
       error: err,
@@ -105,6 +117,9 @@ function MochaReporter(runner, opts) {
       code: process.env.TESTOMATIO_UPDATE_CODE ? test.body.toString() : '',
       time: test.duration,
       logs,
+      manuallyAttachedArtifacts: artifacts,
+      meta: keyValues,
+      links,
     });
   });
 

package/src/adapter/webdriver.js

@@ -53,11 +53,13 @@ class WebdriverReporter extends WDIOReporter {
     test.suite = test.parent;
     const logs = getTestLogs(test.fullTitle);
     // TODO: FIX: artifacts for some reason leads to empty report on Testomat.io
-    // const artifacts = services.artifacts.get(test.fullTitle);
-    // const keyValues = services.keyValues.get(test.fullTitle);
+    // ^ not reproduced anymore (Jul 2025)
+    // but still be under investigation
+    const artifacts = services.artifacts.get(test.fullTitle);
+    const keyValues = services.keyValues.get(test.fullTitle);
     test.logs = logs;
-    // test.artifacts = artifacts;
-    // test.meta = keyValues;
+    test.artifacts = artifacts;
+    test.meta = keyValues;
 
     this._addTestPromises.push(this.addTest(test));
   }

package/src/bin/startTest.js

@@ -1,124 +1,53 @@
 #!/usr/bin/env node
-import { spawn } from 'cross-spawn';
-import { Command } from 'commander';
-import pc from 'picocolors';
-import TestomatClient from '../client.js';
-import { APP_PREFIX, STATUS } from '../constants.js';
+import { spawn } from 'node:child_process';
+import { join, dirname } from 'node:path';
 import { getPackageVersion } from '../utils/utils.js';
-import { config } from '../config.js';
-import dotenv from 'dotenv';
+import pc from 'picocolors';
+
+// Define __dirname - this will be replaced by build script with actual __dirname for CommonJS
+const __dirname = typeof globalThis.__dirname !== 'undefined' ? globalThis.__dirname : '.';
+const cliPath = join(__dirname, 'cli.js');
 
 const version = getPackageVersion();
 console.log(pc.cyan(pc.bold(` 🤩 Testomat.io Reporter v${version}`)));
-const program = new Command();
-
-program
-  .option('-c, --command <cmd>', 'Test runner command')
-  .option('--launch', 'Start a new run and return its ID')
-  .option('--finish', 'Finish Run by its ID')
-  .option('--env-file <envfile>', 'Load environment variables from env file')
-  .option('--filter <filter>', 'Additional execution filter')
-  .action(async opts => {
-    const { launch, finish, filter } = opts;
-    let { command } = opts;
-
-    if (opts.envFile) dotenv.config({ path: opts.envFile });
-
-    const apiKey = process.env['INPUT_TESTOMATIO-KEY'] || config.TESTOMATIO;
-    const title = process.env.TESTOMATIO_TITLE;
-
-    if (launch) {
-      console.log('Starting a new Run on Testomat.io...');
-      const client = new TestomatClient({ apiKey });
-
-      client.createRun().then(() => {
-        console.log(process.env.runId);
-        process.exit(0);
-      });
-      return;
-    }
-
-    if (finish) {
-      // TODO: add error in case of TESTOMATIO environment variable is not set
-      // because command is fine in console, but actually (on testomat.io) run is not finished
-      if (!process.env.TESTOMATIO_RUN) {
-        console.log('TESTOMATIO_RUN environment variable must be set.');
-        return process.exit(1);
-      }
-
-      console.log('Finishing Run on Testomat.io...');
-
-      const client = new TestomatClient({ apiKey });
 
-      // @ts-ignore
-      client.updateRunStatus(STATUS.FINISHED).then(() => {
-        console.log(pc.yellow(`Run ${process.env.TESTOMATIO_RUN} was finished`));
-        process.exit(0);
-      });
-      return;
+// Parse command line arguments to map start-test-run options to @testomatio/reporter run format
+const args = process.argv.slice(2);
+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++;
+    if (i < args.length) {
+      newArgs.push(args[i]);
     }
+  } else if (arg.startsWith('--command=')) {
+    // Handle --command=value format
+    const command = arg.split('=', 2)[1];
+    newArgs.push(command);
+  } else if (arg === '--launch') {
+    // Map --launch to start command
+    newArgs[0] = 'start';
+  } else if (arg === '--finish') {
+    // Map --finish to finish command  
+    newArgs[0] = 'finish';
+  } else {
+    // Pass through other arguments
+    newArgs.push(arg);
+  }
+  i++;
+}
 
-    let exitCode = 0;
-
-    if (!command.split) {
-      process.exitCode = 255;
-      console.log(APP_PREFIX, `No command provided. Use -c option to launch a test runner.`);
-      return;
-    }
-
-    const client = new TestomatClient({ apiKey, title, parallel: true });
-
-    if (filter) {
-      const [pipe, ...optsArray] = filter.split(':');
-      const pipeOptions = optsArray.join(':');
-
-      try {
-        const tests = await client.prepareRun({ pipe, pipeOptions });
-
-        if (!tests || tests.length === 0) {
-          return;
-        }
-
-        const grep = ` --grep (${tests.join('|')})`;
-        command += grep;
-      } catch (err) {
-        console.log(APP_PREFIX, err);
-      }
-    }
-
-    const testCmds = command.split(' ');
-    console.log(APP_PREFIX, `🚀 Running`, pc.green(command));
-
-    if (!apiKey) {
-      const cmd = spawn(testCmds[0], testCmds.slice(1), { stdio: 'inherit' });
-
-      cmd.on('close', code => {
-        console.log(APP_PREFIX, '⚠️ ', `Runner exited with ${pc.bold(code)}, report is ignored`);
-
-        if (code > exitCode) exitCode = code;
-        process.exitCode = exitCode;
-      });
-
-      return;
-    }
-
-    client.createRun().then(() => {
-      const cmd = spawn(testCmds[0], testCmds.slice(1), { stdio: 'inherit' });
-
-      cmd.on('close', code => {
-        const emoji = code === 0 ? '🟢' : '🔴';
-        console.log(APP_PREFIX, emoji, `Runner exited with ${pc.bold(code)}`);
-        const status = code === 0 ? 'passed' : 'failed';
-        client.updateRunStatus(status, true);
-
-        if (code > exitCode) exitCode = code;
-        process.exitCode = exitCode;
-      });
-    });
-  });
+// Execute the main CLI with mapped arguments
 
-if (process.argv.length <= 2) {
-  program.outputHelp();
-}
+const child = spawn(process.execPath, [cliPath, ...newArgs], {
+  stdio: 'inherit'
+});
 
-program.parse(process.argv);
+child.on('exit', (code) => {
+  process.exit(code);
+});

package/src/client.js

@@ -11,6 +11,7 @@ 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 { linkStorage } from './services/links.js';
 import { filesize as prettyBytes } from 'filesize';
 
 const debug = createDebugMessages('@testomatio/reporter:client');
@@ -182,7 +183,6 @@ class Client {
       test_id,
       timestamp,
       manuallyAttachedArtifacts,
-      labels,
       overwrite,
     } = testData;
     let { message = '', meta = {} } = testData;
@@ -224,7 +224,9 @@ class Client {
         return acc;
       }, {});
 
-    // Labels are simple array of strings, no processing needed
+    // Get links from storage using the test context
+    const testContext = suite_title ? `${suite_title} ${title}` : title;
+    const links = linkStorage.get(testContext) || [];
 
     let errorFormatted = '';
     if (error) {
@@ -280,7 +282,7 @@ class Client {
       timestamp,
       artifacts,
       meta,
-      labels,
+      links,
       overwrite,
       ...(rootSuiteId && { root_suite_id: rootSuiteId }),
     };