testbeats 2.1.6 → 2.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testbeats",
-  "version": "2.1.6",
+  "version": "2.2.1",
   "description": "Publish test results to Microsoft Teams, Google Chat, Slack and InfluxDB",
   "main": "src/index.js",
   "types": "./src/index.d.ts",
@@ -53,6 +53,7 @@
     "performance-results-parser": "latest",
     "phin-retry": "^1.0.3",
     "pretty-ms": "^7.0.1",
+    "prompts": "^2.4.2",
     "rosters": "0.0.1",
     "sade": "^1.8.1",
     "test-results-parser": "0.2.5"

package/src/beats/beats.attachments.js

@@ -139,7 +139,6 @@ class BeatsAttachments {
    */
   #compressAttachment(attachment_path) {
     return new Promise((resolve, _) => {
-      console.log(attachment_path)
       if (attachment_path.endsWith('.br') || attachment_path.endsWith('.gz') || attachment_path.endsWith('.zst') || attachment_path.endsWith('.zip') || attachment_path.endsWith('.7z') || attachment_path.endsWith('.png') || attachment_path.endsWith('.jpg') || attachment_path.endsWith('.jpeg') || attachment_path.endsWith('.svg') || attachment_path.endsWith('.gif') || attachment_path.endsWith('.webp')) {
         resolve(attachment_path);
         return;

package/src/cli.js

@@ -5,13 +5,18 @@ const sade = require('sade');
 
 const prog = sade('testbeats');
 const { PublishCommand } = require('./commands/publish.command');
+const { GenerateConfigCommand } = require('./commands/generate-config.command');
 const logger = require('./utils/logger');
 const pkg = require('../package.json');
 
 prog
   .version(pkg.version)
-  .option('-c, --config', 'path to config file')
   .option('-l, --logLevel', 'Log Level', "INFO")
+
+
+// Command to publish test results
+prog.command('publish')
+  .option('-c, --config', 'path to config file')
   .option('--api-key', 'api key')
   .option('--project', 'project name')
   .option('--run', 'run name')
@@ -27,9 +32,7 @@ prog
   .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')
+  .option('-chart-test-summary', 'chart test summary extension')
   .action(async (opts) => {
     try {
       logger.setLevel(opts.logLevel);
@@ -41,4 +44,22 @@ prog.command('publish')
     }
   });
 
+// Command to initialize and generate TestBeats Configuration file
+prog.command('init')
+  .describe('Generate a TestBeats configuration file')
+  .example('init')
+  .action(async (opts) => {
+    try {
+      const generate_command = new GenerateConfigCommand(opts);
+      await generate_command.execute();
+    } catch (error) {
+      if (error.name === 'ExitPromptError') {
+        logger.info('😿 Configuration generation was canceled by the user.');
+      } else {
+        throw new Error(`❌ Error in generating configuration file: ${error.message}`)
+      }
+      process.exit(1);
+    }
+  });
+
 prog.parse(process.argv);

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

@@ -0,0 +1,440 @@
+const prompts = require('prompts');
+const fs = require('fs/promises');
+const logger = require('../utils/logger');
+const pkg = require('../../package.json');
+
+
+class GenerateConfigCommand {
+    /**
+     * TODO: [BETA / Experimental Mode]
+     * Generates initial TestBests configuration file
+     */
+    constructor(opts) {
+        this.opts = opts;
+        this.configPath = '.testbeats.json';
+        this.config = {};
+    }
+
+    async execute() {
+        logger.setLevel(this.opts.logLevel);
+        this.#printBanner();
+        logger.info(`🚧 Config generation is still in BETA mode, please report any issues at ${pkg.bugs.url}\n`);
+
+        await this.#buildConfigFilePath();
+        await this.#buildTestResultsConfig();
+        await this.#buildTargetsConfig();
+        await this.#buildGobalExtensionConfig();
+        await this.#buildTestBeatsPortalConfig();
+        await this.#saveConfigFile();
+    }
+
+    #printBanner() {
+        const banner = `
+         _____             _    ___                  _         
+        (_   _)           ( )_ (  _'\\               ( )_       
+          | |   __    ___ | ,_)| (_) )   __     _ _ | ,_)  ___ 
+          | | /'__'\\/',__)| |  |  _ <' /'__'\\ /'_' )| |  /',__)
+          | |(  ___/\\__, \\| |_ | (_) )(  ___/( (_| || |_ \\__, \\
+          (_)'\\____)(____/'\\__)(____/''\\____)'\\__,_)'\\__)(____/
+        
+                             v${pkg.version}  
+                        Config Generation [BETA]
+        `;
+        console.log(banner);
+    }
+
+    async #buildConfigFilePath() {
+        const { configPath } = await prompts({
+            type: 'text',
+            name: 'configPath',
+            message: 'Enter path for configuration file :',
+            initial: '.testbeats.json'
+        });
+        this.configPath = configPath;
+    }
+
+    async #buildTestResultsConfig() {
+        const runnerChoices = [
+            { title: 'Mocha', value: 'mocha', selected: true },
+            { title: 'JUnit', value: 'junit' },
+            { title: 'TestNG', value: 'testng' },
+            { title: 'Cucumber', value: 'cucumber' },
+            { title: 'NUnit', value: 'nunit' },
+            { title: 'xUnit', value: 'xunit' },
+            { title: 'MSTest', value: 'mstest' }
+        ]
+        // Get test results details
+        const { testResults } = await prompts([{
+            type: 'toggle',
+            name: 'includeResults',
+            message: 'Do you want to configure test results?',
+            initial: true,
+            active: 'Yes',
+            inactive: 'No'
+        },
+        {
+            type: (prev) => (prev ? "multiselect" : null),
+            name: 'testResults',
+            message: 'Select test result types to include:',
+            choices: runnerChoices,
+            min: 1
+        }]);
+
+        if (!testResults) { return };
+
+        // Handle result paths
+        this.config.results = []
+        for (const resultType of testResults) {
+            const { path } = await prompts({
+                type: 'text',
+                name: 'path',
+                message: `Enter file path for ${resultType} results (.json, .xml etc):`,
+                initial: ""
+            });
+            this.config.results.push({
+                files: path,
+                type: resultType
+            });
+        }
+    }
+
+    async #buildTargetsConfig() {
+        const targetChoices = [
+            { title: 'Slack', value: 'slack' },
+            { title: 'Microsoft Teams', value: 'teams' },
+            { title: 'Google Chat', value: 'chat' }
+        ];
+
+        const { titleInput, targets } = await prompts([{
+            type: 'toggle',
+            name: 'includeTargets',
+            message: 'Do you want to configure notification targets (slack, teams, chat etc)?',
+            initial: true,
+            active: 'Yes',
+            inactive: 'No'
+        },
+        {
+            type: (prev) => (prev ? "text" : null),
+            name: 'titleInput',
+            message: 'Enter notification title (optional):',
+            initial: 'TestBeats Report'
+        },
+        {
+            type: (prev, values) => (values.includeTargets ? "multiselect" : null),
+            name: 'targets',
+            message: 'Select notification targets:',
+            choices: targetChoices,
+            min: 1
+        }]);
+
+        if (!targets) { return }
+
+        this.config.targets = []
+
+        // For each target, ask about target-specific extensions
+        for (const target of targets) {
+            const { webhookEnvVar, selectedExtensions } = await prompts([{
+                type: 'text',
+                name: 'webhookEnvVar',
+                message: `Enter environment variable name for ${target} webhook URL:`,
+                initial: `${target.toUpperCase()}_WEBHOOK_URL`
+            },
+            {
+                type: 'toggle',
+                name: 'useExtensions',
+                message: `Do you want to configure extensions for ${target}?`,
+                initial: true,
+                active: 'Yes',
+                inactive: 'No'
+            },
+            {
+                type: (prev, values) => (values.useExtensions ? 'multiselect' : null),
+                name: 'selectedExtensions',
+                message: `Select extensions for ${target}:`,
+                choices: this.#getExtensionsList(),
+                min: 1
+            }]);
+
+            const targetConfig = {
+                name: target,
+                inputs: {
+                    title: titleInput,
+                    url: `{${webhookEnvVar}}`,
+                    publish: 'test-summary'
+                }
+            };
+
+            if (selectedExtensions) {
+                targetConfig.extensions = [];
+                // Configure extension-specific inputs
+                for (const ext of selectedExtensions) {
+                    const extConfig = await this.#buildExtensionConfig(ext, target);
+                    targetConfig.extensions.push(extConfig);
+                }
+            }
+            this.config.targets.push(targetConfig);
+        }
+    }
+
+    async #buildGobalExtensionConfig() {
+        const { globalExtensionsSelected } = await prompts([{
+            type: 'toggle',
+            name: 'includeGlobalExtensions',
+            message: 'Do you want to configure global extensions?',
+            initial: false,
+            active: 'Yes',
+            inactive: 'No'
+        },
+        {
+            type: (prev) => (prev ? 'multiselect' : null),
+            name: 'globalExtensionsSelected',
+            message: 'Select global extensions to enable:',
+            choices: this.#getExtensionsList()
+        }]);
+
+        if (!globalExtensionsSelected) { return };
+
+        this.config.extensions = [];
+
+        // Configure extension-specific inputs
+        for (const ext of globalExtensionsSelected) {
+            const extDetails = await this.#buildExtensionConfig(ext, null);
+            this.config.extensions.push(extDetails);
+        }
+    }
+
+    async #buildExtHyperlinks() {
+        const links = [];
+        const { addLink } = await prompts({
+            type: 'toggle',
+            name: 'addLink',
+            message: 'Do you want to add a hyperlink?',
+            initial: true,
+            active: 'Yes',
+            inactive: 'No'
+        });
+
+        while (addLink) {
+            const { text, url } = await prompts([
+                {
+                    type: 'text',
+                    name: 'text',
+                    message: 'Enter link text:'
+                },
+                {
+                    type: 'text',
+                    name: 'url',
+                    message: 'Enter link URL:'
+                }
+            ]);
+
+            links.push({ text, url });
+
+            const { addAnother } = await prompts({
+                type: 'toggle',
+                name: 'addAnother',
+                message: 'Add another link?',
+                initial: false,
+                active: 'Yes',
+                inactive: 'No'
+            });
+            if (!addAnother) break;
+        }
+        return { links };
+    }
+
+    async #buildExtMentions(targetName) {
+        const users = [];
+        const { addUser } = await prompts({
+            type: 'toggle',
+            name: 'addUser',
+            message: 'Do you want to add user mentions?',
+            initial: true,
+            active: 'Yes',
+            inactive: 'No'
+        });
+
+        while (addUser) {
+            const user = {};
+            const { name } = await prompts({
+                type: 'text',
+                name: 'name',
+                message: 'Enter user name:'
+            });
+            user.name = name;
+
+            if (targetName === 'teams') {
+                const { teams_upn } = await prompts({
+                    type: 'text',
+                    name: 'teams_upn',
+                    message: 'Enter Teams UPN (user principal name):'
+                });
+                user.teams_upn = teams_upn;
+            } else if (targetName === 'slack') {
+                const { slack_uid } = await prompts({
+                    type: 'text',
+                    name: 'slack_uid',
+                    message: 'Enter Slack user ID:'
+                });
+                user.slack_uid = slack_uid;
+            } else if (targetName === 'chat') {
+                const { chat_uid } = await prompts({
+                    type: 'text',
+                    name: 'chat_uid',
+                    message: 'Enter Google Chat user ID:'
+                });
+                user.chat_uid = chat_uid;
+            }
+
+            users.push(user);
+
+            const { addAnother } = await prompts({
+                type: 'toggle',
+                name: 'addAnother',
+                message: 'Add another user?',
+                initial: false,
+                active: 'Yes',
+                inactive: 'No'
+            });
+            if (!addAnother) break;
+        }
+        return { users };
+    }
+
+    async #buildExtMetadata() {
+        const data = [];
+        const { addMetadata } = await prompts({
+            type: 'toggle',
+            name: 'addMetadata',
+            message: 'Do you want to add metadata?',
+            initial: true,
+            active: 'Yes',
+            inactive: 'No'
+        });
+
+        while (addMetadata) {
+            const { key, value } = await prompts([
+                {
+                    type: 'text',
+                    name: 'key',
+                    message: 'Enter metadata key:'
+                },
+                {
+                    type: 'text',
+                    name: 'value',
+                    message: 'Enter metadata value:'
+                }
+            ]);
+
+            data.push({ key, value });
+
+            const { addAnother } = await prompts({
+                type: 'toggle',
+                name: 'addAnother',
+                message: 'Add another metadata item?',
+                initial: false,
+                active: 'Yes',
+                inactive: 'No'
+            });
+            if (!addAnother) break;
+        }
+        return { data };
+    }
+
+    async #buildExtensionConfig(extension, target) {
+        const extConfig = {
+            name: extension
+        };
+
+        switch (extension) {
+            case 'hyperlinks':
+                extConfig.inputs = await this.#buildExtHyperlinks()
+                break;
+
+            case 'mentions':
+                extConfig.inputs = await this.#buildExtMentions(target);
+                break;
+
+            case 'metadata':
+                extConfig.inputs = await this.#buildExtMetadata();
+                break;
+
+            default:
+                // Add default configuration for other extensions
+                extConfig.inputs = {
+                    title: '',
+                    separator: target === 'slack' ? false : true
+                };
+        }
+        return extConfig;
+    }
+
+    async #buildTestBeatsPortalConfig() {
+        // TestBeats configuration
+        const { apiKey, project } = await prompts([{
+            type: 'toggle',
+            name: 'includeTestBeats',
+            message: 'Do you want to configure TestBeats API key (optional)?',
+            initial: false,
+            active: 'Yes',
+            inactive: 'No'
+        },
+        {
+            type: (prev) => (prev ? 'text' : null),
+            name: 'apiKey',
+            message: 'Enter environment variable name for API key (optional):',
+            initial: '{TEST_RESULTS_API_KEY}'
+        },
+        {
+            type: (prev, values) => (values.includeTestBeats ? 'text' : null),
+            name: 'project',
+            message: 'Enter project name (optional):'
+        }]);
+
+        if (apiKey) {
+            this.config.api_key = apiKey;
+            // Add optional fields only if they have values
+            if (project?.trim()) {
+                this.config.project = project.trim();
+            }
+        }
+    }
+
+    #sortConfig() {
+        // Sort keys alphabetically
+        this.config = Object.keys(this.config).sort()
+            .reduce((sortedConfig, key) => {
+                sortedConfig[key] = this.config[key];
+                return sortedConfig;
+            }, {});
+    }
+
+    async #saveConfigFile() {
+        // Write config to file
+        try {
+            await fs.writeFile(this.configPath, JSON.stringify(this.config, null, 2));
+            logger.info(`✅ Configuration file successfully generated: ${this.configPath}`);
+        } catch (error) {
+            throw new Error(`Error: ${error.message}`)
+        }
+    }
+
+    #getExtensionsList() {
+        // List of Extensions supported
+        return [
+            { title: 'Quick Chart Test Summary', value: 'quick-chart-test-summary' },
+            { title: 'CI Information', value: 'ci-info' },
+            { title: 'Hyperlinks', value: 'hyperlinks' },
+            { title: 'Mentions', value: 'mentions' },
+            { title: 'Report Portal Analysis', value: 'report-portal-analysis' },
+            { title: 'Report Portal History', value: 'report-portal-history' },
+            { title: 'Percy Analysis', value: 'percy-analysis' },
+            { title: 'Metadata', value: 'metadata' },
+            { title: 'AI Failure Summary', value: 'ai-failure-summary' },
+            { title: 'Smart Analysis', value: 'smart-analysis' },
+            { title: 'Error Clusters', value: 'error-clusters' }
+        ];
+    }
+}
+
+module.exports = { GenerateConfigCommand }; 

package/src/commands/publish.command.js

@@ -8,6 +8,7 @@ const { ConfigBuilder } = require('../utils/config.builder');
 const target_manager = require('../targets');
 const logger = require('../utils/logger');
 const { processData } = require('../helpers/helper');
+const { ExtensionsSetup } = require('../setups/extensions.setup');
 const pkg = require('../../package.json');
 const { MIN_NODE_VERSION } = require('../helpers/constants');
 
@@ -32,6 +33,7 @@ class PublishCommand {
     this.#processConfig();
     this.#validateConfig();
     this.#processResults();
+    await this.#setupExtensions();
     await this.#publishResults();
     await this.#publishErrors();
   }
@@ -209,6 +211,19 @@ class PublishCommand {
     }
   }
 
+  async #setupExtensions() {
+    logger.info('⚙️  Setting up extensions...');
+    try {
+      for (const config of this.configs) {
+        const extensions = config.extensions || [];
+        const setup = new ExtensionsSetup(extensions, this.results ? this.results[0] : null);
+        await setup.run();
+      }
+    } catch (error) {
+      logger.error(`❌ Error setting up extensions: ${error.message}`);
+    }
+  }
+
   async #publishResults() {
     if (!this.results.length) {
       logger.warn('⚠️ No results to publish');

package/src/extensions/base.extension.js

@@ -1,3 +1,4 @@
+const TestResult = require('test-results-parser/src/models/TestResult');
 const logger = require('../utils/logger');
 const { addChatExtension, addSlackExtension, addTeamsExtension } = require('../helpers/extension.helper');
 
@@ -7,13 +8,15 @@ class BaseExtension {
    *
    * @param {import('..').ITarget} target
    * @param {import('..').IExtension} extension
-   * @param {import('..').TestResult} result
+   * @param {TestResult} result
    * @param {any} payload
    * @param {any} root_payload
    */
   constructor(target, extension, result, payload, root_payload) {
     this.target = target;
     this.extension = extension;
+
+    /** @type {TestResult} */
     this.result = result;
     this.payload = payload;
     this.root_payload = root_payload;

package/src/extensions/browserstack.extension.js

@@ -0,0 +1,30 @@
+const { HOOK, STATUS } = require("../helpers/constants");
+const { getMetaDataText } = require("../helpers/metadata.helper");
+const { BaseExtension } = require("./base.extension");
+
+
+class BrowserstackExtension extends BaseExtension {
+  constructor(target, extension, result, payload, root_payload) {
+    super(target, extension, result, payload, root_payload);
+    this.#setDefaultOptions();
+  }
+
+  #setDefaultOptions() {
+    this.default_options.hook = HOOK.AFTER_SUMMARY;
+    this.default_options.condition = STATUS.PASS_OR_FAIL;
+  }
+
+  async run() {
+    this.extension.inputs = Object.assign({}, this.extension.inputs);
+    /** @type {import('../index').BrowserstackInputs} */
+    const inputs = this.extension.inputs;
+    if (inputs.automation_build) {
+      const element = { label: 'Browserstack', key: inputs.automation_build.name, value: inputs.automation_build.public_url, type: 'hyperlink' }
+      const text = await getMetaDataText({ elements: [element], target: this.target, extension: this.extension, result: this.result, default_condition: this.default_options.condition });
+      this.text = text;
+      this.attach();
+    }
+  }
+}
+
+module.exports = { BrowserstackExtension };

package/src/extensions/ci-info.extension.js

@@ -56,19 +56,18 @@ class CIInfoExtension extends BaseExtension {
       this.#setRepositoryElement();
     }
     if (this.extension.inputs.show_repository_branch) {
-      if (this.ci.repository_ref.includes('refs/pull')) {
+      if (this.ci.pull_request_name) {
         this.#setPullRequestElement();
       } else {
         this.#setRepositoryBranchElement();
       }
     }
     if (!this.extension.inputs.show_repository && !this.extension.inputs.show_repository_branch && this.extension.inputs.show_repository_non_common) {
-      if (this.ci.repository_ref.includes('refs/pull')) {
+      if (this.ci.pull_request_name) {
         this.#setRepositoryElement();
         this.#setPullRequestElement();
       } else {
-        const branch_name = this.ci.repository_ref.replace('refs/heads/', '');
-        if (!COMMON_BRANCH_NAMES.includes(branch_name.toLowerCase())) {
+        if (!COMMON_BRANCH_NAMES.includes(this.ci.branch_name.toLowerCase())) {
           this.#setRepositoryElement();
           this.#setRepositoryBranchElement();
         }
@@ -81,15 +80,11 @@ class CIInfoExtension extends BaseExtension {
   }
 
   #setPullRequestElement() {
-    const pr_url = this.ci.repository_url + this.ci.repository_ref.replace('refs/pull/', '/pull/');
-    const pr_name = this.ci.repository_ref.replace('refs/pull/', '').replace('/merge', '');
-    this.repository_elements.push({ label: 'Pull Request', key: pr_name, value: pr_url, type: 'hyperlink' });
+    this.repository_elements.push({ label: 'Pull Request', key: this.ci.pull_request_name, value: this.ci.pull_request_url, type: 'hyperlink' });
   }
 
   #setRepositoryBranchElement() {
-    const branch_url = this.ci.repository_url + this.ci.repository_ref.replace('refs/heads/', '/tree/');
-    const branch_name = this.ci.repository_ref.replace('refs/heads/', '');
-    this.repository_elements.push({ label: 'Branch', key: branch_name, value: branch_url, type: 'hyperlink' });
+    this.repository_elements.push({ label: 'Branch', key: this.ci.branch_name, value: this.ci.branch_url, type: 'hyperlink' });
   }
 
   #setBuildElements() {

package/src/extensions/extensions.d.ts

@@ -5,6 +5,10 @@ export type ICIInfo = {
   repository_name: string
   repository_ref: string
   repository_commit_sha: string
+  branch_url: string
+  branch_name: string
+  pull_request_url: string
+  pull_request_name: string
   build_url: string
   build_number: string
   build_name: string

package/src/extensions/index.js

@@ -14,6 +14,7 @@ const { checkCondition } = require('../helpers/helper');
 const logger = require('../utils/logger');
 const { ErrorClustersExtension } = require('./error-clusters.extension');
 const { FailureAnalysisExtension } = require('./failure-analysis.extension');
+const { BrowserstackExtension } = require('./browserstack.extension');
 
 async function run(options) {
   const { target, result, hook } = options;
@@ -72,6 +73,8 @@ function getExtensionRunner(extension, options) {
       return new SmartAnalysisExtension(options.target, extension, options.result, options.payload, options.root_payload);
     case EXTENSION.ERROR_CLUSTERS:
       return new ErrorClustersExtension(options.target, extension, options.result, options.payload, options.root_payload);
+    case EXTENSION.BROWSERSTACK:
+      return new BrowserstackExtension(options.target, extension, options.result, options.payload, options.root_payload);
     default:
       return require(extension.name);
   }