testbeats 2.0.2 → 2.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testbeats",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "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

@@ -32,6 +32,17 @@ class BeatsApi {
     });
   }
 
+  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";
   }

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

@@ -2,6 +2,8 @@ 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 {
 
@@ -22,6 +24,7 @@ class Beats {
     this.#setRunName();
     this.#setApiKey();
     await this.#publishTestResults();
+    await this.#uploadAttachments();
     this.#updateTitleLink();
     await this.#attachFailureSummary();
   }
@@ -69,6 +72,33 @@ class Beats {
     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;

package/src/cli.js

@@ -4,20 +4,33 @@ 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');
 
 prog
-  .version('2.0.1')
-  .option('-c, --config', 'Provide path to custom config', 'config.json')
-  .option('-l, --logLevel', 'Log Level', "INFO");
+  .version('2.0.4')
+  .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 {
       logger.setLevel(opts.logLevel);
-      logger.info(`Initiating...`);
-      await publish.run(opts);
+      const publish_command = new PublishCommand(opts);
+      await publish_command.publish();
     } catch (error) {
       logger.error(`Report publish failed: ${error.message}`);
       process.exit(1);

package/src/commands/publish.command.js

@@ -0,0 +1,197 @@
+const path = require('path');
+const trp = require('test-results-parser');
+const prp = require('performance-results-parser');
+
+const beats = require('../beats');
+const { ConfigBuilder } = require('../utils/config.builder');
+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.#buildConfig();
+    this.#validateOptions();
+    this.#setConfigFromFile();
+    this.#processConfig();
+    this.#validateConfig();
+    this.#processResults();
+    await this.#publishResults();
+    logger.info('✅ Results published successfully!');
+  }
+
+  #buildConfig() {
+    const config_builder = new ConfigBuilder(this.opts);
+    config_builder.build();
+  }
+
+  #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 {
+        const config_json = require(path.join(cwd, this.opts.config));
+        this.opts.config = config_json;
+      } catch (error) {
+        logger.error({ error }, `Failed to read config file: '${file_path}' with error: '${error.message}'`);
+        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/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,117 @@
+const path = require('path');
+const logger = require('./logger');
+
+class ConfigBuilder {
+
+  /**
+   * @param {import('../index').CommandLineOptions} opts
+   */
+  constructor(opts) {
+    this.opts = opts;
+  }
+
+  build() {
+    if (!this.opts) {
+      return;
+    }
+    if (typeof this.opts.config === 'object') {
+      return
+    }
+    if (this.opts.config && typeof this.opts.config === 'string') {
+      return;
+    }
+
+    logger.info('🏗 Building config...')
+    this.#buildConfig();
+    this.#buildBeats();
+    this.#buildResults();
+    this.#buildTargets();
+    this.#buildExtensions();
+
+    logger.debug(`🛠️ Generated Config: \n${JSON.stringify(this.config, null, 2)}`);
+
+    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: [path.join(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/commands/publish.js

@@ -1,168 +0,0 @@
-const path = require('path');
-const trp = require('test-results-parser');
-const prp = require('performance-results-parser');
-
-const pkg = require('../../package.json');
-const { processData } = require('../helpers/helper');
-const beats = require('../beats');
-const target_manager = require('../targets');
-const logger = require('../utils/logger');
-
-/**
- * @param {import('../index').PublishOptions} opts
- */
-async function run(opts) {
-  logger.info(`💡 TestBeats v${pkg.version}`);
-  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);
-  }
-  logger.info('✅ Results published successfully!');
-}
-
-/**
- *
- * @param {import('../index').PublishReport} report
- */
-async function processReport(report) {
-  logger.debug("processReport: Started")
-  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 {
-      logger.warn('No targets defined, skipping sending results to targets');
-    }
-  }
-  logger.debug("processReport: Ended")
-}
-
-/**
- *
- * @param {import('../index').PublishReport} config
- */
-function validateConfig(config) {
-  logger.info("🛠️  Validating configuration...")
-  if (!config) {
-    throw new Error('Missing configuration');
-  }
-  validateResults(config);
-  validateTargets(config);
-}
-
-/**
- *
- * @param {import('../index').PublishReport} config
- */
-function 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('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');
-      }
-    }
-  }
-  logger.debug("Validating results - Successful!")
-}
-
-/**
- *
- * @param {import('../index').PublishReport} config
- */
-function 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('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'`);
-        }
-      }
-    }
-  }
-  logger.debug("Validating targets - Successful!")
-}
-
-module.exports = {
-  run
-}