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

package/src/reporter-functions.js

@@ -3,8 +3,6 @@ import { services } from './services/index.js';
 /**
  * Stores path to file as artifact and uploads it to the S3 storage
  * @param {string | {path: string, type: string, name: string}} data - path to file or object with path, type and name
- * @param {any} [context=null] - optional context parameter
- * @returns {void}
  */
 function saveArtifact(data, context = null) {
   if (process.env.IS_PLAYWRIGHT)
@@ -16,8 +14,7 @@ function saveArtifact(data, context = null) {
 
 /**
  * Attach log message(s) to the test report
- * @param {...any} args - log messages to attach
- * @returns {void}
+ * @param  string
  */
 function logMessage(...args) {
   if (process.env.IS_PLAYWRIGHT) throw new Error('This function is not available in Playwright framework');
@@ -26,8 +23,7 @@ function logMessage(...args) {
 
 /**
  * Similar to "log" function but marks message in report as a step
- * @param {string} message - step message
- * @returns {void}
+ * @param {string} message
  */
 function addStep(message) {
   if (process.env.IS_PLAYWRIGHT)
@@ -38,9 +34,8 @@ function addStep(message) {
 
 /**
  * Add key-value pair(s) to the test report
- * @param {{[key: string]: string} | string} keyValue - object { key: value } (multiple props allowed) or key (string)
- * @param {string|null} [value=null] - optional value when keyValue is a string
- * @returns {void}
+ * @param {{[key: string]: string} | string} keyValue object { key: value } (multiple props allowed) or key (string)
+ * @param {string?} value
  */
 function setKeyValue(keyValue, value = null) {
   if (process.env.IS_PLAYWRIGHT)
@@ -53,32 +48,48 @@ function setKeyValue(keyValue, value = null) {
 }
 
 /**
- * Add label(s) to the test report
+ * Add a single label to the test report
  * @param {string} key - label key (e.g. 'severity', 'feature', or just 'smoke' for labels without values)
- * @param {string|string[]|null} [value=null] - optional label value(s) (e.g. 'high', 'login') or array of values
- * @returns {void}
+ * @param {string} [value] - optional label value (e.g. 'high', 'login')
  */
 function setLabel(key, value = null) {
   if (Array.isArray(value)) {
-    value.forEach(val => setLabel(key, val));
+    value.forEach(v => setLabel(key, v));
     return;
   }
 
-  const labelObject = value !== null && value !== undefined && value !== '' 
-    ? { label: `${key}:${value}` } 
-    : { label: key };
-  services.links.put([labelObject]);
-}
+  if (!key || typeof key !== 'string') {
+    console.warn('Label key must be a non-empty string');
+    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);
+  }
 
-/**
- * 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);
+  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}`;
+  }
+
+  // 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]);
 }
 
 export default {
@@ -87,5 +98,4 @@ export default {
   step: addStep,
   keyValue: setKeyValue,
   label: setLabel,
-  linkTest,
 };

package/src/reporter.js

@@ -9,15 +9,14 @@ 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
- * @typedef {typeof import('./reporter-functions.js').default.log} LogFunction
- * @typedef {typeof import('./services/index.js').services.logger} LoggerService
- * @typedef {typeof import('./reporter-functions.js').default.keyValue} MetaFunction
- * @typedef {typeof import('./reporter-functions.js').default.step} StepFunction
- * @typedef {typeof import('./reporter-functions.js').default.label} LabelFunction
+ * @typedef {import('./reporter-functions.js')} artifact
+ * @typedef {import('./reporter-functions.js')} log
+ * @typedef {import('./services/index.js')} logger
+ * @typedef {import('./reporter-functions.js')} meta
+ * @typedef {import('./reporter-functions.js')} step
+ * @typedef {import('./reporter-functions.js')} label
  */
 export default {
   /**
@@ -31,7 +30,6 @@ 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 { linkStorage } from './links.js';
+import { labelStorage } from './labels.js';
 import { dataStorage } from '../data-storage.js';
 
 export const services = {
   logger,
   artifacts: artifactStorage,
   keyValues: keyValueStorage,
-  links: linkStorage,
+  labels: labelStorage,
   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('links', labels, context);
+    dataStorage.putData('labels', 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('links', context);
+    const labelsList = dataStorage.getData('labels', context);
     if (!labelsList || !labelsList?.length) return [];
 
     const allLabels = [];

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 console.log(app, `✅ We found ${n === 1 ? 'one test' : `${n} tests`} in Testomat.io!`);
+  return n === 1 ? console.log(app, `✅ We found one test!`) : console.log(app, `✅ We found ${n} tests!`);
 };
 
 const humanize = text => {
@@ -354,14 +354,12 @@ 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;

package/src/xmlReader.js

@@ -161,11 +161,8 @@ class XmlReader {
 
     reduceOptions.preferClassname = this.stats.language === 'python';
     const resultTests = processTestSuite(jsonSuite['test-suite']);
-    
-    // Deduplicate tests based on FQN (Assembly + Namespace + Class + Method)
-    const deduplicatedTests = this.deduplicateTestsByFQN(resultTests);
 
-    this.tests = this.tests.concat(deduplicatedTests);
+    this.tests = this.tests.concat(resultTests);
 
     return {
       status: result?.toLowerCase(),
@@ -174,7 +171,7 @@ class XmlReader {
       passed_count: parseInt(passed, 10),
       failed_count: parseInt(failed, 10),
       skipped_count: parseInt(inconclusive + skipped, 10),
-      tests: deduplicatedTests,
+      tests: resultTests,
     };
   }
 
@@ -322,145 +319,6 @@ class XmlReader {
     };
   }
 
-  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,
@@ -627,8 +485,7 @@ function reduceTestCases(prev, item) {
   testCases
     .filter(t => !!t)
     .forEach(testCaseItem => {
-      // Use consistent Test Explorer structure: prioritize fullname for file path
-      const file = extractSourceFilePath(testCaseItem, item);
+      const file = testCaseItem.file || item.filepath || item.fullname || item.package || '';
 
       let stack = '';
       let message = '';
@@ -643,13 +500,12 @@ 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;
-      
-      // Use consistent Test Explorer structure for suite title
-      const suiteTitle = extractTestExplorerSuiteTitle(testCaseItem, item);
+      const suiteTitle = preferClassname ? testCaseItem.classname : item.name || testCaseItem.classname;
 
       title ||= testCaseItem.name || testCaseItem.methodname || testCaseItem.classname;
       tags ||= [];
@@ -721,57 +577,6 @@ 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 [];
   if (testsuite.testsuite) return processTestSuite(testsuite.testsuite);
@@ -782,17 +587,9 @@ function processTestSuite(testsuite) {
     suites = [testsuite];
   }
 
-  // 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, []);
+  const subSuites = suites.filter(s => s['test-suite'] && !testsuite['test-case']);
 
-  return [...childResults, ...leafResults];
+  return [...subSuites.map(s => processTestSuite(s['test-suite'])), ...suites.reduce(reduceTestCases, [])].flat();
 }
 
 function fetchProperties(item) {

package/src/services/links.js

@@ -1,69 +0,0 @@
-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();