@testomatio/reporter 2.3.0-beta.1-links → 2.3.0-beta.2-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,171 @@ class XmlReader {
             tests,
         };
     }
+    deduplicateTestsByFQN(tests) {
+        const fqnMap = new Map();
+        tests.forEach(test => {
+            const fqn = this.generateNormalizedFQN(test);
+            if (fqnMap.has(fqn)) {
+                const existingTest = fqnMap.get(fqn);
+                // For parameterized tests, merge as Examples
+                if (test.example && Array.isArray(test.example) && test.example.length > 0) {
+                    // Initialize examples array if it doesn't exist
+                    if (!existingTest.examples) {
+                        existingTest.examples = [];
+                        // Add the existing test's example as the first item if it has parameters
+                        if (existingTest.example && Array.isArray(existingTest.example) && existingTest.example.length > 0) {
+                            existingTest.examples.push({
+                                parameters: existingTest.example,
+                                status: existingTest.status,
+                                run_time: existingTest.run_time,
+                                message: existingTest.message,
+                                stack: existingTest.stack
+                            });
+                            // Clear the main test's example since it's now in examples array
+                            delete existingTest.example;
+                        }
+                    }
+                    // Add this test's execution as an example
+                    existingTest.examples.push({
+                        parameters: test.example,
+                        status: test.status,
+                        run_time: test.run_time,
+                        message: test.message,
+                        stack: test.stack
+                    });
+                    // Update the main test status to reflect the worst status
+                    if (test.status === 'failed' || existingTest.status === 'failed') {
+                        existingTest.status = 'failed';
+                    }
+                    else if (test.status === 'skipped' && existingTest.status !== 'failed') {
+                        existingTest.status = 'skipped';
+                    }
+                    // Update total run time
+                    existingTest.run_time = (existingTest.run_time || 0) + (test.run_time || 0);
+                }
+                else {
+                    // Merge test properties for non-parameterized tests, prioritizing Test Explorer structure
+                    if (test.test_id && !existingTest.test_id) {
+                        existingTest.test_id = test.test_id;
+                    }
+                    // Keep the most complete test data
+                    if (test.stack && !existingTest.stack) {
+                        existingTest.stack = test.stack;
+                    }
+                    if (test.message && !existingTest.message) {
+                        existingTest.message = test.message;
+                    }
+                }
+                // Prefer Test Explorer structure (longer, more complete suite_title)
+                if (test.suite_title && test.suite_title.length > existingTest.suite_title.length) {
+                    existingTest.suite_title = test.suite_title;
+                }
+                // Always use the source file path if available
+                if (test.file && test.file.endsWith('.cs')) {
+                    existingTest.file = test.file;
+                }
+                else if (!existingTest.file || !existingTest.file.endsWith('.cs')) {
+                    existingTest.file = this.extractCsFileFromPath(test);
+                }
+            }
+            else {
+                // Fix file path to use proper .cs file names from source paths
+                if (!test.file || !test.file.endsWith('.cs')) {
+                    test.file = this.extractCsFileFromPath(test);
+                }
+                fqnMap.set(fqn, test);
+            }
+        });
+        return Array.from(fqnMap.values());
+    }
+    generateFQN(test) {
+        // Generate Fully Qualified Name: Namespace + Class + Method (standard .NET FQN)
+        // Don't include assembly as it can vary between different test structures
+        const namespace = this.extractNamespace(test);
+        const className = this.extractClassName(test);
+        const methodName = test.title;
+        // Use the most complete namespace.class structure available
+        if (test.suite_title && test.suite_title.includes('.')) {
+            return `${test.suite_title}.${methodName}`;
+        }
+        return `${namespace}.${className}.${methodName}`;
+    }
+    generateNormalizedFQN(test) {
+        // Generate normalized FQN for deduplication by extracting the core namespace.class.method
+        // For parameterized tests, we want the SAME FQN so they merge into one test with multiple Examples
+        const fullClassName = test.suite_title || '';
+        const methodName = test.title;
+        // Extract the most specific namespace.class pattern
+        if (fullClassName.includes('.')) {
+            const parts = fullClassName.split('.');
+            if (parts.length >= 2) {
+                const className = parts[parts.length - 1];
+                // Look for common .NET namespace patterns and normalize them:
+                // TestProject.Tests.MyClass -> Tests.MyClass
+                // Tests.MyClass -> Tests.MyClass
+                // MyProject.SubNamespace.Tests.MyClass -> Tests.MyClass
+                let normalizedNamespace = '';
+                for (let i = parts.length - 2; i >= 0; i--) {
+                    const part = parts[i];
+                    // Build namespace from right to left, excluding project names
+                    if (part === 'Tests' || part.endsWith('Tests') || part.includes('Test')) {
+                        // Found a test namespace, use it as the normalized namespace
+                        normalizedNamespace = part;
+                        break;
+                    }
+                    else if (i === parts.length - 2) {
+                        // If no test namespace found, use the immediate parent as namespace
+                        normalizedNamespace = part;
+                    }
+                }
+                return `${normalizedNamespace}.${className}.${methodName}`;
+            }
+        }
+        // Fallback for simple class names
+        return `${fullClassName}.${methodName}`;
+    }
+    extractAssemblyName(test) {
+        // Extract assembly name from file path or use default
+        if (test.file) {
+            const parts = test.file.split(/[/\\]/);
+            return parts[0] || 'DefaultAssembly';
+        }
+        return 'DefaultAssembly';
+    }
+    extractNamespace(test) {
+        // Extract namespace from suite_title or classname
+        if (test.suite_title && test.suite_title.includes('.')) {
+            const parts = test.suite_title.split('.');
+            return parts.slice(0, -1).join('.');
+        }
+        return test.suite_title || 'DefaultNamespace';
+    }
+    extractClassName(test) {
+        // Extract class name from suite_title
+        if (test.suite_title && test.suite_title.includes('.')) {
+            const parts = test.suite_title.split('.');
+            return parts[parts.length - 1];
+        }
+        return test.suite_title || 'DefaultClass';
+    }
+    extractCsFileFromPath(test) {
+        // Extract .cs file name from source file path, not namespace
+        if (test.file) {
+            // Look for actual .cs file path patterns
+            const csFileMatch = test.file.match(/([^/\\]+\.cs)$/);
+            if (csFileMatch) {
+                return test.file;
+            }
+            // If no .cs extension, assume it's a namespace path and convert to likely file name
+            const className = this.extractClassName(test);
+            const pathParts = test.file.split(/[/\\]/);
+            pathParts[pathParts.length - 1] = `${className}.cs`;
+            return pathParts.join('/');
+        }
+        // Fallback to class name
+        const className = this.extractClassName(test);
+        return `${className}.cs`;
+    }
     calculateStats() {
         this.stats = {
             ...this.stats,
@@ -430,7 +597,8 @@ function reduceTestCases(prev, item) {
     testCases
         .filter(t => !!t)
         .forEach(testCaseItem => {
-        const file = testCaseItem.file || item.filepath || item.fullname || item.package || '';
+        // Use consistent Test Explorer structure: prioritize fullname for file path
+        const file = extractSourceFilePath(testCaseItem, item);
         let stack = '';
         let message = '';
         if (testCaseItem.error)
@@ -450,17 +618,33 @@ function reduceTestCases(prev, item) {
         if (!message)
             message = stack.trim().split('\n')[0];
         const isParametrized = item.type === 'ParameterizedMethod';
-        const preferClassname = reduceOptions.preferClassname || isParametrized;
         // SpecFlow config
         let { title, tags, testId } = fetchProperties(isParametrized ? item : testCaseItem);
         let example = null;
-        const suiteTitle = preferClassname ? testCaseItem.classname : item.name || testCaseItem.classname;
+        // Use consistent Test Explorer structure for suite title
+        const suiteTitle = extractTestExplorerSuiteTitle(testCaseItem, item);
         title ||= testCaseItem.name || testCaseItem.methodname || testCaseItem.classname;
         tags ||= [];
-        const exampleMatches = testCaseItem.name?.match(/\S\((.*?)\)/);
-        if (exampleMatches) {
-            example = { ...exampleMatches[1].split(',').map(v => v.trim().replace(/[^\w\s-]/g, '')) };
-            title = title.replace(/\(.*?\)/, '').trim();
+        // Store original test name for parameter extraction
+        const originalTestName = testCaseItem.name || testCaseItem.methodname;
+        // Handle NUnit-style arguments from <arguments> element
+        if (testCaseItem.arguments && testCaseItem.arguments.arg) {
+            const args = Array.isArray(testCaseItem.arguments.arg)
+                ? testCaseItem.arguments.arg
+                : [testCaseItem.arguments.arg];
+            example = args; // Store as array instead of object
+            // Remove parameters from title for NUnit tests
+            title = (testCaseItem.methodname || title).replace(/\(.*?\)/, '').trim();
+        }
+        else {
+            // Fallback to parsing parameters from test name (SpecFlow, etc.)
+            const exampleMatches = originalTestName?.match(/\((.*?)\)$/);
+            if (exampleMatches) {
+                // Extract and store parameters as Examples
+                const parameterValues = exampleMatches[1].split(',').map(v => v.trim().replace(/['"]/g, ''));
+                example = parameterValues;
+                title = title.replace(/\(.*?\)/, '').trim();
+            }
         }
         stack = `${testCaseItem['system-out'] || testCaseItem.output || testCaseItem.log || ''}\n\n${stack}\n\n${suiteOutput}\n\n${suiteErr}`.trim();
         if (!testId)
@@ -508,6 +692,7 @@ function reduceTestCases(prev, item) {
             run_time: parseFloat(testCaseItem.time || testCaseItem.duration) * 1000,
             status,
             title,
+            originalTestName, // Store original name for parameter-aware FQN generation
             root_suite_id: TESTOMATIO_SUITE,
             suite_title: suiteTitle,
             files,
@@ -516,6 +701,54 @@ function reduceTestCases(prev, item) {
     });
     return prev;
 }
+function extractSourceFilePath(testCaseItem, item) {
+    // Priority order for file path extraction to match Test Explorer structure:
+    // 1. filepath attribute (direct .cs file path from NUnit)
+    // 2. fullname (contains full project path)
+    // 3. file attribute from test case
+    // 4. package (fallback)
+    // NUnit provides filepath attribute with actual .cs file path - use this first
+    if (item.filepath) {
+        // Clean up Windows/Unix path separators and ensure proper format
+        return item.filepath.replace(/\\/g, '/');
+    }
+    if (testCaseItem.file)
+        return testCaseItem.file.replace(/\\/g, '/');
+    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.package)
+        return item.package.replace(/\\/g, '/');
+    // Fallback: construct from classname
+    if (testCaseItem.classname) {
+        const parts = testCaseItem.classname.split('.');
+        const className = parts[parts.length - 1];
+        const namespacePath = parts.slice(0, -1).join('/');
+        return `${namespacePath}/${className}.cs`;
+    }
+    return '';
+}
+function extractTestExplorerSuiteTitle(testCaseItem, item) {
+    // Extract suite title to match Test Explorer structure (Project/Namespace hierarchy)
+    // Priority: fullname > classname > name
+    if (item.fullname) {
+        // Use fullname to maintain Test Explorer structure
+        return item.fullname;
+    }
+    if (testCaseItem.classname) {
+        return testCaseItem.classname;
+    }
+    // Fallback to item name but prefer classname structure
+    return item.name || testCaseItem.classname || 'UnknownClass';
+}
 function processTestSuite(testsuite) {
     if (!testsuite)
         return [];
@@ -527,8 +760,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.3.0-beta.1-links",
+  "version": "2.3.0-beta.2-xml-import",
   "description": "Testomatio Reporter Client",
   "engines": {
     "node": ">=18"

package/src/adapter/codecept.js

@@ -25,9 +25,6 @@ const HOOK_EXECUTION_ORDER = {
   POST_TEST: ['AfterHook', 'AfterSuiteHook']
 };
 
-// codeceptjs workers are self-contained
-dataStorage.isFileStorage = false;
-
 const DATA_REGEXP = /[|\s]+?(\{".*\}|\[.*\])/;
 
 if (MAJOR_VERSION < 3) {

package/src/adapter/cucumber/current.js

@@ -113,7 +113,6 @@ class CucumberReporter extends Formatter {
     const logs = services.logger.getLogs(testTitle).join('\n');
     const artifacts = services.artifacts.get(testTitle);
     const keyValues = services.keyValues.get(testTitle);
-    const links = services.links.get(testTitle);
 
     this.client.addTestRun(status, {
       // error: testCaseAttempt.worstTestStepResult.message,
@@ -124,7 +123,6 @@ class CucumberReporter extends Formatter {
         .trim(),
       example: { ...example },
       logs,
-      links,
       manuallyAttachedArtifacts: artifacts,
       meta: keyValues,
       title: scenario,

package/src/adapter/jest.js

@@ -59,7 +59,6 @@ export class JestReporter {
       const logs = getTestLogs(result);
       const artifacts = services.artifacts.get(result.fullName);
       const keyValues = services.keyValues.get(result.fullName);
-      const links = services.links.get(result.fullName);
 
       const deducedStatus = status === 'pending' ? 'skipped' : status;
       // In jest if test is not matched with test name pattern it is considered as skipped.
@@ -73,7 +72,6 @@ export class JestReporter {
           title,
           time: duration,
           logs,
-          links,
           manuallyAttachedArtifacts: artifacts,
           meta: keyValues,
         });

package/src/adapter/playwright.js

@@ -58,7 +58,6 @@ class PlaywrightReporter {
     }
     const manuallyAttachedArtifacts = services.artifacts.get(fullTestTitle);
     const testMeta = services.keyValues.get(fullTestTitle);
-    const links = services.links.get(fullTestTitle);
     const rid = test.id || test.testId || uuidv4();
 
     /**
@@ -96,7 +95,6 @@ class PlaywrightReporter {
       steps: steps.length ? steps : undefined,
       time: duration,
       logs,
-      links,
       manuallyAttachedArtifacts,
       meta: {
         browser: project.browser,

package/src/adapter/webdriver.js

@@ -52,10 +52,14 @@ class WebdriverReporter extends WDIOReporter {
   onTestEnd(test) {
     test.suite = test.parent;
     const logs = getTestLogs(test.fullTitle);
-    test.artifacts = services.artifacts.get(test.fullTitle);
-    test.meta = services.keyValues.get(test.fullTitle);
-    test.links = services.links.get(test.fullTitle);
+    // TODO: FIX: artifacts for some reason leads to empty report on Testomat.io
+    // ^ 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;
 
     this._addTestPromises.push(this.addTest(test));
   }
@@ -70,7 +74,7 @@ class WebdriverReporter extends WDIOReporter {
   async addTest(test) {
     if (!this.client) return;
 
-    const { title, _duration: duration, state, error, output, links, artifacts, meta, logs } = test;
+    const { title, _duration: duration, state, error, output } = test;
 
     const testId = getTestomatIdFromTestTitle(title);
 
@@ -81,11 +85,10 @@ class WebdriverReporter extends WDIOReporter {
 
     await this.client.addTestRun(state, {
       rid: test.uid || '',
-      manuallyAttachedArtifacts: artifacts,
+      manuallyAttachedArtifacts: test.artifacts,
       error,
-      logs,
-      meta,
-      links,
+      logs: test.logs,
+      meta: test.meta,
       title,
       test_id: testId,
       time: duration,

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');
@@ -181,7 +182,6 @@ class Client {
       suite_id,
       test_id,
       timestamp,
-      links,
       manuallyAttachedArtifacts,
       overwrite,
     } = testData;
@@ -190,6 +190,35 @@ class Client {
     // stringify meta values and limit keys and values length to 255
     meta = Object.entries(meta)
       .filter(([, value]) => value !== null && value !== undefined)
+      .map(([key, value]) => {
+        try {
+          if (typeof value === 'object') {
+            value = JSON.stringify(value);
+          } else if (typeof value !== 'string') {
+            try {
+              value = value.toString();
+            } catch (err) {
+              console.warn(APP_PREFIX, `Can't convert meta value to string`, err);
+            }
+          }
+
+          if (value?.length > 255) {
+            value = value.substring(0, 255);
+            debug(APP_PREFIX, `Meta info value "${value}" is too long, trimmed to 255 characters`);
+          }
+
+          if (key?.length > 255) {
+            const newKey = key.substring(0, 255);
+            debug(APP_PREFIX, `Meta info key "${key}" is too long, trimmed to 255 characters`);
+            return [newKey, value];
+          }
+
+          return [key, value];
+        } catch (err) {
+          debug(APP_PREFIX, `Error while processing meta info key ${key}`, err);
+          return [null, null];
+        }
+      })
       .reduce((acc, [key, value]) => {
         if (key) acc[key] = value;
         return acc;
@@ -197,6 +226,7 @@ class Client {
 
     // 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) {

package/src/data-storage.js

@@ -116,7 +116,7 @@ class DataStorage {
     try {
       if (global?.testomatioDataStore[dataType]) {
         const testData = global.testomatioDataStore[dataType][context];
-        if (testData) debug('<=', dataType, 'global', context, testData);
+        if (testData) debug(`"${dataType}" data for constext "${context}":`, testData.join(', '));
         return testData || [];
       }
       // debug(`No ${this.dataType} data for context ${context} in <global> storage`);
@@ -137,7 +137,7 @@ class DataStorage {
       const filepath = join(dataDirPath, `${dataType}_${context}`);
       if (fs.existsSync(filepath)) {
         const testDataAsText = fs.readFileSync(filepath, 'utf-8');
-        if (testDataAsText) debug('<=', dataType, 'file', context, testDataAsText);
+        if (testDataAsText) debug(`"${dataType}" data for context "${context}":`, testDataAsText);
         const testDataArr = testDataAsText?.split(os.EOL) || [];
         return testDataArr;
       }
@@ -156,7 +156,7 @@ class DataStorage {
    * @param {*} context
    */
   #putDataToGlobalVar(dataType, data, context) {
-    debug('=>', dataType, 'global', context, data);
+    debug('Saving data to global variable for ', context, ':', data);
     if (!global.testomatioDataStore) global.testomatioDataStore = {};
     if (!global.testomatioDataStore?.[dataType]) global.testomatioDataStore[dataType] = {};
 
@@ -177,7 +177,7 @@ class DataStorage {
     const filename = `${dataType}_${context}`;
     const filepath = join(dataDirPath, filename);
     if (!fs.existsSync(dataDirPath)) fileSystem.createDir(dataDirPath);
-    debug('=>', dataType, 'file', context, data);
+    debug(`Saving data to file for context "${context}" to ${filepath}. Data: ${JSON.stringify(data)}`);
 
     // append new line if file already exists (in this case its definitely includes some data)
     if (fs.existsSync(filepath)) {
@@ -192,7 +192,8 @@ function stringToMD5Hash(str) {
   const md5 = crypto.createHash('md5');
   md5.update(str);
   const hash = md5.digest('hex');
-  return `${process.env.runId || 'run'}_${hash}`;
+
+  return hash;
 }
 
 export const dataStorage = DataStorage.getInstance();

package/src/reporter-functions.js

@@ -53,21 +53,24 @@ 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 (Array.isArray(value)) {
-    return value.forEach(label => setLabel(key, label));
+    value.forEach(val => setLabel(key, val));
+    return;
   }
-  const labelObject = value !== null && value !== undefined && value !== ''
-    ? { label: `${key}:${value}` }
+
+  const labelObject = value !== null && value !== undefined && value !== '' 
+    ? { label: `${key}:${value}` } 
     : { label: key };
   services.links.put([labelObject]);
 }
 
+
 /**
  * Add link(s) to the test report
  * @param {...string} testIds - test IDs to link
@@ -78,16 +81,6 @@ function linkTest(...testIds) {
   services.links.put(links);
 }
 
-/**
- * Add JIRA issue link(s) to the test report
- * @param {...string} jiraIds - JIRA issue IDs to link
- * @returns {void}
- */
-function linkJira(...jiraIds) {
-  const links = jiraIds.map(jiraId => ({ jira: jiraId }));
-  services.links.put(links);
-}
-
 export default {
   artifact: saveArtifact,
   log: logMessage,
@@ -95,5 +88,4 @@ export default {
   keyValue: setKeyValue,
   label: setLabel,
   linkTest,
-  linkJira,
 };

package/src/services/labels.js

@@ -1 +1,59 @@
+import createDebugMessages from 'debug';
+import { dataStorage } from '../data-storage.js';
 
+const debug = createDebugMessages('@testomatio/reporter:services-labels');
+class LabelStorage {
+  static #instance;
+
+  /**
+   *
+   * @returns {LabelStorage}
+   */
+  static getInstance() {
+    if (!this.#instance) {
+      this.#instance = new LabelStorage();
+    }
+    return this.#instance;
+  }
+
+  /**
+   * Stores labels array and passes it to reporter
+   * @param {string[]} labels - array of label strings
+   * @param {*} context - full test title
+   */
+  put(labels, context = null) {
+    if (!labels || !Array.isArray(labels)) return;
+    dataStorage.putData('links', labels, context);
+  }
+
+  /**
+   * Returns labels array for the test
+   * @param {*} context testId or test context from test runner
+   * @returns {string[]} labels array, e.g. ['smoke', 'severity:high', 'feature:user_account']
+   */
+  get(context = null) {
+    const labelsList = dataStorage.getData('links', context);
+    if (!labelsList || !labelsList?.length) return [];
+
+    const allLabels = [];
+    for (const labels of labelsList) {
+      if (Array.isArray(labels)) {
+        allLabels.push(...labels);
+      } else if (typeof labels === 'string') {
+        try {
+          const parsedLabels = JSON.parse(labels);
+          if (Array.isArray(parsedLabels)) {
+            allLabels.push(...parsedLabels);
+          }
+        } catch (e) {
+          debug(`Error parsing labels for test ${context}`, labels);
+        }
+      }
+    }
+
+    // Remove duplicates
+    return [...new Set(allLabels)];
+  }
+}
+
+export const labelStorage = LabelStorage.getInstance();