@testomatio/reporter 1.5.1 → 1.6.0-beta-2-artifacts

package/lib/adapter/codecept.js

@@ -2,7 +2,6 @@ const debug = require('debug')('@testomatio/reporter:adapter:codeceptjs');
 const chalk = require('chalk');
 const TestomatClient = require('../client');
 const { STATUS, APP_PREFIX, TESTOMAT_TMP_STORAGE_DIR } = require('../constants');
-const upload = require('../fileUploader');
 const { getTestomatIdFromTestTitle, fileSystem } = require('../utils/utils');
 const { services } = require('../services');
 
@@ -128,10 +127,8 @@ function CodeceptReporter(config) {
     // all tests were reported and we can upload videos
     await Promise.all(reportTestPromises);
 
-    if (upload.isArtifactsEnabled()) {
-      await uploadAttachments(client, videos, '🎞️ Uploading', 'video');
-      await uploadAttachments(client, traces, '📁 Uploading', 'trace');
-    }
+    await uploadAttachments(client, videos, '🎞️ Uploading', 'video');
+    await uploadAttachments(client, traces, '📁 Uploading', 'trace');
 
     const status = failedTests.length === 0 ? STATUS.PASSED : STATUS.FAILED;
     client.updateRunStatus(status);
@@ -304,13 +301,17 @@ function CodeceptReporter(config) {
 }
 
 async function uploadAttachments(client, attachments, messagePrefix, attachmentType) {
-  if (!attachments?.length) return;
+  if (!attachments?.length) return;  
 
-  console.log(APP_PREFIX, `Attachments: ${messagePrefix} ${attachments.length} ${attachmentType} ...`);
+  if (client.uploader.isEnabled) console.log(APP_PREFIX, `Attachments: ${messagePrefix} ${attachments.length} ${attachmentType} ...`);
 
   const promises = attachments.map(async attachment => {
     const { rid, title, path, type } = attachment;
     const file = { path, type, title };
+
+    // we are storing file if upload is disabled
+    if (!client.uploader.isEnabled) return client.uploader.storeUploadedFile(path, client.runId, rid, false);
+
     return client.addTestRun(undefined, {
       ...stripExampleFromTitle(title),
       rid,

package/lib/adapter/playwright.js

@@ -6,7 +6,6 @@ const { v4: uuidv4 } = require('uuid');
 const fs = require('fs');
 const { APP_PREFIX, STATUS: Status, TESTOMAT_TMP_STORAGE_DIR } = require('../constants');
 const TestomatioClient = require('../client');
-const { isArtifactsEnabled } = require('../fileUploader');
 const { getTestomatIdFromTestTitle, fileSystem } = require('../utils/utils');
 // const debug = require('debug')('@testomatio/reporter:adapter:playwright');
 const { services } = require('../services');
@@ -106,31 +105,37 @@ class PlaywrightReporter {
 
     await Promise.all(reportTestPromises);
 
-    if (this.uploads.length && isArtifactsEnabled()) {
-      console.log(APP_PREFIX, `🎞️  Uploading ${this.uploads.length} files...`);
+    if (!this.uploads.length) return;
+      
+    if (this.client.uploader.isEnabled) console.log(APP_PREFIX, `🎞️  Uploading ${this.uploads.length} files...`);
 
-      const promises = [];
+    const promises = [];
 
-      for (const upload of this.uploads) {
-        const { rid, file, title } = upload;
+    for (const upload of this.uploads) {
+      const { rid, file, title } = upload;
 
-        const files = upload.files.map(attachment => ({
-          path: this.#getArtifactPath(attachment),
-          title,
-          type: attachment.contentType,
-        }));
-
-        promises.push(
-          this.client.addTestRun(undefined, {
-            rid,
-            title,
-            files,
-            file,
-          }),
-        );
+      const files = upload.files.map(attachment => ({
+        path: this.#getArtifactPath(attachment),
+        title,
+        type: attachment.contentType,
+      }));
+
+      if (!this.client.uploader.isEnabled) {
+        files.forEach(f => this.client.uploader.storeUploadedFile(f, this.client.runId, rid, false));
+        continue;
       }
-      await Promise.all(promises);
+
+      promises.push(
+        this.client.addTestRun(undefined, {
+          rid,
+          title,
+          files,
+          file,
+        }),
+      );
     }
+    await Promise.all(promises);
+  
 
     await this.client.updateRunStatus(checkStatus(result.status));
   }

package/lib/bin/cli.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+const { program } = require('commander');
+const spawn = require('cross-spawn');
+const chalk = require('chalk');
+const glob = require('glob');
+const debug = require('debug')('@testomatio/reporter:cli');
+const TestomatClient = require('../client');
+const XmlReader = require('../xmlReader');
+const { APP_PREFIX, STATUS } = require('../constants');
+const { version } = require('../../package.json');
+const config = require('../config');
+
+console.log(chalk.cyan.bold(` 🤩 Testomat.io Reporter v${version}`));
+
+program
+  .version(version)
+  .option('--env-file <envfile>', 'Load environment variables from env file')
+  .hook('preAction', (thisCommand) => {
+    const opts = thisCommand.opts();
+    if (opts.envFile) {
+      require('dotenv').config({ path: opts.envFile });
+    } else {
+      require('dotenv').config();
+    }
+  });
+
+program
+  .command('start')
+  .description('Start a new run and return its ID')
+  .action(async () => {
+    console.log('Starting a new Run on Testomat.io...');
+    const apiKey = process.env['INPUT_TESTOMATIO-KEY'] || config.TESTOMATIO;
+    const client = new TestomatClient({ apiKey });
+
+    client.createRun().then(() => {
+      console.log(process.env.runId);
+      process.exit(0);
+    });
+  });
+
+program
+  .command('finish')
+  .description('Finish Run by its ID')
+  .action(async () => {
+    if (!process.env.TESTOMATIO_RUN) {
+      console.log('TESTOMATIO_RUN environment variable must be set.');
+      return process.exit(1);
+    }
+
+    console.log('Finishing Run on Testomat.io...');
+    const apiKey = process.env['INPUT_TESTOMATIO-KEY'] || config.TESTOMATIO;
+    const client = new TestomatClient({ apiKey });
+
+    client.updateRunStatus(STATUS.FINISHED).then(() => {
+      console.log(chalk.yellow(`Run ${process.env.TESTOMATIO_RUN} was finished`));
+      process.exit(0);
+    });
+  });
+
+program
+  .command('run')
+  .description('Run tests with the specified command')
+  .argument('<command>', 'Test runner command')
+  .option('--filter <filter>', 'Additional execution filter')
+  .action(async (command, opts) => {
+    const apiKey = process.env['INPUT_TESTOMATIO-KEY'] || config.TESTOMATIO;
+    const title = process.env.TESTOMATIO_TITLE;
+
+    if (!command || !command.split) {
+      console.log(APP_PREFIX, `No command provided. Use -c option to launch a test runner.`);
+      return process.exit(255);
+    }
+
+    const client = new TestomatClient({ apiKey, title, parallel: true });
+
+    if (opts.filter) {
+      const [pipe, ...optsArray] = opts.filter.split(':');
+      const pipeOptions = optsArray.join(':');
+
+      try {
+        const tests = await client.prepareRun({ pipe, pipeOptions });
+        if (tests && tests.length > 0) {
+          command += ` --grep (${tests.join('|')})`;
+        }
+      } catch (err) {
+        console.log(APP_PREFIX, err);
+      }
+    }
+
+    console.log(APP_PREFIX, `🚀 Running`, chalk.green(command));
+
+    const runTests = () => {
+      const testCmds = command.split(' ');
+      const cmd = spawn(testCmds[0], testCmds.slice(1), { stdio: 'inherit' });
+
+      cmd.on('close', code => {
+        const emoji = code === 0 ? '🟢' : '🔴';
+        console.log(APP_PREFIX, emoji, `Runner exited with ${chalk.bold(code)}`);
+        if (apiKey) {
+          const status = code === 0 ? 'passed' : 'failed';
+          client.updateRunStatus(status, true);
+        }
+        process.exit(code);
+      });
+    };
+
+    if (apiKey) {
+      client.createRun().then(runTests);
+    } else {
+      runTests();
+    }
+  });
+
+program
+  .command('xml')
+  .description('Parse XML reports and upload to Testomat.io')
+  .argument('<pattern>', 'XML file pattern')
+  .option('-d, --dir <dir>', 'Project directory')
+  .option('--java-tests [java-path]', 'Load Java tests from path, by default: src/test/java')
+  .option('--lang <lang>', 'Language used (python, ruby, java)')
+  .option('--timelimit <time>', 'default time limit in seconds to kill a stuck process')
+  .action(async (pattern, opts) => {
+    if (!pattern.endsWith('.xml')) {
+      pattern += '.xml';
+    }
+    let { javaTests, lang } = opts;
+    if (javaTests === true) javaTests = 'src/test/java';
+    lang = lang?.toLowerCase();
+    const runReader = new XmlReader({ javaTests, lang });
+    const files = glob.sync(pattern, { cwd: opts.dir || process.cwd() });
+    if (!files.length) {
+      console.log(APP_PREFIX, `Report can't be created. No XML files found 😥`);
+      process.exit(1);
+    }
+
+    for (const file of files) {
+      console.log(APP_PREFIX, `Parsed ${file}`);
+      runReader.parse(file);
+    }
+
+    let timeoutTimer;
+    if (opts.timelimit) {
+      timeoutTimer = setTimeout(() => {
+        console.log(`⚠️  Reached timeout of ${opts.timelimit}s. Exiting... (Exit code is 0 to not fail the pipeline)`);
+        process.exit(0);
+      }, parseInt(opts.timelimit, 10) * 1000);
+    }
+
+    try {
+      await runReader.createRun();
+      await runReader.uploadData();
+    } catch (err) {
+      console.log(APP_PREFIX, 'Error updating status, skipping...', err);
+    }
+
+    if (timeoutTimer) clearTimeout(timeoutTimer);
+  });
+
+program
+  .command('upload-artifacts')
+  .description('Upload artifacts to Testomat.io')
+  .option('--force', 'Re-upload artifacts even if they were uploaded before')
+  .action(async (opts) => {
+    const apiKey = config.TESTOMATIO;
+
+    process.env.TESTOMATIO_DISABLE_ARTIFACTS = '';
+
+    const client = new TestomatClient({
+      apiKey,
+      isBatchEnabled: false,
+    });
+
+    let testruns = client.uploader.readUploadedFiles(process.env.TESTOMATIO_RUN);
+    const numTotalArtifacts = testruns.length;
+
+    debug('Found testruns:', testruns);
+
+    if (!opts.force) testruns = testruns.filter(tr => !tr.uploaded);
+
+    if (!testruns.length) {
+      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');
+      }
+      process.exit(0);
+    }
+
+    const testrunsByRid = testruns.reduce((acc, { rid, file }) => {
+      if (!acc[rid]) {
+        acc[rid] = [];
+      }
+      if (!acc[rid].includes(file)) acc[rid].push(file);
+      return acc;
+    }, {});
+
+    await client.createRun();
+    client.uploader.checkEnabled();
+    client.uploader.disbleLogStorage();
+
+    for (const rid in testrunsByRid) {
+      const files = testrunsByRid[rid];
+      await client.addTestRun(undefined, { rid, files });
+    }
+
+    console.log(APP_PREFIX, client.uploader.totalUploaded, 'artifacts uploaded');
+    if (client.uploader.failedUpload) {
+      console.log(APP_PREFIX, client.uploader.failedUpload, 'artifacts failed to upload');
+    }
+  });
+
+program.parse(process.argv);
+
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}

package/lib/bin/uploadArtifacts.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+const program = require('commander');
+const chalk = require('chalk');
+const debug = require('debug')('@testomatio/reporter:upload-cli');
+const TestomatClient = require('../client');
+const { APP_PREFIX } = require('../constants');
+const { version } = require('../../package.json');
+const config = require('../config');
+
+console.log(chalk.cyan.bold(` 🤩 Testomat.io Reporter v${version}`));
+
+program
+  .option('--env-file <envfile>', 'Load environment variables from env file')
+  .option('--force', 'Re-upload artifacts even if they were uploaded before')
+  .action(async opts => {
+
+    if (opts.envFile) {
+      require('dotenv').config(opts.envFile); // eslint-disable-line
+    } else {
+      // try to load from env file
+      require('dotenv').config(); // eslint-disable-line
+    }
+
+    const apiKey = config.TESTOMATIO;
+
+    process.env.TESTOMATIO_DISABLE_ARTIFACTS = '';
+    // process.env.TESTOMATIO_ARTIFACTS_SIZE = null;
+
+    const client = new TestomatClient({
+      apiKey,
+      isBatchEnabled: false,
+     });
+
+    let testruns = client.uploader.readUploadedFiles(process.env.TESTOMATIO_RUN);
+
+    const numTotalArtifacts = testruns.length;
+
+    debug('Found testruns:', testruns);
+
+    if (!opts.force) testruns = testruns.filter(tr => !tr.uploaded);
+
+    if (!testruns.length) {
+      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');
+      }
+      process.exit(0);
+    }
+
+    const testrunsByRid = testruns.reduce((acc, { rid, file }) => {
+      if (!acc[rid]) {
+        acc[rid] = [];
+      }
+      if (!acc[rid].includes(file)) acc[rid].push(file);
+      return acc;
+    }, {});
+
+    let numArtifacts = 0;
+
+    // we need to obtain S3 credentials
+    await client.createRun();
+
+    client.uploader.checkEnabled();
+    client.uploader.disbleLogStorage();
+
+    for (const rid in testrunsByRid) {
+      const files = testrunsByRid[rid];
+      numArtifacts += files.length;
+      await client.addTestRun(undefined, {
+        rid,
+        files,
+      });
+    }
+
+  console.log(APP_PREFIX, client.uploader.totalUploaded, 'artifacts uploaded');
+    if (client.uploader.failedUpload) {
+      console.log(APP_PREFIX, client.uploader.failedUpload, 'artifacts failed to upload');
+    }
+  });
+
+if (process.argv.length <= 1) {
+  program.outputHelp();
+}
+
+program.parse(process.argv);

package/lib/client.js

@@ -5,7 +5,7 @@ const { minimatch } = require('minimatch');
 const fs = require('fs');
 const chalk = require('chalk');
 const { randomUUID } = require('crypto');
-const upload = require('./fileUploader');
+const S3Uploader = require('./uploader');
 const { APP_PREFIX, STATUS } = require('./constants');
 const pipesFactory = require('./pipe');
 const { glob } = require('glob');
@@ -26,14 +26,14 @@ class Client {
    * @param {*} params
    */
   constructor(params = {}) {
-    const store = {};
-    this.uuid = randomUUID();
-    this.pipes = pipesFactory(params, store);
+    this.pipeStore = {};
+    this.runId = randomUUID(); // will be replaced by real run id
+    this.pipes = pipesFactory(params, this.pipeStore);
     this.queue = Promise.resolve();
-    this.totalUploaded = 0;
-    this.failedToUpload = 0;
     this.version = JSON.parse(fs.readFileSync(join(__dirname, '..', 'package.json')).toString()).version;
     this.executionList = Promise.resolve();
+    this.uploader = new S3Uploader();
+    this.uploader.checkEnabled();
 
     console.log(APP_PREFIX, `Testomatio Reporter v${this.version}`);
   }
@@ -104,7 +104,13 @@ class Client {
     this.queue = this.queue
       .then(() => Promise.all(this.pipes.map(p => p.createRun())))
       .catch(err => console.log(APP_PREFIX, err))
+      .then(() => {
+        const runId = this.pipeStore?.runId;
+        if (runId) this.runId = runId;
+        this.uploader.checkEnabled();
+      })
       .then(() => undefined); // fixes return type
+
     // debug('Run', this.queue);
     return this.queue;
   }
@@ -169,24 +175,28 @@ class Client {
 
     const uploadedFiles = [];
 
-    for (const f of files) {
-      uploadedFiles.push(upload.uploadFileByPath(f, this.uuid));
+    for (let f of files) {
+      if (typeof f === 'object') {
+        if (!f.path) continue;
+
+        f = f.path;
+      }
+
+      uploadedFiles.push(this.uploader.uploadFileByPath(f, [
+        this.runId,
+        rid,
+        path.basename(f)
+      ]));
+
     }
 
     for (const [idx, buffer] of filesBuffers.entries()) {
       const fileName = `${idx + 1}-${title.replace(/\s+/g, '-')}`;
-      uploadedFiles.push(upload.uploadFileAsBuffer(buffer, fileName, this.uuid));
+      uploadedFiles.push(this.uploader.uploadFileAsBuffer(buffer, [this.runId, rid, fileName]));
     }
 
     const artifacts = (await Promise.all(uploadedFiles)).filter(n => !!n);
 
-    if (artifacts.length < uploadedFiles.length) {
-      const failedUploading = uploadedFiles.length - artifacts.length;
-      this.failedToUpload += failedUploading;
-    }
-
-    this.totalUploaded += artifacts.length;
-
     const data = {
       rid,
       files,
@@ -242,28 +252,30 @@ class Client {
     this.queue = this.queue
       .then(() => Promise.all(this.pipes.map(p => p.finishRun(runParams))))
       .then(() => {
-        debug('TOTAL artifacts', this.totalUploaded);
-        if (this.totalUploaded && !upload.isArtifactsEnabled())
-          debug(`${this.totalUploaded} artifacts are not uploaded, because artifacts uploading is not enabled`);
+        debug('TOTAL artifacts', this.uploader.totalUploaded);        
+        debug(`${this.uploader.skippedUpload} artifacts skipped`);
 
-        if (this.totalUploaded && upload.isArtifactsEnabled()) {
+        if (this.uploader.totalUploaded && this.uploader.isEnabled) {
           console.log(
             APP_PREFIX,
-            `🗄️ ${this.totalUploaded} artifacts ${
+            `🗄️ ${this.uploader.totalUploaded} artifacts ${
               process.env.TESTOMATIO_PRIVATE_ARTIFACTS ? 'privately' : chalk.bold('publicly')
             } uploaded to S3 bucket`,
-          );
-
-          if (this.failedToUpload > 0) {
-            console.log(
-              APP_PREFIX,
-              chalk.yellow(
-                `Some artifacts were not uploaded. ${this.failedToUpload} artifacts could not be uploaded.
-                Run tests with DEBUG="@testomatio/reporter:file-uploader" to see details"`,
-              ),
-            );
-          }
+          );          
         }
+
+        if (this.uploader.failedUpload) {
+          console.log(APP_PREFIX, `${this.uploader.failedUpload} artifacts failed to upload`);
+        }
+
+        if (this.uploader.isEnabled && this.uploader.skippedUpload) {
+          console.log(APP_PREFIX, `${chalk.bold(this.uploader.skippedUpload)} artifacts skipped to upload`);
+        }
+
+        if (this.uploader.skippedUpload || this.uploader.failedUpload) {
+          console.log(APP_PREFIX, `Run "${chalk.magenta(`TESTOMATIO_RUN=${this.runId} npx upload-artifacts`)}" with valid S3 credentials to upload skipped & failed artifacts`);
+        }
+
       })
       .catch(err => console.log(APP_PREFIX, err));
 

package/lib/pipe/testomatio.js

@@ -37,7 +37,7 @@ class TestomatioPipe {
     this.isEnabled = false;
     this.url = params.testomatioUrl || process.env.TESTOMATIO_URL || 'https://app.testomat.io';
     this.apiKey = params.apiKey || config.TESTOMATIO;
-    debug('Testomatio Pipe: ', this.apiKey ? 'API KEY' : '*no api key*');
+
     if (!this.apiKey) {
       return;
     }
@@ -149,7 +149,6 @@ class TestomatioPipe {
    */
   async createRun(params = {}) {
     this.batch.isEnabled = params.isBatchEnabled ?? this.batch.isEnabled;
-    debug('Creating run...');
     if (!this.isEnabled) return;
     if (this.batch.isEnabled) this.batch.intervalFunction = setInterval(this.#batchUpload, this.batch.intervalTime);
 
@@ -191,12 +190,14 @@ class TestomatioPipe {
     debug('Run params', JSON.stringify(runParams, null, 2));
 
     if (this.runId) {
+      this.store.runId = this.runId;
       debug(`Run with id ${this.runId} already created, updating...`);
       const resp = await this.axios.put(`/api/reporter/${this.runId}`, runParams);
       if (resp.data.artifacts) setS3Credentials(resp.data.artifacts);
       return;
     }
 
+    debug('Creating run...');
     try {
       const resp = await this.axios.post(`/api/reporter`, runParams, {
         maxContentLength: Infinity,
@@ -412,6 +413,7 @@ class TestomatioPipe {
         console.log(APP_PREFIX, `📊 ${notFinishedMessage}. Report URL: ${chalk.magenta(this.runUrl)}`);
         console.log(APP_PREFIX, `🛬 Run to finish it: TESTOMATIO_RUN=${this.runId} npx start-test-run --finish`);
       }
+
       if (this.hasUnmatchedTests) {
         console.log('');
         // eslint-disable-next-line max-len

package/lib/uploader.js

@@ -0,0 +1,312 @@
+const debug = require('debug')('@testomatio/reporter:uploader');
+const { S3 } = require('@aws-sdk/client-s3');
+const { Upload } = require('@aws-sdk/lib-storage');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const promiseRetry = require('promise-retry');
+const chalk = require('chalk');
+const { APP_PREFIX } = require('./constants');
+
+class S3Uploader {
+  constructor() {
+    this.isEnabled = undefined;
+    this.storeEnabled = true;
+    this.config = undefined;
+
+    // counters
+    this.skippedUpload = 0;
+    this.failedUpload = 0;
+    this.totalUploaded = 0;
+
+    this.succesfulUploads = {};
+
+    this.configKeys = [
+      'S3_ENDPOINT',
+      'S3_REGION',
+      'S3_BUCKET',
+      'S3_ACCESS_KEY_ID',
+      'S3_SECRET_ACCESS_KEY',
+      'S3_SESSION_TOKEN',
+      'S3_FORCE_PATH_STYLE',
+      'TESTOMATIO_DISABLE_ARTIFACTS',
+      'TESTOMATIO_PRIVATE_ARTIFACTS',
+      'TESTOMATIO_ARTIFACTS_SIZE'
+    ];
+  }
+
+  resetConfig() {
+    this.config = undefined;
+    this.isEnabled = undefined;
+  }
+
+  getConfig() {
+    if (this.config) return this.config;
+    this.config = this.configKeys.reduce((acc, key) => {
+      acc[key] = process.env[key];
+      return acc;
+    }, {});
+    return this.config;
+  }
+
+  getMaskedConfig() {
+    return Object.fromEntries(
+      Object.entries(this.getConfig()).map(([key, value]) => [
+        key,
+        key === 'S3_SECRET_ACCESS_KEY' || key === 'S3_ACCESS_KEY_ID' ? '***' : value,
+      ]),
+    );
+  }
+
+  checkEnabled() {
+    if (this.isEnabled !== undefined) return this.isEnabled;
+
+    const { S3_BUCKET, TESTOMATIO_DISABLE_ARTIFACTS } = this.getConfig();
+    if (!S3_BUCKET) debug(`Upload is disabled because S3_BUCKET is not set`);
+    this.isEnabled = !!(S3_BUCKET && !TESTOMATIO_DISABLE_ARTIFACTS);
+
+    if (this.isEnabled) debug('S3 uploader is enabled');
+    debug(this.getMaskedConfig());
+
+    return this.isEnabled;
+  }
+
+  enableLogStorage() {
+    this.storeEnabled = true;
+  }
+
+  disbleLogStorage() {
+    this.storeEnabled = false;
+  }
+
+  async uploadToS3(Body, Key) {
+    const { S3_BUCKET, TESTOMATIO_PRIVATE_ARTIFACTS } = this.getConfig();
+    const ACL = TESTOMATIO_PRIVATE_ARTIFACTS ? 'private' : 'public-read';
+
+    if (!S3_BUCKET || !Body) {
+      console.log(APP_PREFIX, chalk.bold.red(`Failed uploading '${Key}'. Please check S3 credentials`), this.getMaskedConfig());
+      return;
+    }
+
+    debug('Uploading to S3:', Key);
+
+    const s3 = new S3(this.getS3Config());
+
+    try {
+      const upload = new Upload({
+        client: s3,
+        params: {
+          Bucket: S3_BUCKET,
+          Key,
+          Body,
+          ACL,
+        },
+      });
+
+      const link = await this.getS3LocationLink(upload);
+      this.totalUploaded++;
+      this.succesfulUploads[Key] = link;
+      return link;
+    } catch (e) {
+      this.failedUpload++;
+      debug('S3 uploading error:', e);
+      console.log(APP_PREFIX, "Upload failed:", e.message, this.getMaskedConfig());
+    }
+  }
+
+  readUploadedFiles(runId = null) {
+    const tempFilePath = this.#getUploadFilePath(runId);
+
+    debug('Reading file', tempFilePath);
+
+    if (!fs.existsSync(tempFilePath)) {
+      debug('File not found:', tempFilePath);
+      return [];
+    }
+
+    const stats = fs.statSync(tempFilePath);
+    const diff = (+new Date()) - (+stats.mtime);
+    const diffHours = diff / 1000 / 60 / 60;
+    if (diffHours > 3) {
+      console.log(APP_PREFIX, 'Artifacts file is too old, can\'t process artifacts. Please re-run the tests.');
+      return [];
+    }
+
+    const data = fs.readFileSync(tempFilePath, 'utf8');
+    const lines = data.split('\n').filter(Boolean);
+    return lines.map(line => JSON.parse(line));
+  }
+
+  #getUploadFilePath(runId = null, forceCreate = false) {
+    if (!runId && !forceCreate) {
+      return path.join(os.tmpdir(), 'testomatio.run.latest.jsonl');
+    }
+
+    const tempFilePath = path.join(os.tmpdir(), `testomatio.run.${runId}.jsonl`);
+    if (!fs.existsSync(tempFilePath) || forceCreate) {
+      debug('Creating artifacts file:', tempFilePath);
+      fs.writeFileSync(tempFilePath, '');
+      // make symlink to 'testomatio.run.latest.jsonl' file
+      const latestFilePath = path.join(os.tmpdir(), 'testomatio.run.latest.jsonl');
+      if (fs.existsSync(latestFilePath)) {
+        fs.unlinkSync(latestFilePath);
+      }
+      fs.symlinkSync(tempFilePath, latestFilePath);
+
+    }
+    return tempFilePath;
+  }
+
+  storeUploadedFile(filePath, runId, rid, uploaded = false) {
+    if (!this.storeEnabled) return;
+
+    if (!filePath || !runId || !rid ) return;
+
+    const tempFilePath = this.#getUploadFilePath(runId);
+
+    const data = { rid, file: filePath, uploaded };
+    const jsonLine = JSON.stringify(data) + '\n';
+
+    fs.appendFileSync(tempFilePath, jsonLine);
+  }
+
+  getskippedUpload() {
+    return this.skippedUpload;
+  }
+
+  async uploadFileByPath(filePath, pathInS3) {
+    const [runId, rid] = pathInS3;
+
+    if (!this.isEnabled) {
+      this.storeUploadedFile(filePath, runId, rid, false);
+      this.skippedUpload++;
+      return;
+    }
+
+    const {
+      S3_BUCKET,
+      TESTOMATIO_ARTIFACTS_SIZE,
+    } = this.getConfig();
+
+    debug('Started upload', filePath, 'to', S3_BUCKET);
+
+    const isFileExist = await this.checkFileExists(filePath, 20, 500);
+
+    if (!isFileExist) {
+      this.failedUpload++;
+      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_ARTIFACTS_SIZE && fileSizeInMb > parseInt(TESTOMATIO_ARTIFACTS_SIZE)) {
+      this.skippedUpload++;
+      console.error(chalk.yellow(`Artifacts file ${filePath} exceeds the maximum allowed size. Skipping...`));
+      return;
+    }
+    debug('File:', filePath, 'exists, size:', fileSizeInMb.toFixed(2), 'MB');
+
+    const fileStream = fs.createReadStream(filePath);
+    const Key = pathInS3.join('/');
+
+    const link = await this.uploadToS3(fileStream, Key);
+
+    this.storeUploadedFile(filePath, runId, rid, !!link);
+
+    return link;
+  }
+
+  async uploadFileAsBuffer(buffer, pathInS3) {
+    if (!this.isEnabled) return;
+
+    let Key = pathInS3.join('/');
+    const ext = this.#getFileExtBase64(buffer);
+
+    if (ext) {
+      Key = `${Key}.${ext}`;
+    }
+
+    return this.uploadToS3(buffer, Key);
+  }
+
+  async checkFileExists(filePath, attempts = 5, intervalMs = 500) {
+    return promiseRetry(
+      async (retry, number) => {
+        try {
+          fs.accessSync(filePath);
+          return true;
+        } catch (err) {
+          if (number === attempts) {
+            return false;
+          }
+          debug(`File not found, retrying (attempt ${number}/${attempts})`);
+          await new Promise((resolve) => setTimeout(resolve, intervalMs));
+          retry(err);
+        }
+      },
+      {
+        retries: attempts,
+        minTimeout: intervalMs,
+        maxTimeout: intervalMs,
+      }
+    );
+  }
+
+  async getS3LocationLink(out) {
+    const response = await out.done();
+
+    let s3Location = response?.Location;
+
+    if (!s3Location) {
+      s3Location = out?.singleUploadResult?.Location;
+      debug('Uploaded singleUploadResult.Location', s3Location);
+
+      if (!s3Location) {
+        throw new Error("Problems getting the S3 artifact's link. Please check S3 permissions!");
+      }
+    }
+
+    return s3Location;
+  }
+
+  #getFileExtBase64(str) {
+    const type = str.charAt(0);
+
+    return (
+      {
+        '/': 'jpg',
+        i: 'png',
+        R: 'gif',
+        U: 'webp',
+      }[type] || ''
+    );
+  }
+
+  getS3Config() {
+    const { S3_REGION, S3_SESSION_TOKEN, S3_ACCESS_KEY_ID, S3_SECRET_ACCESS_KEY, S3_FORCE_PATH_STYLE, S3_ENDPOINT } =
+      this.getConfig();
+
+    const cfg = {
+      region: S3_REGION,
+      credentials: {
+        accessKeyId: S3_ACCESS_KEY_ID,
+        secretAccessKey: S3_SECRET_ACCESS_KEY,
+        s3ForcePathStyle: S3_FORCE_PATH_STYLE,
+      },
+    };
+
+    if (S3_SESSION_TOKEN) {
+      cfg.credentials.sessionToken = S3_SESSION_TOKEN;
+    }
+
+    if (S3_ENDPOINT) {
+      cfg.endpoint = S3_ENDPOINT;
+    }
+
+    return cfg;
+  }
+}
+
+module.exports = S3Uploader;

package/lib/utils/pipe_utils.js

@@ -1,4 +1,3 @@
-const { resetConfig } = require('../fileUploader');
 const { APP_PREFIX } = require('../constants');
 
 /**
@@ -17,7 +16,6 @@ function setS3Credentials(artifacts) {
   if (artifacts.ENDPOINT) process.env.S3_ENDPOINT = artifacts.ENDPOINT;
   if (artifacts.SESSION_TOKEN) process.env.S3_SESSION_TOKEN = artifacts.SESSION_TOKEN;
   if (artifacts.presign) process.env.TESTOMATIO_PRIVATE_ARTIFACTS = '1';
-  resetConfig();
 }
 /**
  * Generates mode request parameters based on the input params.

package/lib/xmlReader.js

@@ -13,7 +13,7 @@ const {
   fetchIdFromCode,
   humanize,
 } = require('./utils/utils');
-const upload = require('./fileUploader');
+const S3Uploader = require('./uploader');
 const pipesFactory = require('./pipe');
 const adapterFactory = require('./junit-adapter');
 const config = require('./config');
@@ -56,7 +56,7 @@ class XmlReader {
     this.tests = [];
     this.stats = {};
     this.stats.language = opts.lang?.toLowerCase();
-    this.filesToUpload = {};
+    this.uploader = new S3Uploader();
 
     this.version = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json')).toString()).version;
     console.log(APP_PREFIX, `Testomatio Reporter v${this.version}`);
@@ -382,7 +382,7 @@ class XmlReader {
       if (!files.length) continue;
 
       const runId = this.runId || this.store.runId || Date.now().toString();
-      test.artifacts = await Promise.all(files.map(f => upload.uploadFileByPath(f, runId)));
+      test.artifacts = await Promise.all(files.map(f => this.uploader.uploadFileByPath(f, [runId])));
       console.log(APP_PREFIX, `🗄️ Uploaded ${chalk.bold(`${files.length} artifacts`)} for test ${test.title}`);
     }
   }
@@ -398,7 +398,9 @@ class XmlReader {
 
     debug('Run', runParams);
 
-    return Promise.all(this.pipes.map(p => p.createRun(runParams)));
+    await Promise.all(this.pipes.map(p => p.createRun(runParams)));
+
+    this.uploader.checkEnabled();
   }
 
   async uploadData() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testomatio/reporter",
-  "version": "1.5.1",
+  "version": "1.6.0-beta-2-artifacts",
   "description": "Testomatio Reporter Client",
   "main": "./lib/reporter.js",
   "typings": "typings/index.d.ts",
@@ -16,7 +16,7 @@
     "axios-retry": "^3.9.1",
     "callsite-record": "^4.1.4",
     "chalk": "^4.1.0",
-    "commander": "^4.1.1",
+    "commander": "^12",
     "cross-spawn": "^7.0.3",
     "csv-writer": "^1.6.0",
     "debug": "^4.3.4",
@@ -81,7 +81,9 @@
     "puppeteer": "^22.15.0"
   },
   "bin": {
+    "@testomatio/reporter": "./lib/bin/cli.js",
     "report-xml": "./lib/bin/reportXml.js",
-    "start-test-run": "./lib/bin/startTest.js"
+    "start-test-run": "./lib/bin/startTest.js",
+    "upload-artifacts": "./lib/bin/uploadArtifacts.js"
   }
 }

package/lib/fileUploader.js

@@ -1,306 +0,0 @@
-const debug = require('debug')('@testomatio/reporter:file-uploader');
-const { S3 } = require('@aws-sdk/client-s3');
-const { Upload } = require('@aws-sdk/lib-storage');
-
-const fs = require('fs');
-const util = require('util');
-const path = require('path');
-const promiseRetry = require('promise-retry');
-
-const readFile = util.promisify(fs.readFile);
-const stat = util.promisify(fs.stat);
-const chalk = require('chalk');
-const { randomUUID } = require('crypto');
-
-const { APP_PREFIX } = require('./constants');
-
-const keys = [
-  'S3_ENDPOINT',
-  'S3_REGION',
-  'S3_BUCKET',
-  'S3_ACCESS_KEY_ID',
-  'S3_SECRET_ACCESS_KEY',
-  'S3_SESSION_TOKEN',
-  'TESTOMATIO_DISABLE_ARTIFACTS',
-  'TESTOMATIO_PRIVATE_ARTIFACTS',
-  'S3_FORCE_PATH_STYLE',
-];
-
-let config;
-
-function resetConfig() {
-  config = undefined;
-  isEnabled = undefined;
-}
-
-function getConfig() {
-  if (config) return config;
-  config = keys.reduce((acc, key) => {
-    acc[key] = process.env[key];
-    return acc;
-  }, {});
-  return config;
-}
-
-function getMaskedConfig() {
-  return Object.fromEntries(
-    Object.entries(getConfig()).map(([key, value]) => [
-      key,
-      key === 'S3_SECRET_ACCESS_KEY' || key === 'S3_ACCESS_KEY_ID' ? '***' : value,
-    ]),
-  );
-}
-
-let isEnabled;
-
-const isArtifactsEnabled = () => {
-  if (isEnabled !== undefined) return isEnabled;
-  const { S3_BUCKET, TESTOMATIO_DISABLE_ARTIFACTS } = getConfig();
-  isEnabled = !!(S3_BUCKET && !TESTOMATIO_DISABLE_ARTIFACTS);
-  debug(`Upload is ${isEnabled ? 'enabled' : 'disabled'}`);
-  return isEnabled;
-};
-
-const _getFileExtBase64 = str => {
-  const type = str.charAt(0);
-
-  return (
-    {
-      '/': '.jpg',
-      i: '.png',
-      R: '.gif',
-      U: '.webp',
-    }[type] || ''
-  );
-};
-
-const _getS3Config = () => {
-  const { S3_REGION, S3_SESSION_TOKEN, S3_ACCESS_KEY_ID, S3_SECRET_ACCESS_KEY, S3_FORCE_PATH_STYLE, S3_ENDPOINT } =
-    getConfig();
-
-  const cfg = {
-    region: S3_REGION,
-    credentials: {
-      accessKeyId: S3_ACCESS_KEY_ID,
-      secretAccessKey: S3_SECRET_ACCESS_KEY,
-      s3ForcePathStyle: S3_FORCE_PATH_STYLE,
-    },
-  };
-
-  if (S3_SESSION_TOKEN) {
-    cfg.credentials.sessionToken = S3_SESSION_TOKEN;
-  }
-
-  if (S3_ENDPOINT) {
-    cfg.endpoint = S3_ENDPOINT;
-  }
-
-  return cfg;
-};
-
-const uploadUsingS3 = async (filePath, runId) => {
-  let ContentType;
-  let Key;
-
-  if (typeof filePath === 'object') {
-    ContentType = filePath?.type;
-    filePath = filePath?.path;
-    Key = filePath?.name;
-  }
-
-  const { TESTOMATIO_PRIVATE_ARTIFACTS, S3_BUCKET } = getConfig();
-
-  try {
-    debug('S3 config', getMaskedConfig());
-    debug('Started upload', filePath, 'to ', S3_BUCKET);
-
-    // Verification that the file was actually created: 20 attempts of 0.5 second => 10sec
-    const isFileExist = await checkFileExists(filePath, 20, 500);
-
-    if (!isFileExist) {
-      console.error(chalk.yellow(`Artifacts file ${filePath} does not exist. Skipping...`));
-      return;
-    }
-
-    debug('File: ', filePath, ' exists');
-
-    const fileData = await readFile(filePath);
-
-    Key = `${runId}/${randomUUID()}-${Key || path.basename(filePath)}`;
-
-    const ACL = TESTOMATIO_PRIVATE_ARTIFACTS ? 'private' : 'public-read';
-
-    if (!S3_BUCKET || !fileData) {
-      console.log(
-        APP_PREFIX,
-        chalk.bold.red(`Failed uploading '${Key}'. Please check S3 credentials`),
-        getMaskedConfig(),
-      );
-      return;
-    }
-
-    const s3 = new S3(_getS3Config());
-
-    const params = {
-      Bucket: S3_BUCKET,
-      Key,
-      Body: fileData,
-      ContentType,
-      ACL,
-    };
-
-    const out = new Upload({
-      client: s3,
-      params,
-    });
-
-    const link = await getS3LocationLink(out);
-
-    debug(`Succesfully uploaded ${filePath} => ${S3_BUCKET}/${Key} | URL: ${link}`);
-
-    return link;
-  } catch (e) {
-    debug('S3 file uploading error: ', e);
-
-    console.log(APP_PREFIX, `To ${chalk.bold('disable')} artifact uploads set: TESTOMATIO_DISABLE_ARTIFACTS=1`);
-
-    if (!TESTOMATIO_PRIVATE_ARTIFACTS) {
-      console.log(APP_PREFIX, `To enable ${chalk.bold('PRIVATE')} uploads set: TESTOMATIO_PRIVATE_ARTIFACTS=1`);
-    } else {
-      console.log(
-        APP_PREFIX,
-        `To enable ${chalk.bold('PUBLIC')} uploads remove TESTOMATIO_PRIVATE_ARTIFACTS env variable`,
-      );
-    }
-    console.log(APP_PREFIX, '---------------');
-  }
-};
-
-const uploadUsingS3AsBuffer = async (buffer, fileName, runId) => {
-  const { S3_REGION, S3_ACCESS_KEY_ID, S3_SECRET_ACCESS_KEY, S3_ENDPOINT, TESTOMATIO_PRIVATE_ARTIFACTS, S3_BUCKET } =
-    getConfig();
-
-  const ACL = TESTOMATIO_PRIVATE_ARTIFACTS ? 'private' : 'public-read';
-
-  const fileExtension = _getFileExtBase64(buffer.toString('base64'));
-  const Key = `${runId}/${fileName}${fileExtension}`;
-
-  if (!S3_BUCKET || !buffer) {
-    console.log(APP_PREFIX, chalk.bold.red(`Failed uploading '${Key}'. Please check S3 credentials`), {
-      accessKeyId: S3_ACCESS_KEY_ID,
-      secretAccessKey: S3_SECRET_ACCESS_KEY ? '**** (hidden) ***' : '(empty)',
-      region: S3_REGION,
-      bucket: S3_BUCKET,
-      acl: ACL,
-      endpoint: S3_ENDPOINT,
-    });
-    return;
-  }
-
-  const s3 = new S3(_getS3Config());
-
-  try {
-    const out = new Upload({
-      client: s3,
-
-      params: {
-        Bucket: S3_BUCKET,
-        Key,
-        Body: buffer,
-        ACL,
-      },
-    });
-
-    return await getS3LocationLink(out);
-  } catch (e) {
-    debug('S3 buffer uploading error: ', e);
-
-    console.log(APP_PREFIX, `To ${chalk.bold('disable')} artifact uploads set: TESTOMATIO_DISABLE_ARTIFACTS=1`);
-
-    if (!TESTOMATIO_PRIVATE_ARTIFACTS) {
-      console.log(APP_PREFIX, `To enable ${chalk.bold('PRIVATE')} uploads set: TESTOMATIO_PRIVATE_ARTIFACTS=1`);
-    } else {
-      console.log(
-        APP_PREFIX,
-        `To enable ${chalk.bold('PUBLIC')} uploads remove TESTOMATIO_PRIVATE_ARTIFACTS env variable`,
-      );
-    }
-    console.log(APP_PREFIX, '---------------');
-  }
-};
-
-const uploadFileByPath = async (filePath, runId) => {
-  try {
-    if (isArtifactsEnabled()) {
-      return uploadUsingS3(filePath, runId);
-    }
-  } catch (e) {
-    debug(e);
-
-    console.error(chalk.red('Error occurred while uploading artifacts! '), e);
-  }
-};
-
-const uploadFileAsBuffer = async (buffer, fileName, runId) => {
-  try {
-    if (isArtifactsEnabled()) {
-      return uploadUsingS3AsBuffer(buffer, fileName, runId);
-    }
-  } catch (e) {
-    debug(e);
-
-    console.error(chalk.red('Error occurred while uploading artifacts! '), e);
-  }
-};
-
-const checkFileExists = async (filePath, attempts = 5, intervalMs = 500) => {
-  const checkFile = async () => {
-    const fileStats = await stat(filePath);
-    if (fileStats.isFile()) {
-      return true;
-    }
-
-    throw new Error('File not found');
-  };
-
-  try {
-    await promiseRetry(
-      {
-        retries: attempts,
-        minTimeout: intervalMs,
-      },
-      checkFile,
-    );
-
-    return true;
-  } catch (err) {
-    console.error(chalk.yellow(`File ${filePath} was not found or did not have time to be generated...`));
-
-    return false;
-  }
-};
-
-const getS3LocationLink = async out => {
-  const response = await out.done();
-
-  let s3Location = response?.Location;
-
-  if (!s3Location) {
-    // TODO: out: a fallback case  - remove after deeper testing
-    s3Location = out?.singleUploadResult?.Location;
-    debug('Uploaded singleUploadResult.Location', s3Location);
-
-    if (!s3Location) {
-      throw new Error("Problems getting the S3 artifact's link. Please check S3 permissions!");
-    }
-  }
-
-  return s3Location;
-};
-
-module.exports = {
-  uploadFileByPath,
-  uploadFileAsBuffer,
-  isArtifactsEnabled,
-  resetConfig,
-};