testomatio-reporter-cli 2.9.3-beta.4-allure-links → 2.9.4

package/package.json

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

package/src/adapter/codecept.js

@@ -154,21 +154,40 @@ function CodeceptReporter(config) {
 
   // mark as failed all tests inside the failed hook
   event.dispatcher.on(event.hook.failed, hook => {
-    if (hook.name !== 'BeforeSuiteHook' && hook.name !== 'BeforeHook') return;
-    const suite = hook.runnable.parent;
+    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') {
+      const suite = hook.runnable.parent;
+      if (!suite) return;
+
+      for (const test of suite.tests) {
+        reportedTestUids.add(test.uid);
+        const reportTestPromise = client.addTestRun('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);
+      }
+    }
 
-    if (!suite) return;
+    if (hook.name === 'AfterSuiteHook') {
+      const suite = hook.runnable?.parent || hook.suite;
+      const suiteTitle = suite ? stripTagsFromTitle(suite.title) : 'Unknown Suite';
 
-    const error = hook?.ctx?.currentTest?.err;
+      const stepHierarchy = buildUnifiedStepHierarchy(null, hookSteps);
 
-    for (const test of suite.tests) {
-      reportedTestUids.add(test.uid);
+      // Report the hook failure as a separate test entry
       const reportTestPromise = client.addTestRun('failed', {
-        ...stripExampleFromTitle(test.title),
-        rid: test.uid,
-        test_id: getTestomatIdFromTestTitle(test.title),
-        suite_title: stripTagsFromTitle(suite.title),
+        title: 'AfterSuite Hook',
+        suite_title: suiteTitle,
         error,
+        message: error?.message || 'AfterSuite hook failed',
+        steps: stepHierarchy,
         time: hook?.runnable?.duration,
       });
       reportTestPromises.push(reportTestPromise);
@@ -194,8 +213,10 @@ function CodeceptReporter(config) {
   });
 
   event.dispatcher.on(event.all.after, () => {
-    recorder.add('Finishing run', async () => {
-      await finalizeRun('all.after');
+    setImmediate(() => {
+      finalizeRun('all.after').catch(err => {
+        debug('Error finalizing run:', err);
+      });
     });
   });
 
@@ -278,6 +299,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,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/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];