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

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' | 'links'} dataType
+   * @param {'log' | 'artifact' | 'keyvalue' | 'labels'} 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' | 'links'} dataType
+   * @param {'log' | 'artifact' | 'keyvalue' | 'labels'} 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' | 'links'} dataType
+   * @param {'log' | 'artifact' | 'keyvalue' | 'labels'} dataType
    * @param {string} context
    * @returns aray of data (any type)
    */
@@ -127,7 +127,7 @@ class DataStorage {
   }
 
   /**
-   * @param {'log' | 'artifact' | 'keyvalue' | 'links'} dataType
+   * @param {'log' | 'artifact' | 'keyvalue' | 'labels'} 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' | 'links'} dataType
+   * @param {'log' | 'artifact' | 'keyvalue' | 'labels'} 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' | 'links'} dataType
+   * @param {'log' | 'artifact' | 'keyvalue' | 'labels'} dataType
    * @param {*} data
    * @param {string} context
    * @returns

package/src/pipe/testomatio.js

@@ -119,7 +119,8 @@ class TestomatioPipe {
       const resp = await this.client.request({
         method: 'GET',
         url: '/api/test_grep',
-        ...q,
+        params: q.params,
+        responseType: q.responseType
       });
 
       if (Array.isArray(resp.data?.tests) && resp.data?.tests?.length > 0) {

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,194 +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);
-        
-        // For parameterized tests, merge as Examples
-        if (test.example) {
-          // Initialize examples array if it doesn't exist
-          if (!existingTest.examples) {
-            existingTest.examples = [];
-            // Add the existing test's example as the first item
-            if (existingTest.example) {
-              existingTest.examples.push({
-                parameters: existingTest.example,
-                status: existingTest.status,
-                run_time: existingTest.run_time,
-                message: existingTest.message,
-                stack: existingTest.stack
-              });
-            }
-          }
-          
-          // 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);
-          
-          // Merge stack traces if they're different
-          if (test.stack && test.stack !== existingTest.stack) {
-            existingTest.stack = existingTest.stack + '\n\n---\n\n' + test.stack;
-          }
-          
-          // Merge messages if they're different
-          if (test.message && test.message !== existingTest.message) {
-            existingTest.message = existingTest.message + '; ' + test.message;
-          }
-        } 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;
-          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
-    // 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,
@@ -676,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 = '';
@@ -692,25 +500,19 @@ 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 ||= [];
 
-      // Store original test name for parameter extraction
-      const originalTestName = testCaseItem.name || testCaseItem.methodname;
-      
-      const exampleMatches = originalTestName?.match(/\((.*?)\)$/);
+      const exampleMatches = testCaseItem.name?.match(/\S\((.*?)\)/);
       if (exampleMatches) {
-        // Extract and store parameters as Examples
-        const parameterValues = exampleMatches[1].split(',').map(v => v.trim().replace(/['"]/g, ''));
-        example = { ...parameterValues };
+        example = { ...exampleMatches[1].split(',').map(v => v.trim().replace(/[^\w\s-]/g, '')) };
         title = title.replace(/\(.*?\)/, '').trim();
       }
 
@@ -766,7 +568,6 @@ 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,
@@ -776,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);
@@ -837,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) {