@testomatio/reporter 1.6.0-beta-artifacts → 1.6.0

package/lib/adapter/mocha.js

@@ -66,7 +66,7 @@ function MochaReporter(runner, opts) {
       test_id: testId,
       suite_title: getSuiteTitle(test),
       title: getTestName(test),
-      code: test.body.toString(),
+      code: process.env.TESTOMATIO_UPDATE_CODE ? test.body.toString() : '',
       file: getFile(test),
       time: test.duration,
       logs,
@@ -82,7 +82,7 @@ function MochaReporter(runner, opts) {
     client.addTestRun(STATUS.SKIPPED, {
       title: getTestName(test),
       suite_title: getSuiteTitle(test),
-      code: test.body.toString(),
+      code: process.env.TESTOMATIO_UPDATE_CODE ? test.body.toString() : '',
       file: getFile(test),
       test_id: testId,
       time: test.duration,
@@ -102,7 +102,7 @@ function MochaReporter(runner, opts) {
       file: getFile(test),
       test_id: testId,
       title: getTestName(test),
-      code: test.body.toString(),
+      code: process.env.TESTOMATIO_UPDATE_CODE ? test.body.toString() : '',
       time: test.duration,
       logs,
     });

package/lib/adapter/playwright.js

@@ -104,7 +104,6 @@ class PlaywrightReporter {
     if (!this.client) return;
 
     await Promise.all(reportTestPromises);
-    await this.client.updateRunStatus(checkStatus(result.status));
 
     if (!this.uploads.length) return;
 
@@ -112,6 +111,7 @@ class PlaywrightReporter {
 
     const promises = [];
 
+    // ? possible move to addTestRun (needs investigation if files are ready)
     for (const upload of this.uploads) {
       const { rid, file, title } = upload;
 
@@ -136,6 +136,8 @@ class PlaywrightReporter {
       );
     }
     await Promise.all(promises);
+
+    await this.client.updateRunStatus(checkStatus(result.status));
   }
 }
 

package/lib/adapter/webdriver.js

@@ -70,10 +70,10 @@ class WebdriverReporter extends WDIOReporter {
       .map(el => Buffer.from(el.result.value, 'base64'));
 
     await this.client.addTestRun(state, {
-      // manuallyAttachedArtifacts: test.artifacts,
+      manuallyAttachedArtifacts: test.artifacts,
       error,
       logs: test.logs,
-      // meta: test.meta,
+      meta: test.meta,
       title,
       test_id: testId,
       time: duration,

package/lib/bin/cli.js

@@ -10,6 +10,7 @@ const { APP_PREFIX, STATUS } = require('../constants');
 const { version } = require('../../package.json');
 const config = require('../config');
 const { readLatestRunId } = require('../utils/utils');
+const { filesize: prettyBytes } = require('filesize');
 
 console.log(chalk.cyan.bold(` 🤩 Testomat.io Reporter v${version}`));
 
@@ -193,7 +194,7 @@ program
     if (!opts.force) testruns = testruns.filter(tr => !tr.uploaded);
 
     if (!testruns.length) {
-      console.log(APP_PREFIX, 'Total artifacts:', numTotalArtifacts);
+      console.log(APP_PREFIX, '🗄️ Total artifacts:', numTotalArtifacts);
       if (numTotalArtifacts) {
         console.log(APP_PREFIX, 'No new artifacts to upload');
         console.log(APP_PREFIX, 'To re-upload artifacts run this command with --force flag');
@@ -211,16 +212,38 @@ program
 
     await client.createRun();
     client.uploader.checkEnabled();
-    client.uploader.disbleLogStorage();
+    client.uploader.disableLogStorage();
 
     for (const rid in testrunsByRid) {
       const files = testrunsByRid[rid];
       await client.addTestRun(undefined, { rid, files });
     }
 
-    console.log(APP_PREFIX, client.uploader.totalUploadsCount, 'artifacts uploaded');
-    if (client.uploader.failedUploadsCount) {
-      console.log(APP_PREFIX, client.uploader.failedUploadsCount, 'artifacts failed to upload');
+    console.log(APP_PREFIX, '🗄️', client.uploader.totalSuccessfulUploadsCount, 'artifacts 🟢uploaded');
+    const filesizeStrMaxLength = 7;
+
+    if (client.uploader.failedUploads.length) {
+      console.log(
+        '\n',
+        APP_PREFIX,
+        '🗄️',
+        client.uploader.failedUploads.length,
+        `artifacts 🔴${chalk.bold('failed')} to upload`,
+      );
+
+      const failedUploads = client.uploader.failedUploads.map(({ path, size }) => ({
+        relativePath: path.replace(process.cwd(), ''),
+        sizePretty: prettyBytes(size, { round: 0 }).toString(),
+      }));
+
+      const pathPadding = Math.max(...failedUploads.map(upload => upload.relativePath.length)) + 1;
+      failedUploads.forEach(upload => {
+        console.log(
+          `  ${chalk.gray('|')} 🔴 ${upload.relativePath.padEnd(pathPadding)} ${chalk.gray(
+            `| ${upload.sizePretty.padStart(filesizeStrMaxLength)} |`,
+          )}`,
+        );
+      });
     }
   });
 

package/lib/bin/uploadArtifacts.js

@@ -64,7 +64,7 @@ program
     await client.createRun();
 
     client.uploader.checkEnabled();
-    client.uploader.disbleLogStorage();
+    client.uploader.disableLogStorage();
 
     for (const rid in testrunsByRid) {
       const files = testrunsByRid[rid];
@@ -74,9 +74,9 @@ program
       });
     }
 
-    console.log(APP_PREFIX, client.uploader.totalUploadsCount, 'artifacts uploaded');
-    if (client.uploader.failedUploadsCount) {
-      console.log(APP_PREFIX, client.uploader.failedUploadsCount, 'artifacts failed to upload');
+    console.log(APP_PREFIX, client.uploader.totalSuccessfulUploadsCount, 'artifacts uploaded');
+    if (client.uploader.failedUploads.length) {
+      console.log(APP_PREFIX, client.uploader.failedUploads.length, 'artifacts failed to upload');
     }
   });
 

package/lib/client.js

@@ -10,7 +10,8 @@ const { APP_PREFIX, STATUS } = require('./constants');
 const pipesFactory = require('./pipe');
 const { glob } = require('glob');
 const path = require('path');
-const { storeRunId } = require('./utils/utils');
+const { storeRunId, formatStep } = require('./utils/utils');
+const { filesize: prettyBytes } = require('filesize');
 
 let listOfTestFilesToExcludeFromReport = null;
 
@@ -250,32 +251,65 @@ class Client {
     this.queue = this.queue
       .then(() => Promise.all(this.pipes.map(p => p.finishRun(runParams))))
       .then(() => {
-        debug('TOTAL artifacts', this.uploader.totalUploadsCount);
-        debug(`${this.uploader.skippedUploadsCount} artifacts skipped`);
-
-        if (this.uploader.totalUploadsCount && this.uploader.isEnabled) {
+        if (this.uploader.totalSuccessfulUploadsCount && this.uploader.isEnabled) {
           console.log(
             APP_PREFIX,
-            `🗄️ ${this.uploader.totalUploadsCount} artifacts ${
+            `🗄️ ${this.uploader.totalSuccessfulUploadsCount} artifacts ${
               process.env.TESTOMATIO_PRIVATE_ARTIFACTS ? 'privately' : chalk.bold('publicly')
-            } uploaded to S3 bucket`,
+            } 🟢 uploaded to S3 bucket`,
           );
         }
 
-        if (this.uploader.failedUploadsCount) {
+        const filesizeStrMaxLength = 7;
+
+        if (this.uploader.failedUploads.length) {
           console.log(
+            '\n',
             APP_PREFIX,
-            chalk.gray('[CLIENT]'),
-            `${this.uploader.failedUploadsCount} artifacts failed to upload`,
+            `🗄️ ${this.uploader.failedUploads.length} artifacts 🔴${chalk.bold('failed')} to upload`,
           );
+          const failedUploads = this.uploader.failedUploads.map(file => ({
+            relativePath: file.path.replace(process.cwd(), ''),
+            sizePretty: prettyBytes(file.size, { round: 0 }).toString(),
+          }));
+
+          const pathPadding = Math.max(...failedUploads.map(upload => upload.relativePath.length)) + 1;
+
+          failedUploads.forEach(upload => {
+            console.log(
+              `  ${chalk.gray('|')} 🔴 ${upload.relativePath.padEnd(pathPadding)} ${chalk.gray(
+                `| ${upload.sizePretty.padStart(filesizeStrMaxLength)} |`,
+              )}`,
+            );
+          });
         }
 
-        if (this.uploader.isEnabled && this.uploader.skippedUploadsCount) {
-          console.log(APP_PREFIX, `${chalk.bold(this.uploader.skippedUploadsCount)} artifacts skipped to upload`);
+        if (this.uploader.isEnabled && this.uploader.skippedUploads.length) {
+          console.log(
+            '\n',
+            APP_PREFIX,
+            `🗄️ ${chalk.bold(this.uploader.skippedUploads.length)} artifacts uploading 🟡${chalk.bold(
+              'skipped',
+            )} (due to large size)`,
+          );
+          const skippedUploads = this.uploader.skippedUploads.map(file => ({
+            relativePath: file.path.replace(process.cwd(), ''),
+            sizePretty: file.size === null ? 'unknown' : prettyBytes(file.size, { round: 0 }).toString(),
+          }));
+          const pathPadding = Math.max(...skippedUploads.map(upload => upload.relativePath.length)) + 1;
+          skippedUploads.forEach(upload => {
+            console.log(
+              `  ${chalk.gray('|')} 🟡 ${upload.relativePath.padEnd(pathPadding)} ${chalk.gray(
+                `| ${upload.sizePretty.padStart(filesizeStrMaxLength)} |`,
+              )}`,
+            );
+          });
         }
 
-        if (this.uploader.skippedUploadsCount || this.uploader.failedUploadsCount) {
-          const command = `TESTOMATIO_RUN=${this.runId} npx @testomatio/reporter upload-artifacts`;
+        if (this.uploader.skippedUploads.length || this.uploader.failedUploads.length) {
+          const command = `TESTOMATIO=<your_api_key> TESTOMATIO_RUN=${
+            this.runId
+          } npx @testomatio/reporter upload-artifacts`;
           console.log(
             APP_PREFIX,
             `Run "${chalk.magenta(command)}" with valid S3 credentials to upload skipped & failed artifacts`,
@@ -365,24 +399,6 @@ function isNotInternalFrame(frame) {
   );
 }
 
-function formatStep(step, shift = 0) {
-  const prefix = ' '.repeat(shift);
-
-  const lines = [];
-
-  if (step.error) {
-    lines.push(`${prefix}${chalk.red(step.title)} ${chalk.gray(`${step.duration}ms`)}`);
-  } else {
-    lines.push(`${prefix}${step.title} ${chalk.gray(`${step.duration}ms`)}`);
-  }
-
-  for (const child of step.steps || []) {
-    lines.push(...formatStep(child, shift + 2));
-  }
-
-  return lines;
-}
-
 /**
  *
  * @param {TestData} testData

package/lib/constants.js

@@ -3,7 +3,11 @@ const os = require('os');
 const path = require('path');
 
 const APP_PREFIX = chalk.gray('[TESTOMATIO]');
-const AXIOS_TIMEOUT = 20 * 1000; // sum = 20sec
+const TESTOMATIO_REQUEST_TIMEOUT = parseInt(process.env.TESTOMATIO_REQUEST_TIMEOUT, 10);
+if (TESTOMATIO_REQUEST_TIMEOUT) {
+  console.log(`${APP_PREFIX} Request timeout is set to ${TESTOMATIO_REQUEST_TIMEOUT / 1000}s`);
+}
+const AXIOS_TIMEOUT = TESTOMATIO_REQUEST_TIMEOUT || 20 * 1000;
 
 const TESTOMAT_TMP_STORAGE_DIR = path.join(os.tmpdir(), 'testomatio_tmp');
 

package/lib/pipe/debug.js

@@ -0,0 +1,102 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { APP_PREFIX } = require('../constants');
+const debug = require('debug')('@testomatio/reporter:pipe:debug');
+// upgrade to latest for ESM
+const prettyMs = require('pretty-ms');
+
+class DebugPipe {
+  constructor(params, store) {
+    this.isEnabled = !!process.env.TESTOMATIO_DEBUG;
+    if (this.isEnabled) {
+      this.batch = {
+        isEnabled: params.isBatchEnabled ?? !process.env.TESTOMATIO_DISABLE_BATCH_UPLOAD ?? true,
+        intervalFunction: null,
+        intervalTime: 5000,
+        tests: [],
+        batchIndex: 0,
+      };
+      this.logFilePath = path.join(os.tmpdir(), `testomatio.debug.${Date.now()}.json`);
+      this.store = store || {};
+
+      debug('Creating debug file:', this.logFilePath);
+      fs.writeFileSync(this.logFilePath, '');
+      console.log(APP_PREFIX, '🪲. Debug created:');
+      this.testomatioEnvVars = Object.keys(process.env)
+        .filter(key => key.startsWith('TESTOMATIO_'))
+        .reduce((acc, key) => {
+          acc[key] = process.env[key];
+          return acc;
+        }, {});
+      this.logToFile({ datetime: new Date().toISOString(), timestamp: Date.now() });
+      this.logToFile({ data: 'variables', testomatioEnvVars: this.testomatioEnvVars });
+      this.logToFile({ data: 'store', store: this.store || {} });
+      // Bind batchUpload to the instance
+      this.batchUpload = this.batchUpload.bind(this);
+    }
+  }
+
+  /**
+   * Logs data to a file if logging is enabled.
+   *
+   * @param {Object} logData - The data to be logged.
+   * @returns {Promise<void>} A promise that resolves when the log data has been appended to the file.
+   */
+  logToFile(logData) {
+    if (!this.isEnabled) return;
+    const timePassedFromLastAction = Date.now() - (this.lastActionTimestamp || Date.now());
+    this.lastActionTimestamp = Date.now();
+
+    const logLine = JSON.stringify({ t: `+${prettyMs(timePassedFromLastAction)}`, ...logData });
+    fs.appendFileSync(this.logFilePath, `${logLine}\n`);
+  }
+
+  async prepareRun(opts) {
+    if (!this.isEnabled) return [];
+
+    this.logToFile({ action: 'prepareRun', data: opts });
+  }
+
+  async createRun(params = {}) {
+    if (params.isBatchEnabled === true || params.isBatchEnabled === false) this.batch.isEnabled = params.isBatchEnabled;
+
+    if (!this.isEnabled) return {};
+    if (this.batch.isEnabled) this.batch.intervalFunction = setInterval(this.batchUpload, this.batch.intervalTime);
+
+    this.logToFile({ action: 'createRun', params });
+  }
+
+  async addTest(data) {
+    if (!this.isEnabled) return;
+
+    if (!this.batch.isEnabled) this.logToFile({ action: 'addTest', testId: data });
+    else this.batch.tests.push(data);
+
+    if (!this.batch.intervalFunction) await this.batchUpload();
+  }
+
+  async batchUpload() {
+    this.batch.batchIndex++;
+    if (!this.batch.isEnabled) return;
+    if (!this.batch.tests.length) return;
+
+    const testsToSend = this.batch.tests.splice(0);
+
+    this.logToFile({ action: 'addTestsBatch', tests: testsToSend });
+  }
+
+  async finishRun(params) {
+    if (!this.isEnabled) return;
+    this.logToFile({ actions: 'finishRun', params });
+    await this.batchUpload();
+    if (this.batch.intervalFunction) clearInterval(this.batch.intervalFunction);
+    console.log(APP_PREFIX, '🪲. Debug Saved to', this.logFilePath);
+  }
+
+  toString() {
+    return 'Debug Reporter';
+  }
+}
+
+module.exports = DebugPipe;

package/lib/pipe/html.js

@@ -5,8 +5,7 @@ const path = require('path');
 const chalk = require('chalk');
 const handlebars = require('handlebars');
 const fileUrl = require('file-url');
-
-const { fileSystem, isSameTest, ansiRegExp } = require('../utils/utils');
+const { fileSystem, isSameTest, ansiRegExp, formatStep } = require('../utils/utils');
 const { HTML_REPORT } = require('../constants');
 
 class HtmlPipe {
@@ -123,6 +122,14 @@ class HtmlPipe {
     }
 
     tests.forEach(test => {
+      // steps could be an array or a string
+      test.steps = Array.isArray(test.steps)
+        ? (test.steps = test.steps
+            .map(step => formatStep(step))
+            .flat()
+            .join('\n'))
+        : test.steps;
+
       if (!test.message?.trim()) {
         test.message = "This test has no 'message' code";
       }

package/lib/pipe/index.js

@@ -8,6 +8,7 @@ const GitLabPipe = require('./gitlab');
 const CsvPipe = require('./csv');
 const HtmlPipe = require('./html');
 const BitbucketPipe = require('./bitbucket');
+const DebugPipe = require('./debug');
 
 function PipeFactory(params, opts) {
   const extraPipes = [];
@@ -47,6 +48,7 @@ function PipeFactory(params, opts) {
     new CsvPipe(params, opts),
     new HtmlPipe(params, opts),
     new BitbucketPipe(params, opts),
+    new DebugPipe(params, opts),
     ...extraPipes,
   ];
 

package/lib/pipe/testomatio.js

@@ -218,11 +218,13 @@ class TestomatioPipe {
       process.env.runId = this.runId;      
       debug('Run created', this.runId);
     } catch (err) {
-      const errorInfo = `${err?.response?.statusText} ${chalk.red(err?.status)} ${err.message}`;
+      const errorText = err.response?.data?.message || err.message;
+      console.log(errorText || err);
+      if (!this.apiKey) console.error('Testomat.io API key is not set');
+      if (!this.apiKey?.startsWith('tstmt')) console.error('Testomat.io API key is invalid');
       console.error(
         APP_PREFIX,
-        'Error creating Testomat.io report, please check if your API key is valid. Skipping report\n',
-        errorInfo || JSON.stringify(err),
+        'Error creating Testomat.io report (see details above), please check if your API key is valid. Skipping report'
       );
       printCreateIssue(err);
     }

package/lib/reporter.js

@@ -27,4 +27,4 @@ module.exports.logger = services.logger;
 module.exports.meta = reporterFunctions.keyValue;
 module.exports.step = reporterFunctions.step;
 module.exports.TestomatClient = TestomatClient;
-module.exports.TRConstants = TRConstants;
+module.exports.TRConstants = TRConstants;

package/lib/uploader.js

@@ -7,6 +7,7 @@ const path = require('path');
 const promiseRetry = require('promise-retry');
 const chalk = require('chalk');
 const { APP_PREFIX } = require('./constants');
+const { filesize: prettyBytes } = require('filesize');
 
 class S3Uploader {
   constructor() {
@@ -15,9 +16,12 @@ class S3Uploader {
     this.config = undefined;
 
     // counters
-    this.skippedUploadsCount = 0;
-    this.failedUploadsCount = 0;
-    this.totalUploadsCount = 0;
+    /**
+     * @type {{path: string, size: number}[]}
+     */
+    this.skippedUploads = [];
+    this.failedUploads = [];
+    this.totalSuccessfulUploadsCount = 0;
 
     this.succesfulUploads = {};
 
@@ -75,11 +79,18 @@ class S3Uploader {
     this.storeEnabled = true;
   }
 
-  disbleLogStorage() {
+  disableLogStorage() {
     this.storeEnabled = false;
   }
 
-  async #uploadToS3(Body, Key) {
+  /**
+   *
+   * @param {*} Body
+   * @param {*} Key
+   * @param {{path: string, size?: number}} file
+   * @returns
+   */
+  async #uploadToS3(Body, Key, file) {
     const { S3_BUCKET, TESTOMATIO_PRIVATE_ARTIFACTS } = this.getConfig();
     const ACL = TESTOMATIO_PRIVATE_ARTIFACTS ? 'private' : 'public-read';
 
@@ -108,20 +119,20 @@ class S3Uploader {
       });
 
       const link = await this.getS3LocationLink(upload);
-      this.totalUploadsCount++;
+      this.totalSuccessfulUploadsCount++;
       this.succesfulUploads[Key] = link;
       return link;
     } catch (e) {
-      this.failedUploadsCount++;
+      this.failedUploads.push({ path: file.path, size: file.size });
       debug('S3 uploading error:', e);
-      console.log(APP_PREFIX, 'Upload failed:', e.message, this.getMaskedConfig());
+      console.log(APP_PREFIX, 'Upload failed:', e.message, '\nConfig:\n', this.getMaskedConfig());
     }
   }
 
   /**
-    * Returns an array of uploaded files list
-    * 
-    * @returns {{rid: string, file: string, uploaded: boolean}[]}
+   * Returns an array of uploaded files
+   *
+   * @returns {{rid: string, file: string, uploaded: boolean}[]}
    */
   readUploadedFiles(runId) {
     const tempFilePath = this.#getFilePathWithUploadsList(runId);
@@ -181,19 +192,30 @@ class S3Uploader {
   }
 
   /**
-   * 
-   * @param {*} filePath 
+   *
+   * @param {*} filePath
    * @param {*} pathInS3 contains runId, rid and filename
-   * @returns 
+   * @returns
    */
   async uploadFileByPath(filePath, pathInS3) {
     const [runId, rid] = pathInS3;
 
     if (!filePath) return;
 
+    let fileSize = null;
+    let fileSizeInMb = null;
+
+    try {
+      // file may not exist
+      fileSize = fs.statSync(filePath).size;
+      fileSizeInMb = Number((fileSize / (1024 * 1024)).toFixed(2));
+    } catch (e) {
+      debug(`File ${filePath} does not exist`);
+    }
+
     if (!this.isEnabled) {
       this.storeUploadedFile(filePath, runId, rid, false);
-      this.skippedUploadsCount++;
+      this.skippedUploads.push({ path: filePath, size: fileSize });
       return;
     }
 
@@ -208,26 +230,37 @@ class S3Uploader {
       return;
     }
 
-    const fileSize = fs.statSync(filePath).size;
-    const fileSizeInMb = fileSize / (1024 * 1024);
-
-    if (TESTOMATIO_ARTIFACT_MAX_SIZE_MB && fileSizeInMb > parseInt(TESTOMATIO_ARTIFACT_MAX_SIZE_MB, 10)) {
-      this.skippedUploadsCount++;
-      console.error(chalk.yellow(`Artifacts file ${filePath} exceeds the maximum allowed size. Skipping...`));
+    // skipping artifact only if: 1. storing to file is enabled, 2. max size is set and 3. file size exceeds the limit
+    if (
+      this.storeEnabled &&
+      TESTOMATIO_ARTIFACT_MAX_SIZE_MB &&
+      fileSizeInMb > parseFloat(TESTOMATIO_ARTIFACT_MAX_SIZE_MB)
+    ) {
+      const skippedArtifact = { path: filePath, size: fileSize };
+      this.storeUploadedFile(filePath, runId, rid, false);
+      this.skippedUploads.push(skippedArtifact);
+      debug(
+        chalk.yellow(`Artifacts file ${JSON.stringify(skippedArtifact)} exceeds the maximum allowed size. Skipping.`),
+      );
       return;
     }
-    debug('File:', filePath, 'exists, size:', fileSizeInMb.toFixed(2), 'MB');
+    debug('File:', filePath, 'exists, size:', prettyBytes(fileSize));
 
     const fileStream = fs.createReadStream(filePath);
     const Key = pathInS3.join('/');
 
-    const link = await this.#uploadToS3(fileStream, Key);
+    const link = await this.#uploadToS3(fileStream, Key, { path: filePath, size: fileSize });
 
     this.storeUploadedFile(filePath, runId, rid, !!link);
 
     return link;
   }
 
+  /**
+   * @param {Buffer} buffer
+   * @param {string[]} pathInS3
+   * @returns
+   */
   async uploadFileAsBuffer(buffer, pathInS3) {
     if (!this.isEnabled) return;
 
@@ -238,7 +271,7 @@ class S3Uploader {
       Key = `${Key}.${ext}`;
     }
 
-    return this.#uploadToS3(buffer, Key);
+    return this.#uploadToS3(buffer, Key, { path: Key });
   }
 
   async checkArtifactExistsInFileSystem(filePath, attempts = 5, intervalMs = 500) {

package/lib/utils/utils.js

@@ -340,6 +340,24 @@ function readLatestRunId() {
   }
 }
 
+function formatStep(step, shift = 0) {
+  const prefix = ' '.repeat(shift);
+
+  const lines = [];
+
+  if (step.error) {
+    lines.push(`${prefix}${chalk.red(step.title)} ${chalk.gray(`${step.duration}ms`)}`);
+  } else {
+    lines.push(`${prefix}${step.title} ${chalk.gray(`${step.duration}ms`)}`);
+  }
+
+  for (const child of step.steps || []) {
+    lines.push(...formatStep(child, shift + 2));
+  }
+
+  return lines;
+}
+
 module.exports = {
   storeRunId,
   readLatestRunId,
@@ -350,6 +368,7 @@ module.exports = {
   fetchIdFromOutput,
   fetchFilesFromStackTrace,
   fileSystem,
+  formatStep,
   getCurrentDateTime,
   specificTestInfo,
   isValidUrl,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testomatio/reporter",
-  "version": "1.6.0-beta-artifacts",
+  "version": "1.6.0",
   "description": "Testomatio Reporter Client",
   "main": "./lib/reporter.js",
   "typings": "typings/index.d.ts",
@@ -23,6 +23,7 @@
     "dotenv": "^16.0.1",
     "fast-xml-parser": "^4.4.1",
     "file-url": "3.0.0",
+    "filesize": "^10.1.6",
     "glob": "^10.3",
     "handlebars": "^4.7.8",
     "has-flag": "^5.0.1",
@@ -32,6 +33,7 @@
     "lodash.memoize": "^4.1.2",
     "lodash.merge": "^4.6.2",
     "minimatch": "^9.0.3",
+    "pretty-ms": "^7.0.1",
     "promise-retry": "^2.0.1",
     "strip-ansi": "^7.1.0",
     "uuid": "^9.0.0"