@testomatio/reporter 0.8.0-beta.9 → 0.8.2-beta.1

package/lib/client.js

@@ -1,29 +1,30 @@
-const axios = require('axios');
+const debug = require('debug')('@testomatio/reporter:client');
 const createCallsiteRecord = require('callsite-record');
 const { sep, join } = require('path');
 const fs = require('fs');
 const chalk = require('chalk');
+const { randomUUID } = require('crypto');
 const upload = require('./fileUploader');
-const { PASSED, FAILED, FINISHED, APP_PREFIX } = require('./constants');
+const { APP_PREFIX } = require('./constants');
 const pipesFactory = require('./pipe');
 
-const { TESTOMATIO_ENV } = process.env;
+/**
+ * @typedef {import('../types').TestData} TestData
+ * @typedef {import('../types').RunStatus} RunStatus
+ */
 
-
-class TestomatClient {
+class Client {
   /**
    * Create a Testomat client instance
    *
    * @param {*} params
    */
   constructor(params = {}) {
-    this.title = params.title || process.env.TESTOMATIO_TITLE;
-    this.env  = TESTOMATIO_ENV;
     this.parallel = params.parallel;
-    const store = {}
+    const store = {};
+    this.uuid = randomUUID();
     this.pipes = pipesFactory(params, store);
     this.queue = Promise.resolve();
-    this.axios = axios.create();
     this.totalUploaded = 0;
     this.version = JSON.parse(fs.readFileSync(join(__dirname, '..', 'package.json')).toString()).version;
     console.log(APP_PREFIX, `Testomatio Reporter v${this.version}`);
@@ -32,11 +33,11 @@ class TestomatClient {
   /**
    * Used to create a new Test run
    *
-   * @returns {Promise} - resolves to Run id which should be used to update / add test
+   * @returns {Promise<void>} - resolves to Run id which should be used to update / add test
    */
   createRun() {
     // all pipes disabled, skipping
-    if (!this.pipes.filter(p => p.isEnabled).length) return;
+    if (!this.pipes.filter(p => p.isEnabled).length) return Promise.resolve();
 
     const runParams = {
       title: this.title,
@@ -46,27 +47,39 @@ class TestomatClient {
 
     global.testomatioArtifacts = [];
 
-    this.queue = this.queue.then(() => Promise.all(this.pipes.map(p => p.createRun(runParams))));
-
+    this.queue = this.queue
+      .then(() => Promise.all(this.pipes.map(p => p.createRun(runParams))))
+      .catch(err => console.log(APP_PREFIX, err))
+      .then(() => undefined); // fixes return type
+    debug('Run', this.queue);
     return this.queue;
   }
 
   /**
-   * Used to add a new test to Run instance
-   *
-   * @returns {Promise}
+   * Updates test status and its data
+   * 
+   * @param {string|undefined} status
+   * @param {TestData} [testData]
+   * @param {string[]} [storeArtifacts]
+   * @returns {Promise<void>}
    */
-  async addTestRun(testId, status, testData = {}) {
+  async addTestRun(status, testData, storeArtifacts = []) {
     // all pipes disabled, skipping
     if (!this.pipes.filter(p => p.isEnabled).length) return;
 
+    if (!testData) testData = {
+      title: 'Unknown test',
+      suite_title: 'Unknown suite',
+    }
+
     const {
-      error = '',
+      error = null,
       time = '',
       example = null,
       files = [],
       filesBuffers = [],
       steps,
+      code = null,
       title,
       suite_title,
       suite_id,
@@ -76,33 +89,37 @@ class TestomatClient {
 
     const uploadedFiles = [];
 
-    if (testId) testData.test_id = testId;
-
     let stack = '';
 
     if (error) {
-      stack = this.formatError(error);
-      message = error.message;
+      stack = this.formatError(error) || '';
+      message = error?.message;
     }
     if (steps) {
       stack = this.formatSteps(stack, steps);
     }
 
+    if (Array.isArray(storeArtifacts) && storeArtifacts.length) {
+      debug("CLIENT storeArtifact", storeArtifacts);
+      files.push(...storeArtifacts);
+    }
+
     if (Array.isArray(global.testomatioArtifacts)) {
+      debug("CLIENT global[testomatioArtifacts]", global.testomatioArtifacts);
       files.push(...global.testomatioArtifacts);
       global.testomatioArtifacts = [];
     }
 
     for (const file of files) {
-      uploadedFiles.push(upload.uploadFileByPath(file, this.runId));
+      uploadedFiles.push(upload.uploadFileByPath(file, this.uuid));
     }
 
     for (const [idx, buffer] of filesBuffers.entries()) {
       const fileName = `${idx + 1}-${title.replace(/\s+/g, '-')}`;
-      uploadedFiles.push(upload.uploadFileAsBuffer(buffer, fileName, this.runId));
+      uploadedFiles.push(upload.uploadFileAsBuffer(buffer, fileName, this.uuid));
     }
 
-    const artifacts = await Promise.all(uploadedFiles)
+    const artifacts = await Promise.all(uploadedFiles);
 
     global.testomatioArtifacts = [];
 
@@ -114,7 +131,8 @@ class TestomatClient {
       status,
       stack,
       example,
-      title,      
+      code,
+      title,
       suite_title,
       suite_id,
       test_id,
@@ -123,36 +141,42 @@ class TestomatClient {
       artifacts,
     };
 
-    this.queue = this.queue.then(() => Promise.all(this.pipes.map(p => p.addTest(data))));
+    this.queue = this.queue
+      .then(() => Promise.all(this.pipes.map(p => p.addTest(data))))
+      .catch(err => console.log(APP_PREFIX, err))
+      .then(() => undefined);
     return this.queue;
   }
 
   /**
-   * Update run status
    *
-   * @returns {Promise}
+   * Updates the status of the current test run and finishes the run.
+   * @param {RunStatus} status - The status of the current test run. Must be one of "passed", "failed", or "finished"
+   * @param {boolean} [isParallel] - Whether the current test run was executed in parallel with other tests.
+   * @returns {Promise<void>} - A Promise that resolves when finishes the run.
    */
-  updateRunStatus(status, isParallel) {
+  updateRunStatus(status, isParallel = false) {
     // all pipes disabled, skipping
-    if (!this.pipes.filter(p => p.isEnabled).length) return;
+    if (!this.pipes.filter(p => p.isEnabled).length) return Promise.resolve();
+
+    const runParams = { status, parallel: isParallel };
+
+    this.queue = this.queue
+      .then(() => Promise.all(this.pipes.map(p => p.finishRun(runParams))))
+      .then(() => {
+        debug("TOTAL uploaded files", this.totalUploaded);
+        
+        if (upload.isArtifactsEnabled() && this.totalUploaded > 0) {
+          console.log(
+            APP_PREFIX,
+            `🗄️  Total ${this.totalUploaded} artifacts ${
+              process.env.TESTOMATIO_PRIVATE_ARTIFACTS ? 'privately' : chalk.bold('publicly')
+            } uploaded to S3 bucket  `,
+          );
+        }
+      })
+      .catch(err => console.log(APP_PREFIX, err));
 
-    let statusEvent;
-    if (status === FINISHED) statusEvent = 'finish';
-    if (status === PASSED) statusEvent = 'pass';
-    if (status === FAILED) statusEvent = 'fail';
-    if (isParallel) statusEvent += '_parallel';
-    const runParams = { status, statusEvent }
-
-    this.queue = this.queue.then(() => Promise.all(this.pipes.map(p => p.finishRun(runParams))));
-
-    if (upload.isArtifactsEnabled && this.totalUploaded > 0) {
-      console.log(
-        APP_PREFIX,
-        `🗄️  Total ${this.totalUploaded} artifacts ${
-          process.env.TESTOMATIO_PRIVATE_ARTIFACTS ? 'privately' : chalk.bold('publicly')
-        } uploaded to S3 bucket  `,
-      );
-    }
     return this.queue;
   }
 
@@ -193,4 +217,4 @@ class TestomatClient {
   }
 }
 
-module.exports = TestomatClient;
+module.exports = Client;

package/lib/constants.js

@@ -1,11 +1,26 @@
 const chalk = require('chalk');
 
 const APP_PREFIX = chalk.gray('[TESTOMATIO]');
+const TESTOMAT_ARTIFACT_SUFFIX = "testomatio_artifact_";
 
-module.exports = Object.freeze({
+const CSV_HEADERS = [
+  { id: 'suite_title', title: 'Suite_title' },
+  { id: 'title', title: 'Title' },
+  { id: 'status', title: 'Status' },
+  { id: 'message', title: 'Message' },
+  { id: 'stack', title: 'Stack' },
+];
+
+const STATUS = {
   PASSED: 'passed',
   FAILED: 'failed',
   SKIPPED: 'skipped',
   FINISHED: 'finished',
+};
+
+module.exports = {
   APP_PREFIX,
-});
+  TESTOMAT_ARTIFACT_SUFFIX,
+  CSV_HEADERS,
+  STATUS,
+}

package/lib/fileUploader.js

@@ -1,4 +1,7 @@
-const AWS = require('aws-sdk');
+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 path = require('path');
 const chalk = require('chalk');
@@ -6,18 +9,42 @@ const { randomUUID } = require('crypto');
 const memoize = require('lodash.memoize');
 const { APP_PREFIX } = require('./constants');
 
-const {
-  S3_ENDPOINT,
-  S3_REGION,
-  S3_BUCKET,
-  S3_ACCESS_KEY_ID,
-  S3_SECRET_ACCESS_KEY,
-  TESTOMATIO_DISABLE_ARTIFACTS,
-  TESTOMATIO_PRIVATE_ARTIFACTS,
-  S3_FORCE_PATH_STYLE,
-} = process.env;
-
-const isArtifactsEnabled = S3_BUCKET && !TESTOMATIO_DISABLE_ARTIFACTS;
+const keys = [
+  'S3_ENDPOINT',
+  'S3_REGION',
+  'S3_BUCKET',
+  'S3_ACCESS_KEY_ID',
+  'S3_SECRET_ACCESS_KEY',
+  'TESTOMATIO_DISABLE_ARTIFACTS',
+  'TESTOMATIO_PRIVATE_ARTIFACTS',
+  'S3_FORCE_PATH_STYLE',
+];
+
+let config;
+
+function getConfig() {
+  if (config) return config;
+  config = keys.reduce((acc, key) => {
+    acc[key] = process.env[key];
+    return acc;
+  }, {});
+  return config;
+}
+
+function getMaskedConfig() {
+  const config = getConfig();
+  return Object.fromEntries(Object.entries(config).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);
@@ -32,6 +59,25 @@ const _getFileExtBase64 = str => {
   );
 };
 
+const _getS3Config = () => {
+  const { S3_REGION, 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_ENDPOINT) {
+    cfg.endpoint = S3_ENDPOINT;
+  }
+
+  return cfg;
+}
+
 const uploadUsingS3 = async (filePath, runId) => {
   let ContentType;
   let Key;
@@ -42,49 +88,45 @@ const uploadUsingS3 = async (filePath, runId) => {
     Key = filePath.name;
   }
 
-  const config = {
-    region: S3_REGION,
-    accessKeyId: S3_ACCESS_KEY_ID,
-    secretAccessKey: S3_SECRET_ACCESS_KEY,
-    s3ForcePathStyle: S3_FORCE_PATH_STYLE,
-  };
-
-  if (S3_ENDPOINT) {
-    config.endpoint = new AWS.Endpoint(S3_ENDPOINT);
-  }
-
-  const s3 = new AWS.S3(config);
   if (!fs.existsSync(filePath)) {
     console.error(chalk.yellow(`Artifacts file ${filePath} does not exist. Skipping...`));
     return;
   }
+
+  const {
+    TESTOMATIO_PRIVATE_ARTIFACTS, S3_BUCKET
+  } = getConfig();
+
+  debug('S3 config', getMaskedConfig());
+  debug('Uploading', filePath, 'to', S3_BUCKET);
   
-  const file = fs.readFileSync(filePath);
+const fileData = fs.readFileSync(filePath);
 
   Key = `${runId}/${randomUUID()}-${Key || path.basename(filePath)}`;
   const ACL = TESTOMATIO_PRIVATE_ARTIFACTS ? 'private' : 'public-read';
 
+  const s3 = new S3(_getS3Config());
+
+  const params = {
+    Bucket: S3_BUCKET,
+    Key,
+    Body: fileData,
+    ACL,
+  };
+
   try {
-    const out = await s3
-      .upload({
-        Bucket: S3_BUCKET,
-        Key,
-        Body: file,
-        ContentType,
-        ACL,
-      })
-      .promise();
+    const out = new Upload({
+      client: s3,
+      params
+    });
+
+    await out.done();
+    debug('Uploaded', out.singleUploadResult.Location)
 
-    return out.Location;
+    return out.singleUploadResult.Location;
   } catch (e) {
-    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,
-    });
+    console.log(e);
+    console.log(APP_PREFIX, chalk.bold.red(`Failed uploading '${Key}'. Please check S3 credentials`), getMaskedConfig());
 
     console.log(APP_PREFIX, `To ${chalk.bold('disable')} artifact uploads set: TESTOMATIO_DISABLE_ARTIFACTS=1`);
     if (!TESTOMATIO_PRIVATE_ARTIFACTS) {
@@ -96,39 +138,36 @@ const uploadUsingS3 = async (filePath, runId) => {
       );
     }
     console.log(APP_PREFIX, '---------------');
-  }
+  } 
 };
 
 const uploadUsingS3AsBuffer = async (buffer, fileName, runId) => {
-  const config = {
-    region: S3_REGION,
-    accessKeyId: S3_ACCESS_KEY_ID,
-    secretAccessKey: S3_SECRET_ACCESS_KEY,
-    s3ForcePathStyle: S3_FORCE_PATH_STYLE,
-  };
 
-  if (S3_ENDPOINT) {
-    config.endpoint = new AWS.Endpoint(S3_ENDPOINT);
-  }
-
-  const s3 = new AWS.S3(config);
+  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}`;
 
+  const s3 = new S3(_getS3Config());
+
   try {
-    const out = await s3
-      .upload({
+    const out = new Upload({
+      client: s3,
+
+      params: {
         Bucket: S3_BUCKET,
         Key,
         Body: buffer,
         ACL,
-      })
-      .promise();
+      }
+    });
+    await out.done();
 
-    return out.Location;
+    return out.singleUploadResult.Location;
   } catch (e) {
     console.log(APP_PREFIX, chalk.bold.red(`Failed uploading '${Key}'. Please check S3 credentials`), {
       accessKeyId: S3_ACCESS_KEY_ID,
@@ -154,7 +193,7 @@ const uploadUsingS3AsBuffer = async (buffer, fileName, runId) => {
 
 const uploadFileByPath = async (filePath, runId) => {
   try {
-    if (isArtifactsEnabled) {
+    if (isArtifactsEnabled()) {
       return uploadUsingS3(filePath, runId);
     }
   } catch (e) {
@@ -164,7 +203,7 @@ const uploadFileByPath = async (filePath, runId) => {
 
 const uploadFileAsBuffer = async (buffer, fileName, runId) => {
   try {
-    if (isArtifactsEnabled) {
+    if (isArtifactsEnabled()) {
       return uploadUsingS3AsBuffer(buffer, fileName, runId);
     }
   } catch (e) {
@@ -175,5 +214,5 @@ const uploadFileAsBuffer = async (buffer, fileName, runId) => {
 module.exports = {
   uploadFileByPath: memoize(uploadFileByPath),
   uploadFileAsBuffer: memoize(uploadFileAsBuffer),
-  isArtifactsEnabled,
+  isArtifactsEnabled: memoize(isArtifactsEnabled),
 };

package/lib/junit-adapter/csharp.js

@@ -14,5 +14,4 @@ class CSharpAdapter extends Adapter {
   }
 }
 
-
 module.exports = CSharpAdapter;

package/lib/junit-adapter/index.js

@@ -5,8 +5,7 @@ const PythonAdapter = require('./python');
 const RubyAdapter = require('./ruby');
 const CSharpAdapter = require('./csharp');
 
-
-module.exports = function (lang, opts) {
+function AdapterFactory(lang, opts) {
   if (!lang) return new Adapter(opts);
 
   if (lang === 'java') {
@@ -25,3 +24,5 @@ module.exports = function (lang, opts) {
     return new CSharpAdapter(opts);
   }
 }
+
+module.exports = AdapterFactory;

package/lib/pipe/csv.js

@@ -0,0 +1,133 @@
+const debug = require('debug')('@testomatio/reporter:pipe:csv');
+const path = require('path');
+const fs = require('fs');
+const csvWriter = require('csv-writer');
+const chalk = require('chalk');
+const merge = require('lodash.merge');
+const { isSameTest, getCurrentDateTime } = require('../util');
+const { CSV_HEADERS } = require('../constants');
+
+/**
+ * @typedef {import('../../types').Pipe} Pipe
+ * @typedef {import('../../types').TestData} TestData
+ * @class CsvPipe
+ * @implements {Pipe}
+ */
+class CsvPipe {
+
+  constructor(params, store) {
+    this.store = store || {};
+    this.title = params.title || process.env.TESTOMATIO_TITLE;
+    this.isEnabled = true;
+    this.results = [];
+
+    this.outputDir = 'export';
+    this.csvFilename = process.env.TESTOMATIO_CSV_FILENAME;
+    this.isCsvSave = false;
+
+    if (this.csvFilename !== undefined && this.csvFilename.split('.').length > 0) {
+      this.isCsvSave = true;
+
+      if (this.csvFilename.split('.')[0] === 'report') {
+        this.outputFile = path.resolve(process.cwd(), this.outputDir, 'report.csv');
+      } else {
+        this.outputFile = path.resolve(
+          process.cwd(),
+          this.outputDir,
+          `${getCurrentDateTime()}_${this.csvFilename.split('.')[0]}.csv`,
+        );
+      }
+    }
+  }
+
+  async createRun() {
+    // empty
+  }
+
+  updateRun() {}
+
+  /**
+   * Create a folder that will contain the exported files
+   */
+  checkExportDir() {
+    if (!fs.existsSync(this.outputDir)) {
+      return fs.mkdirSync(this.outputDir);
+    }
+  }
+
+  /**
+   * Save data to the csv file.
+   * @param {Object} data - data that will be added to the CSV file.
+   * Example: [{suite_title: "Suite #1", test: "Test-case-1", message: "Test msg"}]
+   * @param {Object} headers - csv file headers. Example: [{ id: 'suite_title', title: 'Suite_title' }]
+   */
+  async saveToCsv(data, headers) {
+    debug('Data', data);
+    // First, we check whether the export directory exists: if yes - OK, no - create it.
+    this.checkExportDir();
+
+    if (!this.outputFile) {
+      console.log(this, chalk.yellow(`CSV file is not set, ignoring`));
+      return;
+    }
+
+    console.log(this, chalk.yellow(`The test results will be added to the csv. It will take some time...`));
+    // Create csv writer object
+    const writer = csvWriter.createObjectCsvWriter({
+      path: this.outputFile,
+      header: headers,
+    });
+    // Save csv file based on the current data
+    try {
+      await writer.writeRecords(data);
+      console.log(this, chalk.green(`Recording completed! You can check the result in file = ${this.outputFile}`));
+    } catch (e) {
+      console.log('Unknown error: ', e);
+    }
+  }
+
+  /**
+   * Add test data to the result array for saving. As a result of this function, we get a result object to save.
+   * @param {Object} test - object which includes each test entry.
+   */
+  addTest(test) {
+    if (!this.isEnabled) return;
+
+    const index = this.results.findIndex(t => isSameTest(t, test));
+    // update if they were already added
+    if (index >= 0) {
+      this.results[index] = merge(this.results[index], test);
+      return;
+    }
+
+    const { suite_title, title, status, message, stack } = test;
+
+    this.results.push({
+      suite_title,
+      title,
+      status,
+      message,
+      stack,
+    });
+  }
+
+  /**
+   * @param {{ tests?: TestData[] }} runParams
+   * @returns {Promise<void>}
+   */
+  async finishRun(runParams) {
+    if (!this.isEnabled) return;
+
+    if (runParams.tests) runParams.tests.forEach(t => this.addTest(t));
+    // Save results based on the default headers
+    if (this.isCsvSave) {
+      this.saveToCsv(this.results, CSV_HEADERS);
+    }
+  }
+
+  toString() {
+    return 'csv exporter';
+  }
+}
+
+module.exports = CsvPipe;