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

package/lib/utils/utils.js

@@ -321,7 +321,7 @@ const fileSystem = {
 exports.fileSystem = 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!`);
 };
 exports.foundedTestLog = foundedTestLog;
 const humanize = text => {
@@ -399,8 +399,6 @@ function storeRunId(runId) {
 function readLatestRunId() {
     try {
         const filePath = path_1.default.join(os_1.default.tmpdir(), `testomatio.latest.run`);
-        if (!fs_1.default.existsSync(filePath))
-            return null;
         const stats = fs_1.default.statSync(filePath);
         const diff = +new Date() - +stats.mtime;
         const diffHours = diff / 1000 / 60 / 60;

package/lib/xmlReader.d.ts

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

package/lib/xmlReader.js

@@ -131,9 +131,7 @@ class XmlReader {
         const { result, total, passed, failed, inconclusive, skipped } = jsonSuite;
         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(),
             create_tests: true,
@@ -141,7 +139,7 @@ class XmlReader {
             passed_count: parseInt(passed, 10),
             failed_count: parseInt(failed, 10),
             skipped_count: parseInt(inconclusive + skipped, 10),
-            tests: deduplicatedTests,
+            tests: resultTests,
         };
     }
     processTRX(jsonSuite) {
@@ -277,169 +275,6 @@ 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) {
-                    // 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,
@@ -595,8 +430,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 = '';
         if (testCaseItem.error)
@@ -616,20 +450,16 @@ 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();
         }
         stack = `${testCaseItem['system-out'] || testCaseItem.output || testCaseItem.log || ''}\n\n${stack}\n\n${suiteOutput}\n\n${suiteErr}`.trim();
@@ -678,7 +508,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,
@@ -687,51 +516,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 [];
@@ -743,14 +527,8 @@ function processTestSuite(testsuite) {
     if (!Array.isArray(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, []);
-    return [...childResults, ...leafResults];
+    const subSuites = suites.filter(s => s['test-suite'] && !testsuite['test-case']);
+    return [...subSuites.map(s => processTestSuite(s['test-suite'])), ...suites.reduce(reduceTestCases, [])].flat();
 }
 function fetchProperties(item) {
     const tags = [];

package/package.json

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

package/src/adapter/codecept.js

@@ -54,6 +54,8 @@ function CodeceptReporter(config) {
     say: output.say,
   };
 
+  output.stepShift = 0;
+
   output.debug = function(msg) {
     originalOutput.debug(msg);
     dataStorage.putData('log', repeat(this?.stepShift || 0) + pc.cyan(msg.toString()));
@@ -69,7 +71,6 @@ function CodeceptReporter(config) {
     originalOutput.log(msg);
     dataStorage.putData('log', repeat(this?.stepShift || 0) + pc.gray(msg));
   };
-  output.stepShift = 0;
 
   recorder.startUnlessRunning();
 
@@ -163,7 +164,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 links = services.links.get(test.fullTitle());
+    const labels = services.labels.get(test.fullTitle());
 
     services.setContext(null);
 
@@ -178,7 +179,7 @@ function CodeceptReporter(config) {
       files,
       steps: stepHierarchy, // Array of step objects per API schema
       logs,
-      links,
+      labels,
       manuallyAttachedArtifacts,
       meta: { ...keyValues, ...test.meta },
     });

package/src/adapter/mocha.js

@@ -61,7 +61,6 @@ 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,
@@ -73,7 +72,6 @@ function MochaReporter(runner, opts) {
       logs,
       manuallyAttachedArtifacts: artifacts,
       meta: keyValues,
-      links,
     });
   });
 
@@ -81,10 +79,6 @@ 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),
@@ -92,9 +86,6 @@ function MochaReporter(runner, opts) {
       file: getFile(test),
       test_id: testId,
       time: test.duration,
-      manuallyAttachedArtifacts: artifacts,
-      meta: keyValues,
-      links,
     });
   });
 
@@ -104,9 +95,6 @@ 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,
@@ -117,9 +105,6 @@ 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,13 +53,11 @@ 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
-    // ^ not reproduced anymore (Jul 2025)
-    // but still be under investigation
-    const artifacts = services.artifacts.get(test.fullTitle);
-    const keyValues = services.keyValues.get(test.fullTitle);
+    // const artifacts = services.artifacts.get(test.fullTitle);
+    // const keyValues = services.keyValues.get(test.fullTitle);
     test.logs = logs;
-    test.artifacts = artifacts;
-    test.meta = keyValues;
+    // test.artifacts = artifacts;
+    // test.meta = keyValues;
 
     this._addTestPromises.push(this.addTest(test));
   }

package/src/bin/startTest.js

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

package/src/client.js

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