@testomatio/reporter 2.9.3-beta.4-allure-links → 2.9.4

package/src/pipe/html.js

@@ -6,11 +6,12 @@ import pc from 'picocolors';
 import handlebars from 'handlebars';
 import { marked } from 'marked';
 import fileUrl from 'file-url';
-import { fileSystem, isSameTest, ansiRegExp, formatStep } from '../utils/utils.js';
+import { fileSystem, isSameTest, ansiRegExp, formatStep, transformEnvVarToBoolean } from '../utils/utils.js';
 import { HTML_REPORT } from '../constants.js';
 import { fileURLToPath } from 'node:url';
 
 const debug = createDebugMessages('@testomatio/reporter:pipe:html');
+const HTML_ARTIFACTS_DIR = 'artifacts';
 
 // @ts-ignore – this line will be removed in compiled code (already defined in the global scope of commonjs)
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -22,6 +23,7 @@ class HtmlPipe {
     this.description = params.description || process.env.TESTOMATIO_DESCRIPTION;
     this.apiKey = params.apiKey || process.env.TESTOMATIO;
     this.isHtml = params.html ?? process.env.TESTOMATIO_HTML_REPORT_SAVE;
+    this.htmlCopyArtifacts = params.htmlCopyArtifacts;
 
     debug('HTML Pipe: ', this.apiKey ? 'API KEY' : '*no api key provided*');
 
@@ -151,6 +153,8 @@ class HtmlPipe {
 
     const aggregatedTests = aggregateTestRetries(tests);
 
+    const copyLocalArtifacts = resolveHtmlCopyArtifacts(this.htmlCopyArtifacts);
+    const portableArtifacts = new Map();
     aggregatedTests.forEach(test => {
       const logsRaw =
         test.logs || test.meta?.logs || test.meta?.console || test.meta?.stdout || test.meta?.stderr || '';
@@ -228,7 +232,12 @@ class HtmlPipe {
         test.title = 'Unknown test title';
       }
 
+      test.title = buildExampleTitle(test.title, test.example);
+
       test.artifacts = normalizeArtifacts(test);
+      if (copyLocalArtifacts) {
+        makeLocalArtifactsPortable(test, outputPath, portableArtifacts);
+      }
 
       const allPossibleArtifacts = [
         ...(test.artifacts || []),
@@ -460,6 +469,21 @@ function parseRetryInfo(test) {
   }
 }
 
+function buildExampleTitle(title, example) {
+  if (example == null) return title;
+
+  let exampleText;
+  try {
+    exampleText = JSON.stringify(example);
+  } catch (e) {
+    return title;
+  }
+
+  if (!exampleText || title.includes(exampleText)) return title;
+
+  return `${title} | ${exampleText}`;
+}
+
 function escapeHtml(str = '') {
   return String(str).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
@@ -1013,57 +1037,7 @@ function normalizeArtifacts(test) {
   ];
 
   return allArtifacts
-    .map(artifact => {
-      if (typeof artifact === 'string') {
-        if (/^https?:\/\//i.test(artifact)) {
-          const base = path.basename(new URL(artifact).pathname) || artifact;
-
-          return {
-            name: base,
-            title: base,
-            path: artifact,
-            fsPath: null,
-            relativePath: artifact,
-          };
-        }
-
-        const abs = path.isAbsolute(artifact) ? artifact : path.resolve(process.cwd(), artifact);
-        const href = artifact.startsWith('file://') ? artifact : fileUrl(abs, { resolve: true });
-        const base = path.basename(abs);
-
-        return {
-          name: base,
-          title: base,
-          path: href,
-          fsPath: abs,
-          relativePath: artifact,
-        };
-      }
-
-      if (artifact?.path) {
-        const raw = String(artifact.path);
-        const isFileUrl = raw.startsWith('file://');
-        const isHttpUrl = /^https?:\/\//i.test(raw);
-        const abs = isFileUrl || isHttpUrl ? null : path.isAbsolute(raw) ? raw : path.resolve(process.cwd(), raw);
-        const href = isFileUrl || isHttpUrl ? raw : fileUrl(abs, { resolve: true });
-        const base = abs
-          ? path.basename(abs)
-          : isHttpUrl
-            ? path.basename(new URL(raw).pathname) || artifact.name || artifact.title || 'attachment'
-            : artifact.name || artifact.title || 'attachment';
-
-        return {
-          ...artifact,
-          name: artifact.name || artifact.title || base,
-          title: artifact.title || artifact.name || base,
-          path: href,
-          fsPath: abs || artifact.fsPath || null,
-          relativePath: artifact.relativePath || raw,
-        };
-      }
-
-      return artifact;
-    })
+    .map(normalizeArtifact)
     .filter(Boolean)
     .filter(artifact => {
       const isTrace = (artifact.title === 'trace' || artifact.name === 'trace') &&
@@ -1074,6 +1048,151 @@ function normalizeArtifacts(test) {
     });
 }
 
+function resolveHtmlCopyArtifacts(value) {
+  if (value !== undefined) return transformEnvVarToBoolean(value);
+  if (process.env.TESTOMATIO_HTML_REPORT_COPY_ARTIFACTS !== undefined) {
+    return transformEnvVarToBoolean(process.env.TESTOMATIO_HTML_REPORT_COPY_ARTIFACTS);
+  }
+  return !isS3ArtifactsUploadEnabled();
+}
+
+function isS3ArtifactsUploadEnabled() {
+  return Boolean(process.env.S3_BUCKET && !transformEnvVarToBoolean(process.env.TESTOMATIO_DISABLE_ARTIFACTS));
+}
+
+function normalizeArtifact(artifact) {
+  if (typeof artifact === 'string') {
+    return normalizeArtifactPath({ raw: artifact });
+  }
+
+  if (artifact?.path) {
+    return normalizeArtifactPath({
+      raw: String(artifact.path),
+      artifact,
+    });
+  }
+
+  return artifact;
+}
+
+/**
+ * @param {{
+ *   raw: string,
+ *   artifact?: { name?: string, title?: string, relativePath?: string, [key: string]: any }
+ * }} params
+ */
+function normalizeArtifactPath({ raw, artifact = {} }) {
+  const url = parseUrl(raw);
+  const fsPath = getLocalArtifactPath(raw, url);
+  const base = getArtifactBaseName({ raw, url, fsPath, artifact });
+  const href = fsPath && url?.protocol !== 'file:' ? fileUrl(fsPath, { resolve: true }) : raw;
+
+  return {
+    ...artifact,
+    name: artifact.name || artifact.title || base,
+    title: artifact.title || artifact.name || base,
+    path: href,
+    fsPath,
+    relativePath: artifact.relativePath || raw,
+  };
+}
+
+function makeLocalArtifactsPortable(test, outputPath, portableArtifacts) {
+  const reportDir = path.dirname(path.resolve(outputPath));
+
+  test.artifacts = makeArtifactsPortable(test.artifacts, reportDir, portableArtifacts);
+
+  if (Array.isArray(test.stepsArray)) {
+    makeStepArtifactsPortable(test.stepsArray, reportDir, portableArtifacts);
+  }
+}
+
+function makeStepArtifactsPortable(steps, reportDir, portableArtifacts) {
+  steps.forEach(step => {
+    if (Array.isArray(step.artifacts)) {
+      const normalizedArtifacts = step.artifacts.map(normalizeArtifact).filter(Boolean);
+      step.artifacts = makeArtifactsPortable(normalizedArtifacts, reportDir, portableArtifacts);
+    }
+
+    if (Array.isArray(step.steps)) {
+      makeStepArtifactsPortable(step.steps, reportDir, portableArtifacts);
+    }
+  });
+}
+
+function makeArtifactsPortable(artifacts, reportDir, portableArtifacts) {
+  if (!Array.isArray(artifacts)) return artifacts;
+
+  return artifacts.map(artifact => {
+    const fsPath = artifact?.fsPath;
+    if (!fsPath || !fs.existsSync(fsPath)) return artifact;
+
+    const relativePath = copyArtifactToReport(fsPath, reportDir, portableArtifacts);
+    return { ...artifact, path: relativePath, relativePath };
+  });
+}
+
+function copyArtifactToReport(fsPath, reportDir, portableArtifacts) {
+  const absoluteSource = path.resolve(fsPath);
+  if (portableArtifacts.has(absoluteSource)) return portableArtifacts.get(absoluteSource);
+
+  const artifactsDir = path.join(reportDir, HTML_ARTIFACTS_DIR);
+  const ext = path.extname(absoluteSource);
+  const baseName = path.basename(absoluteSource, ext) || 'attachment';
+  let destinationPath = path.join(artifactsDir, `${baseName}${ext}`);
+  let index = 1;
+
+  while (Array.from(portableArtifacts.values()).includes(getRelativeArtifactPath(reportDir, destinationPath))) {
+    destinationPath = path.join(artifactsDir, `${baseName}-${index}${ext}`);
+    index += 1;
+  }
+
+  fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
+  fs.copyFileSync(absoluteSource, destinationPath);
+
+  const relativePath = getRelativeArtifactPath(reportDir, destinationPath);
+  portableArtifacts.set(absoluteSource, relativePath);
+  return relativePath;
+}
+
+function getLocalArtifactPath(raw, url = parseUrl(raw)) {
+  if (path.isAbsolute(raw)) return raw;
+  if (isRemoteUrl(url)) return null;
+
+  if (url?.protocol === 'file:') {
+    try {
+      return fileURLToPath(url);
+    } catch (_) {
+      return null;
+    }
+  }
+
+  if (url) return null;
+  return path.resolve(process.cwd(), raw);
+}
+
+function getArtifactBaseName({ raw, url, fsPath, artifact }) {
+  if (fsPath) return path.basename(fsPath);
+  if (url?.pathname) return path.basename(url.pathname) || artifact.name || artifact.title || 'attachment';
+  return artifact.name || artifact.title || path.basename(raw) || 'attachment';
+}
+
+function parseUrl(value) {
+  try {
+    return new URL(String(value));
+  } catch (_) {
+    return null;
+  }
+}
+
+function isRemoteUrl(url) {
+  return url?.protocol === 'http:' || url?.protocol === 'https:';
+}
+
+function getRelativeArtifactPath(reportDir, artifactPath) {
+  return `./${String(path.relative(reportDir, artifactPath)).split(path.sep).join('/')}`;
+}
+
 /**
  * Loads trace files from test.files and converts them to base64 data URLs
  * @param {object} test - Test object with files array

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;