@testomatio/reporter 1.6.0-beta-6-artifacts → 1.6.1-beta-artifacts

package/lib/adapter/mocha.js

@@ -24,7 +24,6 @@ function MochaReporter(runner, opts) {
   let passes = 0;
   let failures = 0;
   let skipped = 0;
-  // let artifactStore;
 
   const apiKey = opts?.reporterOptions?.apiKey || config.TESTOMATIO;
 
@@ -33,6 +32,7 @@ function MochaReporter(runner, opts) {
   runner.on(EVENT_RUN_BEGIN, () => {
     client.createRun();
 
+    // clear dir with artifacts/logs
     fileSystem.clearDir(TESTOMAT_TMP_STORAGE_DIR);
   });
 

package/lib/adapter/playwright.js

@@ -111,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;
 

package/lib/adapter/webdriver.js

@@ -1,7 +1,9 @@
 // eslint-disable-next-line global-require, import/no-extraneous-dependencies
 const WDIOReporter = require('@wdio/reporter').default;
 const TestomatClient = require('../client');
-const { getTestomatIdFromTestTitle } = require('../utils/utils');
+const { getTestomatIdFromTestTitle, fileSystem } = require('../utils/utils');
+const { services } = require('../services');
+const { TESTOMAT_TMP_STORAGE_DIR } = require('../constants');
 
 class WebdriverReporter extends WDIOReporter {
   constructor(options) {
@@ -15,6 +17,15 @@ class WebdriverReporter extends WDIOReporter {
     this._isSynchronising = false;
   }
 
+  onRunnerStart() {
+    // clear dir with artifacts/logs
+    fileSystem.clearDir(TESTOMAT_TMP_STORAGE_DIR);
+  }
+
+  onTestStart(test) {
+    services.setContext(test.fullTitle);
+  }
+
   get isSynchronised() {
     return this._isSynchronising === false;
   }
@@ -28,15 +39,18 @@ class WebdriverReporter extends WDIOReporter {
   }
 
   onTestEnd(test) {
+    test.suite = test.parent;
+    const logs = getTestLogs(test.fullTitle);
+    // TODO: FIX: artifacts for some reason leads to empty report on Testomat.io
+    // const artifacts = services.artifacts.get(test.fullTitle);
+    // const keyValues = services.keyValues.get(test.fullTitle);
+    test.logs = logs;
+    // test.artifacts = artifacts;
+    // test.meta = keyValues;
     this._addTestPromises.push(this.addTest(test));
   }
 
   // wdio-cucumber does not trigger onTestEnd hook, thus, using this one
-  /**
-   *
-   * @param {} scerario
-   * @returns
-   */
   onSuiteEnd(scerario) {
     if (scerario.type === 'scenario') {
       this._addTestPromises.push(this.addBddScenario(scerario));
@@ -56,7 +70,10 @@ class WebdriverReporter extends WDIOReporter {
       .map(el => Buffer.from(el.result.value, 'base64'));
 
     await this.client.addTestRun(state, {
+      // manuallyAttachedArtifacts: test.artifacts,
       error,
+      logs: test.logs,
+      // meta: test.meta,
       title,
       test_id: testId,
       time: duration,
@@ -98,4 +115,16 @@ class WebdriverReporter extends WDIOReporter {
   }
 }
 
+/**
+ *
+ * @param {*} fullTestTitle
+ * @returns string
+ */
+function getTestLogs(fullTestTitle) {
+  const logsArr = services.logger.getLogs(fullTestTitle);
+  // remove duplicates (for some reason, logs are duplicated several times)
+  const logs = logsArr ? Array.from(new Set(logsArr)).join('\n').trim() : '';
+  return logs;
+}
+
 module.exports = WebdriverReporter;

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}`));
 
@@ -185,7 +186,7 @@ program
       isBatchEnabled: false,
     });
 
-    let testruns = client.uploader.readUploadedFiles(process.env.TESTOMATIO_RUN);
+    let testruns = client.uploader.readUploadedFiles(runId);
     const numTotalArtifacts = testruns.length;
 
     debug('Found testruns:', testruns);
@@ -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

@@ -98,6 +98,7 @@ class TestomatioPipe {
     this.runId = params.runId || process.env.runId;
     this.createNewTests = params.createNewTests ?? !!process.env.TESTOMATIO_CREATE;
     this.hasUnmatchedTests = false;
+    this.requestFailures = 0;
 
     if (!isValidUrl(this.url.trim())) {
       this.isEnabled = false;
@@ -217,10 +218,13 @@ class TestomatioPipe {
       process.env.runId = this.runId;      
       debug('Run created', this.runId);
     } catch (err) {
+      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 | ',
-        err?.response?.statusText || err?.status || err.message,
+        'Error creating Testomat.io report (see details above), please check if your API key is valid. Skipping report'
       );
       printCreateIssue(err);
     }
@@ -229,37 +233,25 @@ class TestomatioPipe {
 
   /**
    * Decides whether to skip test reporting in case of too many request failures
-   * @param {TestData} testData
    * @returns {boolean}
    */
-  #cancelTestReportingInCaseOfTooManyReqFailures(testData) {
-    if (this.reportingCanceledDueToReqFailures) return true;
-
-    const retriesCountWithinTime = this.retriesTimestamps.filter(
-      timestamp => Date.now() - timestamp < REPORTER_REQUEST_RETRIES.withinTimeSeconds * 1000,
-    ).length;
-    debug(`${retriesCountWithinTime} failed requests within ${REPORTER_REQUEST_RETRIES.withinTimeSeconds}s`);
-
-    if (retriesCountWithinTime > REPORTER_REQUEST_RETRIES.maxTotalRetries) {
-      const errorMessage = chalk.yellow(
-        `${retriesCountWithinTime} requests were failed within ${REPORTER_REQUEST_RETRIES.withinTimeSeconds}s,\
- reporting for test "${testData.title}" to Testomat is skipped`,
-      );
-      console.warn(`${APP_PREFIX} ${errorMessage}`);
+  #cancelTestReportingInCaseOfTooManyReqFailures() {
+    if (!process.env.TESTOMATIO_MAX_REQUEST_FAILURES) return;
 
+    const cancelReporting = this.requestFailures >= parseInt(process.env.TESTOMATIO_MAX_REQUEST_FAILURES, 10);
+    if (cancelReporting) {
       this.reportingCanceledDueToReqFailures = true;
-      this.notReportedTestsCount++;
-
-      return true;
+      const errorMessage = 
+        `⚠️ ${process.env.TESTOMATIO_MAX_REQUEST_FAILURES} requests were failed, reporting to Testomat aborted.`;
+      console.warn(`${APP_PREFIX} ${chalk.yellow(errorMessage)}`);
     }
-
-    return false;
+    return cancelReporting;
   }
 
   #uploadSingleTest = async data => {
     if (!this.isEnabled) return;
     if (!this.runId) return;
-    if (this.#cancelTestReportingInCaseOfTooManyReqFailures(data)) return;
+    if (this.#cancelTestReportingInCaseOfTooManyReqFailures()) return;
 
     data.api_key = this.apiKey;
     data.create = this.createNewTests;
@@ -275,6 +267,8 @@ class TestomatioPipe {
     return this.axios
       .post(`/api/reporter/${this.runId}/testrun`, json, axiosAddTestrunRequestConfig)
       .catch(err => {
+        this.requestFailures++;
+        this.notReportedTestsCount++;
         if (err.response) {
           if (err.response.status >= 400) {
             const responseData = err.response.data || { message: '' };
@@ -308,6 +302,7 @@ class TestomatioPipe {
     this.batch.batchIndex++;
     if (!this.batch.isEnabled) return;
     if (!this.batch.tests.length) return;
+    if (this.#cancelTestReportingInCaseOfTooManyReqFailures()) return;
 
     // get tests from batch and clear batch
     const testsToSend = this.batch.tests.splice(0);
@@ -322,6 +317,8 @@ class TestomatioPipe {
         axiosAddTestrunRequestConfig,
       )
       .catch(err => {
+        this.requestFailures++;
+        this.notReportedTestsCount += testsToSend.length;
         if (err.response) {
           if (err.response.status >= 400) {
             const responseData = err.response.data || { message: '' };
@@ -399,6 +396,7 @@ class TestomatioPipe {
         await this.axios.put(`/api/reporter/${this.runId}`, {
           api_key: this.apiKey,
           status_event,
+          duration: params.duration,
           tests: params.tests,
         });
         if (this.runUrl) {

package/lib/reporter.js

@@ -4,7 +4,7 @@ const { services } = require('./services');
 
 const reporterFunctions = require('./reporter-functions');
 
-module.exports = {
+const testomat = {
   // TODO: deprecate in future; use log or testomat.log
   testomatioLogger: services.logger,
 
@@ -17,3 +17,14 @@ module.exports = {
   TestomatClient,
   TRConstants,
 };
+
+module.exports = testomat;
+
+module.exports.testomatioLogger = testomat;
+module.exports.artifact = reporterFunctions.artifact;
+module.exports.log = reporterFunctions.log;
+module.exports.logger = services.logger;
+module.exports.meta = reporterFunctions.keyValue;
+module.exports.step = reporterFunctions.step;
+module.exports.TestomatClient = TestomatClient;
+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';
 
@@ -94,7 +105,7 @@ class S3Uploader {
 
     debug('Uploading to S3:', Key);
 
-    const s3 = new S3(this.getS3Config());
+    const s3 = new S3(this.#getS3Config());
 
     try {
       const upload = new Upload({
@@ -108,18 +119,23 @@ 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
+   *
+   * @returns {{rid: string, file: string, uploaded: boolean}[]}
+   */
   readUploadedFiles(runId) {
-    const tempFilePath = this.#getUploadFilePath(runId);
+    const tempFilePath = this.#getFilePathWithUploadsList(runId);
 
     debug('Reading file', tempFilePath);
 
@@ -146,9 +162,9 @@ class S3Uploader {
     return lines.map(line => JSON.parse(line));
   }
 
-  #getUploadFilePath(runId, forceCreate = false) {
-    const tempFilePath = path.join(os.tmpdir(), `testomatio.run.${runId}.jsonl`);
-    if (!fs.existsSync(tempFilePath) || forceCreate) {
+  #getFilePathWithUploadsList(runId) {
+    const tempFilePath = path.join(os.tmpdir(), `testomatio.run.${runId}.json`);
+    if (!fs.existsSync(tempFilePath)) {
       debug('Creating artifacts file:', tempFilePath);
       fs.writeFileSync(tempFilePath, '');
     }
@@ -160,7 +176,11 @@ class S3Uploader {
 
     if (!filePath || !runId || !rid) return;
 
-    const tempFilePath = this.#getUploadFilePath(runId);
+    const tempFilePath = this.#getFilePathWithUploadsList(runId);
+
+    if (typeof filePath === 'object') {
+      filePath = filePath.path;
+    }
 
     if (typeof filePath === 'string' && !path.isAbsolute(filePath)) {
       filePath = path.join(process.cwd(), filePath);
@@ -168,22 +188,34 @@ class S3Uploader {
 
     const data = { rid, file: filePath, uploaded };
     const jsonLine = `${JSON.stringify(data)}\n`;
-
     fs.appendFileSync(tempFilePath, jsonLine);
   }
 
-  getskippedUpload() {
-    return this.skippedUploadsCount;
-  }
-
+  /**
+   *
+   * @param {*} filePath
+   * @param {*} pathInS3 contains runId, rid and filename
+   * @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;
     }
 
@@ -191,33 +223,44 @@ class S3Uploader {
 
     debug('Started upload', filePath, 'to', S3_BUCKET);
 
-    const isFileExist = await this.checkFileExists(filePath, 20, 500);
+    const isFileExist = await this.checkArtifactExistsInFileSystem(filePath, 20, 500);
 
     if (!isFileExist) {
       console.error(chalk.yellow(`Artifacts file ${filePath} does not exist. Skipping...`));
       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;
 
@@ -228,10 +271,10 @@ class S3Uploader {
       Key = `${Key}.${ext}`;
     }
 
-    return this.uploadToS3(buffer, Key);
+    return this.#uploadToS3(buffer, Key, { path: Key });
   }
 
-  async checkFileExists(filePath, attempts = 5, intervalMs = 500) {
+  async checkArtifactExistsInFileSystem(filePath, attempts = 5, intervalMs = 500) {
     return promiseRetry(
       async (retry, number) => {
         try {
@@ -286,7 +329,7 @@ class S3Uploader {
     );
   }
 
-  getS3Config() {
+  #getS3Config() {
     const { S3_REGION, S3_SESSION_TOKEN, S3_ACCESS_KEY_ID, S3_SECRET_ACCESS_KEY, S3_FORCE_PATH_STYLE, S3_ENDPOINT } =
       this.getConfig();
 

package/lib/utils/utils.js

@@ -321,6 +321,7 @@ const testRunnerHelper = {
 };
 
 function storeRunId(runId) {
+  if (!runId || runId === 'undefined') return;
   const filePath = path.join(os.tmpdir(), `testomatio.latest.run`);
   fs.writeFileSync(filePath, runId);
 }
@@ -339,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,
@@ -349,6 +368,7 @@ module.exports = {
   fetchIdFromOutput,
   fetchFilesFromStackTrace,
   fileSystem,
+  formatStep,
   getCurrentDateTime,
   specificTestInfo,
   isValidUrl,

package/lib/xmlReader.js

@@ -107,7 +107,7 @@ class XmlReader {
   }
 
   processJUnit(jsonSuite) {
-    const { testsuite, name, tests, failures, errors } = jsonSuite;
+    const { testsuite, name, tests, failures, errors, time } = jsonSuite;
 
     reduceOptions.preferClassname = this.stats.language === 'python';
     const resultTests = processTestSuite(testsuite);
@@ -115,12 +115,18 @@ class XmlReader {
     const hasFailures = resultTests.filter(t => t.status === 'failed').length > 0;
     const status = failures > 0 || errors > 0 || hasFailures ? 'failed' : 'passed';
 
+    if (time) {
+      if (!this.stats.duration) this.stats.duration = 0;
+      this.stats.duration += parseFloat(time);
+    }
+
     this.tests = this.tests.concat(resultTests);
 
     return {
       status,
       create_tests: true,
       name,
+      duration: parseFloat(time),
       tests_count: parseInt(tests, 10),
       passed_count: parseInt(tests, 10) - parseInt(failures, 10),
       failed_count: parseInt(failures, 10),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testomatio/reporter",
-  "version": "1.6.0-beta-6-artifacts",
+  "version": "1.6.1-beta-artifacts",
   "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"