testomatio-reporter-cli 2.19.0 → 2.20.0

package/package.json

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

package/src/adapter/codecept.js

@@ -11,6 +11,8 @@ import codeceptjs from 'codeceptjs';
 import { log } from '../utils/log.js';
 
 const debug = createDebugMessages('@testomatio/reporter:adapter:codeceptjs');
+
+global.TESTOMATIO_ADAPTER = 'codeceptjs';
 // @ts-ignore
 if (!global.codeceptjs) {
   // @ts-ignore

package/src/adapter/cucumber/current.js

@@ -8,6 +8,8 @@ import { getTestomatIdFromTestTitle, fileSystem } from '../../utils/utils.js';
 import { config } from '../../config.js';
 import { services } from '../../services/index.js';
 
+global.TESTOMATIO_ADAPTER = 'cucumber';
+
 const { GherkinDocumentParser, PickleParser } = formatterHelpers;
 const { getGherkinScenarioLocationMap, getGherkinStepMap } = GherkinDocumentParser;
 const { getPickleStepMap } = PickleParser;

package/src/adapter/cypress-plugin/index.js

@@ -3,6 +3,8 @@ import { getTestomatIdFromTestTitle, parseSuite } from '../../utils/utils.js';
 import TestomatClient from '../../client.js';
 import { config } from '../../config.js';
 
+global.TESTOMATIO_ADAPTER = 'cypress';
+
 const testomatioReporter = on => {
   if (!config.TESTOMATIO) {
     console.log('TESTOMATIO key is empty, ignoring reports');

package/src/adapter/e2e.js

@@ -0,0 +1,245 @@
+import path from 'path';
+import createDebugMessages from 'debug';
+import TestomatioClient from '../client.js';
+import { STATUS, SCREENSHOTS_ON_STEPS } from '../constants.js';
+import { getTestomatIdFromTestTitle, truncate } from '../utils/utils.js';
+import { formatStep, addStatusToStep, addArtifactsToStep } from './utils/step-formatter.js';
+import { log } from '../utils/log.js';
+
+const debug = createDebugMessages('@testomatio/reporter:adapter-e2e');
+
+/**
+ * Reporter for the e2e framework (https://github.com/tester-army/e2e).
+ * Add it to `reporters` in `e2e.config.ts`: `reporters: ['list', testomatio()]`.
+ *
+ * The config is loaded by every worker, so the client is created only inside
+ * handlers, which run in the runner process.
+ *
+ * @param {{ apiKey?: string }} [options]
+ */
+export function testomatio(options = {}) {
+  let client = null;
+  let runPromise = null;
+
+  function getClient() {
+    if (!client) client = new TestomatioClient({ apiKey: options.apiKey });
+    return client;
+  }
+
+  function startRun() {
+    if (!runPromise) {
+      runPromise = getClient()
+        .createRun()
+        .catch(err => log.error('Failed to create Testomat.io run:', err?.message || err));
+    }
+    return runPromise;
+  }
+
+  return {
+    name: 'testomatio',
+
+    onEvent(event) {
+      try {
+        if (event?.type === 'run-started') startRun();
+      } catch (err) {
+        debug('onEvent failed', err);
+      }
+    },
+
+    async onRunFinished(run, signal) {
+      const reporter = getClient();
+      await startRun();
+
+      const { report, artifactsRoot } = run;
+      const groups = new Map((report.run.serialGroups || []).map(group => [group.id, group]));
+
+      const promises = [];
+      for (const result of report.run.results) {
+        if (signal?.aborted) break;
+        // results left out by `--last-failed` belong to the previous run
+        if (result.selected === false) continue;
+        const { status, data } = toTestData(result, groups, artifactsRoot);
+        promises.push(reporter.addTestRun(status, data));
+      }
+      await Promise.all(promises);
+
+      const duration = (Date.parse(report.run.finishedAt) - Date.parse(report.run.startedAt)) / 1000;
+      await reporter.updateRunStatus(runStatus(report.run.status), { duration });
+
+      const runUrl = reporter.pipeStore?.runUrl;
+      if (runUrl) return [{ label: 'Testomat.io', text: runUrl }];
+    },
+  };
+}
+
+/**
+ * Converts one report-1 result into Testomat.io test data.
+ * Only the final attempt is reported; earlier attempts are counted as retries.
+ */
+export function toTestData(result, groups, artifactsRoot) {
+  const attempts = attemptsOf(result, groups);
+  const final = attempts.at(-1);
+  const titlePath = [...result.titlePath];
+  const title = titlePath.pop();
+
+  let suiteTitle = titlePath.join(' › ');
+  if (!suiteTitle) suiteTitle = path.basename(result.file);
+
+  const meta = {
+    target: result.targetId,
+    platform: result.platform,
+    browser: final?.environment?.browser,
+  };
+  if (result.agent && result.agent !== 'default') meta.agent = result.agent;
+  if (result.repeat) meta.repeat = result.repeat;
+  if (attempts.length > 1) meta.retryCount = attempts.length - 1;
+  if (result.status === 'flaky') meta.isFlaky = true;
+
+  const filesById = new Map();
+  for (const artifact of final?.artifacts || []) {
+    if (artifact.path) {
+      filesById.set(artifact.id, {
+        path: path.join(artifactsRoot, artifact.path),
+        type: artifact.mediaType,
+        title: artifact.kind,
+      });
+    } else if (artifact.url) {
+      // hosted engines keep videos remotely
+      meta[artifact.kind] = artifact.url;
+    }
+  }
+  const files = [...filesById.values()];
+
+  const steps = (final?.steps || []).map(step => toStep(step, filesById));
+
+  const data = {
+    rid: result.id,
+    title,
+    suite_title: suiteTitle,
+    file: result.file,
+    test_id: getTestomatIdFromTestTitle(title),
+    tags: result.tags || [],
+    time: final?.durationMs || 0,
+    timestamp: timestampOf(final),
+    error: toError(final?.error, final?.secondaryErrors),
+    steps: steps.length ? steps : undefined,
+    logs: logsOf(result, final),
+    files: files.length ? files : undefined,
+    meta,
+  };
+
+  return { status: testStatus(result.status), data };
+}
+
+/** Attempts of a result; a serial member keeps its part of the group's attempts. */
+function attemptsOf(result, groups) {
+  if (!result.serialGroupId) return result.attempts || [];
+  const groupAttempts = groups.get(result.serialGroupId)?.attempts || [];
+  return groupAttempts.map(attempt => {
+    const member = attempt.members?.find(candidate => candidate.testId === result.testId);
+    return {
+      status: member?.status || attempt.status,
+      error: member?.error || attempt.error,
+      steps: member?.steps || [],
+      appLog: member?.appLog || [],
+      skip: member?.skip,
+      durationMs: member?.durationMs,
+      startedAt: member?.startedAt || attempt.startedAt,
+      artifacts: attempt.artifacts || [],
+      secondaryErrors: [...(member?.secondaryErrors || []), ...(attempt.secondaryErrors || [])],
+      environment: attempt.environment,
+    };
+  });
+}
+
+function timestampOf(attempt) {
+  if (!attempt?.startedAt) return undefined;
+  return Date.parse(attempt.startedAt);
+}
+
+function testStatus(status) {
+  if (status === 'passed' || status === 'flaky') return STATUS.PASSED;
+  if (status === 'skipped') return STATUS.SKIPPED;
+  // failed, timed-out, interrupted: the test reached no passing verdict
+  return STATUS.FAILED;
+}
+
+function runStatus(status) {
+  if (status === 'passed') return STATUS.PASSED;
+  return STATUS.FAILED;
+}
+
+function toError(error, secondaryErrors = []) {
+  if (!error) return undefined;
+  /** @type {Error & { expected?: string, actual?: string }} */
+  const err = new Error(error.message);
+  err.name = error.code;
+  err.stack = `${error.code}: ${error.message}\n${error.stack || sourceFrame(error.source)}`;
+  if (error.details?.expected && error.details?.observed) {
+    err.expected = error.details.expected;
+    err.actual = error.details.observed;
+  }
+  for (const secondary of secondaryErrors) {
+    err.stack += `\n\nAlso failed (${secondary.phase || secondary.category}) ${secondary.code}: ${secondary.message}`;
+  }
+  return err;
+}
+
+function sourceFrame(source) {
+  if (!source) return '';
+  return `    at ${source.file}:${source.line}:${source.column}`;
+}
+
+function toStep(step, filesById) {
+  let category = 'user';
+  if (step.phase === 'beforeEach' || step.phase === 'afterEach') category = 'hook';
+
+  let title = step.api;
+  if (step.label) title = `${step.api} ${step.label}`;
+
+  const formatted = formatStep({
+    category,
+    title,
+    duration: step.durationMs,
+    log: stepLog(step),
+  });
+
+  let status = 'failed';
+  if (step.status === 'passed') status = 'passed';
+  addStatusToStep(formatted, status, step.error);
+
+  if (step.error) {
+    formatted.error = { message: truncate(`${step.error.code}: ${step.error.message}`, 250) };
+  }
+
+  if (SCREENSHOTS_ON_STEPS) {
+    const screenshot = (step.artifacts || []).map(id => filesById.get(id)).find(file => file?.type === 'image/png');
+    if (screenshot) addArtifactsToStep(formatted, { screenshot: screenshot.path });
+  }
+
+  return formatted;
+}
+
+/** Agent reasoning and non-binary step statuses, which a passed/failed step would lose. */
+function stepLog(step) {
+  const lines = [];
+  if (step.status !== 'passed' && step.status !== 'failed') lines.push(`status: ${step.status}`);
+  if (step.explanation) lines.push(step.explanation);
+  for (const event of step.events || []) {
+    if (event.reasoning) lines.push(event.reasoning);
+  }
+  return lines.join('\n');
+}
+
+function logsOf(result, final) {
+  const lines = [];
+  const skip = final?.skip || result.skip;
+  if (skip) lines.push(`Skipped (${skip.cause}): ${skip.reason}`);
+  if (final?.appLog?.length) {
+    lines.push('App log:');
+    for (const line of final.appLog) lines.push(`[${line.source}] ${line.level}: ${line.text}`);
+  }
+  return lines.join('\n');
+}
+
+export default testomatio;

package/src/adapter/jasmine.js

@@ -2,6 +2,8 @@ import TestomatClient from '../client.js';
 import { getTestomatIdFromTestTitle, ansiRegExp } from '../utils/utils.js';
 import { STATUS } from '../constants.js';
 
+global.TESTOMATIO_ADAPTER = 'jasmine';
+
 class JasmineReporter {
   constructor(options) {
     this.testTimeMap = {};

package/src/adapter/jest.js

@@ -8,6 +8,8 @@ import createDebugMessages from 'debug';
 
 const debug = createDebugMessages('@testomatio/reporter:adapter-jest');
 
+global.TESTOMATIO_ADAPTER = 'jest';
+
 export class JestReporter {
   constructor(globalConfig, options) {
     this._globalConfig = globalConfig;

package/src/adapter/mocha.js

@@ -6,6 +6,8 @@ import { config } from '../config.js';
 import { services } from '../services/index.js';
 import pc from 'picocolors';
 
+global.TESTOMATIO_ADAPTER = 'mocha';
+
 const {
   EVENT_RUN_BEGIN,
   EVENT_RUN_END,
@@ -18,157 +20,160 @@ const {
   EVENT_TEST_END,
 } = Mocha.Runner.constants;
 
-function MochaReporter(runner, opts) {
-  Mocha.reporters.Base.call(this, runner);
-  let passes = 0;
-  let failures = 0;
-  let skipped = 0;
-  // let artifactStore;
-
-  const apiKey = opts?.reporterOptions?.apiKey || config.TESTOMATIO;
-
-  const client = new TestomatClient({ apiKey });
-
-  // Track hook failures
-  const hookFailures = new Map();
-
-  runner.on(EVENT_RUN_BEGIN, () => {
-    client.createRun();
-
-    // clear dir with artifacts/logs
-    fileSystem.clearDir(TESTOMAT_TMP_STORAGE_DIR);
-  });
-
-  runner.on(EVENT_SUITE_BEGIN, async suite => {
-    services.setContext(suite.fullTitle());
-  });
-
-  runner.on(EVENT_SUITE_END, async suite => {
-    if (hookFailures.has(suite.fullTitle())) {
-      const { error, suiteTitle } = hookFailures.get(suite.fullTitle());
-
-      for (const test of suite.tests) {
-        if (test.state === 'pending' || !test.state) {
-          const testId = getTestomatIdFromTestTitle(test.title);
-          const artifacts = services.artifacts.get(test.fullTitle());
-          const keyValues = services.keyValues.get(test.fullTitle());
-          const links = services.links.get(test.fullTitle());
-
-          client.addTestRun(STATUS.FAILED, {
-            error,
-            suite_title: suiteTitle || suite.title,
-            file: suite.file,
-            test_id: testId,
-            title: test.title,
-            code: process.env.TESTOMATIO_UPDATE_CODE ? test.body.toString() : '',
-            time: 0,
-            manuallyAttachedArtifacts: artifacts,
-            meta: keyValues,
-            links,
-          });
+// ES class so it works with mocha 12, where Base is a class and utils.inherits is gone
+class MochaReporter extends Mocha.reporters.Base {
+  constructor(runner, opts) {
+    super(runner, opts);
+    let passes = 0;
+    let failures = 0;
+    let skipped = 0;
+    // let artifactStore;
+
+    const apiKey = opts?.reporterOptions?.apiKey || config.TESTOMATIO;
+
+    const client = new TestomatClient({ apiKey });
+
+    // Track hook failures
+    const hookFailures = new Map();
+
+    runner.on(EVENT_RUN_BEGIN, () => {
+      client.createRun();
+
+      // clear dir with artifacts/logs
+      fileSystem.clearDir(TESTOMAT_TMP_STORAGE_DIR);
+    });
+
+    runner.on(EVENT_SUITE_BEGIN, async suite => {
+      services.setContext(suite.fullTitle());
+    });
+
+    runner.on(EVENT_SUITE_END, async suite => {
+      if (hookFailures.has(suite.fullTitle())) {
+        const { error, suiteTitle } = hookFailures.get(suite.fullTitle());
+
+        for (const test of suite.tests) {
+          if (test.state === 'pending' || !test.state) {
+            const testId = getTestomatIdFromTestTitle(test.title);
+            const artifacts = services.artifacts.get(test.fullTitle());
+            const keyValues = services.keyValues.get(test.fullTitle());
+            const links = services.links.get(test.fullTitle());
+
+            client.addTestRun(STATUS.FAILED, {
+              error,
+              suite_title: suiteTitle || suite.title,
+              file: suite.file,
+              test_id: testId,
+              title: test.title,
+              code: process.env.TESTOMATIO_UPDATE_CODE ? test.body.toString() : '',
+              time: 0,
+              manuallyAttachedArtifacts: artifacts,
+              meta: keyValues,
+              links,
+            });
+          }
         }
       }
-    }
-
-    services.setContext(null);
-  });
-
-  runner.on(EVENT_TEST_BEGIN, async test => {
-    services.setContext(test.fullTitle());
-  });
-
-  runner.on(EVENT_TEST_END, async () => {
-    services.setContext(null);
-  });
-
-  runner.on(EVENT_TEST_PASS, async test => {
-    passes += 1;
-
-    console.log(pc.bold(pc.green('✔')), test.fullTitle());
-    const testId = getTestomatIdFromTestTitle(test.title);
-
-    const logs = getTestLogs(test);
-    const artifacts = services.artifacts.get(test.fullTitle());
-    const keyValues = services.keyValues.get(test.fullTitle());
-    const links = services.links.get(test.fullTitle());
-
-    client.addTestRun(STATUS.PASSED, {
-      test_id: testId,
-      suite_title: getSuiteTitle(test),
-      title: getTestName(test),
-      code: process.env.TESTOMATIO_UPDATE_CODE ? test.body.toString() : '',
-      file: getFile(test),
-      time: test.duration,
-      logs,
-      manuallyAttachedArtifacts: artifacts,
-      meta: keyValues,
-      links,
+
+      services.setContext(null);
+    });
+
+    runner.on(EVENT_TEST_BEGIN, async test => {
+      services.setContext(test.fullTitle());
+    });
+
+    runner.on(EVENT_TEST_END, async () => {
+      services.setContext(null);
     });
-  });
-
-  runner.on(EVENT_TEST_PENDING, test => {
-    skipped += 1;
-    console.log('skip: %s', test.fullTitle());
-    const testId = getTestomatIdFromTestTitle(test.title);
-    const artifacts = services.artifacts.get(test.fullTitle());
-    const keyValues = services.keyValues.get(test.fullTitle());
-    const links = services.links.get(test.fullTitle());
-
-    client.addTestRun(STATUS.SKIPPED, {
-      title: getTestName(test),
-      suite_title: getSuiteTitle(test),
-      code: process.env.TESTOMATIO_UPDATE_CODE ? test.body.toString() : '',
-      file: getFile(test),
-      test_id: testId,
-      time: test.duration,
-      manuallyAttachedArtifacts: artifacts,
-      meta: keyValues,
-      links,
+
+    runner.on(EVENT_TEST_PASS, async test => {
+      passes += 1;
+
+      console.log(pc.bold(pc.green('✔')), test.fullTitle());
+      const testId = getTestomatIdFromTestTitle(test.title);
+
+      const logs = getTestLogs(test);
+      const artifacts = services.artifacts.get(test.fullTitle());
+      const keyValues = services.keyValues.get(test.fullTitle());
+      const links = services.links.get(test.fullTitle());
+
+      client.addTestRun(STATUS.PASSED, {
+        test_id: testId,
+        suite_title: getSuiteTitle(test),
+        title: getTestName(test),
+        code: process.env.TESTOMATIO_UPDATE_CODE ? test.body.toString() : '',
+        file: getFile(test),
+        time: test.duration,
+        logs,
+        manuallyAttachedArtifacts: artifacts,
+        meta: keyValues,
+        links,
+      });
     });
-  });
 
-  runner.on(EVENT_TEST_FAIL, async (test, err) => {
-    failures += 1;
-    console.log(pc.bold(pc.red('✖')), test.fullTitle(), pc.gray(err.message));
+    runner.on(EVENT_TEST_PENDING, test => {
+      skipped += 1;
+      console.log('skip: %s', test.fullTitle());
+      const testId = getTestomatIdFromTestTitle(test.title);
+      const artifacts = services.artifacts.get(test.fullTitle());
+      const keyValues = services.keyValues.get(test.fullTitle());
+      const links = services.links.get(test.fullTitle());
+
+      client.addTestRun(STATUS.SKIPPED, {
+        title: getTestName(test),
+        suite_title: getSuiteTitle(test),
+        code: process.env.TESTOMATIO_UPDATE_CODE ? test.body.toString() : '',
+        file: getFile(test),
+        test_id: testId,
+        time: test.duration,
+        manuallyAttachedArtifacts: artifacts,
+        meta: keyValues,
+        links,
+      });
+    });
+
+    runner.on(EVENT_TEST_FAIL, async (test, err) => {
+      failures += 1;
+      console.log(pc.bold(pc.red('✖')), test.fullTitle(), pc.gray(err.message));
+
+      const isHookFailure = test.title.includes('before each') || test.title.includes('after each');
 
-    const isHookFailure = test.title.includes('before each') || test.title.includes('after each');
+      if (isHookFailure && test.parent) {
+        hookFailures.set(test.parent.fullTitle(), {
+          error: err,
+          suiteTitle: getSuiteTitle(test),
+        });
+        return;
+      }
+
+      const testId = getTestomatIdFromTestTitle(test.title);
 
-    if (isHookFailure && test.parent) {
-      hookFailures.set(test.parent.fullTitle(), {
+      const logs = getTestLogs(test);
+      const artifacts = services.artifacts.get(test.fullTitle());
+      const keyValues = services.keyValues.get(test.fullTitle());
+      const links = services.links.get(test.fullTitle());
+
+      client.addTestRun(STATUS.FAILED, {
         error: err,
-        suiteTitle: getSuiteTitle(test),
+        suite_title: getSuiteTitle(test),
+        file: getFile(test),
+        test_id: testId,
+        title: getTestName(test),
+        code: process.env.TESTOMATIO_UPDATE_CODE ? test.body.toString() : '',
+        time: test.duration,
+        logs,
+        manuallyAttachedArtifacts: artifacts,
+        meta: keyValues,
+        links,
       });
-      return;
-    }
-
-    const testId = getTestomatIdFromTestTitle(test.title);
-
-    const logs = getTestLogs(test);
-    const artifacts = services.artifacts.get(test.fullTitle());
-    const keyValues = services.keyValues.get(test.fullTitle());
-    const links = services.links.get(test.fullTitle());
-
-    client.addTestRun(STATUS.FAILED, {
-      error: err,
-      suite_title: getSuiteTitle(test),
-      file: getFile(test),
-      test_id: testId,
-      title: getTestName(test),
-      code: process.env.TESTOMATIO_UPDATE_CODE ? test.body.toString() : '',
-      time: test.duration,
-      logs,
-      manuallyAttachedArtifacts: artifacts,
-      meta: keyValues,
-      links,
     });
-  });
-
-  runner.on(EVENT_RUN_END, () => {
-    const status = failures === 0 ? STATUS.PASSED : STATUS.FAILED;
-    console.log(pc.bold(status), `${passes} passed, ${failures} failed, ${skipped} skipped`);
-    // @ts-ignore
-    client.updateRunStatus(status);
-  });
+
+    runner.on(EVENT_RUN_END, () => {
+      const status = failures === 0 ? STATUS.PASSED : STATUS.FAILED;
+      console.log(pc.bold(status), `${passes} passed, ${failures} failed, ${skipped} skipped`);
+      // @ts-ignore
+      client.updateRunStatus(status);
+    });
+  }
 }
 
 function getTestLogs(test) {
@@ -204,8 +209,4 @@ function getTestName(test) {
   return test.title;
 }
 
-// To have this reporter "extend" a built-in reporter uncomment the following line:
-// @ts-ignore
-Mocha.utils.inherits(MochaReporter, Mocha.reporters.Spec);
-
 export default MochaReporter;

package/src/adapter/nightwatch.js

@@ -3,6 +3,8 @@ import { config } from '../config.js';
 import { STATUS } from '../constants.js';
 import { getTestomatIdFromTestTitle } from '../utils/utils.js';
 
+global.TESTOMATIO_ADAPTER = 'nightwatch';
+
 const apiKey = config.TESTOMATIO;
 const client = new TestomatClient({ apiKey });
 

package/src/adapter/playwright.js

@@ -14,6 +14,8 @@ import { fetchLinksFromLogs } from './utils/playwright.js';
 import { formatStep, addStatusToStep, addArtifactsToStep } from './utils/step-formatter.js';
 import { log } from '../utils/log.js';
 
+global.TESTOMATIO_ADAPTER = 'playwright';
+
 class PlaywrightReporter {
   constructor(config = {}) {
     this.client = new TestomatioClient({ apiKey: config?.apiKey });

package/src/adapter/vitest.js

@@ -6,6 +6,8 @@ import createDebugMessages from 'debug';
 
 const debug = createDebugMessages('@testomatio/reporter:adapter-jest');
 
+global.TESTOMATIO_ADAPTER = 'vitest';
+
 /**
  * @typedef {import('../../types/types.js').VitestTest} VitestTest
  * @typedef {import('../../types/types.js').VitestTestFile} VitestTestFile

package/src/adapter/webdriver.js

@@ -5,6 +5,8 @@ import { services } from '../services/index.js';
 import { TESTOMAT_TMP_STORAGE_DIR } from '../constants.js';
 import { stringToMD5Hash } from '../data-storage.js';
 
+global.TESTOMATIO_ADAPTER = 'webdriverio';
+
 class WebdriverReporter extends WDIOReporter {
   constructor(options) {
     super(options);

package/src/allureReader.js

@@ -186,7 +186,8 @@ class AllureReader {
       steps: this.convertSteps(result.steps || [], resultsDir),
       message: result.statusDetails?.message || '',
       stack: result.statusDetails?.trace || '',
-      meta: this.extractMeta(result),
+      // meta must always include reporter version and adapter used
+      meta: { ...this.extractMeta(result), reporterVersion: this.version, adapter: 'allure' },
       links: this.extractLinks(result),
       artifacts: [],
       create: true,

package/src/bin/cli.js

@@ -16,7 +16,7 @@ import { filesize as prettyBytes } from 'filesize';
 import dotenv from 'dotenv';
 import Replay from '../replay.js';
 import { log } from '../utils/log.js';
-import { formatFilterListIds, formatRunOutput, formatFetchRunsOutput } from '../utils/pipe_utils.js';
+import { formatFilterListIds, formatRunOutput, formatFetchRunsOutput, parseRunsUrl } from '../utils/pipe_utils.js';
 import fs from 'fs';
 import path from 'path';
 
@@ -130,7 +130,9 @@ program
 program
   .command('fetch')
   .description('Fetch runs from Testomat.io API v2')
+  .argument('[url]', 'URL of a run or of a (filtered) runs page in Testomat.io')
   .option('--project <slug>', 'Project slug (or set TESTOMATIO_PROJECT)')
+  .option('--run <id>', 'Fetch a single run by its id')
   .option('--title <text>', 'Filter by run title')
   .option('--tql <query>', 'Filter using Testomat Query Language')
   .option('--rungroup <uid>', 'Filter by rungroup id')
@@ -144,27 +146,44 @@ program
     '--format <format>',
     'Machine-readable output: run ids, one per line (--format id) or run details (--format json)',
   )
-  .action(async opts => {
+  .action(async (pageUrl, opts) => {
     const apiKey = process.env['INPUT_TESTOMATIO-KEY'] || config.TESTOMATIO;
     if (!apiKey) {
       log.error(pc.red('⚠️  TESTOMATIO API key required'));
       process.exit(1);
     }
 
-    const project = opts.project || process.env.TESTOMATIO_PROJECT;
+    let page = {};
+    if (pageUrl) {
+      page = parseRunsUrl(pageUrl);
+      if (!page) {
+        log.error(pc.red(`⚠️  Not a Testomat.io run or runs page URL: ${pageUrl}`));
+        process.exit(1);
+      }
+    }
+
+    const project = opts.project || page.project || process.env.TESTOMATIO_PROJECT;
     if (!project) {
       log.error(pc.red('⚠️  --project (or TESTOMATIO_PROJECT) is required'));
       process.exit(1);
     }
 
-    const baseUrl = process.env.TESTOMATIO_URL || 'https://app.testomat.io';
-    const url = new URL(`/api/v2/${project}/runs`, baseUrl);
-    if (opts.title) url.searchParams.set('search', opts.title);
-    if (opts.tql) url.searchParams.set('tql', opts.tql);
-    if (opts.rungroup) url.searchParams.set('groupId', opts.rungroup);
-    const requestedLimit = opts.latest ? 1 : parseInt(opts.limit, 10) || FETCH_RUNS_DEFAULT_LIMIT;
-    const limit = Math.min(Math.max(requestedLimit, 1), FETCH_RUNS_MAX_LIMIT);
-    url.searchParams.set('per_page', String(limit));
+    const baseUrl = page.baseUrl || process.env.TESTOMATIO_URL || 'https://app.testomat.io';
+    const runId = opts.run || page.runId;
+    let url;
+
+    if (runId) {
+      url = new URL(`/api/v2/${project}/runs/${runId}`, baseUrl);
+    } else {
+      url = new URL(`/api/v2/${project}/runs`, baseUrl);
+      for (const [key, value] of page.params || []) url.searchParams.append(key, value);
+      if (opts.title) url.searchParams.set('search', opts.title);
+      if (opts.tql) url.searchParams.set('tql', opts.tql);
+      if (opts.rungroup) url.searchParams.set('groupId', opts.rungroup);
+      const requestedLimit = opts.latest ? 1 : parseInt(opts.limit, 10) || FETCH_RUNS_DEFAULT_LIMIT;
+      const limit = Math.min(Math.max(requestedLimit, 1), FETCH_RUNS_MAX_LIMIT);
+      url.searchParams.set('per_page', String(limit));
+    }
 
     const response = await fetch(url, { headers: { Authorization: `Bearer ${apiKey}` } });
     const body = await response.json();

package/src/client.js

@@ -36,6 +36,8 @@ class Client {
     this.pipeStore = {};
     this.runId = '';
     this.queue = Promise.resolve();
+    // adapter name is set by the adapter module itself on load (global.TESTOMATIO_ADAPTER)
+    this.adapterName = params.adapter || global.TESTOMATIO_ADAPTER;
 
     // @ts-ignore this line will be removed in compiled code, because __dirname is defined in commonjs
     const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -244,7 +246,9 @@ class Client {
       overwrite,
       tags,
     } = testData;
-    let { files = [], manuallyAttachedArtifacts, message = '', meta = {} } = testData;
+    let { files = [], manuallyAttachedArtifacts, message = '' } = testData;
+    /** @type {Record<string, any>} */
+    let meta = testData.meta || {};
 
     if (stepArtifactPaths.size) {
       const isStepArtifact = item => stepArtifactPaths.has(typeof item === 'object' ? item?.path : item);
@@ -261,6 +265,10 @@ class Client {
         return acc;
       }, {});
 
+    // meta must always include reporter version and adapter used
+    if (this.version) meta.reporterVersion = this.version;
+    if (this.adapterName) meta.adapter = this.adapterName;
+
     const testContext = suite_title ? `${suite_title} ${title}` : title;
 
     let errorFormatted = '';
@@ -389,8 +397,8 @@ class Client {
     this.queue = this.queue
       .then(() => Promise.all(this.pipes.map(p => p.finishRun(runParams))))
       .then(() => {
-        if (!this.uploader.isEnabled) return;
-
+        // no early return when uploading is disabled:
+        // skipped artifacts (e.g. no S3 credentials obtained) must still be reported to the user
         const filesizeStrMaxLength = 7;
 
         if (this.uploader.successfulUploads.length) {

package/src/data-storage.js

@@ -190,9 +190,10 @@ class DataStorage {
 }
 
 function stringToMD5Hash(str) {
-  const md5 = crypto.createHash('md5');
-  md5.update(str);
-  const hash = md5.digest('hex');
+  // sha256 instead of md5 for FIPS-enabled hosts compatibility
+  const sha256 = crypto.createHash('sha256');
+  sha256.update(str);
+  const hash = sha256.digest('hex');
   return `${process.env.runId || 'run'}_${hash}`;
 }
 

package/src/pipe/testomatio.js

@@ -352,6 +352,8 @@ class TestomatioPipe {
       if (resp.data.artifacts) {
         setS3Credentials(resp.data.artifacts);
         this.#startS3CredentialsRefresh(runParams);
+      } else {
+        this.#warnNoS3Credentials();
       }
       if (resp.data.url) {
         const respUrl = new URL(resp.data.url);
@@ -383,6 +385,8 @@ class TestomatioPipe {
       if (resp.data.artifacts) {
         setS3Credentials(resp.data.artifacts);
         this.#startS3CredentialsRefresh(runParams);
+      } else {
+        this.#warnNoS3Credentials();
       }
 
       this.store.runUrl = this.runUrl;
@@ -442,10 +446,32 @@ class TestomatioPipe {
         debug('S3 credentials refreshed');
       }
     } catch (err) {
-      debug('Failed to refresh S3 credentials:', err.message || err);
+      log.warn(
+        '⚠️ Failed to refresh S3 credentials:',
+        err.message || err,
+        '\nArtifact uploads may fail once the current credentials expire.',
+      );
     }
   };
 
+  /**
+   * Warns the user when Testomat.io did not return S3 credentials for artifacts upload.
+   * Skipped when artifacts uploading was intentionally disabled or a custom S3 storage is configured via env.
+   */
+  #warnNoS3Credentials() {
+    if (process.env.TESTOMATIO_DISABLE_ARTIFACTS || process.env.S3_BUCKET) return;
+
+    const command = `TESTOMATIO=<your_api_key> TESTOMATIO_RUN=${
+      this.runId || '<run_id>'
+    } npx @testomatio/reporter upload-artifacts`;
+    log.warn(
+      `⚠️ ${pc.yellow('Testomat.io did not return S3 credentials for artifacts upload.')}`,
+      'Artifacts will not be uploaded.',
+      'Please check the artifact sharing settings of your project.',
+      `\nRun "${pc.magenta(command)}" later with valid S3 credentials to re-upload artifacts to this run.`,
+    );
+  }
+
   #stopS3CredentialsRefresh() {
     if (this.s3CredentialsRefreshTimer) {
       clearInterval(this.s3CredentialsRefreshTimer);

package/src/replay.js

@@ -237,6 +237,7 @@ export class Replay {
 
     const client = new TestomatClient({
       apiKey: this.apiKey,
+      adapter: 'replay',
       batchMode: BATCH_MODE.AUTO,
       ...runParams,
       ...(runId && { runId }),

package/src/uploader.js

@@ -23,6 +23,7 @@ export class S3Uploader {
      */
     this.skippedUploads = [];
     this.failedUploads = [];
+    this.warnedDisabledUpload = false;
     /**
      * @type {{path: string, size: number, link: string}[]}
      */
@@ -90,6 +91,30 @@ export class S3Uploader {
     this.storeEnabled = false;
   }
 
+  /**
+   * Warns once when artifact uploading is disabled not intentionally by the user,
+   * e.g. S3 credentials were not obtained from Testomat.io and no custom S3 storage is configured.
+   * Without this warning artifacts are skipped silently.
+   */
+  #warnDisabledUpload(runId) {
+    if (this.warnedDisabledUpload) return;
+
+    const { S3_BUCKET, TESTOMATIO_DISABLE_ARTIFACTS } = this.getConfig();
+    // uploading was intentionally disabled by the user or a custom S3 storage is used, nothing to warn about
+    if (TESTOMATIO_DISABLE_ARTIFACTS || S3_BUCKET) return;
+
+    this.warnedDisabledUpload = true;
+    const command = `TESTOMATIO=<your_api_key> TESTOMATIO_RUN=${
+      runId || '<run_id>'
+    } npx @testomatio/reporter upload-artifacts`;
+    log.warn(
+      `🗄️ ${pc.yellow('Artifacts uploading is disabled: S3 credentials were not obtained from Testomat.io')}`,
+      pc.yellow('(and no custom S3 storage is configured).'),
+      'Artifacts will not be uploaded.',
+      `\nRun "${pc.magenta(command)}" later with valid S3 credentials to re-upload artifacts to this run.`,
+    );
+  }
+
   /**
    *
    * @param {*} Body
@@ -231,6 +256,7 @@ export class S3Uploader {
     }
 
     if (!this.isEnabled) {
+      this.#warnDisabledUpload(runId);
       this.storeUploadedFile(filePath, runId, rid, false);
       this.skippedUploads.push({ path: filePath, size: fileSize });
       return;
@@ -281,7 +307,10 @@ export class S3Uploader {
     probably, the reason is that run is NOT created in adapter (but via cli) */
 
     this.isEnabled = this.isEnabled ?? this.checkEnabled();
-    if (!this.isEnabled) return;
+    if (!this.isEnabled) {
+      this.#warnDisabledUpload(pathInS3[0]);
+      return;
+    }
 
     let Key = pathInS3.filter(p => !!p).join('/');
     const ext = this.#getFileExtBase64(buffer.toString('base64'));

package/src/utils/pipe_utils.js

@@ -366,17 +366,18 @@ function formatRunOutput(store, format) {
 
 /**
  * Format the runs fetched via the `fetch` command for machine-readable output.
- * `json` prints the full array of run objects; `id` prints one run id per line;
+ * `json` prints the full array of run objects (a single object for one run); `id` prints one run id per line;
  * any other format prints a human-readable multi-line summary per run.
  *
- * @param {{data?: Array}} body - Parsed response body from GET /api/v2/:project/runs.
+ * @param {{data?: Array|Object}} body - Parsed response body from GET /api/v2/:project/runs[/:id].
  * @param {string} [format] - Value of the CLI `--format` option.
  * @returns {string}
  */
 function formatFetchRunsOutput(body, format) {
-  const runs = body?.data || [];
+  const data = body?.data || [];
+  const runs = [data].flat();
 
-  if (format === 'json') return JSON.stringify(runs, null, 2);
+  if (format === 'json') return JSON.stringify(data, null, 2);
 
   if (format === 'id') return runs.map(run => run.id).filter(Boolean).join('\n');
 
@@ -384,6 +385,7 @@ function formatFetchRunsOutput(body, format) {
     .map(run => {
       const lines = [`* ID: ${run.id}`];
       if (run.title) lines.push(`  title: ${run.title}`);
+      if (run.rungroup_id) lines.push(`  rungroup: ${run.rungroup_id}`);
       if (run.launched_at) lines.push(`  started at: ${run.launched_at}`);
       if (run.finished_at) lines.push(`  finished at: ${run.finished_at}`);
       if (run.passed_count != null) lines.push(`  passed: ${run.passed_count} tests`);
@@ -397,6 +399,44 @@ function formatFetchRunsOutput(body, format) {
     .join('\n');
 }
 
+// filterParam keys of the runs page which are API params on their own; the rest go under filter[...]
+const RUNS_PAGE_PARAMS = ['search', 'tql', 'groupId'];
+
+/**
+ * Parse a Testomat.io app URL of a run (/projects/:project/runs/:id)
+ * or of a runs page (/projects/:project/runs?filterParam=...) into API v2 request parts.
+ *
+ * @param {string} pageUrl
+ * @returns {{baseUrl: string, project: string, runId?: string, params: string[][]}|null}
+ */
+function parseRunsUrl(pageUrl) {
+  let url;
+  try {
+    url = new URL(pageUrl);
+  } catch (e) {
+    return null;
+  }
+
+  const match = url.pathname.match(/\/projects\/([^/]+)\/runs(?:\/([^/]+))?\/?$/);
+  if (!match) return null;
+
+  const [, project, runId] = match;
+  const params = [];
+
+  for (const [key, value] of new URLSearchParams(url.searchParams.get('filterParam') || '')) {
+    // "groups" only switches the page to the grouped view
+    if (!value || key === 'groups') continue;
+    if (RUNS_PAGE_PARAMS.includes(key)) {
+      params.push([key, value]);
+      continue;
+    }
+    const [name, ...nested] = key.split('[');
+    params.push([`filter[${name}]${nested.map(part => `[${part}`).join('')}`, value]);
+  }
+
+  return { baseUrl: url.origin, project, runId, params };
+}
+
 export {
   updateFilterType,
   parseFilterParams,
@@ -413,6 +453,7 @@ export {
   formatFilterListIds,
   formatRunOutput,
   formatFetchRunsOutput,
+  parseRunsUrl,
   getObjectSize,
   splitTestsIntoChunks,
 };

package/src/xmlReader.js

@@ -499,6 +499,9 @@ class XmlReader {
       this.adapter.formatTest(t);
 
       t.title = humanize(t.title);
+
+      // meta must always include reporter version and adapter used
+      t.meta = { ...t.meta, reporterVersion: this.version, adapter: 'xml' };
     });
   }
 

package/types/types.d.ts

@@ -374,6 +374,7 @@ declare global {
       testomatioDataStore?: any;
       TESTOMATIO_LOGGER_CONSOLE_INTERCEPTED?: boolean;
       testomatioTestTitle?: string;
+      TESTOMATIO_ADAPTER?: string;
     }
   }
 }