testomatio-reporter-cli 2.9.5 → 2.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testomatio-reporter-cli",
-  "version": "2.9.5",
+  "version": "2.10.0",
   "description": "Yarn Berry compatible standalone CLI for @testomatio/reporter",
   "type": "module",
   "bin": {

package/src/adapter/codecept.js

@@ -152,12 +152,33 @@ function CodeceptReporter(config) {
     services.setContext(null);
   });
 
-  // mark as failed all tests inside the failed hook
+  // Report setup hook failures against the current test while preserving skipped tests in the suite.
   event.dispatcher.on(event.hook.failed, hook => {
     const error = hook?.ctx?.currentTest?.err || hook?.err;
 
-    // Handle BeforeSuite and Before hooks: mark all tests in suite as failed
-    if (hook.name === 'BeforeSuiteHook' || hook.name === 'BeforeHook') {
+    // CodeceptJS does not emit test.after for the test associated with a failed BeforeSuite,
+    // so report that test here. The remaining tests are emitted as skipped.
+    if (hook.name === 'BeforeSuiteHook') {
+      const suite = hook.runnable?.parent || hook.suite;
+      if (!suite) return;
+
+      const test = hook?.ctx?.currentTest || hook?.test || suite.tests?.[0];
+      if (!test) return;
+
+      reportedTestUids.add(test.uid);
+      const reportTestPromise = client.addTestRun(STATUS.FAILED, {
+        ...stripExampleFromTitle(test.title),
+        rid: test.uid,
+        test_id: getTestomatIdFromTestTitle(test.title),
+        suite_title: stripTagsFromTitle(suite.title),
+        error,
+        time: hook?.runnable?.duration,
+      });
+      reportTestPromises.push(reportTestPromise);
+    }
+
+    // Preserve the existing Before hook behavior: mark all tests in the suite as failed.
+    if (hook.name === 'BeforeHook') {
       const suite = hook.runnable.parent;
       if (!suite) return;
 

package/src/allureReader.js

@@ -0,0 +1,954 @@
+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,
+    };
+
+    // @TmsLink references link the result to existing Testomat.io cases. Add EVERY id as
+    // a linked case ({ test: id }) so all of them are updated from this one result, with
+    // consistent behaviour whether the test has one or many @TmsLink. The test_id is kept
+    // a SEPARATE concern — it is never derived from @TmsLink; it is only set from a native
+    // Testomat.io id found in source (see fetchSourceCode / fetchIdFromCode).
+    this.addLinkedTestIds(test, this.extractTmsIds(result));
+
+    // 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 all Testomat.io test ids from Allure links so reported results match
+   * existing cases instead of creating duplicates.
+   *
+   * A test may carry several `@TmsLink`s (e.g. `@TmsLinks(@TmsLink("…"), @TmsLink("…"))`),
+   * each producing 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 id segment of a Testomat.io URL). Ids are normalized and
+   * de-duplicated, preserving order so the first one stays the primary `test_id`.
+   *
+   * @param {object} result - Parsed Allure result JSON
+   * @returns {string[]} Normalized test ids (possibly empty)
+   */
+  extractTmsIds(result) {
+    const links = result.links || [];
+    if (!links.length) return [];
+
+    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 ids = [];
+    for (const link of links) {
+      if (!isTmsLink(link) && !isTestomatioLink(link)) continue;
+
+      // 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];
+      }
+      if (id && !ids.includes(id)) ids.push(id);
+    }
+
+    return ids;
+  }
+
+  /**
+   * The primary Testomat.io test id (the first `@TmsLink`), or null when there is none.
+   *
+   * @param {object} result - Parsed Allure result JSON
+   * @returns {string|null}
+   */
+  extractTestId(result) {
+    return this.extractTmsIds(result)[0] || null;
+  }
+
+  /**
+   * Attach additional linked test cases to a reported test as `{ test: id }` link entries
+   * (the same shape `linkTest()` uses), so a single result updates every case it is linked
+   * to — not just the primary `test_id`. Existing links are preserved; duplicates skipped.
+   *
+   * @param {object} test - converted test
+   * @param {string[]} ids - additional test ids to link
+   */
+  addLinkedTestIds(test, ids) {
+    if (!ids || !ids.length) return;
+    if (!Array.isArray(test.links)) test.links = [];
+    for (const id of ids) {
+      if (!test.links.some(l => l && l.test === id)) {
+        test.links.push({ test: 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;
+  }
+
+  /**
+   * Recover a Testomat.io test id from the `@TmsLink("…")` annotation in test source.
+   *
+   * Allure does not emit link annotations for skipped (`@Ignore` / `@Disabled`) tests,
+   * so their results carry no `tms` link and `extractTestId` returns null — which makes
+   * the server create a duplicate case. The id still lives in the source, on the test
+   * method, so we read it from there as a fallback.
+   *
+   * The lookup is method-scoped: we locate the test method declaration by name, collect
+   * its annotation/comment block (the lines directly above it, up to the previous code
+   * construct) and read every `@TmsLink` from it — so an unrelated method's annotation can
+   * never be picked up. Both `@TmsLink("…")` and the container forms
+   * `@TmsLinks(@TmsLink("…"), @TmsLink("…"))` (single- or multi-line) are supported.
+   *
+   * @param {string} contents - full source file
+   * @param {object} test - converted test (uses `title`)
+   * @returns {string[]} normalized 8-char ids in source order (possibly empty)
+   */
+  extractTmsIdsFromSource(contents, test) {
+    if (!contents || !test || !test.title) return [];
+
+    const lines = contents.split('\n');
+    const title = test.title.replace(/[([].*$/, '').trim();
+    if (!title) return [];
+    const escaped = title.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+    // Locate the test method declaration (Kotlin `fun name(`, then a typed declaration,
+    // then a generic `name(` fallback for other JVM languages).
+    let idx = lines.findIndex(l => new RegExp(`\\bfun\\s+${escaped}\\s*\\(`).test(l));
+    if (idx === -1) idx = lines.findIndex(l => new RegExp(`\\b[\\w.<>\\[\\]]+\\s+${escaped}\\s*\\(`).test(l));
+    if (idx === -1) idx = lines.findIndex(l => new RegExp(`\\b${escaped}\\s*\\(`).test(l));
+    if (idx === -1) return [];
+
+    // Collect the annotation/comment block above the declaration. Stop at the previous
+    // code construct (a line ending in `{`/`}` or another method declaration) so we never
+    // read into a sibling method. Multi-line `@TmsLinks(...)` continuation lines (e.g. a
+    // lone `@TmsLink("…"),` or a closing `)`) are kept because they aren't boundaries.
+    const block = [];
+    for (let i = idx - 1, scanned = 0; i >= 0 && scanned < 60; i--, scanned++) {
+      const trimmed = lines[i].trim();
+      if (trimmed.endsWith('{') || trimmed.endsWith('}')) break;
+      if (/\bfun\s+\w+\s*\(/.test(trimmed)) break;
+      block.push(lines[i]);
+    }
+
+    const ids = [];
+    const tmsRe = /\bTmsLink\s*\(\s*["']([^"']+)["']/g;
+    let match;
+    // block was collected bottom-up; reverse so ids come out in source order
+    const text = block.reverse().join('\n');
+    while ((match = tmsRe.exec(text)) !== null) {
+      const id = this.normalizeTestId(match[1]);
+      if (id && !ids.includes(id)) ids.push(id);
+    }
+
+    return ids;
+  }
+
+  /**
+   * The primary `@TmsLink` id for a test method in source, or null. Convenience wrapper
+   * around {@link extractTmsIdsFromSource}.
+   *
+   * @param {string} contents - full source file
+   * @param {object} test - converted test (uses `title`)
+   * @returns {string|null}
+   */
+  extractTmsIdFromSource(contents, test) {
+    return this.extractTmsIdsFromSource(contents, test)[0] || 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.
+        //
+        // Allure propagates a failure's statusDetails up the whole step chain, so
+        // every ancestor of the real failure point is also `failed` and carries
+        // the same message. To avoid repeating it at every level, only surface the
+        // error on the deepest failed step — skip it whenever a descendant step
+        // already shows the error.
+        const error = this.extractStepError(step);
+        if (error && !this.subtreeHasError(convertedStep.steps)) {
+          convertedStep.error = error;
+        }
+
+        if (convertedStep.steps && convertedStep.steps.length === 0) {
+          delete convertedStep.steps;
+        }
+
+        if (convertedStep.duration === 0) {
+          delete convertedStep.duration;
+        }
+
+        return convertedStep;
+      })
+      .filter(Boolean);
+  }
+
+  /**
+   * Check whether any step in the given (already converted) subtree already
+   * carries an `error`. Used to keep the failure message on the deepest failed
+   * step only, instead of repeating it on every ancestor in the failure chain.
+   *
+   * @param {Array<object>|undefined} steps - converted child steps
+   * @returns {boolean}
+   */
+  subtreeHasError(steps) {
+    if (!steps || !steps.length) return false;
+    return steps.some(step => step.error || this.subtreeHasError(step.steps));
+  }
+
+  /**
+   * 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');
+    }
+
+    // When the final attempt passed (after earlier failures) keep the test as passed —
+    // this mirrors the server's overwrite-by-latest retry model. The aggregated failure
+    // message/stack built above is retained so the flakiness history stays visible.
+    if (finalTest.status === 'passed') {
+      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;
+  }
+
+  /**
+   * Link tests to their Testomat.io cases by reading `@TmsLink` from source for tests that
+   * carry no `{ test: … }` link yet. This rescues skipped (`@Ignore` / `@Disabled`) tests,
+   * whose Allure results drop the `@TmsLink` link and would otherwise create duplicate
+   * cases. Every `@TmsLink` on the method is linked (consistent with executed tests); the
+   * `test_id` is left untouched — links and test_id are separate concerns.
+   *
+   * Opt-in: only runs when `--java-tests` (a source root) is provided. The source files are
+   * indexed once by basename; for each not-yet-linked test we read the candidate file(s)
+   * matching its `testFile` / class name and parse the method's `@TmsLink`(s).
+   */
+  recoverTmsLinksFromSource() {
+    const root = this.opts.javaTests;
+    if (!root) return;
+
+    const hasTestLink = t => Array.isArray(t.links) && t.links.some(l => l && l.test);
+    const unlinked = this._tests.filter(t => !hasTestLink(t));
+    if (!unlinked.length) return;
+
+    if (!fs.existsSync(root)) {
+      debug('java-tests source root not found: %s', root);
+      return;
+    }
+
+    const index = this.indexSourceFiles(root);
+    let recovered = 0;
+
+    for (const t of unlinked) {
+      for (const filePath of this.sourceCandidatesForTest(t, index)) {
+        let contents;
+        try {
+          contents = fs.readFileSync(filePath).toString();
+        } catch (err) {
+          debug('Failed to read source %s: %s', filePath, err.message);
+          continue;
+        }
+        const ids = this.extractTmsIdsFromSource(contents, t);
+        if (ids.length) {
+          this.addLinkedTestIds(t, ids);
+          recovered++;
+          debug('Linked %s to case(s) %s from @TmsLink in %s', t.title, ids.join(', '), filePath);
+          break;
+        }
+      }
+    }
+
+    if (recovered) {
+      console.log(APP_PREFIX, `🔗 Linked ${pc.bold(recovered)} test(s) to cases from @TmsLink in source`);
+    }
+  }
+
+  /**
+   * Fallback: when a test has no `test_id`, adopt the first linked case (`@TmsLink`) as its
+   * `test_id` so it matches an existing case instead of creating a method-named duplicate.
+   *
+   * Runs after `fetchSourceCode`, so a native Testomat.io id parsed from source always wins.
+   * The id stays in `links` as well — every linked case is still updated; this only gives the
+   * test a primary identity to match on.
+   */
+  applyPrimaryTestIdFromLinks() {
+    for (const t of this._tests) {
+      if (t.test_id) continue;
+      const firstTestLink = Array.isArray(t.links) ? t.links.find(l => l && l.test) : null;
+      if (firstTestLink) {
+        t.test_id = firstTestLink.test;
+        debug('Using first linked case %s as test_id for %s', firstTestLink.test, t.title);
+      }
+    }
+  }
+
+  /**
+   * Build (and cache) a basename -> [absolute paths] index of source files under `root`.
+   * Walks synchronously, skipping common build/dependency directories.
+   *
+   * @param {string} root
+   * @returns {Map<string, string[]>}
+   */
+  indexSourceFiles(root) {
+    if (this._sourceIndex) return this._sourceIndex;
+
+    const exts = new Set(['.kt', '.java', '.py', '.rb', '.cs']);
+    const skipDirs = new Set(['node_modules', '.git', 'build', 'out', 'target', '.gradle', 'dist', 'bin']);
+    const index = new Map();
+    const stack = [root];
+
+    while (stack.length) {
+      const dir = stack.pop();
+      let entries;
+      try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+      } catch (err) {
+        debug('Failed to read dir %s: %s', dir, err.message);
+        continue;
+      }
+      for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (!skipDirs.has(entry.name)) stack.push(full);
+        } else if (exts.has(path.extname(entry.name))) {
+          const list = index.get(entry.name) || [];
+          list.push(full);
+          index.set(entry.name, list);
+        }
+      }
+    }
+
+    this._sourceIndex = index;
+    return index;
+  }
+
+  /**
+   * Candidate source file paths for a test, looked up in the basename index.
+   * Uses the `testFile` meta label (e.g. `Foo.kt`) and the class name from `file`,
+   * trying both `.kt` and `.java` extensions. Ambiguity (same basename in several
+   * dirs) is harmless: only the file that actually declares the method will match.
+   *
+   * @param {object} t
+   * @param {Map<string, string[]>} index
+   * @returns {string[]}
+   */
+  sourceCandidatesForTest(t, index) {
+    const names = new Set();
+    if (t.meta?.testFile) names.add(t.meta.testFile);
+    if (t.file) {
+      const base = path.basename(t.file);
+      names.add(base);
+      const stem = base.replace(/\.[^.]+$/, '');
+      ['kt', 'java'].forEach(ext => names.add(`${stem}.${ext}`));
+    }
+
+    const paths = [];
+    for (const name of names) {
+      (index.get(name) || []).forEach(p => paths.push(p));
+    }
+    return paths;
+  }
+
+  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.recoverTmsLinksFromSource();
+    this.applyPrimaryTestIdFromLinks();
+
+    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/bin/cli.js

@@ -6,6 +6,7 @@ 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';
@@ -353,6 +354,48 @@ 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)')
+  .option(
+    '--java-tests [path]',
+    'Path to test sources; links cases from @TmsLink in source for skipped tests (default: src/test)',
+  )
+  .option('--lang <lang>', 'Language used (java, kotlin, ...)')
+  .action(async (pattern, opts) => {
+    let javaTests = opts.javaTests;
+    if (javaTests === true) javaTests = 'src/test';
+
+    const runReader = new AllureReader({ withPackage: opts.withPackage, javaTests, lang: opts.lang });
+
+    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')

package/src/junit-adapter/index.js

@@ -4,6 +4,7 @@ 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') {
@@ -21,6 +22,9 @@ 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/junit-adapter/kotlin.js

@@ -0,0 +1,48 @@
+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;

package/src/utils/pipe_utils.js

@@ -161,6 +161,53 @@ 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,
@@ -190,4 +237,6 @@ export {
   fullName,
   parsePipeOptions,
   formatFilterListIds,
+  getObjectSize,
+  splitTestsIntoChunks,
 };

package/src/utils/utils.js

@@ -289,6 +289,11 @@ 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,6 +18,7 @@ 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';
@@ -553,52 +554,6 @@ 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();
@@ -623,7 +578,7 @@ class XmlReader {
       return Promise.all(this.pipes.map(p => p.finishRun(finishData)));
     }
 
-    const testChunks = this.#splitTestsIntoChunks(this.tests);
+    const testChunks = splitTestsIntoChunks(this.tests);
 
     const totalChunks = testChunks.length;
     const totalTests = this.tests.length;