testbeats 2.0.0 → 2.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testbeats",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Publish test results to Microsoft Teams, Google Chat, Slack and InfluxDB",
   "main": "src/index.js",
   "types": "./src/index.d.ts",
@@ -44,7 +44,7 @@
   "bugs": {
     "url": "https://github.com/test-results-reporter/testbeats/issues"
   },
-  "homepage": "https://test-results-reporter.github.io",
+  "homepage": "https://testbeats.com",
   "dependencies": {
     "async-retry": "^1.3.3",
     "dotenv": "^14.3.2",

package/src/beats/index.js

@@ -1,6 +1,7 @@
 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";
@@ -11,19 +12,42 @@ function get_base_url() {
  * @param {TestResult} result
  */
 async function run(config, result) {
-  if (config.project && config.run && config.api_key) {
+  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 
+ *
+ * @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,
@@ -34,7 +58,7 @@ async function publishTestResults(config, result) {
     if (ci) {
       payload.ci_details = [ci];
     }
-    
+
     const response = await request.post({
       url: `${get_base_url()}/api/core/v1/test-runs`,
       headers: {
@@ -63,9 +87,85 @@ function attachTestBeatsReportHyperLink(config, run_id) {
 }
 
 /**
- * 
- * @param {string} run_id 
- * @returns 
+ * @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}`;

package/src/cli.js

@@ -2,12 +2,12 @@
 require('dotenv').config();
 
 const sade = require('sade');
- 
-const prog = sade('test-results-reporter');
+
+const prog = sade('testbeats');
 const publish = require('./commands/publish');
- 
+
 prog
-  .version('0.0.7')
+  .version('2.0.1')
   .option('-c, --config', 'Provide path to custom config', 'config.json');
 
 prog.command('publish')

package/src/commands/publish.js

@@ -7,26 +7,39 @@ const beats = require('../beats');
 const target_manager = require('../targets');
 
 /**
- * @param {import('../index').PublishOptions} opts 
+ * @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();
-    opts.config = require(path.join(cwd, opts.config));
+    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 
+ *
+ * @param {import('../index').PublishReport} report
  */
 async function processReport(report) {
   const parsed_results = [];
@@ -43,8 +56,98 @@ async function processReport(report) {
   for (let i = 0; i < parsed_results.length; i++) {
     const result = parsed_results[i];
     await beats.run(report, result);
-    for (const target of report.targets) {
-      await target_manager.run(target, 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'`);
+        }
+      }
     }
   }
 }

package/src/extensions/ai-failure-summary.js

@@ -0,0 +1,72 @@
+const { STATUS, HOOK } = require("../helpers/constants");
+const { addChatExtension, addSlackExtension, addTeamsExtension } = require('../helpers/extension.helper');
+
+/**
+ * @param {object} param0
+ * @param {import('..').Target} param0.target
+ * @param {import('..').MetadataExtension} param0.extension
+ */
+async function run({ target, extension, result, payload, root_payload }) {
+  extension.inputs = Object.assign({}, default_inputs, extension.inputs);
+  if (target.name === 'teams') {
+    extension.inputs = Object.assign({}, default_inputs_teams, extension.inputs);
+    await attachForTeams({ target, extension, payload, result });
+  } else if (target.name === 'slack') {
+    extension.inputs = Object.assign({}, default_inputs_slack, extension.inputs);
+    await attachForSlack({ target, extension, payload, result });
+  } else if (target.name === 'chat') {
+    extension.inputs = Object.assign({}, default_inputs_chat, extension.inputs);
+    await attachForChat({ target, extension, payload, result });
+  }
+}
+
+/**
+ * @param {object} param0
+ * @param {import('..').MetadataExtension} param0.extension
+ */
+async function attachForTeams({ target, extension, payload, result }) {
+  const text = extension.inputs.failure_summary
+  if (text) {
+    addTeamsExtension({ payload, extension, text });
+  }
+}
+
+async function attachForSlack({ target, extension, payload, result }) {
+  const text = extension.inputs.failure_summary
+  if (text) {
+    addSlackExtension({ payload, extension, text });
+  }
+}
+
+async function attachForChat({ target, extension, payload, result }) {
+  const text = extension.inputs.failure_summary
+  if (text) {
+    addChatExtension({ payload, extension, text });
+  }
+}
+
+const default_options = {
+  hook: HOOK.AFTER_SUMMARY,
+  condition: STATUS.FAIL,
+}
+
+const default_inputs = {
+  title: 'AI Failure Summary ✨'
+}
+
+const default_inputs_teams = {
+  separator: true
+}
+
+const default_inputs_slack = {
+  separator: false
+}
+
+const default_inputs_chat = {
+  separator: true
+}
+
+module.exports = {
+  run,
+  default_options
+}

package/src/extensions/index.js

@@ -7,6 +7,7 @@ const percy_analysis = require('./percy-analysis');
 const custom = require('./custom');
 const metadata = require('./metadata');
 const ci_info = require('./ci-info');
+const ai_failure_summary = require('./ai-failure-summary');
 const { EXTENSION } = require('../helpers/constants');
 const { checkCondition } = require('../helpers/helper');
 
@@ -53,6 +54,8 @@ function getExtensionRunner(extension) {
       return metadata;
     case EXTENSION.CI_INFO:
       return ci_info;
+    case EXTENSION.AI_FAILURE_SUMMARY:
+      return ai_failure_summary;
     default:
       return require(extension.name);
   }

package/src/helpers/constants.js

@@ -20,6 +20,7 @@ const TARGET = Object.freeze({
 });
 
 const EXTENSION = Object.freeze({
+  AI_FAILURE_SUMMARY: 'ai-failure-summary',
   HYPERLINKS: 'hyperlinks',
   MENTIONS: 'mentions',
   REPORT_PORTAL_ANALYSIS: 'report-portal-analysis',

package/src/index.d.ts

@@ -4,7 +4,7 @@ import { Schedule, User } from 'rosters';
 import { ParseOptions } from 'test-results-parser';
 import TestResult from 'test-results-parser/src/models/TestResult';
 
-export type ExtensionName = 'report-portal-analysis' | 'hyperlinks' | 'mentions' | 'report-portal-history' | 'quick-chart-test-summary' | 'metadata' | 'ci-info' | 'custom';
+export type ExtensionName = 'report-portal-analysis' | 'hyperlinks' | 'mentions' | 'report-portal-history' | 'quick-chart-test-summary' | 'metadata' | 'ci-info' | 'custom' | 'ai-failure-summary';
 export type Hook = 'start' | 'end' | 'after-summary';
 export type TargetName = 'slack' | 'teams' | 'chat' | 'custom' | 'delay';
 export type PublishReportType = 'test-summary' | 'test-summary-slim' | 'failure-details';
@@ -61,11 +61,15 @@ export interface CIInfoInputs extends ExtensionInputs {
   data?: Metadata[];
 }
 
+export interface AIFailureSummaryInputs extends ExtensionInputs {
+  failure_summary: string;
+}
+
 export interface Extension {
   name: ExtensionName;
   condition?: Condition;
   hook?: Hook;
-  inputs?: ReportPortalAnalysisInputs | ReportPortalHistoryInputs | HyperlinkInputs | MentionInputs | QuickChartTestSummaryInputs | PercyAnalysisInputs | CustomExtensionInputs | MetadataInputs | CIInfoInputs;
+  inputs?: ReportPortalAnalysisInputs | ReportPortalHistoryInputs | HyperlinkInputs | MentionInputs | QuickChartTestSummaryInputs | PercyAnalysisInputs | CustomExtensionInputs | MetadataInputs | CIInfoInputs | AIFailureSummaryInputs;
 }
 
 export interface PercyAnalysisInputs extends ExtensionInputs {
@@ -208,8 +212,8 @@ export interface CustomTargetInputs {
 
 export interface Target {
   name: TargetName;
-  condition: Condition;
-  inputs: SlackInputs | TeamsInputs | ChatInputs | CustomTargetInputs | InfluxDBTargetInputs;
+  condition?: Condition;
+  inputs?: SlackInputs | TeamsInputs | ChatInputs | CustomTargetInputs | InfluxDBTargetInputs;
   extensions?: Extension[];
 }
 
@@ -222,6 +226,7 @@ export interface PublishReport {
   api_key?: string;
   project?: string;
   run?: string;
+  show_failure_summary?: boolean;
   targets?: Target[];
   results?: ParseOptions[] | PerformanceParseOptions[] | CustomResultOptions[];
 }
@@ -232,7 +237,6 @@ export interface PublishConfig {
   run?: string;
   targets?: Target[];
   results?: ParseOptions[] | PerformanceParseOptions[] | CustomResultOptions[];
-  reports?: PublishReport[];
 }
 
 export interface PublishOptions {