testomatio-reporter-cli 2.14.0-beta → 2.15.0-beta.1-json-output

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testomatio-reporter-cli",
-  "version": "2.14.0-beta",
+  "version": "2.15.0-beta.1-json-output",
   "description": "Yarn Berry compatible standalone CLI for @testomatio/reporter",
   "type": "module",
   "bin": {

package/src/allureReader.js

@@ -183,7 +183,7 @@ class AllureReader {
       suite_title: this.extractSuiteTitle(result),
       file: this.extractFile(result),
       run_time: this.calculateRunTime(result),
-      steps: this.convertSteps(result.steps || []),
+      steps: this.convertSteps(result.steps || [], resultsDir),
       message: result.statusDetails?.message || '',
       stack: result.statusDetails?.trace || '',
       meta: this.extractMeta(result),
@@ -209,21 +209,9 @@ class AllureReader {
       test.example = this.convertParameters(result.parameters);
     }
 
-    if (result.attachments && result.attachments.length > 0) {
-      const attachments = result.attachments
-        .map(att => {
-          const fullPath = path.join(resultsDir, att.source);
-          if (fs.existsSync(fullPath)) {
-            return fullPath;
-          }
-          debug('Attachment file not found:', fullPath);
-          return null;
-        })
-        .filter(Boolean);
-
-      if (attachments.length > 0) {
-        test.files = attachments;
-      }
+    const attachments = this.resolveAttachments(result.attachments, resultsDir);
+    if (attachments.length > 0) {
+      test.files = attachments;
     }
 
     return test;
@@ -531,7 +519,7 @@ class AllureReader {
     return this.extractTmsIdsFromSource(contents, test)[0] || null;
   }
 
-  convertSteps(steps, depth = 0) {
+  convertSteps(steps, resultsDir = '', depth = 0) {
     if (depth >= 10) return null;
 
     return steps
@@ -541,9 +529,15 @@ class AllureReader {
           title: step.name || step.title || 'Unknown step',
           status: this.mapStepStatus(step.status),
           duration: this.calculateRunTime(step),
-          steps: this.convertSteps(step.steps || [], depth + 1),
+          steps: this.convertSteps(step.steps || [], resultsDir, depth + 1),
         };
 
+        // step attachments stay on the step; uploadArtifacts() swaps the paths for links
+        const attachments = this.resolveAttachments(step.attachments, resultsDir);
+        if (attachments.length > 0) {
+          convertedStep.artifacts = attachments;
+        }
+
         // Attach the failure description (error message + trace with the failing
         // code line) straight onto the failed step. Testomat.io renders a step's
         // `error` inline in the step tree, so the failure shows up on the exact
@@ -876,16 +870,68 @@ class AllureReader {
     return paths;
   }
 
+  /**
+   * @param {Array<{source?: string}>|undefined} attachments
+   * @param {string} resultsDir
+   * @returns {string[]} paths of attachments that exist on disk
+   */
+  resolveAttachments(attachments, resultsDir) {
+    if (!attachments || !attachments.length) return [];
+
+    return attachments
+      .map(att => {
+        if (!att?.source) return null;
+        const fullPath = path.join(resultsDir || '', att.source);
+        if (fs.existsSync(fullPath)) return fullPath;
+        debug('Attachment file not found:', fullPath);
+        return null;
+      })
+      .filter(Boolean);
+  }
+
+  /**
+   * Replaces step artifact paths with S3 links, dropping failed uploads (a local path
+   * would be a dead link in the UI).
+   *
+   * @param {Array<object>|undefined} steps
+   * @param {string} runId
+   * @param {string} rid
+   * @returns {Promise<number>} number of uploaded step artifacts
+   */
+  async uploadStepArtifacts(steps, runId, rid) {
+    if (!steps || !steps.length) return 0;
+
+    let uploaded = 0;
+    for (const step of steps) {
+      if (step.artifacts?.length) {
+        const links = await Promise.all(
+          step.artifacts.map(f => this.uploader.uploadFileByPath(f, [runId, rid, 'steps', path.basename(f)])),
+        );
+        step.artifacts = links.filter(link => !!link);
+        uploaded += step.artifacts.length;
+        if (!step.artifacts.length) delete step.artifacts;
+      }
+      uploaded += await this.uploadStepArtifacts(step.steps, runId, rid);
+    }
+    return uploaded;
+  }
+
   async uploadArtifacts() {
-    for (const test of this._tests.filter(t => t.files && t.files.length > 0)) {
+    for (const test of this._tests) {
       const runId = this.runId || this.store.runId || Date.now().toString();
-      const artifacts = await Promise.all(
-        test.files.map(f => this.uploader.uploadFileByPath(f, [runId, test.rid, path.basename(f)])),
+
+      // uploadFileByPath resolves to a link string, or undefined if skipped or failed
+      const links = await Promise.all(
+        (test.files || []).map(f => this.uploader.uploadFileByPath(f, [runId, test.rid, path.basename(f)])),
       );
-      test.artifacts = artifacts.filter(a => a && a.link).map(a => a.link);
+      test.artifacts = links.filter(link => !!link);
       delete test.files;
-      if (test.artifacts.length > 0) {
-        console.log(APP_PREFIX, `🗄️ Uploaded ${pc.bold(`${test.artifacts.length} artifacts`)} for test ${test.title}`);
+
+      const stepArtifacts = await this.uploadStepArtifacts(test.steps, runId, test.rid);
+
+      const total = test.artifacts.length + stepArtifacts;
+      if (total > 0) {
+        console.log(APP_PREFIX, `🗄️ Uploaded ${pc.bold(`${total} artifacts`)} for test ${test.title}`);
       }
     }
   }

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 } from '../utils/pipe_utils.js';
+import { formatFilterListIds, formatRunOutput } from '../utils/pipe_utils.js';
 import fs from 'fs';
 import path from 'path';
 
@@ -51,9 +51,9 @@ program
 program
   .command('start')
   .description('Start a new run and return its ID')
-  .option('--kind <type>', 'Specify run type: automated, manual, or mixed')
+  .option('--kind <type>', 'Specify run type: automated, manual, mixed, or detect')
   .option('--filter <filter>', 'Scope the prepared run to tests matching the filter (no execution)')
-  .option('--format <format>', 'Machine-readable output: print only the run id to stdout (e.g. --format id)')
+  .option('--format <format>', 'Machine-readable output: the run id (--format id) or run details (--format json)')
   .option('--warn', 'Exit 0 instead of 1 when the filter matches no tests (warn only)')
   .action(async opts => {
     cleanLatestRunId();
@@ -93,8 +93,8 @@ program
     const plannedTests = (client.pipeStore.preparedTestIds || []).map(id => ({ test_id: id, title: id }));
     await client.updateRunStatus('pending', { tests: plannedTests });
 
-    // stdout carries ONLY the run id so it can be captured: RUN_ID=$(reporter start)
-    console.log(runId);
+    // stdout carries ONLY the run data so it can be captured: RUN_ID=$(reporter start)
+    console.log(formatRunOutput({ ...client.pipeStore, runId }, opts.format));
     process.exit(0);
   });
 
@@ -129,8 +129,11 @@ program
   .argument('[command]', 'Test runner command')
   .option('--filter <filter>', 'Additional execution filter')
   .option('--filter-list <filter>', 'Get a list of all tests by filter before running')
-  .option('--format <format>', 'Machine-readable output format for --filter-list (grep, json, newline, ids)')
-  .option('--kind <type>', 'Specify run type: automated, manual, or mixed')
+  .option(
+    '--format <format>',
+    'Machine-readable output: test ids for --filter-list (grep, json, newline, ids), or the run created (id, json)',
+  )
+  .option('--kind <type>', 'Specify run type: automated, manual, mixed, or detect')
   .option('--remote <profile>', 'Trigger run on the named Testomat.io CI profile instead of executing locally')
   .option(
     '--remote-param <kv>',
@@ -230,6 +233,8 @@ program
 
       log.info(`🚀 CI build triggered on profile ${pc.cyan(opts.remote)}`);
       log.info(`📊 Report URL: ${pc.magenta(client.pipeStore.runUrl)}`);
+      const remoteOutput = formatRunOutput(client.pipeStore, opts.format);
+      if (opts.format && remoteOutput) console.log(remoteOutput);
       return process.exit(0);
     }
 
@@ -252,6 +257,8 @@ program
           log.info( `No command passed, so you need to run tests yourself:`);
           log.info( `TESTOMATIO_RUN=${runId} <command>`);
         }
+        const runOutput = formatRunOutput({ ...client.pipeStore, runId }, opts.format);
+        if (opts.format && runOutput) console.log(runOutput);
       } else {
         log.info( '⚠️  No API key provided. Cannot create run without TESTOMATIO key.');
         process.exit(1);
@@ -288,7 +295,11 @@ program
     }
 
     if (apiKey) {
-      await client.createRun(createRunParams).then(runTests);
+      await client.createRun(createRunParams);
+      // the runner inherits stdout, so the run data is printed first, on its own line
+      const createdOutput = formatRunOutput(client.pipeStore, opts.format);
+      if (opts.format && createdOutput) console.log(createdOutput);
+      await runTests();
     } else {
       await runTests();
     }

package/src/pipe/html.js

@@ -32,6 +32,7 @@ class HtmlPipe {
     this.filenameMsg = '';
     this.tests = [];
     this.configuration = null;
+    this.startedAt = null;
 
     if (this.isHtml) {
       this.isEnabled = true;
@@ -70,6 +71,8 @@ class HtmlPipe {
   }
 
   async createRun(params = {}) {
+    this.startedAt ??= new Date();
+
     if (params?.configuration && typeof params.configuration === 'object') {
       this.configuration = { ...(this.configuration || {}), ...params.configuration };
     }
@@ -266,7 +269,7 @@ class HtmlPipe {
       parallel: runParams.isParallel || 'No parallel info',
       runUrl: this.store.runUrl || '',
       executionTime: testExecutionSumTime(aggregatedTests),
-      executionDate: getCurrentDateTimeFormatted(),
+      executionDate: getDateTimeFormatted(this.startedAt || new Date()),
       description:
         [this.description, runParams.description || this.store.coverageDescription || this.store.description]
           .filter(Boolean)
@@ -722,17 +725,17 @@ function formatDuration(duration) {
 }
 
 /**
- * Retrieves the current date and time in a formatted string.
+ * Formats a date and time for display in the report.
+ * @param {Date} date - Date and time to format.
  * @returns {string} - The formatted date and time string (e.g., "(01/01/2023 12:00:00)").
  */
-function getCurrentDateTimeFormatted() {
-  const currentDate = new Date();
-  const day = currentDate.getDate().toString().padStart(2, '0');
-  const month = (currentDate.getMonth() + 1).toString().padStart(2, '0');
-  const year = currentDate.getFullYear();
-  const hours = currentDate.getHours().toString().padStart(2, '0');
-  const minutes = currentDate.getMinutes().toString().padStart(2, '0');
-  const seconds = currentDate.getSeconds().toString().padStart(2, '0');
+function getDateTimeFormatted(date) {
+  const day = date.getDate().toString().padStart(2, '0');
+  const month = (date.getMonth() + 1).toString().padStart(2, '0');
+  const year = date.getFullYear();
+  const hours = date.getHours().toString().padStart(2, '0');
+  const minutes = date.getMinutes().toString().padStart(2, '0');
+  const seconds = date.getSeconds().toString().padStart(2, '0');
 
   return `(${day}/${month}/${year} ${hours}:${minutes}:${seconds})`;
 }

package/src/utils/pipe_utils.js

@@ -304,6 +304,27 @@ function plannedTestsLabel(tests, testsCount) {
   return `**${knownTestsCount}** tests and **${suitesCount}** suites planned`;
 }
 
+/**
+ * Format the created run for machine-readable output of `start` and `run`.
+ * `json` prints an object with the run details, any other format prints the bare run id.
+ *
+ * @param {{runId?: string, runUrl?: string, runPublicUrl?: string}} store - Pipe store of the client.
+ * @param {string} [format] - Value of the CLI `--format` option.
+ * @returns {string} Empty string if there is no run id.
+ */
+function formatRunOutput(store, format) {
+  const runId = store?.runId;
+  if (!runId) return '';
+
+  if (format !== 'json') return runId;
+
+  const output = { runId };
+  if (store.runUrl) output.runUrl = store.runUrl;
+  if (store.runPublicUrl) output.runPublicUrl = store.runPublicUrl;
+
+  return JSON.stringify(output);
+}
+
 export {
   updateFilterType,
   parseFilterParams,
@@ -317,6 +338,7 @@ export {
   plannedTestsLabel,
   parsePipeOptions,
   formatFilterListIds,
+  formatRunOutput,
   getObjectSize,
   splitTestsIntoChunks,
 };

package/src/xmlReader.js

@@ -533,8 +533,10 @@ class XmlReader {
       if (!files.length) continue;
 
       const runId = this.runId || this.store.runId || Date.now().toString();
-      test.artifacts = await Promise.all(files.map(f => this.uploader.uploadFileByPath(f, [runId, path.basename(f)])));
-      log.info(`🗄️ Uploaded ${pc.bold(`${files.length} artifacts`)} for test ${test.title}`);
+      // undefined for skipped/failed uploads; keeping those serializes as `null` links
+      const links = await Promise.all(files.map(f => this.uploader.uploadFileByPath(f, [runId, path.basename(f)])));
+      test.artifacts = links.filter(link => !!link);
+      log.info(`🗄️ Uploaded ${pc.bold(`${test.artifacts.length} artifacts`)} for test ${test.title}`);
     }
   }
 

package/types/types.d.ts

@@ -337,8 +337,8 @@ export interface PipeResult {
  * `TESTOMATIO_CI_PROFILE` and `TESTOMATIO_CI_OVERRIDE`.
  */
 export interface CreateRunParams {
-  /** Run kind. Defaults to `automated` server-side. */
-  kind?: 'automated' | 'manual' | 'mixed';
+  /** Run kind. Defaults to `automated` server-side. `detect` resolves to one of the other three from the scoped tests. */
+  kind?: 'automated' | 'manual' | 'mixed' | 'detect';
 
   /** Run title. */
   title?: string;