testbeats 2.1.5 → 2.1.7

package/package.json

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

@@ -1,6 +1,9 @@
 const fs = require('fs');
 const path = require('path');
+const zlib = require('zlib');
+const stream = require('stream');
 const FormData = require('form-data-lite');
+const ml = require('mime-lite')
 const TestResult = require('test-results-parser/src/models/TestResult');
 const { BeatsApi } = require('./beats.api');
 const logger = require('../utils/logger');
@@ -23,12 +26,14 @@ class BeatsAttachments {
     this.test_run_id = test_run_id;
     this.failed_test_cases = [];
     this.attachments = [];
+    this.compressed_attachment_paths = [];
   }
 
   async upload() {
     this.#setAllFailedTestCases();
     this.#setAttachments();
     await this.#uploadAttachments();
+    this.#deleteCompressedAttachments();
   }
 
   #setAllFailedTestCases() {
@@ -67,17 +72,22 @@ class BeatsAttachments {
         form.append('test_run_id', this.test_run_id);
         const file_images = []
         for (const attachment of attachments_subset) {
-          const attachment_path = this.#getAttachmentFilePath(attachment);
+          let attachment_path = this.#getAttachmentFilePath(attachment);
           if (!attachment_path) {
             logger.warn(`⚠️ Unable to find attachment ${attachment.path}`);
             continue;
           }
+          attachment_path = await this.#compressAttachment(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 });
+          form.append('images', fs.readFileSync(attachment_path), {
+            filename: path.basename(attachment_path),
+            filepath: attachment_path,
+            contentType: ml.getType(attachment.path),
+          });
           file_images.push({
             file_name: attachment.name,
             file_path: attachment.path,
@@ -123,7 +133,38 @@ class BeatsAttachments {
     return null;
   }
 
+  /**
+   *
+   * @param {string} attachment_path
+   */
+  #compressAttachment(attachment_path) {
+    return new Promise((resolve, _) => {
+      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;
+      }
+      const read_stream = fs.createReadStream(attachment_path);
+      const br = zlib.createBrotliCompress();
 
+      const compressed_file_path = attachment_path + '.br';
+      const write_stream = fs.createWriteStream(compressed_file_path);
+      stream.pipeline(read_stream, br, write_stream, (err) => {
+        if (err) {
+          resolve(attachment_path);
+          return;
+        }
+        this.compressed_attachment_paths.push(compressed_file_path);
+        resolve(compressed_file_path);
+        return;
+      });
+    });
+  }
+
+  #deleteCompressedAttachments() {
+    for (const attachment_path of this.compressed_attachment_paths) {
+      fs.unlinkSync(attachment_path);
+    }
+  }
 
 }
 

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/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/helpers/ci/azure-devops.js

@@ -0,0 +1,37 @@
+const ENV = process.env;
+
+/**
+ * @returns {import('../../extensions/extensions').ICIInfo}
+ */
+function info() {
+  const azure_devops = {
+    ci: 'AZURE_DEVOPS_PIPELINES',
+    git: 'AZURE_DEVOPS_REPOS',
+    repository_url: ENV.BUILD_REPOSITORY_URI,
+    repository_name: ENV.BUILD_REPOSITORY_NAME,
+    repository_ref: ENV.BUILD_SOURCEBRANCH,
+    repository_commit_sha: ENV.BUILD_SOURCEVERSION,
+    branch_url: '',
+    branch_name: '',
+    pull_request_url:'',
+    pull_request_name: '',
+    build_url: ENV.SYSTEM_TEAMFOUNDATIONCOLLECTIONURI + ENV.SYSTEM_TEAMPROJECT + '/_build/results?buildId=' + ENV.BUILD_BUILDID,
+    build_number: ENV.BUILD_BUILDNUMBER,
+    build_name: ENV.BUILD_DEFINITIONNAME,
+    build_reason: ENV.BUILD_REASON,
+    user: ENV.BUILD_REQUESTEDFOR
+  }
+
+  azure_devops.branch_url = azure_devops.repository_url + azure_devops.repository_ref.replace('refs/heads/', '/tree/');
+  azure_devops.branch_name = azure_devops.repository_ref.replace('refs/heads/', '');
+
+  if (azure_devops.repository_ref.includes('refs/pull')) {
+    azure_devops.pull_request_url = azure_devops.repository_url + azure_devops.repository_ref.replace('refs/pull/', '/pull/');
+    azure_devops.pull_request_name = azure_devops.repository_ref.replace('refs/pull/', '').replace('/merge', '');
+  }
+  return azure_devops;
+}
+
+module.exports = {
+  info
+}

package/src/helpers/ci/github.js

@@ -0,0 +1,38 @@
+const ENV = process.env;
+
+/**
+ * @returns {import('../../extensions/extensions').ICIInfo}
+ */
+function info() {
+  const github = {
+    ci: 'GITHUB_ACTIONS',
+    git: 'GITHUB',
+    repository_url: ENV.GITHUB_SERVER_URL + '/' + ENV.GITHUB_REPOSITORY,
+    repository_name: ENV.GITHUB_REPOSITORY,
+    repository_ref: ENV.GITHUB_REF,
+    repository_commit_sha: ENV.GITHUB_SHA,
+    branch_url: '',
+    branch_name: '',
+    pull_request_url:'',
+    pull_request_name: '',
+    build_url: ENV.GITHUB_SERVER_URL + '/' + ENV.GITHUB_REPOSITORY + '/actions/runs/' + ENV.GITHUB_RUN_ID,
+    build_number: ENV.GITHUB_RUN_NUMBER,
+    build_name: ENV.GITHUB_WORKFLOW,
+    build_reason: ENV.GITHUB_EVENT_NAME,
+    user: ENV.GITHUB_ACTOR,
+  }
+
+  github.branch_url = github.repository_url + github.repository_ref.replace('refs/heads/', '/tree/');
+  github.branch_name = github.repository_ref.replace('refs/heads/', '');
+
+  if (github.repository_ref.includes('refs/pull')) {
+    github.pull_request_url = github.repository_url + github.repository_ref.replace('refs/pull/', '/pull/');
+    github.pull_request_name = github.repository_ref.replace('refs/pull/', '').replace('/merge', '');
+  }
+
+  return github
+}
+
+module.exports = {
+  info
+}

package/src/helpers/ci/gitlab.js

@@ -0,0 +1,36 @@
+const ENV = process.env;
+
+/**
+ * @returns {import('../../extensions/extensions').ICIInfo}
+ */
+function info() {
+  const gitlab = {
+    ci: 'GITLAB',
+    git: 'GITLAB',
+    repository_url: ENV.CI_PROJECT_URL,
+    repository_name: ENV.CI_PROJECT_NAME,
+    repository_ref: '/-/tree/' + (ENV.CI_MERGE_REQUEST_SOURCE_BRANCH_NAME || ENV.CI_COMMIT_REF_NAME),
+    repository_commit_sha: ENV.CI_MERGE_REQUEST_SOURCE_BRANCH_SHA || ENV.CI_COMMIT_SHA,
+    branch_url: ENV.CI_PROJECT_URL + '/-/tree/' + (ENV.CI_COMMIT_REF_NAME || ENV.CI_COMMIT_BRANCH),
+    branch_name: ENV.CI_COMMIT_REF_NAME || ENV.CI_COMMIT_BRANCH,
+    pull_request_url:'',
+    pull_request_name: '',
+    build_url: ENV.CI_JOB_URL,
+    build_number: ENV.CI_JOB_ID,
+    build_name: ENV.CI_JOB_NAME,
+    build_reason: ENV.CI_PIPELINE_SOURCE,
+    user: ENV.GITLAB_USER_LOGIN || ENV.CI_COMMIT_AUTHOR
+  }
+
+  if (ENV.CI_OPEN_MERGE_REQUESTS) {
+    const pr_number = ENV.CI_OPEN_MERGE_REQUESTS.split("!")[1];
+    gitlab.pull_request_name = "#" + pr_number;
+    gitlab.pull_request_url = ENV.CI_PROJECT_URL + "/-/merge_requests/" + pr_number;
+  }
+
+  return gitlab
+}
+
+module.exports = {
+  info
+}

package/src/helpers/ci/index.js

@@ -0,0 +1,60 @@
+const os = require('os');
+const github = require('./github');
+const gitlab = require('./gitlab');
+const jenkins = require('./jenkins');
+const azure_devops = require('./azure-devops');
+const system = require('./system');
+
+const ENV = process.env;
+
+/**
+ * @returns {import('../../extensions/extensions').ICIInfo}
+ */
+function getCIInformation() {
+  const ci_info = getBaseCIInfo();
+  const system_info = system.info();
+  return {
+    ...ci_info,
+    ...system_info
+  }
+}
+
+function getBaseCIInfo() {
+  if (ENV.GITHUB_ACTIONS) {
+    return github.info();
+  }
+  if (ENV.GITLAB_CI) {
+    return gitlab.info();
+  }
+  if (ENV.JENKINS_URL) {
+    return jenkins.info();
+  }
+  if (ENV.SYSTEM_TEAMFOUNDATIONCOLLECTIONURI) {
+    return azure_devops.info();
+  }
+  return getDefaultInformation();
+}
+
+function getDefaultInformation() {
+  return {
+    ci: ENV.TEST_BEATS_CI_NAME,
+    git: ENV.TEST_BEATS_CI_GIT,
+    repository_url: ENV.TEST_BEATS_CI_REPOSITORY_URL,
+    repository_name: ENV.TEST_BEATS_CI_REPOSITORY_NAME,
+    repository_ref: ENV.TEST_BEATS_CI_REPOSITORY_REF,
+    repository_commit_sha: ENV.TEST_BEATS_CI_REPOSITORY_COMMIT_SHA,
+    branch_url: ENV.TEST_BEATS_BRANCH_URL,
+    branch_name: ENV.TEST_BEATS_BRANCH_NAME,
+    pull_request_url: ENV.TEST_BEATS_PULL_REQUEST_URL,
+    pull_request_name: ENV.TEST_BEATS_PULL_REQUEST_NAME,
+    build_url: ENV.TEST_BEATS_CI_BUILD_URL,
+    build_number: ENV.TEST_BEATS_CI_BUILD_NUMBER,
+    build_name: ENV.TEST_BEATS_CI_BUILD_NAME,
+    build_reason: ENV.TEST_BEATS_CI_BUILD_REASON,
+    user: ENV.TEST_BEATS_CI_USER || os.userInfo().username
+  }
+}
+
+module.exports = {
+  getCIInformation
+}

package/src/helpers/ci/jenkins.js

@@ -0,0 +1,38 @@
+const ENV = process.env;
+
+/**
+ * @returns {import('../../extensions/extensions').ICIInfo}
+ */
+function info() {
+  const jenkins = {
+    ci: 'JENKINS',
+    git: '',
+    repository_url: ENV.GIT_URL || ENV.GITHUB_URL || ENV.BITBUCKET_URL,
+    repository_name: ENV.JOB_NAME,
+    repository_ref: ENV.BRANCH || ENV.BRANCH_NAME,
+    repository_commit_sha: ENV.GIT_COMMIT || ENV.GIT_COMMIT_SHA || ENV.GITHUB_SHA || ENV.BITBUCKET_COMMIT,
+    branch_url: '',
+    branch_name: '',
+    pull_request_url:'',
+    pull_request_name: '',
+    build_url: ENV.BUILD_URL,
+    build_number: ENV.BUILD_NUMBER,
+    build_name: ENV.JOB_NAME,
+    build_reason: ENV.BUILD_CAUSE,
+    user: ENV.USER || ENV.USERNAME
+  }
+
+  jenkins.branch_url = jenkins.repository_url + jenkins.repository_ref.replace('refs/heads/', '/tree/');
+  jenkins.branch_name = jenkins.repository_ref.replace('refs/heads/', '');
+
+  if (jenkins.repository_ref.includes('refs/pull')) {
+    jenkins.pull_request_url = jenkins.repository_url + jenkins.repository_ref.replace('refs/pull/', '/pull/');
+    jenkins.pull_request_name = jenkins.repository_ref.replace('refs/pull/', '').replace('/merge', '');
+  }
+
+  return jenkins_info;
+}
+
+module.exports = {
+  info
+}

package/src/helpers/ci/system.js

@@ -0,0 +1,30 @@
+const os = require('os');
+const pkg = require('../../../package.json');
+
+function info() {
+  function getRuntimeInfo() {
+    if (typeof process !== 'undefined' && process.versions && process.versions.node) {
+      return { name: 'node', version: process.versions.node };
+    } else if (typeof Deno !== 'undefined') {
+      return { name: 'deno', version: Deno.version.deno };
+    } else if (typeof Bun !== 'undefined') {
+      return { name: 'bun', version: Bun.version };
+    } else {
+      return { name: 'unknown', version: 'unknown' };
+    }
+  }
+
+  const runtime = getRuntimeInfo();
+
+  return {
+    runtime: runtime.name,
+    runtime_version: runtime.version,
+    os: os.platform(),
+    os_version: os.release(),
+    testbeats_version: pkg.version
+  }
+}
+
+module.exports = {
+  info
+}

package/src/index.js

@@ -1,15 +1,22 @@
 const { PublishCommand } = require('./commands/publish.command');
+const { GenerateConfigCommand } = require('./commands/generate-config.command');
 
 function publish(options) {
   const publish_command = new PublishCommand(options);
   return publish_command.publish();
 }
 
+function generateConfig() {
+  const generate_command = new GenerateConfigCommand();
+  return generate_command.execute();
+}
+
 function defineConfig(config) {
-  return config
+  return config;
 }
 
 module.exports = {
   publish,
+  generateConfig,
   defineConfig
 }

package/src/helpers/ci.js

@@ -1,140 +0,0 @@
-const os = require('os');
-const pkg = require('../../package.json');
-
-const ENV = process.env;
-
-/**
- * @returns {import('../extensions/extensions').ICIInfo}
- */
-function getCIInformation() {
-  const ci_info = getBaseCIInfo();
-  const system_info = getSystemInfo();
-  return {
-    ...ci_info,
-    ...system_info
-  }
-}
-
-function getBaseCIInfo() {
-  if (ENV.GITHUB_ACTIONS) {
-    return getGitHubActionsInformation();
-  }
-  if (ENV.GITLAB_CI) {
-    return getGitLabInformation();
-  }
-  if (ENV.JENKINS_URL) {
-    return getJenkinsInformation();
-  }
-  if (ENV.SYSTEM_TEAMFOUNDATIONCOLLECTIONURI) {
-    return getAzureDevOpsInformation();
-  }
-  return getDefaultInformation();
-}
-
-function getGitHubActionsInformation() {
-  return {
-    ci: 'GITHUB_ACTIONS',
-    git: 'GITHUB',
-    repository_url: ENV.GITHUB_SERVER_URL + '/' + ENV.GITHUB_REPOSITORY,
-    repository_name: ENV.GITHUB_REPOSITORY,
-    repository_ref: ENV.GITHUB_REF,
-    repository_commit_sha: ENV.GITHUB_SHA,
-    build_url: ENV.GITHUB_SERVER_URL + '/' + ENV.GITHUB_REPOSITORY + '/actions/runs/' + ENV.GITHUB_RUN_ID,
-    build_number: ENV.GITHUB_RUN_NUMBER,
-    build_name: ENV.GITHUB_WORKFLOW,
-    build_reason: ENV.GITHUB_EVENT_NAME,
-    user: ENV.GITHUB_ACTOR,
-  }
-}
-
-function getAzureDevOpsInformation() {
-  return {
-    ci: 'AZURE_DEVOPS_PIPELINES',
-    git: 'AZURE_DEVOPS_REPOS',
-    repository_url: ENV.BUILD_REPOSITORY_URI,
-    repository_name: ENV.BUILD_REPOSITORY_NAME,
-    repository_ref: ENV.BUILD_SOURCEBRANCH,
-    repository_commit_sha: ENV.BUILD_SOURCEVERSION,
-    build_url: ENV.SYSTEM_TEAMFOUNDATIONCOLLECTIONURI + ENV.SYSTEM_TEAMPROJECT + '/_build/results?buildId=' + ENV.BUILD_BUILDID,
-    build_number: ENV.BUILD_BUILDNUMBER,
-    build_name: ENV.BUILD_DEFINITIONNAME,
-    build_reason: ENV.BUILD_REASON,
-    user: ENV.BUILD_REQUESTEDFOR
-  }
-}
-
-function getJenkinsInformation() {
-  return {
-    ci: 'JENKINS',
-    git: '',
-    repository_url: ENV.GIT_URL || ENV.GITHUB_URL || ENV.BITBUCKET_URL,
-    repository_name: ENV.JOB_NAME,
-    repository_ref: ENV.BRANCH || ENV.BRANCH_NAME,
-    repository_commit_sha: ENV.GIT_COMMIT || ENV.GIT_COMMIT_SHA || ENV.GITHUB_SHA || ENV.BITBUCKET_COMMIT,
-    build_url: ENV.BUILD_URL,
-    build_number: ENV.BUILD_NUMBER,
-    build_name: ENV.JOB_NAME,
-    build_reason: ENV.BUILD_CAUSE,
-    user: ENV.USER || ENV.USERNAME
-  }
-}
-
-function getGitLabInformation() {
-  return {
-    ci: 'GITLAB',
-    git: 'GITLAB',
-    repository_url: ENV.CI_PROJECT_URL,
-    repository_name: ENV.CI_PROJECT_NAME,
-    repository_ref: ENV.CI_MERGE_REQUEST_SOURCE_BRANCH_NAME || ENV.CI_COMMIT_REF_NAME,
-    repository_commit_sha:ENV.CI_MERGE_REQUEST_SOURCE_BRANCH_SHA || ENV.CI_COMMIT_SHA,
-    build_url: ENV.CI_JOB_URL,
-    build_number: ENV.CI_JOB_ID,
-    build_name: ENV.CI_JOB_NAME,
-    build_reason: ENV.CI_PIPELINE_SOURCE,
-    user: ENV.GITLAB_USER_LOGIN || ENV.CI_COMMIT_AUTHOR
-  }
-}
-
-function getDefaultInformation() {
-  return {
-    ci: ENV.TEST_BEATS_CI_NAME,
-    git: ENV.TEST_BEATS_CI_GIT,
-    repository_url: ENV.TEST_BEATS_CI_REPOSITORY_URL,
-    repository_name: ENV.TEST_BEATS_CI_REPOSITORY_NAME,
-    repository_ref: ENV.TEST_BEATS_CI_REPOSITORY_REF,
-    repository_commit_sha: ENV.TEST_BEATS_CI_REPOSITORY_COMMIT_SHA,
-    build_url: ENV.TEST_BEATS_CI_BUILD_URL,
-    build_number: ENV.TEST_BEATS_CI_BUILD_NUMBER,
-    build_name: ENV.TEST_BEATS_CI_BUILD_NAME,
-    build_reason: ENV.TEST_BEATS_CI_BUILD_REASON,
-    user: ENV.TEST_BEATS_CI_USER || os.userInfo().username
-  }
-}
-
-function getSystemInfo() {
-  function getRuntimeInfo() {
-    if (typeof process !== 'undefined' && process.versions && process.versions.node) {
-      return { name: 'node', version: process.versions.node };
-    } else if (typeof Deno !== 'undefined') {
-      return { name: 'deno', version: Deno.version.deno };
-    } else if (typeof Bun !== 'undefined') {
-      return { name: 'bun', version: Bun.version };
-    } else {
-      return { name: 'unknown', version: 'unknown' };
-    }
-  }
-
-  const runtime = getRuntimeInfo();
-
-  return {
-    runtime: runtime.name,
-    runtime_version: runtime.version,
-    os: os.platform(),
-    os_version: os.release(),
-    testbeats_version: pkg.version
-  }
-}
-
-module.exports = {
-  getCIInformation
-}