testbeats 2.0.1 → 2.0.3

package/README.md

@@ -1,4 +1,4 @@
-> !IMPORTANT - This npm package has been renamed from [test-results-reporter](https://www.npmjs.com/package/test-results-reporter) to [testbeats](https://www.npmjs.com/package/testbeats). test-results-reporter will soon be phased out, and users are encouraged to transition to testbeats.
+> This npm package has been renamed from [test-results-reporter](https://www.npmjs.com/package/test-results-reporter) to [testbeats](https://www.npmjs.com/package/testbeats). test-results-reporter will soon be phased out, and users are encouraged to transition to testbeats.
 
 <span align="center">
 
@@ -19,35 +19,23 @@
 
 <hr>
 
-### Targets
-
-<img height="48" style="margin: 6px;" src="./assets/slack.png" alt="slack" /> <img height="48" style="margin: 6px;"  src="./assets/teams.png" alt="teams" /> <img height="48" style="margin: 6px;"  src="./assets/chat.png" alt="chat" />
-
-### Extensions
-
-<img height="48" style="margin: 6px;" src="./assets/reportportal.jpeg" alt="reportportal" /> <img height="48" style="margin: 6px;"  src="./assets/quickchart.png" alt="quickchart" /> <img height="48" style="margin: 6px;"  src="./assets/hyperlink.png" alt="hyperlink" /> <img height="48" style="margin: 6px;"  src="./assets/mentions.png" alt="mentions" />
-
-### Test Results
-
-<img height="48" style="margin: 6px;" src="./assets/testng.png" alt="testng" /> <img height="48" style="margin: 6px;"  src="./assets/junit.png" alt="junit" /> <img height="48" style="margin: 6px;"  src="./assets/cucumber.png" alt="cucumber" /> <img height="48" style="margin: 6px;"  src="./assets/mocha.png" alt="mocha" /> <img height="48" style="margin: 6px;"  src="./assets/xunit.png" alt="xunit" /> <img height="48" style="margin: 6px;"  src="./assets/jmeter.png" alt="jmeter" />
+</span>
 
-<hr>
+### Get Started
 
-## Sample Reports
+TestBeats is a tool designed to streamline the process of publishing test results from various automation testing frameworks to communication platforms like **slack**, **teams** and more for easy access and collaboration. It unifies your test reporting to build quality insights and make faster decisions.
 
-<br>
+Read more about the project at [https://testbeats.com](https://testbeats.com)
 
-![teams-summary-report](https://github.com/test-results-reporter/testbeats/raw/main/assets/teams-qc.png)
+### Sample Reports
 
-![slack-summary-report](https://github.com/test-results-reporter/testbeats/raw/main/assets/slack-report-portal-analysis.png)
+#### Alerts in Slack
 
-<br />
+![testbeats-failure-summary](./assets/testbeats-slack-failure-summary.png)
 
-<hr >
+#### Results in Portal
 
-# [Documentation](https://test-results-reporter.github.io/)
-
-</span>
+![testbeats-failure-summary](./assets/testbeats-failure-summary.png)
 
 <br />
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testbeats",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "Publish test results to Microsoft Teams, Google Chat, Slack and InfluxDB",
   "main": "src/index.js",
   "types": "./src/index.d.ts",
@@ -11,7 +11,7 @@
     "/src"
   ],
   "scripts": {
-    "test": "c8 mocha test",
+    "test": "c8 mocha test --reporter mocha-multi-reporters --reporter-options configFile=mocha.report.json",
     "build": "pkg --out-path dist ."
   },
   "repository": {
@@ -48,6 +48,7 @@
   "dependencies": {
     "async-retry": "^1.3.3",
     "dotenv": "^14.3.2",
+    "form-data-lite": "^1.0.3",
     "influxdb-lite": "^1.0.0",
     "performance-results-parser": "latest",
     "phin-retry": "^1.0.3",
@@ -59,6 +60,8 @@
   "devDependencies": {
     "c8": "^7.12.0",
     "mocha": "^10.1.0",
+    "mocha-junit-reporter": "^2.2.1",
+    "mocha-multi-reporters": "^1.5.1",
     "pactum": "^3.2.3",
     "pkg": "^5.8.0"
   }

package/src/beats/beats.api.js

@@ -0,0 +1,51 @@
+const request = require('phin-retry');
+
+class BeatsApi {
+
+  /**
+   * @param {import('../index').PublishReport} config
+   */
+  constructor(config) {
+    this.config = config;
+  }
+
+  postTestRun(payload) {
+    return request.post({
+      url: `${this.getBaseUrl()}/api/core/v1/test-runs`,
+      headers: {
+        'x-api-key': this.config.api_key
+      },
+      body: payload
+    });
+  }
+
+ /**
+  * @param {string} run_id
+  * @returns
+  */
+  getTestRun(run_id) {
+    return request.get({
+      url: `${this.getBaseUrl()}/api/core/v1/test-runs/key?id=${run_id}`,
+      headers: {
+        'x-api-key': this.config.api_key
+      }
+    });
+  }
+
+  uploadAttachments(headers, payload) {
+    return request.post({
+      url: `${this.getBaseUrl()}/api/core/v1/test-cases/attachments`,
+      headers: {
+        'x-api-key': this.config.api_key,
+        ...headers
+      },
+      body: payload
+    });
+  }
+
+  getBaseUrl() {
+    return process.env.TEST_BEATS_URL || "https://app.testbeats.com";
+  }
+}
+
+module.exports = { BeatsApi }

package/src/beats/beats.attachments.js

@@ -0,0 +1,100 @@
+const fs = require('fs');
+const path = require('path');
+const FormData = require('form-data-lite');
+const TestResult = require('test-results-parser/src/models/TestResult');
+const { BeatsApi } = require('./beats.api');
+const logger = require('../utils/logger');
+
+const MAX_ATTACHMENTS_PER_REQUEST = 5;
+const MAX_ATTACHMENTS_PER_RUN = 20;
+const MAX_ATTACHMENT_SIZE = 1024 * 1024;
+
+class BeatsAttachments {
+
+  /**
+   * @param {import('../index').PublishReport} config
+   * @param {TestResult} result
+   */
+  constructor(config, result, test_run_id) {
+    this.config = config;
+    this.result = result;
+    this.api = new BeatsApi(config);
+    this.test_run_id = test_run_id;
+    this.failed_test_cases = [];
+    this.attachments = [];
+  }
+
+  async upload() {
+    this.#setAllFailedTestCases();
+    this.#setAttachments();
+    await this.#uploadAttachments();
+  }
+
+  #setAllFailedTestCases() {
+    for (const suite of this.result.suites) {
+      for (const test of suite.cases) {
+        if (test.status === 'FAIL') {
+          this.failed_test_cases.push(test);
+        }
+      }
+    }
+  }
+
+  #setAttachments() {
+    for (const test_case of this.failed_test_cases) {
+      for (const attachment of test_case.attachments) {
+        this.attachments.push(attachment);
+      }
+    }
+  }
+
+  async #uploadAttachments() {
+    if (this.attachments.length === 0) {
+      return;
+    }
+    logger.info(`⏳ Uploading ${this.attachments.length} attachments...`);
+    const result_file = this.config.results[0].files[0];
+    const result_file_dir = path.dirname(result_file);
+    try {
+      let count = 0;
+      const size = MAX_ATTACHMENTS_PER_REQUEST;
+      for (let i = 0; i < this.attachments.length; i += size) {
+        if (count >= MAX_ATTACHMENTS_PER_RUN) {
+          logger.warn('⚠️ Maximum number of attachments per run reached. Skipping remaining attachments.');
+          break;
+        }
+        const attachments_subset = this.attachments.slice(i, i + size);
+        const form = new FormData();
+        form.append('test_run_id', this.test_run_id);
+        const file_images = []
+        for (const attachment of attachments_subset) {
+          const attachment_path = path.join(result_file_dir, attachment.path);
+          const stats = fs.statSync(attachment_path);
+          if (stats.size > MAX_ATTACHMENT_SIZE) {
+            logger.warn(`⚠️ Attachment ${attachment.path} is too big (${stats.size} bytes). Allowed size is ${MAX_ATTACHMENT_SIZE} bytes.`);
+            continue;
+          }
+          form.append('images', fs.readFileSync(attachment_path), { filename: path.basename(attachment_path), filepath: attachment_path });
+          file_images.push({
+            file_name: attachment.name,
+            file_path: attachment.path,
+          });
+          count += 1;
+        }
+        if (file_images.length === 0) {
+          return;
+        }
+        form.append('file_images', JSON.stringify(file_images));
+        await this.api.uploadAttachments(form.getHeaders(), form.getBuffer());
+        logger.info(`🏞️  Uploaded ${count} attachments`);
+      }
+    } catch (error) {
+      logger.error(`❌ Unable to upload attachments: ${error.message}`, error);
+    }
+  }
+
+
+
+}
+
+module.exports = { BeatsAttachments }

package/src/beats/beats.js

@@ -0,0 +1,181 @@
+const { getCIInformation } = require('../helpers/ci');
+const logger = require('../utils/logger');
+const { BeatsApi } = require('./beats.api');
+const { HOOK } = require('../helpers/constants');
+const TestResult = require('test-results-parser/src/models/TestResult');
+const { BeatsAttachments } = require('./beats.attachments');
+
+class Beats {
+
+  /**
+   * @param {import('../index').PublishReport} config
+   * @param {TestResult} result
+   */
+  constructor(config, result) {
+    this.config = config;
+    this.result = result;
+    this.api = new BeatsApi(config);
+    this.test_run_id = '';
+  }
+
+  async publish() {
+    this.#setCIInfo();
+    this.#setProjectName();
+    this.#setRunName();
+    this.#setApiKey();
+    await this.#publishTestResults();
+    await this.#uploadAttachments();
+    this.#updateTitleLink();
+    await this.#attachFailureSummary();
+  }
+
+  #setCIInfo() {
+    this.ci = getCIInformation();
+  }
+
+  #setProjectName() {
+    this.config.project = this.config.project || process.env.TEST_BEATS_PROJECT || (this.ci && this.ci.repository_name) || 'demo-project';
+  }
+
+  #setApiKey() {
+    this.config.api_key = this.config.api_key || process.env.TEST_BEATS_API_KEY;
+  }
+
+  #setRunName() {
+    this.config.run = this.config.run || process.env.TEST_BEATS_RUN || (this.ci && this.ci.build_name) || 'demo-run';
+  }
+
+  async #publishTestResults() {
+    if (!this.config.api_key) {
+      logger.warn('😿 No API key provided, skipping publishing results to TestBeats Portal');
+      return;
+    }
+    logger.info("🚀 Publishing results to TestBeats Portal...");
+    try {
+      const payload = this.#getPayload();
+      const response = await this.api.postTestRun(payload);
+      this.test_run_id = response.id;
+    } catch (error) {
+      logger.error(`❌ Unable to publish results to TestBeats Portal: ${error.message}`, error);
+    }
+  }
+
+  #getPayload() {
+    const payload = {
+      project: this.config.project,
+      run: this.config.run,
+      ...this.result
+    }
+    if (this.ci) {
+      payload.ci_details = [this.ci];
+    }
+    return payload;
+  }
+
+  async #uploadAttachments() {
+    if (!this.test_run_id) {
+      return;
+    }
+    if (this.result.status !== 'FAIL') {
+      return;
+    }
+    try {
+      const attachments = new BeatsAttachments(this.config, this.result, this.test_run_id);
+      await attachments.upload();
+    } catch (error) {
+      logger.error(`❌ Unable to upload attachments: ${error.message}`, error);
+    }
+  }
+
+  #getAllFailedTestCases() {
+    const test_cases = [];
+    for (const suite of this.result.suites) {
+      for (const test of suite.cases) {
+        if (test.status === 'FAIL') {
+          test_cases.push(test);
+        }
+      }
+    }
+    return test_cases;
+  }
+
+  #updateTitleLink() {
+    if (!this.test_run_id) {
+      return;
+    }
+    if (!this.config.targets) {
+      return;
+    }
+    const link = `${this.api.getBaseUrl()}/reports/${this.test_run_id}`;
+    for (const target of this.config.targets) {
+      target.inputs.title_link = link;
+    }
+  }
+
+  async #attachFailureSummary() {
+    if (!this.test_run_id) {
+      return;
+    }
+    if (!this.config.targets) {
+      return;
+    }
+    if (this.result.status !== 'FAIL') {
+      return;
+    }
+    if (this.config.show_failure_summary === false) {
+      return;
+    }
+    const text = await this.#getFailureSummary();
+    if (!text) {
+      return;
+    }
+    const extension = this.#getAIFailureSummaryExtension(text);
+    for (const target of this.config.targets) {
+      target.extensions = target.extensions || [];
+      target.extensions.push(extension);
+    }
+  }
+
+  async #getFailureSummary() {
+    logger.info('✨ Fetching AI Failure Summary...');
+    let retry = 3;
+    while (retry >= 0) {
+      retry = retry - 1;
+      await new Promise(resolve => setTimeout(resolve, this.#getDelay()));
+      const test_run = await this.api.getTestRun(this.test_run_id);
+      const status = test_run && test_run.failure_summary_status;
+      switch (status) {
+        case 'COMPLETED':
+          return test_run.execution_metrics[0].failure_summary;
+        case 'FAILED':
+          logger.error(`❌ Failed to generate AI Failure Summary`);
+          return;
+        case 'SKIPPED':
+          logger.warn(`❗ Skipped generating AI Failure Summary`);
+          return;
+      }
+      logger.info(`🔄 AI Failure Summary not generated, retrying...`);
+    }
+    logger.warn(`🙈 AI Failure Summary not generated in given time`);
+  }
+
+  #getDelay() {
+    if (process.env.TEST_BEATS_DELAY) {
+      return parseInt(process.env.TEST_BEATS_DELAY);
+    }
+    return 3000;
+  }
+
+  #getAIFailureSummaryExtension(text) {
+    return {
+      name: 'ai-failure-summary',
+      hook: HOOK.AFTER_SUMMARY,
+      inputs: {
+        failure_summary: text
+      }
+    };
+  }
+
+}
+
+module.exports = { Beats }

package/src/beats/index.js

@@ -1,174 +1,13 @@
-const request = require('phin-retry');
 const TestResult = require('test-results-parser/src/models/TestResult');
-const { getCIInformation } = require('../helpers/ci');
-const { HOOK } = require('../helpers/constants');
-
-function get_base_url() {
-  return process.env.TEST_BEATS_URL || "https://app.testbeats.com";
-}
+const { Beats } = require('./beats');
 
 /**
  * @param {import('../index').PublishReport} config
  * @param {TestResult} result
  */
 async function run(config, result) {
-  init(config);
-  if (isValid(config)) {
-    const run_id = await publishTestResults(config, result);
-    if (run_id) {
-      attachTestBeatsReportHyperLink(config, run_id);
-      await attachTestBeatsFailureSummary(config, result, run_id);
-    }
-  } else {
-    console.warn('Missing testbeats config parameters');
-  }
-}
-
-/**
- *
- * @param {import('../index').PublishReport} config
- */
-function init(config) {
-  config.project = config.project || process.env.TEST_BEATS_PROJECT;
-  config.run = config.run || process.env.TEST_BEATS_RUN;
-  config.api_key = config.api_key || process.env.TEST_BEATS_API_KEY;
-}
-
-/**
- *
- * @param {import('../index').PublishReport} config
- */
-function isValid(config) {
-  return config.project && config.run && config.api_key
-}
-
-/**
- * @param {import('../index').PublishReport} config
- * @param {TestResult} result
- */
-async function publishTestResults(config, result) {
-  console.log("Publishing results to TestBeats");
-  try {
-    const payload = {
-      project: config.project,
-      run: config.run,
-      ...result
-    }
-    const ci = getCIInformation();
-    if (ci) {
-      payload.ci_details = [ci];
-    }
-
-    const response = await request.post({
-      url: `${get_base_url()}/api/core/v1/test-runs`,
-      headers: {
-        'x-api-key': config.api_key
-      },
-      body: payload
-    });
-    return response.id;
-  } catch (error) {
-    console.log("Unable to publish results to TestBeats");
-    console.log(error);
-  }
-}
-
-/**
- * @param {import('../index').PublishReport} config
- * @param {string} run_id
- */
-function attachTestBeatsReportHyperLink(config, run_id) {
-  const beats_link = get_test_beats_report_link(run_id);
-  if (config.targets) {
-    for (const target of config.targets) {
-      target.inputs.title_link = beats_link;
-    }
-  }
-}
-
-/**
- * @param {import('../index').PublishReport} config
- * @param {TestResult} result
- * @param {string} run_id
- */
-async function attachTestBeatsFailureSummary(config, result, run_id) {
-  if (result.status !== 'FAIL') {
-    return;
-  }
-  if (config.show_failure_summary === false) {
-    return;
-  }
-  try {
-    await processFailureSummary(config, run_id);
-  } catch (error) {
-    console.log(error);
-    console.log("error processing failure summary");
-  }
-}
-
-async function processFailureSummary(config, run_id) {
-  let retry = 3;
-  while (retry > 0) {
-    const test_run = await getTestRun(config, run_id);
-    if (test_run && test_run.failure_summary_status) {
-      if (test_run.failure_summary_status === 'COMPLETED') {
-        addAIFailureSummaryExtension(config, test_run);
-        return;
-      } else if (test_run.failure_summary_status === 'FAILED') {
-        console.log(`Test run failure summary failed`);
-        return;
-      } else if (test_run.failure_summary_status === 'SKIPPED') {
-        console.log(`Test run failure summary failed`);
-        return;
-      }
-    }
-    console.log(`Test run failure summary not completed, retrying...`);
-    await new Promise(resolve => setTimeout(resolve, 3000));
-    retry = retry - 1;
-  }
-}
-
-/**
- * @param {import('../index').PublishReport} config
- * @param {string} run_id
- */
-function getTestRun(config, run_id) {
-  return request.get({
-    url: `${get_base_url()}/api/core/v1/test-runs/key?id=${run_id}`,
-    headers: {
-      'x-api-key': config.api_key
-    }
-  });
-}
-
-function getAIFailureSummaryExtension(test_run) {
-  const execution_metric = test_run.execution_metrics[0];
-  return {
-    name: 'ai-failure-summary',
-    hook: HOOK.AFTER_SUMMARY,
-    inputs: {
-      failure_summary: execution_metric.failure_summary
-    }
-  };
-}
-
-function addAIFailureSummaryExtension(config, test_run) {
-  const extension = getAIFailureSummaryExtension(test_run);
-  if (config.targets) {
-    for (const target of config.targets) {
-      target.extensions = target.extensions || [];
-      target.extensions.push(extension);
-    }
-  }
-}
-
-/**
- *
- * @param {string} run_id
- * @returns
- */
-function get_test_beats_report_link(run_id) {
-  return `${get_base_url()}/reports/${run_id}`;
+  const beats = new Beats(config, result);
+  await beats.publish();
 }
 
 module.exports = { run }

package/src/cli.js

@@ -4,18 +4,38 @@ require('dotenv').config();
 const sade = require('sade');
 
 const prog = sade('testbeats');
-const publish = require('./commands/publish');
+const { PublishCommand } = require('./commands/publish.command');
+const logger = require('./utils/logger');
+const { ConfigBuilder } = require('./utils/config.builder');
 
 prog
-  .version('2.0.1')
-  .option('-c, --config', 'Provide path to custom config', 'config.json');
+  .version('2.0.3')
+  .option('-c, --config', 'path to config file')
+  .option('-l, --logLevel', 'Log Level', "INFO")
+  .option('--slack', 'slack webhook url')
+  .option('--teams', 'teams webhook url')
+  .option('--chat', 'chat webhook url')
+  .option('--title', 'title of the test run')
+  .option('--junit', 'junit xml path')
+  .option('--testng', 'testng xml path')
+  .option('--cucumber', 'cucumber json path')
+  .option('--mocha', 'mocha json path')
+  .option('--nunit', 'nunit xml path')
+  .option('--xunit', 'xunit xml path')
+  .option('--mstest', 'mstest xml path')
+  .option('-ci-info', 'ci info extension')
+  .option('-chart-test-summary', 'chart test summary extension');
 
 prog.command('publish')
   .action(async (opts) => {
     try {
-      await publish.run(opts);
+      logger.setLevel(opts.logLevel);
+      const config_builder = new ConfigBuilder(opts);
+      config_builder.build();
+      const publish_command = new PublishCommand(opts);
+      await publish_command.publish();
     } catch (error) {
-      console.error(error);
+      logger.error(`Report publish failed: ${error.message}`);
       process.exit(1);
     }
   });

package/src/commands/publish.command.js

@@ -0,0 +1,188 @@
+const path = require('path');
+const trp = require('test-results-parser');
+const prp = require('performance-results-parser');
+
+const beats = require('../beats');
+const target_manager = require('../targets');
+const logger = require('../utils/logger');
+const { processData } = require('../helpers/helper');
+const pkg = require('../../package.json');
+
+class PublishCommand {
+
+  /**
+   * @param {import('../index').PublishOptions} opts
+   */
+  constructor(opts) {
+    this.opts = opts;
+  }
+
+  async publish() {
+    logger.info(`🥁 TestBeats v${pkg.version}`);
+    this.#validateOptions();
+    this.#setConfigFromFile();
+    this.#processConfig();
+    this.#validateConfig();
+    this.#processResults();
+    await this.#publishResults();
+    logger.info('✅ Results published successfully!');
+  }
+
+  #validateOptions() {
+    if (!this.opts) {
+      throw new Error('Missing publish options');
+    }
+    if (!this.opts.config) {
+      throw new Error('Missing publish config');
+    }
+  }
+
+  #setConfigFromFile() {
+    if (typeof this.opts.config === 'string') {
+      const cwd = process.cwd();
+      const file_path = path.join(cwd, this.opts.config);
+      try {
+        this.opts.config = require(path.join(cwd, this.opts.config));
+      } catch (error) {
+        throw new Error(`Config file not found: ${file_path}`);
+      }
+    }
+  }
+
+  #processConfig() {
+    const processed_config = processData(this.opts.config);
+    /**@type {import('../index').PublishConfig[]} */
+    this.configs = [];
+    if (processed_config.reports) {
+      for (const report of config.reports) {
+        this.configs.push(report);
+      }
+    } else {
+      this.configs.push(processed_config);
+    }
+  }
+
+  #validateConfig() {
+    logger.info("🛠️  Validating configuration...")
+    for (const config of this.configs) {
+      this.#validateResults(config);
+      this.#validateTargets(config);
+    }
+  }
+
+  /**
+ *
+ * @param {import('../index').PublishReport} config
+ */
+  #validateResults(config) {
+    logger.debug("Validating results...")
+    if (!config.results) {
+      throw new Error('Missing results properties in config');
+    }
+    if (!Array.isArray(config.results)) {
+      throw new Error(`'config.results' must be an array`);
+    }
+    if (!config.results.length) {
+      throw new Error('At least one result must be defined');
+    }
+    for (const result of config.results) {
+      if (!result.type) {
+        throw new Error('Missing result type');
+      }
+      if (result.type === 'custom') {
+        if (!result.result) {
+          throw new Error(`custom 'config.results[*].result' is missing`);
+        }
+      } else {
+        if (!result.files) {
+          throw new Error('Missing result files');
+        }
+        if (!Array.isArray(result.files)) {
+          throw new Error('result files must be an array');
+        }
+        if (!result.files.length) {
+          throw new Error('At least one result file must be defined');
+        }
+      }
+    }
+    logger.debug("Validating results - Successful!")
+  }
+
+  /**
+   *
+   * @param {import('../index').PublishReport} config
+   */
+  #validateTargets(config) {
+    logger.debug("Validating targets...")
+    if (!config.targets) {
+      logger.warn('⚠️ Targets are not defined in config');
+      return;
+    }
+    if (!Array.isArray(config.targets)) {
+      throw new Error('targets must be an array');
+    }
+    for (const target of config.targets) {
+      if (!target.name) {
+        throw new Error(`'config.targets[*].name' is missing`);
+      }
+      if (target.name === 'slack' || target.name === 'teams' || target.name === 'chat') {
+        if (!target.inputs) {
+          throw new Error(`missing inputs in ${target.name} target`);
+        }
+      }
+      if (target.inputs) {
+        const inputs = target.inputs;
+        if (target.name === 'slack' || target.name === 'teams' || target.name === 'chat') {
+          if (!inputs.url) {
+            throw new Error(`missing url in ${target.name} target inputs`);
+          }
+          if (typeof inputs.url !== 'string') {
+            throw new Error(`url in ${target.name} target inputs must be a string`);
+          }
+          if (!inputs.url.startsWith('http')) {
+            throw new Error(`url in ${target.name} target inputs must start with 'http' or 'https'`);
+          }
+        }
+      }
+    }
+    logger.debug("Validating targets - Successful!")
+  }
+
+  #processResults() {
+    logger.info('🧙 Processing results...');
+    this.results = [];
+    for (const config of this.configs) {
+      for (const result_options of config.results) {
+        if (result_options.type === 'custom') {
+          this.results.push(result_options.result);
+        } else if (result_options.type === 'jmeter') {
+          this.results.push(prp.parse(result_options));
+        } else {
+          this.results.push(trp.parse(result_options));
+        }
+      }
+    }
+  }
+
+  async #publishResults() {
+    for (const config of this.configs) {
+      for (let i = 0; i < this.results.length; i++) {
+        const result = this.results[i];
+        const global_extensions = config.extensions || [];
+        await beats.run(config, result);
+        if (config.targets) {
+          for (const target of config.targets) {
+            target.extensions = target.extensions || [];
+            target.extensions = global_extensions.concat(target.extensions);
+            await target_manager.run(target, result);
+          }
+        } else {
+          logger.warn('⚠️ No targets defined, skipping sending results to targets');
+        }
+      }
+    }
+  }
+
+}
+
+module.exports = { PublishCommand }

package/src/extensions/index.js

@@ -10,6 +10,7 @@ const ci_info = require('./ci-info');
 const ai_failure_summary = require('./ai-failure-summary');
 const { EXTENSION } = require('../helpers/constants');
 const { checkCondition } = require('../helpers/helper');
+const logger = require('../utils/logger');
 
 async function run(options) {
   const { target, result, hook } = options;
@@ -25,9 +26,9 @@ async function run(options) {
         try {
           await extension_runner.run(options);
         } catch (error) {
-          console.log('Failed to run extension');
-          console.log(extension);
-          console.log(error);
+          logger.error(`Failed to run extension: ${error.message}`);
+          logger.debug(`Extension details`, extension);
+          logger.debug(`Error: `, error);
         }
       }
     }

package/src/extensions/report-portal-history.js

@@ -1,6 +1,7 @@
 const { getSuiteHistory, getLastLaunchByName, getLaunchDetails } = require('../helpers/report-portal');
 const { addChatExtension, addSlackExtension, addTeamsExtension } = require('../helpers/extension.helper');
 const { HOOK, STATUS } = require('../helpers/constants');
+const logger = require('../utils/logger');
 
 async function getLaunchHistory(extension) {
   const { inputs, outputs } = extension;
@@ -71,8 +72,8 @@ async function run({ extension, target, payload }) {
       }
     }
   } catch (error) {
-    console.log('Failed to get report portal history');
-    console.log(error);
+    logger.error(`Failed to get report portal history: ${error.message}`);
+    logger.debug(`Error: ${error}`);
   }
 }
 

package/src/index.d.ts

@@ -228,6 +228,7 @@ export interface PublishReport {
   run?: string;
   show_failure_summary?: boolean;
   targets?: Target[];
+  extensions?: Extension[];
   results?: ParseOptions[] | PerformanceParseOptions[] | CustomResultOptions[];
 }
 
@@ -236,6 +237,7 @@ export interface PublishConfig {
   project?: string;
   run?: string;
   targets?: Target[];
+  extensions?: Extension[];
   results?: ParseOptions[] | PerformanceParseOptions[] | CustomResultOptions[];
 }
 
@@ -243,5 +245,25 @@ export interface PublishOptions {
   config: string | PublishConfig;
 }
 
+export interface CommandLineOptions {
+  config?: string;
+  project?: string;
+  run?: string;
+  'api-key'?: string;
+  slack?: string;
+  teams?: string;
+  chat?: string;
+  title?: string;
+  'ci-info'?: boolean;
+  'chart-test-summary'?: boolean;
+  junit?: string;
+  testng?: string;
+  cucumber?: string;
+  mocha?: string;
+  nunit?: string;
+  xunit?: string;
+  mstest?: string;
+}
+
 export function publish(options: PublishOptions): Promise<any>
 export function defineConfig(config: PublishConfig): PublishConfig

package/src/index.js

@@ -1,7 +1,8 @@
-const cmd_publish = require('./commands/publish');
+const { PublishCommand } = require('./commands/publish.command');
 
 function publish(options) {
-  return cmd_publish.run(options);
+  const publish_command = new PublishCommand(options);
+  return publish_command.publish();
 }
 
 function defineConfig(config) {

package/src/utils/config.builder.js

@@ -0,0 +1,108 @@
+class ConfigBuilder {
+
+  /**
+   * @param {import('../index').CommandLineOptions} opts
+   */
+  constructor(opts) {
+    this.opts = opts;
+  }
+
+  build() {
+    if (!this.opts) {
+      return;
+    }
+    if (this.opts.config) {
+      return;
+    }
+
+    this.#buildConfig();
+    this.#buildBeats();
+    this.#buildResults();
+    this.#buildTargets();
+    this.#buildExtensions();
+
+    this.opts.config = this.config;
+  }
+
+  #buildConfig() {
+    /** @type {import('../index').PublishConfig}  */
+    this.config = {};
+  }
+
+  #buildBeats() {
+    this.config.project = this.opts.project || this.config.project;
+    this.config.run = this.opts.run || this.config.run;
+    this.config.api_key = this.opts['api-key'] || this.config.api_key;
+  }
+
+  #buildResults() {
+    if (this.opts.junit) {
+      this.#addResults('junit', this.opts.junit);
+    }
+    if (this.opts.testng) {
+      this.#addResults('testng', this.opts.testng);
+    }
+    if (this.opts.cucumber) {
+      this.#addResults('cucumber', this.opts.cucumber);
+    }
+    if (this.opts.mocha) {
+      this.#addResults('mocha', this.opts.mocha);
+    }
+    if (this.opts.nunit) {
+      this.#addResults('nunit', this.opts.nunit);
+    }
+    if (this.opts.xunit) {
+      this.#addResults('xunit', this.opts.xunit);
+    }
+    if (this.opts.mstest) {
+      this.#addResults('mstest', this.opts.mstest);
+    }
+  }
+
+  /**
+   * @param {string} type
+   * @param {string} file
+   */
+  #addResults(type, file) {
+    this.config.results = [
+      {
+        type,
+        files: [file]
+      }
+    ]
+  }
+
+  #buildTargets() {
+    if (this.opts.slack) {
+      this.#addTarget('slack', this.opts.slack);
+    }
+    if (this.opts.teams) {
+      this.#addTarget('teams', this.opts.teams);
+    }
+    if (this.opts.chat) {
+      this.#addTarget('chat', this.opts.chat);
+    }
+  }
+
+  #addTarget(name, url) {
+    this.config.targets = this.config.targets || [];
+    this.config.targets.push({ name, inputs: { url, title: this.opts.title || '', only_failures: true } })
+  }
+
+  #buildExtensions() {
+    if (this.opts['ci-info']) {
+      this.#addExtension('ci-info');
+    }
+    if (this.opts['chart-test-summary']) {
+      this.#addExtension('quick-chart-test-summary');
+    }
+  }
+
+  #addExtension(name) {
+    this.config.extensions = this.config.extensions || [];
+    this.config.extensions.push({ name });
+  }
+
+}
+
+module.exports = { ConfigBuilder };

package/src/utils/logger.js

@@ -0,0 +1,98 @@
+const trm = console;
+
+const LEVEL_VERBOSE = 2;
+const LEVEL_TRACE = 3;
+const LEVEL_DEBUG = 4;
+const LEVEL_INFO = 5;
+const LEVEL_WARN = 6;
+const LEVEL_ERROR = 7;
+const LEVEL_SILENT = 8;
+
+/**
+ * returns log level value
+ * @param {string} level - log level
+ */
+function getLevelValue(level) {
+  const logLevel = level.toUpperCase();
+  switch (logLevel) {
+    case 'TRACE':
+      return LEVEL_TRACE;
+    case 'DEBUG':
+      return LEVEL_DEBUG;
+    case 'INFO':
+      return LEVEL_INFO;
+    case 'WARN':
+      return LEVEL_WARN;
+    case 'ERROR':
+      return LEVEL_ERROR;
+    case 'SILENT':
+      return LEVEL_SILENT;
+    case 'VERBOSE':
+      return LEVEL_VERBOSE;
+    default:
+      return LEVEL_INFO;
+  }
+}
+
+class Logger {
+
+  constructor() {
+    this.level = process.env.TESTBEATS_LOG_LEVEL || 'INFO';
+    this.levelValue = getLevelValue(this.level);
+    if (process.env.TESTBEATS_DISABLE_LOG_COLORS === 'true') {
+      options.disableColors = true;
+    }
+  }
+
+  /**
+   * sets log level
+   * @param {('TRACE'|'DEBUG'|'INFO'|'WARN'|'ERROR')} level - log level
+   */
+  setLevel(level) {
+    this.level = level;
+    this.levelValue = getLevelValue(this.level);
+  }
+
+  trace(...msg) {
+    if (this.levelValue <= LEVEL_TRACE) {
+      msg.forEach(m => trm.debug(m));
+    }
+  }
+
+  debug(...msg) {
+    if (this.levelValue <= LEVEL_DEBUG) {
+      msg.forEach(m => trm.debug(m));
+    }
+  }
+
+  info(...msg) {
+    if (this.levelValue <= LEVEL_INFO) {
+      msg.forEach(m => trm.info(m));
+    }
+  }
+
+  warn(...msg) {
+    if (this.levelValue <= LEVEL_WARN) {
+      msg.forEach(m => trm.warn(getMessage(m)));
+    }
+  }
+
+  error(...msg) {
+    if (this.levelValue <= LEVEL_ERROR) {
+      msg.forEach(m => trm.error(getMessage(m)));
+    }
+  }
+
+}
+
+
+function getMessage(msg) {
+  try {
+    return typeof msg === 'object' ? JSON.stringify(msg, null, 2) : msg;
+  } catch (_) {
+    return msg;
+  }
+}
+
+
+module.exports = new Logger();

package/src/commands/publish.js

@@ -1,157 +0,0 @@
-const path = require('path');
-const trp = require('test-results-parser');
-const prp = require('performance-results-parser');
-
-const { processData } = require('../helpers/helper');
-const beats = require('../beats');
-const target_manager = require('../targets');
-
-/**
- * @param {import('../index').PublishOptions} opts
- */
-async function run(opts) {
-  if (!opts) {
-    throw new Error('Missing publish options');
-  }
-  if (!opts.config) {
-    throw new Error('Missing publish config');
-  }
-  if (typeof opts.config === 'string') {
-    const cwd = process.cwd();
-    const file_path = path.join(cwd, opts.config);
-    try {
-      opts.config = require(path.join(cwd, opts.config));
-    } catch (error) {
-      throw new Error(`Config file not found: ${file_path}`);
-    }
-  }
-  const config = processData(opts.config);
-  if (config.reports) {
-    for (const report of config.reports) {
-      validateConfig(report);
-      await processReport(report);
-    }
-  } else {
-    validateConfig(config);
-    await processReport(config);
-  }
-}
-
-/**
- *
- * @param {import('../index').PublishReport} report
- */
-async function processReport(report) {
-  const parsed_results = [];
-  for (const result_options of report.results) {
-    if (result_options.type === 'custom') {
-      parsed_results.push(result_options.result);
-    } else if (result_options.type === 'jmeter') {
-      parsed_results.push(prp.parse(result_options));
-    } else {
-      parsed_results.push(trp.parse(result_options));
-    }
-  }
-
-  for (let i = 0; i < parsed_results.length; i++) {
-    const result = parsed_results[i];
-    await beats.run(report, result);
-    if (report.targets) {
-      for (const target of report.targets) {
-        await target_manager.run(target, result);
-      }
-    } else {
-      console.log('No targets defined, skipping sending results to targets');
-    }
-  }
-}
-
-/**
- *
- * @param {import('../index').PublishReport} config
- */
-function validateConfig(config) {
-  if (!config) {
-    throw new Error('Missing publish config');
-  }
-  validateResults(config);
-  validateTargets(config);
-}
-
-/**
- *
- * @param {import('../index').PublishReport} config
- */
-function validateResults(config) {
-  if (!config.results) {
-    throw new Error('Missing results properties in config');
-  }
-  if (!Array.isArray(config.results)) {
-    throw new Error('results must be an array');
-  }
-  if (!config.results.length) {
-    throw new Error('At least one result must be defined');
-  }
-  for (const result of config.results) {
-    if (!result.type) {
-      throw new Error('Missing result type');
-    }
-    if (result.type === 'custom') {
-      if (!result.result) {
-        throw new Error('Missing result');
-      }
-    } else {
-      if (!result.files) {
-        throw new Error('Missing result files');
-      }
-      if (!Array.isArray(result.files)) {
-        throw new Error('result files must be an array');
-      }
-      if (!result.files.length) {
-        throw new Error('At least one result file must be defined');
-      }
-    }
-  }
-}
-
-/**
- *
- * @param {import('../index').PublishReport} config
- */
-function validateTargets(config) {
-  if (!config.targets) {
-    console.warn('targets are not defined in config');
-    return;
-  }
-  if (!Array.isArray(config.targets)) {
-    throw new Error('targets must be an array');
-  }
-  for (const target of config.targets) {
-    if (!target.name) {
-      throw new Error('missing target name');
-    }
-    if (target.name === 'slack' || target.name === 'teams' || target.name === 'chat') {
-      if (!target.inputs) {
-        throw new Error(`missing inputs in ${target.name} target`);
-      }
-    }
-    if (target.inputs) {
-      const inputs = target.inputs;
-      if (target.name === 'slack' || target.name === 'teams' || target.name === 'chat') {
-        if (!inputs.url) {
-          throw new Error(`missing url in ${target.name} target inputs`);
-        }
-        if (typeof inputs.url !== 'string') {
-          throw new Error(`url in ${target.name} target inputs must be a string`);
-        }
-        if (!inputs.url.startsWith('http')) {
-          throw new Error(`url in ${target.name} target inputs must start with 'http' or 'https'`);
-        }
-      }
-    }
-  }
-}
-
-module.exports = {
-  run
-}