@testomatio/reporter 2.9.3-beta.3-allure-links → 2.9.3

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,8 @@ 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';
 
 const debug = createDebugMessages('@testomatio/reporter:cli');
 const version = getPackageVersion();
@@ -353,53 +354,61 @@ program
   });
 
 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';
+  .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 (jsonlFile, opts) => {
+    const apiKey = config.TESTOMATIO;
 
-    const runReader = new AllureReader({ withPackage: opts.withPackage, javaTests, lang: opts.lang });
+    // 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);
+      }
 
-    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,
-      );
-    }
+      const replay = new Replay({ apiKey });
+      const { tests, runId } = replay.parseDebugFile(jsonlFile);
 
-    try {
-      await runReader.parse(pattern);
-      await runReader.createRun();
-      await runReader.uploadData();
-    } catch (err) {
-      console.log(APP_PREFIX, 'Error uploading Allure results:', err);
-    }
+      if (!runId) {
+        log.error('runId not found in JSONL file');
+        return process.exit(1);
+      }
 
-    if (timeoutTimer) clearTimeout(timeoutTimer);
-  });
+      log.info(`Processing ${tests.length} tests from ${jsonlFile}`);
 
-program
-  .command('upload-artifacts')
-  .description('Upload artifacts to Testomat.io')
-  .option('--force', 'Re-upload artifacts even if they were uploaded before')
-  .action(async opts => {
-    const apiKey = config.TESTOMATIO;
+      const client = new TestomatClient({
+        apiKey,
+        runId,
+        batchMode: BATCH_MODE.DISABLED,
+      });
+
+      await client.createRun();
+      client.uploader.checkEnabled();
+      client.uploader.disableLogStorage();
+
+      let uploadedCount = 0;
+      let failedCount = 0;
+
+      for (const test of tests) {
+        if (!hasExistingArtifacts(test)) continue;
+
+        try {
+          await client.addTestRun(undefined, { ...test, overwrite: true });
+          uploadedCount++;
+        } catch (e) {
+          log.error(`Failed ${test.test_id || test.rid || test.title}: ${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();
@@ -543,6 +552,28 @@ program
     }
   });
 
+function hasExistingArtifacts(test) {
+  const hasExistingFile = items => {
+    for (const item of items || []) {
+      const artifactPath = typeof item === 'object' ? item?.path : item;
+      if (artifactPath && fs.existsSync(artifactPath)) return true;
+    }
+    return false;
+  };
+
+  if (hasExistingFile(test.files)) return true;
+
+  const stack = [...(test.steps || [])];
+  while (stack.length) {
+    const step = stack.pop();
+    if (!step) continue;
+    if (hasExistingFile(step.artifacts)) return true;
+    if (Array.isArray(step.steps)) stack.push(...step.steps);
+  }
+
+  return false;
+}
+
 program.parse(process.argv);
 
 if (!process.argv.slice(2).length) {

package/src/client.js

@@ -159,11 +159,12 @@ class Client {
 
         const uploadedArtifacts = [];
         for (const artifact of step.artifacts) {
-          if (typeof artifact === 'string' && !isHttpUrl(artifact)) {
-            const filename = generateShortFilename(artifact);
+          const artifactPath = typeof artifact === 'object' ? artifact?.path : artifact;
+          if (typeof artifactPath === 'string' && !isHttpUrl(artifactPath)) {
+            const filename = generateShortFilename(artifactPath);
             try {
               const uploadResult = await this.uploader.uploadFileByPath(
-                artifact, 
+                artifactPath,
                 [this.runId, testRid, 'steps', filename]
               );
               if (uploadResult) {

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;