testomatio-reporter-cli 2.9.1-beta.4-allure-step-status → 2.9.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testomatio-reporter-cli",
-  "version": "2.9.1-beta.4-allure-step-status",
+  "version": "2.9.2",
   "description": "Yarn Berry compatible standalone CLI for @testomatio/reporter",
   "type": "module",
   "bin": {

package/src/adapter/codecept.js

@@ -278,6 +278,8 @@ async function uploadAttachments(client, attachments, messagePrefix, attachmentT
     log.info(`Attachments: ${messagePrefix} ${attachments.length} ${attachmentType} ...`);
   }
 
+  await Promise.all(client.pipes?.map(pipe => pipe.addArtifacts?.(attachments)) || []);
+
   const promises = attachments.map(async attachment => {
     const { rid, title, path, type } = attachment;
     const file = { path, type, title };

package/src/adapter/playwright.js

@@ -48,14 +48,8 @@ class PlaywrightReporter {
     const { title } = test;
     const { error, duration } = result;
     const pwAttachments = (result.attachments || []).filter(a => a.body || a.path);
-
-    const files = pwAttachments
-      .map(att => ({
-        path: this.#getArtifactPath(att),
-        title: att.name || title,
-        type: att.contentType,
-      }))
-      .filter(f => f.path);
+    const files = buildArtifactFiles(pwAttachments, attachment => this.#getArtifactPath(attachment), title);
+    const artifactsForUpload = processArtifactsForUpload(pwAttachments);
 
     const suite_title = test.parent ? test.parent?.title : path.basename(test?.location?.file);
 
@@ -150,7 +144,7 @@ class PlaywrightReporter {
     this.uploads.push({
       rid: `${rid}-${project.name}`,
       title: test.title,
-      files: pwAttachments,
+      files: artifactsForUpload,
       file: test.location?.file,
     });
     // remove empty uploads
@@ -229,6 +223,25 @@ function checkStatus(status) {
   );
 }
 
+function buildArtifactFiles(attachments, getArtifactPath, title) {
+  return attachments
+    .filter(isScreenshotArtifact)
+    .map(attachment => ({
+      path: getArtifactPath(attachment),
+      title: attachment.name || title,
+      type: attachment.contentType,
+    }))
+    .filter(file => file.path);
+}
+
+function processArtifactsForUpload(attachments) {
+  return attachments.filter(attachment => !isScreenshotArtifact(attachment));
+}
+
+function isScreenshotArtifact(attachment) {
+  return attachment?.contentType === 'image/png' && attachment?.name === 'screenshot';
+}
+
 function appendStep(step, shift = 0) {
   // nesting too deep, ignore those steps
   if (shift >= 10) return;

package/src/bin/cli.js

@@ -6,7 +6,6 @@ import { glob } from 'glob';
 import createDebugMessages from 'debug';
 import TestomatClient from '../client.js';
 import XmlReader from '../xmlReader.js';
-import AllureReader from '../allureReader.js';
 import { APP_PREFIX, STATUS, DEBUG_FILE, BATCH_MODE } from '../constants.js';
 import { cleanLatestRunId, getPackageVersion, applyFilter } from '../utils/utils.js';
 import { config } from '../config.js';
@@ -17,6 +16,10 @@ import dotenv from 'dotenv';
 import Replay from '../replay.js';
 import { log } from '../utils/log.js';
 import { formatFilterListIds } from '../utils/pipe_utils.js';
+import fs from 'fs';
+import path from 'path';
+import { Gaxios } from 'gaxios';
+import { generateShortFilename } from '../adapter/utils/step-formatter.js';
 
 const debug = createDebugMessages('@testomatio/reporter:cli');
 const version = getPackageVersion();
@@ -352,47 +355,104 @@ program
     if (timeoutTimer) clearTimeout(timeoutTimer);
   });
 
-program
-  .command('allure')
-  .description('Parse Allure result files and upload to Testomat.io')
-  .argument('<pattern>', 'Allure result directory pattern')
-  .option('-d, --dir <dir>', 'Project directory')
-  .option('--timelimit <time>', 'default time limit in seconds to kill a stuck process')
-  .option('--with-package', 'Keep full package path in file names (default: strip package prefix)')
-  .action(async (pattern, opts) => {
-    const runReader = new AllureReader({ withPackage: opts.withPackage });
-
-    let timeoutTimer;
-    if (opts.timelimit) {
-      timeoutTimer = setTimeout(
-        () => {
-          console.log(
-            `⚠️  Reached timeout of ${opts.timelimit}s. Exiting... (Exit code is 0 to not fail the pipeline)`,
-          );
-          process.exit(0);
-        },
-        parseInt(opts.timelimit, 10) * 1000,
-      );
-    }
-
-    try {
-      await runReader.parse(pattern);
-      await runReader.createRun();
-      await runReader.uploadData();
-    } catch (err) {
-      console.log(APP_PREFIX, 'Error uploading Allure results:', err);
-    }
-
-    if (timeoutTimer) clearTimeout(timeoutTimer);
-  });
-
 program
   .command('upload-artifacts')
   .description('Upload artifacts to Testomat.io')
+  .argument('[jsonl-file]', 'Path to JSONL debug file (optional)')
   .option('--force', 'Re-upload artifacts even if they were uploaded before')
-  .action(async opts => {
+  .action(async (jsonlFile, opts) => {
     const apiKey = config.TESTOMATIO;
 
+    // JSONL file mode: upload artifacts from debug file
+    if (jsonlFile) {
+      if (!fs.existsSync(jsonlFile)) {
+        log.error(`JSONL file not found: ${jsonlFile}`);
+        return process.exit(1);
+      }
+
+      const replay = new Replay({ apiKey });
+      const { tests, runId } = replay.parseDebugFile(jsonlFile);
+
+      if (!runId) {
+        log.error('runId not found in JSONL file');
+        return process.exit(1);
+      }
+
+      log.info(`Processing ${tests.length} tests from ${jsonlFile}`);
+
+      const client = new TestomatClient({
+        apiKey,
+        runId,
+        batchMode: BATCH_MODE.DISABLED,
+      });
+
+      await client.createRun();
+      client.uploader.checkEnabled();
+      client.uploader.disableLogStorage();
+
+      const apiUrl = process.env.TESTOMATIO_URL || 'https://app.testomat.io';
+      const http = new Gaxios();
+      let uploadedCount = 0;
+      let failedCount = 0;
+
+      for (const test of tests) {
+        const testId = test.test_id;
+        if (!testId) continue;
+
+        const artifacts = [];
+
+        const collect = (items) => {
+          for (const item of items || []) {
+            const p = typeof item === 'object' ? item?.path : item;
+            if (p && fs.existsSync(p)) artifacts.push(p);
+          }
+        };
+        collect(test.files);
+
+        const walkSteps = (steps) => {
+          for (const step of steps || []) {
+            collect(step.artifacts);
+            walkSteps(step.steps);
+          }
+        };
+        walkSteps(test.steps);
+
+        if (artifacts.length === 0) continue;
+
+        const urls = [];
+        for (const artifact of artifacts) {
+          try {
+            const s3Id = test.rid || testId.replace('@', '');
+            const filename = generateShortFilename(artifact);
+            const result = await client.uploader.uploadFileByPath(artifact, [runId, s3Id, filename]);
+            if (result) urls.push(typeof result === 'string' ? result : result.link);
+          } catch (e) {
+            debug(`Failed to upload ${artifact}:`, e.message);
+          }
+        }
+
+        if (urls.length === 0) continue;
+
+        try {
+          await http.request({
+            method: 'POST',
+            url: `${apiUrl}/api/reporter/${runId}/testrun?api_key=${apiKey}`,
+            data: { test_id: testId, artifacts: urls },
+          });
+          uploadedCount++;
+        } catch (e) {
+          log.error(`Failed ${testId}: ${e.message}`);
+          failedCount++;
+        }
+      }
+
+      log.info(`🗄️ ${uploadedCount} tests with artifacts uploaded`);
+      if (failedCount > 0) {
+        log.warn(`⚠️ ${failedCount} tests failed to upload artifacts`);
+      }
+      return;
+    }
+
     process.env.TESTOMATIO_DISABLE_ARTIFACTS = '';
     const runId = process.env.TESTOMATIO_RUN || process.env.runId || readLatestRunId();
 

package/src/junit-adapter/index.js

@@ -4,7 +4,6 @@ import JavaAdapter from './java.js';
 import PythonAdapter from './python.js';
 import RubyAdapter from './ruby.js';
 import CSharpAdapter from './csharp.js';
-import KotlinAdapter from './kotlin.js';
 
 function AdapterFactory(lang, opts) {
   if (lang === 'java') {
@@ -22,9 +21,6 @@ function AdapterFactory(lang, opts) {
   if (lang === 'c#' || lang === 'csharp') {
     return new CSharpAdapter(opts);
   }
-  if (lang === 'kotlin') {
-    return new KotlinAdapter(opts);
-  }
 
   return new Adapter(opts);
 }

package/src/pipe/debug.js

@@ -111,6 +111,17 @@ export class DebugPipe {
     log.info(`History: ${this.historyDir}`);
   }
 
+  /**
+   * Logs artifacts data to the debug file.
+   * Used for trace.zip, video files and other artifacts uploaded after tests finish.
+   * @param {Array} artifacts - Array of artifacts with { rid, title, path, type }
+   */
+  addArtifacts(artifacts) {
+    if (!this.isEnabled || !artifacts?.length) return;
+    const logData = { action: 'addArtifacts', artifacts, runId: this.store.runId };
+    this.logToFile(logData);
+  }
+
   async sync() {
     this.flushBufferedTests();
   }

package/src/replay.js

@@ -49,6 +49,7 @@ export class Replay {
     const testsWithoutRid = []; // For tests without rid (backward compatibility)
     const envVars = {};
     let runId = null;
+    const artifactsToAdd = []; // Store artifacts to add after all tests are loaded
 
     // Parse debug file line by line
     for (const [lineIndex, line] of lines.entries()) {
@@ -119,6 +120,11 @@ export class Replay {
             // Handle tests without rid (no deduplication)
             testsWithoutRid.push({ ...test });
           }
+        } else if (logEntry.action === 'addArtifacts' && logEntry.artifacts) {
+          if (logEntry.runId && !runId) {
+            runId = logEntry.runId;
+          }
+          artifactsToAdd.push(...logEntry.artifacts);
         } else if (logEntry.action === 'finishRun') {
           finishParams = logEntry.params || {};
           if (logEntry.runId && !runId) {
@@ -138,6 +144,21 @@ export class Replay {
       this.onError(`${parseErrors - 3} more parse errors occurred`);
     }
 
+    for (const artifact of artifactsToAdd) {
+      if (artifact.rid) {
+        const ridToFind = artifact.rid;
+        const fullRid = runId ? `${runId}-${ridToFind}` : ridToFind;
+
+        const test = testsMap.get(fullRid) || testsMap.get(ridToFind);
+        if (test && artifact.path) {
+          if (!test.files) test.files = [];
+          if (!test.files.includes(artifact.path)) {
+            test.files.push(artifact.path);
+          }
+        }
+      }
+    }
+
     // Combine tests with rid and tests without rid
     const allTests = [...Array.from(testsMap.values()), ...testsWithoutRid];
 

package/src/template/testomatio.hbs

@@ -681,8 +681,9 @@
 
         .test-group-header {
             padding: 20px;
-            background: linear-gradient(135deg, var(--primary-color) 0%, var(--primary-hover) 100%);
-            color: white;
+            background: var(--gray-50);
+            color: var(--gray-800);
+            border-left: 4px solid var(--primary-color);
             cursor: pointer;
             display: flex;
             justify-content: space-between;
@@ -691,7 +692,37 @@
         }
 
         .test-group-header:hover {
-            filter: brightness(1.1);
+            background: var(--gray-100);
+        }
+
+        .test-group-header.has-failures {
+            background: #fef2f2;
+            color: var(--gray-900);
+            border-left-color: var(--danger-color);
+        }
+
+        .test-group-header.has-failures:hover {
+            background: #fee2e2;
+        }
+
+        .test-group-header.has-skips {
+            background: #fffbeb;
+            color: var(--gray-900);
+            border-left-color: var(--warning-color);
+        }
+
+        .test-group-header.has-skips:hover {
+            background: #fef3c7;
+        }
+
+        .test-group-header.all-passed {
+            background: #ecfdf5;
+            color: var(--gray-900);
+            border-left-color: var(--success-color);
+        }
+
+        .test-group-header.all-passed:hover {
+            background: #d1fae5;
         }
 
         .test-group-title {
@@ -707,28 +738,56 @@
         }
 
         .test-group-count {
-            background: rgba(255, 255, 255, 0.2);
+            background: white;
+            color: var(--gray-600);
             padding: 6px 16px;
             border-radius: 20px;
             font-size: 14px;
             font-weight: 600;
+            border: 1px solid var(--gray-200);
         }
 
         .test-group-stats {
             display: flex;
-            gap: 20px;
+            gap: 8px;
             font-size: 14px;
             margin-right: 10px;
+            flex-wrap: wrap;
+            justify-content: flex-end;
         }
 
         .test-group-stat {
             display: flex;
             align-items: center;
             gap: 6px;
+            padding: 6px 10px;
+            border-radius: 999px;
+            font-weight: 700;
+            background: white;
+            border: 1px solid currentColor;
         }
 
-        .test-group-expand {
+        .test-group-stat.passed {
+            color: var(--success-color);
+        }
+
+        .test-group-stat.failed {
             color: white;
+            background: var(--danger-color);
+            border-color: var(--danger-color);
+            box-shadow: 0 1px 3px rgba(239, 68, 68, 0.35);
+        }
+
+        .test-group-stat.skipped {
+            color: var(--warning-color);
+        }
+
+        .test-group-stat.todo {
+            color: #8b5cf6;
+        }
+
+        .test-group-expand {
+            color: var(--gray-500);
             transition: var(--transition);
             font-size: 18px;
         }
@@ -3366,11 +3425,18 @@
             const failedCount = group.tests.filter(t => t.status.toLowerCase() === 'failed').length;
             const skippedCount = group.tests.filter(t => t.status.toLowerCase() === 'skipped').length;
             const todoCount = group.tests.filter(t => t.status.toLowerCase() === 'todo').length;
+            const groupStateClass = failedCount > 0
+                ? 'has-failures'
+                : skippedCount > 0 || todoCount > 0
+                    ? 'has-skips'
+                    : passedCount > 0
+                        ? 'all-passed'
+                        : '';
 
             const groupIcon = group.type === 'suite' ? 'layer-group' : 'file-code';
 
             const header = document.createElement('div');
-            header.className = 'test-group-header';
+            header.className = ['test-group-header', groupStateClass].filter(Boolean).join(' ');
             header.innerHTML = `
                 <div class='test-group-title'>
                     <i class='fas fa-${groupIcon}'></i>
@@ -3378,10 +3444,10 @@
                     <div class='test-group-count'>${group.tests.length} tests</div>
                 </div>
                 <div class='test-group-stats'>
-                    ${passedCount > 0 ? `<div class='test-group-stat' style='color: #10b981;'><i class='fas fa-check-circle'></i> ${passedCount}</div>` : ''}
-                    ${failedCount > 0 ? `<div class='test-group-stat' style='color: #ef4444;'><i class='fas fa-times-circle'></i> ${failedCount}</div>` : ''}
-                    ${skippedCount > 0 ? `<div class='test-group-stat' style='color: #f59e0b;'><i class='fas fa-forward'></i> ${skippedCount}</div>` : ''}
-                    ${todoCount > 0 ? `<div class='test-group-stat' style='color: #8b5cf6;'><i class='fas fa-clock'></i> ${todoCount}</div>` : ''}
+                    ${passedCount > 0 ? `<div class='test-group-stat passed'><i class='fas fa-check-circle'></i> ${passedCount}</div>` : ''}
+                    ${failedCount > 0 ? `<div class='test-group-stat failed'><i class='fas fa-times-circle'></i> ${failedCount}</div>` : ''}
+                    ${skippedCount > 0 ? `<div class='test-group-stat skipped'><i class='fas fa-forward'></i> ${skippedCount}</div>` : ''}
+                    ${todoCount > 0 ? `<div class='test-group-stat todo'><i class='fas fa-clock'></i> ${todoCount}</div>` : ''}
                 </div>
                 <i class='fas fa-chevron-down test-group-expand'></i>
             `;

package/src/utils/pipe_utils.js

@@ -161,53 +161,6 @@ function parsePipeOptions(optionsStr) {
   return options;
 }
 
-/**
- * Calculate the approximate size of data in bytes (JSON stringified, UTF-8 encoded length).
- * @param {Object} data - Data to measure
- * @returns {number} Size in bytes
- */
-function getObjectSize(data) {
-  const body = JSON.stringify(data);
-  return new TextEncoder().encode(body).length;
-}
-
-/**
- * Split a tests array into chunks bounded by serialized size.
- * Used by the XML and Allure readers so both upload tests with identical batching:
- * each chunk becomes a single batch request (manual batch mode), which keeps requests
- * under the size limit and guarantees every test is sent exactly once.
- *
- * @param {Array} tests - Array of tests to split
- * @param {number} [maxSizeBytes=1048576] - Maximum serialized size per chunk (default 1MB)
- * @returns {Array<Array>} Array of test chunks
- */
-function splitTestsIntoChunks(tests, maxSizeBytes = 1 * 1024 * 1024) {
-  const chunks = [];
-  let currentChunk = [];
-  let currentChunkSize = 0;
-
-  for (const test of tests) {
-    const testSize = getObjectSize(test);
-
-    const wouldExceedSize = currentChunkSize + testSize > maxSizeBytes;
-
-    if (wouldExceedSize && currentChunk.length > 0) {
-      chunks.push(currentChunk);
-      currentChunk = [];
-      currentChunkSize = 0;
-    }
-
-    currentChunk.push(test);
-    currentChunkSize += testSize;
-  }
-
-  if (currentChunk.length > 0) {
-    chunks.push(currentChunk);
-  }
-
-  return chunks;
-}
-
 /**
  * Format a list of test IDs for `--filter-list` machine-readable output.
  * Used when the CLI `--format` option is passed,
@@ -237,6 +190,4 @@ export {
   fullName,
   parsePipeOptions,
   formatFilterListIds,
-  getObjectSize,
-  splitTestsIntoChunks,
 };

package/src/utils/utils.js

@@ -289,11 +289,6 @@ const fetchSourceCode = (contents, opts = {}) => {
       if (lineIndex === -1) lineIndex = lines.findIndex(l => l.includes(`@DisplayName("${title}`));
       if (lineIndex === -1) lineIndex = lines.findIndex(l => l.includes(`public void ${title}`));
       if (lineIndex === -1) lineIndex = lines.findIndex(l => l.includes(`${title}(`));
-    } else if (opts.lang === 'kotlin') {
-      lineIndex = lines.findIndex(l => l.includes(`fun test${title}`));
-      if (lineIndex === -1) lineIndex = lines.findIndex(l => l.includes(`@DisplayName("${title}`));
-      if (lineIndex === -1) lineIndex = lines.findIndex(l => l.includes(`fun ${title}`));
-      if (lineIndex === -1) lineIndex = lines.findIndex(l => l.includes(`${title}(`));
     } else if (opts.lang === 'csharp') {
       // Find the method declaration line
       let methodLineIndex = lines.findIndex(l => l.includes(`public void ${title}(`));

package/src/xmlReader.js

@@ -18,7 +18,6 @@ import {
   transformEnvVarToBoolean,
 } from './utils/utils.js';
 import { pipesFactory } from './pipe/index.js';
-import { splitTestsIntoChunks } from './utils/pipe_utils.js';
 import adapterFactory from './junit-adapter/index.js';
 import { config } from './config.js';
 import { S3Uploader } from './uploader.js';
@@ -554,6 +553,52 @@ class XmlReader {
     return run;
   }
 
+  /**
+   * Calculate the approximate size of data in bytes (JSON stringified length)
+   * @param {Object} data - Data to measure
+   * @returns {number} Size in bytes
+   */
+  #getObjectSize(data) {
+    const body = JSON.stringify(data);
+    return new TextEncoder().encode(body).length;
+  }
+
+  /**
+   * Split tests array into chunks based on data size
+   * @param {Array} tests - Array of tests to split
+   * @returns {Array<Array>} Array of test chunks
+   */
+  #splitTestsIntoChunks(tests) {
+    const maxSizeBytes = 1 * 1024 * 1024;
+
+    const chunks = [];
+    let currentChunk = [];
+    let currentChunkSize = 0;
+
+    for (const test of tests) {
+      const testSize = this.#getObjectSize(test);
+
+      const wouldExceedSize = currentChunkSize + testSize > maxSizeBytes;
+
+      if (wouldExceedSize) {
+        if (currentChunk.length > 0) {
+          chunks.push(currentChunk);
+        }
+        currentChunk = [];
+        currentChunkSize = 0;
+      }
+
+      currentChunk.push(test);
+      currentChunkSize += testSize;
+    }
+
+    if (currentChunk.length > 0) {
+      chunks.push(currentChunk);
+    }
+
+    return chunks;
+  }
+
   async uploadData() {
     await this.uploadArtifacts();
     this.calculateStats();
@@ -578,7 +623,7 @@ class XmlReader {
       return Promise.all(this.pipes.map(p => p.finishRun(finishData)));
     }
 
-    const testChunks = splitTestsIntoChunks(this.tests);
+    const testChunks = this.#splitTestsIntoChunks(this.tests);
 
     const totalChunks = testChunks.length;
     const totalTests = this.tests.length;

package/src/allureReader.js

@@ -1,691 +0,0 @@
-import createDebugMessages from 'debug';
-import path from 'path';
-import pc from 'picocolors';
-import fs from 'fs';
-import { glob } from 'glob';
-import { APP_PREFIX, STATUS, BATCH_MODE } from './constants.js';
-import { randomUUID } from 'crypto';
-import { fileURLToPath } from 'url';
-import { config } from './config.js';
-import { S3Uploader } from './uploader.js';
-import { pipesFactory } from './pipe/index.js';
-import { splitTestsIntoChunks } from './utils/pipe_utils.js';
-import {
-  fetchSourceCode,
-  fetchIdFromCode,
-} from './utils/utils.js';
-import adapterFactory from './junit-adapter/index.js';
-
-// @ts-ignore
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-const debug = createDebugMessages('@testomatio/reporter:allure');
-
-const TESTOMATIO_URL = process.env.TESTOMATIO_URL || 'https://app.testomat.io';
-const { TESTOMATIO_RUNGROUP_TITLE, TESTOMATIO_SUITE, TESTOMATIO_TITLE, TESTOMATIO_ENV, TESTOMATIO_RUN } = process.env;
-
-class AllureReader {
-  constructor(opts = {}) {
-    this.requestParams = {
-      apiKey: opts.apiKey || config.TESTOMATIO,
-      url: opts.url || TESTOMATIO_URL,
-      title: TESTOMATIO_TITLE,
-      env: TESTOMATIO_ENV,
-      group_title: TESTOMATIO_RUNGROUP_TITLE,
-      // Buffer tests and flush them manually in size-limited chunks, exactly like XmlReader.
-      // No setInterval auto-upload means each test is sent exactly once (no double-send).
-      batchMode: BATCH_MODE.MANUAL,
-    };
-    this.runId = opts.runId || TESTOMATIO_RUN;
-    this.opts = opts || {};
-    this.withPackage = opts.withPackage || false;
-    this.store = {};
-    this.pipesPromise = pipesFactory(opts, this.store);
-    this._tests = [];
-    this.stats = {};
-    this.suites = {};
-    this.uploader = new S3Uploader();
-
-    // Allure results already contain steps and stack traces for all tests,
-    // so enable passing them for passed tests by default
-    if (!process.env.TESTOMATIO_STACK_PASSED) {
-      process.env.TESTOMATIO_STACK_PASSED = '1';
-    }
-    if (!process.env.TESTOMATIO_STEPS_PASSED) {
-      process.env.TESTOMATIO_STEPS_PASSED = '1';
-    }
-
-    const packageJsonPath = path.resolve(__dirname, '..', 'package.json');
-    this.version = JSON.parse(fs.readFileSync(packageJsonPath).toString()).version;
-    console.log(APP_PREFIX, `Testomatio Reporter v${this.version}`);
-  }
-
-  get tests() {
-    return this._tests;
-  }
-
-  set tests(value) {
-    this._tests = value;
-  }
-
-  async createRun() {
-    const runParams = {
-      api_key: this.requestParams.apiKey,
-      title: this.requestParams.title,
-      env: this.requestParams.env,
-      group_title: this.requestParams.group_title,
-      batchMode: this.requestParams.batchMode,
-    };
-
-    debug('Run', runParams);
-    this.pipes = this.pipes || (await this.pipesPromise);
-
-    const run = await Promise.all(this.pipes.map(p => p.createRun(runParams)));
-    this.uploader.checkEnabled();
-    return run;
-  }
-
-  parse(resultsPattern) {
-    this._tests = [];
-    let pattern = resultsPattern;
-
-    // Auto-append wildcard if pattern refers to a directory (like XML command does)
-    if (!pattern.endsWith('.json') && !pattern.includes('*')) {
-      if (pattern.endsWith('/') || (fs.existsSync(pattern) && fs.statSync(pattern).isDirectory())) {
-        pattern = pattern.replace(/\/+$/, '') + '/*-result.json';
-      } else {
-        pattern += '*-result.json';
-      }
-    }
-
-    const resultsDir = path.dirname(pattern);
-
-    console.log(APP_PREFIX, `Scanning for Allure results in: ${resultsDir}`);
-    console.log(APP_PREFIX, `Using pattern: ${pattern}`);
-
-    const resultFiles = glob.sync(pattern);
-    const containerFiles = glob.sync(pattern.replace('*-result.json', '*-container.json'));
-
-    if (resultFiles.length === 0 && containerFiles.length === 0) {
-      throw new Error(`No Allure result files found matching pattern: ${pattern}`);
-    }
-
-    console.log(APP_PREFIX, `Found ${resultFiles.length} result files and ${containerFiles.length} container files`);
-
-    this.parseContainerFiles(containerFiles);
-
-    // Store all tests temporarily for deduplication by historyId
-    const allTests = [];
-    for (const file of resultFiles) {
-      const fullPath = file;
-      const fileDir = path.dirname(file);
-      try {
-        const resultData = JSON.parse(fs.readFileSync(fullPath, 'utf8'));
-        const test = this.processAllureResult(resultData, fileDir);
-        if (test) {
-          test._historyId = resultData.historyId;
-          test._stop = resultData.stop || 0;
-          allTests.push(test);
-        }
-      } catch (err) {
-        console.warn(APP_PREFIX, `Failed to parse ${file}:`, err.message);
-        debug('Parse error:', err);
-      }
-    }
-
-    const attemptsMap = new Map();
-    for (const test of allTests) {
-      const historyId = test._historyId || test.rid;
-      if (!attemptsMap.has(historyId)) {
-        attemptsMap.set(historyId, []);
-      }
-      attemptsMap.get(historyId).push(test);
-    }
-
-    const uniqueTestsMap = new Map();
-    for (const [historyId, attempts] of attemptsMap) {
-      uniqueTestsMap.set(historyId, this.combineRetryAttempts(attempts));
-    }
-
-    // Convert map to array and clean up internal fields
-    this._tests = Array.from(uniqueTestsMap.values()).map(t => {
-      delete t._historyId;
-      delete t._stop;
-      return t;
-    });
-
-    console.log(APP_PREFIX, `Processed ${this._tests.length} unique tests (from ${allTests.length} result files)`);
-
-    return this.calculateStats();
-  }
-
-  parseContainerFiles(containerFiles) {
-    for (const file of containerFiles) {
-      try {
-        const data = JSON.parse(fs.readFileSync(file, 'utf8'));
-        if (data.name && data.children) {
-          data.children.forEach(uuid => {
-            this.suites[uuid] = data.name;
-          });
-        }
-      } catch (err) {
-        debug('Failed to parse container file:', file, err.message);
-      }
-    }
-    debug('Parsed suites:', this.suites);
-  }
-
-  processAllureResult(result, resultsDir) {
-    const test = {
-      rid: result.uuid || randomUUID(),
-      title: result.name || 'Unknown test',
-      status: this.mapStatus(result.status),
-      suite_title: this.extractSuiteTitle(result),
-      file: this.extractFile(result),
-      run_time: this.calculateRunTime(result),
-      steps: this.convertSteps(result.steps || []),
-      message: result.statusDetails?.message || '',
-      stack: result.statusDetails?.trace || '',
-      meta: this.extractMeta(result),
-      links: this.extractLinks(result),
-      artifacts: [],
-      create: true,
-      overwrite: true,
-    };
-
-    // Use the @TmsLink / Testomat.io link as the test id so reported tests MATCH
-    // existing cases instead of creating duplicates on every run.
-    const testId = this.extractTestId(result);
-    if (testId) {
-      test.test_id = testId;
-    }
-
-    // Add description if present
-    if (result.description) {
-      test.description = result.description;
-    }
-
-    if (result.parameters && result.parameters.length > 0) {
-      test.example = this.convertParameters(result.parameters);
-    }
-
-    if (result.attachments && result.attachments.length > 0) {
-      const attachments = result.attachments
-        .map(att => {
-          const fullPath = path.join(resultsDir, att.source);
-          if (fs.existsSync(fullPath)) {
-            return fullPath;
-          }
-          debug('Attachment file not found:', fullPath);
-          return null;
-        })
-        .filter(Boolean);
-
-      if (attachments.length > 0) {
-        test.files = attachments;
-      }
-    }
-
-    return test;
-  }
-
-  mapStatus(status) {
-    const statusMap = {
-      passed: 'passed',
-      failed: 'failed',
-      broken: 'failed',
-      skipped: 'skipped',
-      pending: 'skipped',
-    };
-    return statusMap[status] || 'failed';
-  }
-
-  /**
-   * Map an Allure step status to the Testomat.io Step status enum
-   * (`passed | failed | none | custom`, see testomat-api-definition.yml).
-   *
-   * Allure marks a step `broken` when it threw an unexpected error — that is a
-   * failure for reporting purposes, matching how `mapStatus` treats tests.
-   * `skipped` and anything unknown/absent become `none` (the neutral value),
-   * since the step enum has no `skipped`.
-   *
-   * @param {string} status - Allure step status
-   * @returns {'passed'|'failed'|'none'} Testomat.io step status
-   */
-  mapStepStatus(status) {
-    const statusMap = {
-      passed: 'passed',
-      failed: 'failed',
-      broken: 'failed',
-      skipped: 'none',
-      pending: 'none',
-    };
-    return statusMap[status] || 'none';
-  }
-
-  extractSuiteTitle(result) {
-    const labels = result.labels || [];
-
-    // Only use suite label for suite_title
-    // Epic and Feature are sent as separate labels in meta
-    const suiteLabel = labels.find(l => l.name === 'suite')?.value;
-
-    if (suiteLabel) {
-      return this.stripNamespace(suiteLabel);
-    }
-
-    // Fallback to parentSuite or subSuite if no suite label
-    const parentSuite = labels.find(l => l.name === 'parentSuite')?.value;
-    const subSuite = labels.find(l => l.name === 'subSuite')?.value;
-
-    if (parentSuite && subSuite) {
-      return `${parentSuite} / ${subSuite}`;
-    }
-    if (parentSuite) return parentSuite;
-    if (subSuite) return subSuite;
-
-    return 'Default Suite';
-  }
-
-  stripNamespace(suiteName) {
-    if (suiteName && suiteName.includes('.')) {
-      return suiteName.split('.').pop();
-    }
-    return suiteName;
-  }
-
-  extractFile(result) {
-    const labels = result.labels || [];
-    const packageLabel = labels.find(l => l.name === 'package')?.value;
-    const testClassLabel = labels.find(l => l.name === 'testClass')?.value;
-
-    if (!packageLabel) {
-      return null;
-    }
-
-    const ext = this.getFileExtension(result);
-    let className;
-
-    if (testClassLabel) {
-      className = testClassLabel.split('.').pop();
-    } else if (result.fullName) {
-      const fullNameParts = result.fullName.split('.');
-      className = fullNameParts[fullNameParts.length - 2] || fullNameParts[fullNameParts.length - 1];
-    } else {
-      return null;
-    }
-
-    if (this.withPackage) {
-      const parts = packageLabel.split('.');
-      return `${parts.join('/')}/${className}.${ext}`;
-    }
-
-    return `${className}.${ext}`;
-  }
-
-  getFileExtension(result) {
-    const labels = result.labels || [];
-    const languageLabel = labels.find(l => l.name === 'language')?.value;
-
-    const extMap = {
-      java: 'java',
-      kotlin: 'kt',
-      javascript: 'js',
-      typescript: 'ts',
-      python: 'py',
-      ruby: 'rb',
-      'c#': 'cs',
-      php: 'php',
-    };
-
-    return extMap[languageLabel?.toLowerCase()] || 'java';
-  }
-
-  extractMeta(result) {
-    const labels = result.labels || [];
-    const excludedLabels = [
-      'suite', 'package', 'parentSuite', 'subSuite',
-      'testClass', 'testMethod', 'epic', 'feature',
-    ];
-
-    const meta = {};
-    labels.forEach(label => {
-      if (!excludedLabels.includes(label.name)) {
-        meta[label.name] = label.value;
-      }
-    });
-
-    return meta;
-  }
-
-  extractLinks(result) {
-    const labels = result.labels || [];
-    const links = [];
-
-    const epicLabel = labels.find(l => l.name === 'epic');
-    const featureLabel = labels.find(l => l.name === 'feature');
-
-    if (epicLabel?.value) {
-      links.push({ label: `epic:${epicLabel.value}` });
-    }
-
-    if (featureLabel?.value) {
-      links.push({ label: `feature:${featureLabel.value}` });
-    }
-
-    return links.length > 0 ? links : undefined;
-  }
-
-  /**
-   * Extract a Testomat.io test id from Allure links so reported tests match
-   * existing cases instead of creating duplicates.
-   *
-   * Allure's `@TmsLink("T1a2b3c4d")` produces a link with `type: "tms"`. Some exporters
-   * omit the type but still point the link URL at a Testomat.io test page; both are
-   * accepted. The link `name` is used as the id (falling back to the last URL segment).
-   *
-   * @param {object} result - Parsed Allure result JSON
-   * @returns {string|null} Normalized test id, or null when no usable link exists
-   */
-  extractTestId(result) {
-    const links = result.links || [];
-    if (!links.length) return null;
-
-    const isTmsLink = l => typeof l?.type === 'string' && l.type.toLowerCase() === 'tms';
-    const isTestomatioLink = l => typeof l?.url === 'string' && /testomat\.io\/[^\s]*\/test\//i.test(l.url);
-
-    const link = links.find(isTmsLink) || links.find(isTestomatioLink);
-    if (!link) return null;
-
-    // Prefer the explicit link name; fall back to the id segment of a Testomat.io URL.
-    let id = this.normalizeTestId(link.name);
-    if (!id && typeof link.url === 'string') {
-      const fromUrl = link.url.match(/\/test\/([\w\d]{8})(?=$|[/?#])/i);
-      if (fromUrl) id = fromUrl[1];
-    }
-
-    return id;
-  }
-
-  /**
-   * Normalize a value into a Testomat.io test id.
-   *
-   * Testomat.io test ids are exactly **8 word characters**. The value may arrive bare
-   * (`1a2b3c4d`), or carrying the `T` / `@T` markers Testomat uses in code and titles
-   * (`T1a2b3c4d`, `@T1a2b3c4d`). The markers are removed only when doing so still leaves
-   * a valid 8-char id, so a real id that happens to start with `T` is preserved.
-   *
-   * Anything that does not resolve to a valid 8-char id — a numeric Allure TestOps id
-   * like `12345`, a JIRA key, a 6-digit TMS number — is rejected (returns null) so we
-   * never send an unmatchable id that would create duplicates.
-   *
-   * @param {string|number|null|undefined} value
-   * @returns {string|null} The bare 8-char id, or null when the value is not a valid id
-   */
-  normalizeTestId(value) {
-    if (value === null || value === undefined) return null;
-    const match = value.toString().trim().match(/^@?T?([\w\d]{8})$/);
-    return match ? match[1] : null;
-  }
-
-  convertSteps(steps, depth = 0) {
-    if (depth >= 10) return null;
-
-    return steps
-      .map(step => {
-        const convertedStep = {
-          category: 'user',
-          title: step.name || step.title || 'Unknown step',
-          status: this.mapStepStatus(step.status),
-          duration: this.calculateRunTime(step),
-          steps: this.convertSteps(step.steps || [], depth + 1),
-        };
-
-        // Attach the failure description (error message + trace with the failing
-        // code line) straight onto the failed step. Testomat.io renders a step's
-        // `error` inline in the step tree, so the failure shows up on the exact
-        // step that broke instead of only at the test level.
-        const error = this.extractStepError(step);
-        if (error) {
-          convertedStep.error = error;
-        }
-
-        if (convertedStep.steps && convertedStep.steps.length === 0) {
-          delete convertedStep.steps;
-        }
-
-        if (convertedStep.duration === 0) {
-          delete convertedStep.duration;
-        }
-
-        return convertedStep;
-      })
-      .filter(Boolean);
-  }
-
-  /**
-   * Build the `error` payload for a failed step from its Allure `statusDetails`.
-   *
-   * Allure stores the failure message and stack trace (which includes the failing
-   * source line) in `statusDetails` on the step itself. We only surface it for
-   * failed/broken steps — passing or skipped steps carry no error. Returns null
-   * when there is no usable failure information so the field is omitted entirely.
-   *
-   * @param {object} step - Allure step
-   * @returns {{message: string, stack: string}|null}
-   */
-  extractStepError(step) {
-    if (this.mapStepStatus(step.status) !== 'failed') return null;
-
-    const details = step.statusDetails || {};
-    const message = details.message || '';
-    const stack = details.trace || '';
-
-    if (!message && !stack) return null;
-
-    return { message, stack };
-  }
-
-  calculateRunTime(item) {
-    if (item.start && item.stop) {
-      const durationMs = item.stop - item.start;
-      return durationMs / 1000;
-    }
-    return null;
-  }
-
-  convertParameters(parameters) {
-    const example = {};
-    parameters.forEach(param => {
-      if (param.name) {
-        example[param.name] = param.value;
-      }
-    });
-    return example;
-  }
-
-  combineRetryAttempts(attempts) {
-    attempts.sort((a, b) => (a._stop || 0) - (b._stop || 0));
-
-    const finalTest = attempts[attempts.length - 1];
-    const retryCount = attempts.length - 1;
-
-    if (retryCount > 0) {
-      finalTest.retries = retryCount;
-    }
-
-    const failedAttempts = attempts.filter(t => t.status === 'failed');
-
-    if (failedAttempts.length === 0) {
-      return finalTest;
-    }
-
-    const failureMessages = [];
-    const failureStacks = [];
-
-    for (const failed of failedAttempts) {
-      const attemptNum = attempts.indexOf(failed) + 1;
-      if (failed.message) {
-        failureMessages.push(`[Attempt ${attemptNum}] ${failed.message}`);
-      }
-      if (failed.stack) {
-        failureStacks.push(`\n--- Attempt ${attemptNum} ---\n${failed.stack}`);
-      }
-    }
-
-    if (failureMessages.length > 0) {
-      finalTest.message = failureMessages.join('\n');
-    }
-    if (failureStacks.length > 0) {
-      finalTest.stack = failureStacks.join('\n');
-    }
-
-    if (finalTest.status === 'passed') {
-      finalTest.status = 'failed';
-      const retryMsg = `Test passed after ${failedAttempts.length} retries. Previous failures:\n`;
-      finalTest.message = retryMsg + finalTest.message;
-    }
-
-    return finalTest;
-  }
-
-  calculateStats() {
-    this.stats = {
-      create_tests: true,
-      tests_count: this._tests.length,
-      passed_count: 0,
-      failed_count: 0,
-      skipped_count: 0,
-      duration: 0,
-      status: 'passed',
-      tests: this._tests,
-    };
-    this._tests.forEach(t => {
-      if (t.status === 'passed') this.stats.passed_count++;
-      if (t.status === 'failed') this.stats.failed_count++;
-      if (t.status === 'skipped') this.stats.skipped_count++;
-    });
-    this.stats.duration = this._tests.reduce((acc, t) => acc + (t.run_time || 0), 0);
-    if (this.stats.failed_count) this.stats.status = 'failed';
-
-    debug('Stats:', this.stats);
-    return this.stats;
-  }
-
-  fetchSourceCode() {
-    const adapter = this.adapter || adapterFactory(this.getLanguage(), this.opts);
-
-    this._tests.forEach(t => {
-      try {
-        let filePath = t.file;
-
-        if (adapter && adapter.getFilePath) {
-          filePath = adapter.getFilePath(t);
-        }
-
-        if (!filePath) return;
-
-        if (!fs.existsSync(filePath)) {
-          debug('Source file not found:', filePath);
-          return;
-        }
-
-        const contents = fs.readFileSync(filePath).toString();
-        const code = fetchSourceCode(contents, { ...t, lang: this.getLanguage() });
-        if (code) {
-          t.code = code;
-          debug('Fetched code for test %s', t.title);
-        }
-
-        // Don't override an id already taken from a @TmsLink — the link is the
-        // explicit, source-independent match key the client maintains.
-        const testId = fetchIdFromCode(contents, { lang: this.getLanguage() });
-        if (testId && !t.test_id) {
-          t.test_id = testId;
-          debug('Fetched test id %s for test %s', testId, t.title);
-        }
-      } catch (err) {
-        debug('Failed to fetch source code:', err.message);
-      }
-    });
-  }
-
-  getLanguage() {
-    if (this._tests.length === 0) return null;
-    return this._tests[0].meta?.language || this.opts.lang;
-  }
-
-  async uploadArtifacts() {
-    for (const test of this._tests.filter(t => t.files && t.files.length > 0)) {
-      const runId = this.runId || this.store.runId || Date.now().toString();
-      const artifacts = await Promise.all(
-        test.files.map(f => this.uploader.uploadFileByPath(f, [runId, test.rid, path.basename(f)])),
-      );
-      test.artifacts = artifacts.filter(a => a && a.link).map(a => a.link);
-      delete test.files;
-      if (test.artifacts.length > 0) {
-        console.log(APP_PREFIX, `🗄️ Uploaded ${pc.bold(`${test.artifacts.length} artifacts`)} for test ${test.title}`);
-      }
-    }
-  }
-
-  async uploadData() {
-    await this.uploadArtifacts();
-    this.calculateStats();
-    this.fetchSourceCode();
-
-    this.pipes = this.pipes || (await this.pipesPromise);
-
-    const finishData = {
-      api_key: this.requestParams.apiKey,
-      status: 'finished',
-      duration: this.stats.duration,
-    };
-
-    if (!this._tests || !Array.isArray(this._tests) || this._tests.length === 0) {
-      debug('No tests to upload, finishing run');
-      return Promise.all(this.pipes.map(p => p.finishRun(finishData)));
-    }
-
-    // Upload tests in size-limited chunks (max 1MB each), exactly like XmlReader.
-    // The testomatio pipe runs in MANUAL batch mode, so addTest only buffers tests and
-    // sync() flushes one batch request per chunk. There is no setInterval auto-upload,
-    // so each test is sent exactly once (no double-send) and requests stay under the limit.
-    const testChunks = splitTestsIntoChunks(this._tests);
-
-    const totalChunks = testChunks.length;
-    const totalTests = this._tests.length;
-
-    debug(`Split ${totalTests} tests into ${totalChunks} chunks (max 1MB per chunk)`);
-
-    let uploadedTests = 0;
-    for (let i = 0; i < testChunks.length; i++) {
-      const chunk = testChunks[i];
-
-      if (totalChunks > 1) {
-        debug(`Uploading chunk ${i + 1}/${totalChunks} (${chunk.length} tests)`);
-      }
-
-      // Buffer each test in the chunk, then flush the whole chunk as a single batch
-      for (const test of chunk) {
-        await Promise.all(this.pipes.map(p => p.addTest(test)));
-      }
-      await Promise.all(this.pipes.map(p => p.sync()));
-
-      uploadedTests += chunk.length;
-      debug(`Uploaded ${uploadedTests}/${totalTests} tests`);
-    }
-
-    if (totalChunks > 1) {
-      console.log(APP_PREFIX, `✅ Successfully uploaded ${uploadedTests} tests in ${totalChunks} chunks`);
-    } else {
-      console.log(APP_PREFIX, `✅ Successfully uploaded ${uploadedTests} tests`);
-    }
-
-    debug('Uploaded %d tests, finishing run', this._tests.length);
-
-    return Promise.all(this.pipes.map(p => p.finishRun(finishData)));
-  }
-}
-
-export default AllureReader;

package/src/junit-adapter/kotlin.js

@@ -1,48 +0,0 @@
-import path from 'path';
-import Adapter from './adapter.js';
-
-class KotlinAdapter extends Adapter {
-  getFilePath(t) {
-    const fileName = namespaceToFileName(t.suite_title);
-    return this.opts.javaTests + path.sep + fileName;
-  }
-
-  formatTest(t) {
-    const fileParts = t.suite_title.split('.');
-
-    t.file = namespaceToFileName(t.suite_title);
-    t.title = t.title.split('(')[0];
-
-    // detect params
-    const paramMatches = t.title.match(/\[(.*?)\]/g);
-
-    if (paramMatches) {
-      const params = paramMatches.map((_match, index) => `param${index + 1}`);
-      if (params.length === 1) params[0] = 'param';
-      let paramIndex = 0;
-
-      t.title = t.title.replace(/: \[(.*?)\]/g, () => {
-        if (params.length < 2) return `\${param}`;
-        const paramName = params[paramIndex] || `param${paramIndex + 1}`;
-        paramIndex++;
-        return `\${${paramName}}`;
-      });
-      const example = {};
-      paramMatches.forEach((match, index) => {
-        example[params[index]] = match.replace(/[[\]]/g, '');
-      });
-      t.example = example;
-    }
-
-    t.suite_title = fileParts[fileParts.length - 1].replace(/\$/g, ' | ');
-    return t;
-  }
-}
-
-function namespaceToFileName(fileName) {
-  const fileParts = fileName.split('.');
-  fileParts[fileParts.length - 1] = fileParts[fileParts.length - 1]?.replace(/\$.*/, '');
-  return `${fileParts.join(path.sep)}.kt`;
-}
-
-export default KotlinAdapter;