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

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.2-beta.1-alias",
+  "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/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 }),
     };

package/src/data-storage.js

@@ -41,7 +41,7 @@ class DataStorage {
   /**
    * Puts any data to storage (file or global variable).
    * If file: stores data as text, if global variable – stores as array of data.
-   * @param {'log' | 'artifact' | 'keyvalue' | 'labels'} dataType
+   * @param {'log' | 'artifact' | 'keyvalue' | 'links'} dataType
    * @param {*} data anything you want to store (string, object, array, etc)
    * @param {*} context could be testId or any context (test name, suite name, including their IDs etc)
    * suite name + test name is used by default
@@ -70,7 +70,7 @@ class DataStorage {
    * Returns data, stored for specific test/context (or data which was stored without test id specified).
    * This method will get data from global variable and/or from from file (previosly saved with put method).
    *
-   * @param {'log' | 'artifact' | 'keyvalue' | 'labels'} dataType
+   * @param {'log' | 'artifact' | 'keyvalue' | 'links'} dataType
    * @param {string} context
    * @returns {any []} array of data (any type), null (if no data found for context) or string (if data type is log)
    */
@@ -108,7 +108,7 @@ class DataStorage {
   }
 
   /**
-   * @param {'log' | 'artifact' | 'keyvalue' | 'labels'} dataType
+   * @param {'log' | 'artifact' | 'keyvalue' | 'links'} dataType
    * @param {string} context
    * @returns aray of data (any type)
    */
@@ -127,7 +127,7 @@ class DataStorage {
   }
 
   /**
-   * @param {'log' | 'artifact' | 'keyvalue' | 'labels'} dataType
+   * @param {'log' | 'artifact' | 'keyvalue' | 'links'} dataType
    * @param {*} context
    * @returns array of data (any type)
    */
@@ -151,7 +151,7 @@ class DataStorage {
 
   /**
    * Puts data to global variable. Unlike the file storage, stores data in array (file storage just append as string).
-   * @param {'log' | 'artifact' | 'keyvalue' | 'labels'} dataType
+   * @param {'log' | 'artifact' | 'keyvalue' | 'links'} dataType
    * @param {*} data
    * @param {*} context
    */
@@ -166,7 +166,7 @@ class DataStorage {
 
   /**
    * Puts data to file. Unlike the global variable storage, stores data as string
-   * @param {'log' | 'artifact' | 'keyvalue' | 'labels'} dataType
+   * @param {'log' | 'artifact' | 'keyvalue' | 'links'} dataType
    * @param {*} data
    * @param {string} context
    * @returns

package/src/reporter-functions.js

@@ -53,44 +53,32 @@ function setKeyValue(keyValue, value = null) {
 }
 
 /**
- * Add a single label to the test report
+ * Add label(s) to the test report
  * @param {string} key - label key (e.g. 'severity', 'feature', or just 'smoke' for labels without values)
- * @param {string|null} [value=null] - optional label value (e.g. 'high', 'login')
+ * @param {string|string[]|null} [value=null] - optional label value(s) (e.g. 'high', 'login') or array of values
  * @returns {void}
  */
 function setLabel(key, value = null) {
-  if (!key || typeof key !== 'string') {
-    console.warn('Label key must be a non-empty string');
+  if (Array.isArray(value)) {
+    value.forEach(val => setLabel(key, val));
     return;
   }
 
-  // Limit key length to 255 characters
-  if (key.length > 255) {
-    console.warn('Label key is too long, trimmed to 255 characters:', key);
-    key = key.substring(0, 255);
-  }
-
-  let labelString = key;
-  if (value !== null && value !== undefined && value !== '') {
-    if (typeof value !== 'string') {
-      console.warn('Label value must be a string, converting:', value);
-      value = String(value);
-    }
-    // Limit value length to 255 characters
-    if (value.length > 255) {
-      console.warn('Label value is too long, trimmed to 255 characters:', value);
-      value = value.substring(0, 255);
-    }
-    labelString = `${key}:${value}`;
-  }
+  const labelObject = value !== null && value !== undefined && value !== '' 
+    ? { label: `${key}:${value}` } 
+    : { label: key };
+  services.links.put([labelObject]);
+}
 
-  // Limit total label length to 255 characters
-  if (labelString.length > 255) {
-    console.warn('Label is too long, trimmed to 255 characters:', labelString);
-    labelString = labelString.substring(0, 255);
-  }
 
-  services.labels.put([labelString]);
+/**
+ * Add link(s) to the test report
+ * @param {...string} testIds - test IDs to link
+ * @returns {void}
+ */
+function linkTest(...testIds) {
+  const links = testIds.map(testId => ({ test: testId }));
+  services.links.put(links);
 }
 
 export default {
@@ -99,4 +87,5 @@ export default {
   step: addStep,
   keyValue: setKeyValue,
   label: setLabel,
+  linkTest,
 };

package/src/reporter.js

@@ -9,6 +9,7 @@ export const logger = services.logger;
 export const meta = reporterFunctions.keyValue;
 export const step = reporterFunctions.step;
 export const label = reporterFunctions.label;
+export const linkTest = reporterFunctions.linkTest;
 
 /**
  * @typedef {typeof import('./reporter-functions.js').default.artifact} ArtifactFunction
@@ -30,6 +31,7 @@ export default {
   meta: reporterFunctions.keyValue,
   step: reporterFunctions.step,
   label: reporterFunctions.label,
+  linkTest: reporterFunctions.linkTest,
 
   // TestomatClient,
   // TRConstants,

package/src/services/index.js

@@ -1,14 +1,14 @@
 import { logger } from './logger.js';
 import { artifactStorage } from './artifacts.js';
 import { keyValueStorage } from './key-values.js';
-import { labelStorage } from './labels.js';
+import { linkStorage } from './links.js';
 import { dataStorage } from '../data-storage.js';
 
 export const services = {
   logger,
   artifacts: artifactStorage,
   keyValues: keyValueStorage,
-  labels: labelStorage,
+  links: linkStorage,
   setContext: context => {
     dataStorage.setContext(context);
   },

package/src/services/labels.js

@@ -23,7 +23,7 @@ class LabelStorage {
    */
   put(labels, context = null) {
     if (!labels || !Array.isArray(labels)) return;
-    dataStorage.putData('labels', labels, context);
+    dataStorage.putData('links', labels, context);
   }
 
   /**
@@ -32,7 +32,7 @@ class LabelStorage {
    * @returns {string[]} labels array, e.g. ['smoke', 'severity:high', 'feature:user_account']
    */
   get(context = null) {
-    const labelsList = dataStorage.getData('labels', context);
+    const labelsList = dataStorage.getData('links', context);
     if (!labelsList || !labelsList?.length) return [];
 
     const allLabels = [];

package/src/services/links.js

@@ -0,0 +1,69 @@
+import createDebugMessages from 'debug';
+import { dataStorage } from '../data-storage.js';
+
+const debug = createDebugMessages('@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;
+    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 = 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;
+  }
+}
+
+export const linkStorage = LinkStorage.getInstance();

package/src/utils/utils.js

@@ -53,7 +53,7 @@ const parseSuite = suiteTitle => {
  */
 const validateSuiteId = suiteId => {
   if (!suiteId) return null;
-  
+
   const match = suiteId.match(SUITE_ID_REGEX);
   return match ? match[0] : null;
 };
@@ -273,7 +273,7 @@ const fileSystem = {
 const foundedTestLog = (app, tests) => {
   const n = tests.length;
 
-  return n === 1 ? console.log(app, `✅ We found one test!`) : console.log(app, `✅ We found ${n} tests!`);
+  return console.log(app, `✅ We found ${n === 1 ? 'one test' : `${n} tests`} in Testomat.io!`);
 };
 
 const humanize = text => {
@@ -354,12 +354,14 @@ function storeRunId(runId) {
 }
 
 /**
- * 
+ *
  * @returns {String|null} latest run ID
  */
 function readLatestRunId() {
   try {
     const filePath = path.join(os.tmpdir(), `testomatio.latest.run`);
+    if (!fs.existsSync(filePath)) return null;
+    
     const stats = fs.statSync(filePath);
     const diff = +new Date() - +stats.mtime;
     const diffHours = diff / 1000 / 60 / 60;