testbeats 2.2.3 → 2.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testbeats",
-  "version": "2.2.3",
+  "version": "2.2.4",
   "description": "Publish test results to Microsoft Teams, Google Chat, Slack and InfluxDB",
   "main": "src/index.js",
   "types": "./src/index.d.ts",

package/src/cli.js

@@ -23,6 +23,7 @@ prog.command('publish')
   .option('--slack', 'slack webhook url')
   .option('--teams', 'teams webhook url')
   .option('--chat', 'chat webhook url')
+  .option('--github', 'github token')
   .option('--title', 'title of the test run')
   .option('--junit', 'junit xml path')
   .option('--testng', 'testng xml path')

package/src/commands/generate-config.command.js

@@ -30,14 +30,14 @@ class GenerateConfigCommand {
 
     #printBanner() {
         const banner = `
-         _____             _    ___                  _         
-        (_   _)           ( )_ (  _'\\               ( )_       
-          | |   __    ___ | ,_)| (_) )   __     _ _ | ,_)  ___ 
+         _____             _    ___                  _
+        (_   _)           ( )_ (  _'\\               ( )_
+          | |   __    ___ | ,_)| (_) )   __     _ _ | ,_)  ___
           | | /'__'\\/',__)| |  |  _ <' /'__'\\ /'_' )| |  /',__)
           | |(  ___/\\__, \\| |_ | (_) )(  ___/( (_| || |_ \\__, \\
           (_)'\\____)(____/'\\__)(____/''\\____)'\\__,_)'\\__)(____/
-        
-                             v${pkg.version}  
+
+                             v${pkg.version}
                         Config Generation [BETA]
         `;
         console.log(banner);
@@ -102,7 +102,7 @@ class GenerateConfigCommand {
         const targetChoices = [
             { title: 'Slack', value: 'slack' },
             { title: 'Microsoft Teams', value: 'teams' },
-            { title: 'Google Chat', value: 'chat' }
+            { title: 'Google Chat', value: 'chat' },
         ];
 
         const { titleInput, targets } = await prompts([{
@@ -437,4 +437,4 @@ class GenerateConfigCommand {
     }
 }
 
-module.exports = { GenerateConfigCommand }; 
+module.exports = { GenerateConfigCommand };

package/src/helpers/constants.js

@@ -14,6 +14,7 @@ const TARGET = Object.freeze({
   SLACK: 'slack',
   TEAMS: 'teams',
   CHAT: 'chat',
+  GITHUB: 'github',
   CUSTOM: 'custom',
   DELAY: 'delay',
   INFLUX: 'influx',

package/src/index.d.ts

@@ -10,7 +10,7 @@ export interface ITarget {
   name: TargetName;
   enable?: string | boolean;
   condition?: Condition;
-  inputs?: SlackInputs | TeamsInputs | ChatInputs | CustomTargetInputs | InfluxDBTargetInputs;
+  inputs?: SlackInputs | TeamsInputs | ChatInputs | GitHubInputs | CustomTargetInputs | InfluxDBTargetInputs;
   extensions?: IExtension[];
 }
 
@@ -25,7 +25,7 @@ export interface IExtension {
 
 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 TargetName = 'slack' | 'teams' | 'chat' | 'github' | 'custom' | 'delay';
 export type PublishReportType = 'test-summary' | 'test-summary-slim' | 'failure-details';
 
 export interface ConditionFunctionContext {
@@ -242,6 +242,13 @@ export interface TeamsInputs extends TargetInputs {
 
 export interface ChatInputs extends TargetInputs { }
 
+export interface GitHubInputs extends TargetInputs {
+  token?: string;
+  owner?: string;
+  repo?: string;
+  pull_number?: string;
+}
+
 export interface InfluxDBTargetInputs {
   url: string;
   version?: string;

package/src/platforms/github.platform.js

@@ -0,0 +1,18 @@
+const { BasePlatform } = require('./base.platform');
+
+class GitHubPlatform extends BasePlatform {
+
+  /**
+   * @param {string|number} text
+   */
+  bold(text) {
+    return `**${text}**`;
+  }
+
+  break() {
+    return '\n';
+  }
+
+}
+
+module.exports = { GitHubPlatform };

package/src/platforms/index.js

@@ -2,6 +2,7 @@ const { TARGET } = require("../helpers/constants");
 const { SlackPlatform } = require('./slack.platform');
 const { TeamsPlatform } = require('./teams.platform');
 const { ChatPlatform } = require('./chat.platform');
+const { GitHubPlatform } = require('./github.platform');
 
 /**
  *
@@ -15,6 +16,8 @@ function getPlatform(name) {
       return new TeamsPlatform();
     case TARGET.CHAT:
       return new ChatPlatform();
+    case TARGET.GITHUB:
+      return new GitHubPlatform();
     default:
       throw new Error('Invalid Platform');
   }

package/src/targets/github.js

@@ -0,0 +1,310 @@
+const request = require('phin-retry');
+const { getPercentage, truncate, getPrettyDuration } = require('../helpers/helper');
+const extension_manager = require('../extensions');
+const { HOOK, STATUS, TARGET } = require('../helpers/constants');
+const logger = require('../utils/logger');
+
+const PerformanceTestResult = require('performance-results-parser/src/models/PerformanceTestResult');
+const { getValidMetrics, getMetricValuesText } = require('../helpers/performance');
+const TestResult = require('test-results-parser/src/models/TestResult');
+const { getPlatform } = require('../platforms');
+
+const STATUSES = {
+  GOOD: '✅',
+  WARNING: '⚠️',
+  DANGER: '❌'
+}
+
+async function run({ result, target }) {
+  setTargetInputs(target);
+  const payload = getMainPayload();
+  if (result instanceof PerformanceTestResult) {
+    await setPerformancePayload({ result, target, payload });
+  } else {
+    await setFunctionalPayload({ result, target, payload });
+  }
+  const message = getMarkdownMessage({ result, target, payload });
+  logger.info(`🔔 Publishing results to GitHub PR...`);
+  return await publishToGitHub({ target, message });
+}
+
+async function setFunctionalPayload({ result, target, payload }) {
+  await extension_manager.run({ result, target, payload, hook: HOOK.START });
+  setMainContent({ result, target, payload });
+  await extension_manager.run({ result, target, payload, hook: HOOK.AFTER_SUMMARY });
+  setSuiteContent({ result, target, payload });
+  await extension_manager.run({ result, target, payload, hook: HOOK.END });
+}
+
+function setTargetInputs(target) {
+  target.inputs = Object.assign({}, default_inputs, target.inputs);
+  if (target.inputs.publish === 'test-summary-slim') {
+    target.inputs.include_suites = false;
+  }
+  if (target.inputs.publish === 'failure-details') {
+    target.inputs.include_failure_details = true;
+  }
+}
+
+function getMainPayload() {
+  return {
+    content: []
+  };
+}
+
+function setMainContent({ result, target, payload }) {
+  const titleText = getTitleText(result, target);
+  const resultText = getResultText(result);
+  const durationText = getPrettyDuration(result.duration, target.inputs.duration);
+
+  let content = `## ${titleText}\n\n`;
+  content += `**Results**: ${resultText}\n`;
+  content += `**Duration**: ${durationText}\n\n`;
+
+  payload.content.push(content);
+}
+
+function getTitleText(result, target) {
+  let text = target.inputs.title ? target.inputs.title : result.name;
+  if (target.inputs.title_suffix) {
+    text = `${text} ${target.inputs.title_suffix}`;
+  }
+  if (target.inputs.title_link) {
+    text = `[${text}](${target.inputs.title_link})`;
+  }
+
+  const status = result.status !== 'PASS' ? STATUSES.DANGER : STATUSES.GOOD;
+  return `${status} ${text}`;
+}
+
+function getResultText(result) {
+  const percentage = getPercentage(result.passed, result.total);
+  return `${result.passed} / ${result.total} Passed (${percentage}%)`;
+}
+
+function setSuiteContent({ result, target, payload }) {
+  let suite_count = 0;
+  if (target.inputs.include_suites) {
+    for (let i = 0; i < result.suites.length && suite_count < target.inputs.max_suites; i++) {
+      const suite = result.suites[i];
+      if (target.inputs.only_failures && suite.status !== 'FAIL') {
+        continue;
+      }
+
+      // if suites length eq to 1 then main content will include suite summary
+      if (result.suites.length > 1) {
+        payload.content.push(getSuiteSummary({ target, suite }));
+        suite_count += 1;
+      }
+
+      if (target.inputs.include_failure_details) {
+        // Only attach failure details if there were failures
+        if (suite.failed > 0) {
+          payload.content.push(getFailureDetails(suite));
+        }
+      }
+    }
+  }
+}
+
+function getSuiteSummary({ target, suite }) {
+  const platform = getPlatform(TARGET.GITHUB);
+  const text = platform.getSuiteSummaryText(target, suite);
+  return `### ${suite.name}\n${text}\n\n`;
+}
+
+function getFailureDetails(suite) {
+  let content = `<details>\n<summary>❌ Failed Tests</summary>\n\n`;
+  const cases = suite.cases;
+  for (let i = 0; i < cases.length; i++) {
+    const test_case = cases[i];
+    if (test_case.status === 'FAIL') {
+      content += `**Test**: ${test_case.name}\n`;
+      content += `**Error**: \n\`\`\`\n${truncate(test_case.failure ?? 'N/A', 500)}\n\`\`\`\n\n`;
+    }
+  }
+  content += `</details>\n\n`;
+  return content;
+}
+
+function getMarkdownMessage({ result, target, payload }) {
+  return payload.content.join('');
+}
+
+async function publishToGitHub({ target, message }) {
+  const { url, repo, owner, pull_number } = extractGitHubInfo(target);
+  const token = target.inputs.token || process.env.GITHUB_TOKEN;
+
+  if (!token) {
+    throw new Error('GitHub token is required. Set GITHUB_TOKEN environment variable or provide github_token in target inputs.');
+  }
+
+  if (!pull_number) {
+    throw new Error('Pull request number not found. This target only works in GitHub Actions triggered by pull requests.');
+  }
+
+  const comment_body = target.inputs.comment_title ?
+    `${target.inputs.comment_title}\n\n${message}` :
+    message;
+
+  const headers = {
+    'Authorization': `token ${token}`,
+    'Accept': 'application/vnd.github.v3+json',
+    'User-Agent': 'testbeats'
+  };
+
+  if (target.inputs.update_comment) {
+    // Try to find existing comment and update it
+    const existingComment = await findExistingComment({ owner, repo, pull_number, github_token: token, comment_title: target.inputs.comment_title });
+    if (existingComment) {
+      return request.patch({
+        url: `${url}/repos/${owner}/${repo}/issues/comments/${existingComment.id}`,
+        headers,
+        body: { body: comment_body }
+      });
+    }
+  }
+
+  // Create new comment
+  return request.post({
+    url: `${url}/repos/${owner}/${repo}/issues/${pull_number}/comments`,
+    headers,
+    body: { body: comment_body }
+  });
+}
+
+async function findExistingComment({ owner, repo, pull_number, github_token, comment_title }) {
+  if (!comment_title) return null;
+
+  try {
+    const url = `https://api.github.com/repos/${owner}/${repo}/issues/${pull_number}/comments`;
+    const headers = {
+      'Authorization': `token ${github_token}`,
+      'Accept': 'application/vnd.github.v3+json',
+      'User-Agent': 'testbeats'
+    };
+
+    const response = await request.get({ url, headers });
+    const comments = JSON.parse(response.body);
+
+    return comments.find(comment => comment.body.includes(comment_title));
+  } catch (error) {
+    logger.warn('Failed to find existing comment:', error.message);
+    return null;
+  }
+}
+
+function extractGitHubInfo(target) {
+  let url = target.inputs.url;
+  let owner = target.inputs.owner;
+  let repo = target.inputs.repo;
+  let pull_number = target.inputs.pull_number;
+
+  if (!owner || !repo) {
+    const repository = process.env.GITHUB_REPOSITORY;
+    const ref = process.env.GITHUB_REF;
+    [owner, repo] = repository.split('/');
+    if (ref && ref.includes('refs/pull/')) {
+      pull_number = ref.replace('refs/pull/', '').replace('/merge', '');
+    }
+  }
+
+  if (!url) {
+    url = `https://api.github.com`;
+  }
+
+  return {
+    url,
+    owner,
+    repo,
+    pull_number
+  };
+}
+
+async function setPerformancePayload({ result, target, payload }) {
+  await extension_manager.run({ result, target, payload, hook: HOOK.START });
+  await setPerformanceMainContent({ result, target, payload });
+  await extension_manager.run({ result, target, payload, hook: HOOK.AFTER_SUMMARY });
+  await setTransactionContent({ result, target, payload });
+  await extension_manager.run({ result, target, payload, hook: HOOK.END });
+}
+
+async function setPerformanceMainContent({ result, target, payload }) {
+  const titleText = getTitleText(result, target);
+  let content = `## ${titleText}\n\n`;
+
+  const metrics = getValidMetrics(result.metrics);
+  if (metrics.length > 0) {
+    content += `**Performance Metrics**:\n`;
+    content += getMetricValuesText(metrics);
+    content += '\n\n';
+  }
+
+  content += `**Duration**: ${getPrettyDuration(result.duration, target.inputs.duration)}\n\n`;
+  payload.content.push(content);
+}
+
+async function setTransactionContent({ result, target, payload }) {
+  let transaction_count = 0;
+  if (target.inputs.include_suites) {
+    for (let i = 0; i < result.transactions.length && transaction_count < target.inputs.max_suites; i++) {
+      const transaction = result.transactions[i];
+      if (target.inputs.only_failures && transaction.status !== 'FAIL') {
+        continue;
+      }
+
+      payload.content.push(getTransactionSummary({ target, transaction }));
+      transaction_count += 1;
+    }
+  }
+}
+
+function getTransactionSummary({ target, transaction }) {
+  let content = `### ${transaction.name}\n`;
+  content += `**Status**: ${transaction.status === 'PASS' ? STATUSES.GOOD : STATUSES.DANGER}\n`;
+  content += `**Duration**: ${getPrettyDuration(transaction.duration, target.inputs.duration)}\n`;
+
+  if (transaction.metrics && transaction.metrics.length > 0) {
+    const metrics = getValidMetrics(transaction.metrics);
+    if (metrics.length > 0) {
+      content += `**Metrics**: ${getMetricValuesText(metrics)}\n`;
+    }
+  }
+
+  content += '\n';
+  return content;
+}
+
+async function handleErrors({ target, errors }) {
+  logger.error('GitHub target errors:', errors);
+}
+
+const default_inputs = {
+  github_token: undefined,
+  comment_title: undefined,
+  update_comment: false,
+  owner: undefined,
+  repo: undefined,
+  pull_number: undefined,
+  title: undefined,
+  title_suffix: undefined,
+  title_link: undefined,
+  include_suites: true,
+  include_failure_details: false,
+  only_failures: false,
+  max_suites: 10,
+  duration: 'long',
+  publish: 'test-summary'
+};
+
+const default_options = {
+  condition: STATUS.PASS_OR_FAIL
+};
+
+module.exports = {
+  name: 'GitHub',
+  run,
+  handleErrors,
+  default_inputs,
+  default_options
+};

package/src/targets/index.js

@@ -1,6 +1,7 @@
 const teams = require('./teams');
 const slack = require('./slack');
 const chat = require('./chat');
+const github = require('./github');
 const custom = require('./custom');
 const delay = require('./delay');
 const influx = require('./influx');
@@ -15,6 +16,8 @@ function getTargetRunner(target) {
       return slack;
     case TARGET.CHAT:
       return chat;
+    case TARGET.GITHUB:
+      return github;
     case TARGET.CUSTOM:
       return custom;
     case TARGET.DELAY:

package/src/utils/config.builder.js

@@ -91,11 +91,18 @@ class ConfigBuilder {
     if (this.opts.chat) {
       this.#addTarget('chat', this.opts.chat);
     }
+    if (this.opts.github) {
+      this.#addTarget('github', this.opts.github);
+    }
   }
 
   #addTarget(name, url) {
     this.config.targets = this.config.targets || [];
-    this.config.targets.push({ name, inputs: { url, title: this.opts.title || '', only_failures: true } })
+    if (name === 'github') {
+      this.config.targets.push({ name, inputs: { token: this.opts.github, title: this.opts.title || '', only_failures: true } })
+    } else {
+      this.config.targets.push({ name, inputs: { url, title: this.opts.title || '', only_failures: true } })
+    }
   }
 
   #buildExtensions() {