testbeats 2.2.7 → 2.2.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testbeats",
-  "version": "2.2.7",
+  "version": "2.2.9",
   "description": "Publish test results to Microsoft Teams, Google Chat, Slack and InfluxDB",
   "main": "src/index.js",
   "types": "./src/index.d.ts",
@@ -50,13 +50,14 @@
     "dotenv": "^16.4.5",
     "form-data-lite": "^1.0.3",
     "influxdb-lite": "^1.0.0",
+    "object-hash": "^3.0.0",
     "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.8"
+    "test-results-parser": "0.2.9"
   },
   "devDependencies": {
     "c8": "^10.1.2",

package/src/beats/beats.attachments.js

@@ -10,7 +10,7 @@ const logger = require('../utils/logger');
 const TestAttachment = require('test-results-parser/src/models/TestAttachment');
 
 const MAX_ATTACHMENTS_PER_REQUEST = 5;
-const MAX_ATTACHMENTS_PER_RUN = 20;
+const MAX_ATTACHMENTS_PER_RUN = 50;
 const MAX_ATTACHMENT_SIZE = 2 * 1024 * 1024;
 
 class BeatsAttachments {

package/src/beats/beats.js

@@ -186,14 +186,14 @@ class Beats {
     if (process.env.TEST_BEATS_DELAY) {
       return parseInt(process.env.TEST_BEATS_DELAY);
     }
-    return 3000;
+    return 5000;
   }
 
   async #setTestRun(text, wait_for = 'smart_analysis_status') {
     if (this.test_run && this.test_run[wait_for] === PROCESS_STATUS.COMPLETED) {
       return;
     }
-    let retry = 3;
+    let retry = 5;
     while (retry >= 0) {
       retry = retry - 1;
       await new Promise(resolve => setTimeout(resolve, this.#getDelay()));

package/src/cli.js

@@ -6,6 +6,7 @@ const sade = require('sade');
 const prog = sade('testbeats');
 const { PublishCommand } = require('./commands/publish.command');
 const { GenerateConfigCommand } = require('./commands/generate-config.command');
+const { ManualSyncCommand } = require('./commands/manual-sync.command');
 const logger = require('./utils/logger');
 const pkg = require('../package.json');
 
@@ -63,4 +64,21 @@ prog.command('init')
     }
   });
 
+// Command to sync manual test cases from gherkin files
+prog.command('manual sync')
+  .describe('Sync manual test cases from gherkin files in a directory')
+  .option('-p, --path', 'Path to directory to sync (default: current directory)')
+  .example('manual sync')
+  .example('manual sync --path ./tests/features')
+  .action(async (opts) => {
+    try {
+      logger.setLevel(opts.logLevel);
+      const manual_sync_command = new ManualSyncCommand(opts);
+      await manual_sync_command.execute();
+    } catch (error) {
+      logger.error(`Manual sync failed: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
 prog.parse(process.argv);

package/src/commands/manual-sync.command.js

@@ -0,0 +1,79 @@
+const path = require('path');
+const { ManualSyncHelper } = require('../manual/sync.helper');
+const logger = require('../utils/logger');
+
+class ManualSyncCommand {
+  /**
+   * @param {Object} opts - Command options
+   */
+  constructor(opts) {
+    this.opts = opts;
+    this.syncHelper = new ManualSyncHelper();
+  }
+
+  /**
+   * Execute the manual sync command
+   */
+  async execute() {
+    try {
+      logger.info('🔄 Starting manual test case sync...');
+
+      const targetPath = this.opts.path || '.';
+      logger.info(`📁 Scanning directory: ${targetPath}`);
+
+      const result = await this.syncHelper.scanDirectory(targetPath);
+
+      // Format output as specified in requirements
+      const output = {
+        folders: [result]
+      };
+
+      // Display results
+      this.displayResults(output);
+
+      logger.info('✅ Manual sync completed successfully!');
+
+      return output;
+
+    } catch (error) {
+      logger.error(`❌ Manual sync failed: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Display sync results in a readable format
+   * @param {Object} output - Sync results
+   */
+  displayResults(output) {
+    logger.info('\n📊 Sync Results:');
+    this.displayFolderRecursive(output.folders[0], 0);
+  }
+
+  /**
+   * Recursively display folder structure
+   * @param {Object} folder - Folder object
+   * @param {number} depth - Current depth for indentation
+   */
+  displayFolderRecursive(folder, depth) {
+    const indent = '  '.repeat(depth);
+
+    logger.info(`${indent}📁 ${folder.name} (${folder.path})`);
+
+    if (folder.test_suites.length > 0) {
+      logger.info(`${indent}  📋 Test Suites: ${folder.test_suites.length}`);
+      folder.test_suites.forEach(suite => {
+        logger.info(`${indent}    • ${suite.name} (${suite.test_cases.length} test cases)`);
+      });
+    }
+
+    if (folder.folders.length > 0) {
+      logger.info(`${indent}  📂 Subfolders: ${folder.folders.length}`);
+      folder.folders.forEach(subFolder => {
+        this.displayFolderRecursive(subFolder, depth + 1);
+      });
+    }
+  }
+}
+
+module.exports = { ManualSyncCommand };

package/src/helpers/constants.js

@@ -15,6 +15,7 @@ const TARGET = Object.freeze({
   TEAMS: 'teams',
   CHAT: 'chat',
   GITHUB: 'github',
+  GITHUB_OUTPUT: 'github-output',
   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 | GitHubInputs | ICustomTargetInputs | InfluxDBTargetInputs;
+  inputs?: SlackInputs | TeamsInputs | ChatInputs | IGitHubInputs | IGitHubOutputInputs | ICustomTargetInputs | 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' | 'github' | 'custom' | 'delay';
+export type TargetName = 'slack' | 'teams' | 'chat' | 'github' | 'github-output' | 'custom' | 'delay';
 export type PublishReportType = 'test-summary' | 'test-summary-slim' | 'failure-details';
 
 export interface ConditionFunctionContext {
@@ -244,13 +244,18 @@ export interface TeamsInputs extends TargetInputs {
 
 export interface ChatInputs extends TargetInputs { }
 
-export interface GitHubInputs extends TargetInputs {
+export interface IGitHubInputs extends TargetInputs {
   token?: string;
   owner?: string;
   repo?: string;
   pull_number?: string;
 }
 
+export interface IGitHubOutputInputs {
+  output_file?: string;
+  key?: string;
+}
+
 export interface InfluxDBTargetInputs {
   url: string;
   version?: string;

package/src/manual/parsers/gherkin.js

@@ -0,0 +1,237 @@
+const fs = require('fs');
+
+/**
+ * Simple and extendable Gherkin parser for Cucumber feature files
+ * Parses .feature files and returns structured test suite objects
+ */
+class GherkinParser {
+  constructor() {
+    /** @type {string[]} Supported step keywords */
+    this.stepKeywords = ['Given', 'When', 'Then', 'And', 'But'];
+  }
+
+  /**
+   * @param {string} file_path
+   * @returns {Object} Parsed test suite structure
+   */
+  parse(file_path) {
+    try {
+      const content = fs.readFileSync(file_path, 'utf8');
+      const lines = content.split('\n').map(line => line.trim()).filter(line => line.length > 0);
+
+      return this.parseLines(lines);
+    } catch (error) {
+      throw new Error(`Failed to parse Gherkin file: ${error.message}`);
+    }
+  }
+
+    /**
+   * Parse lines and build the test suite structure
+   * @param {string[]} lines
+   * @returns {Object}
+   */
+  parseLines(lines) {
+    const testSuite = {
+      name: '',
+      type: 'feature',
+      tags: [],
+      beforeEach: [],
+      cases: []
+    };
+
+    let currentFeature = null;
+    let currentBackground = null;
+    let currentScenario = null;
+    let pendingFeatureTags = [];
+    let pendingScenarioTags = [];
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      if (line.startsWith('@')) {
+        // Handle tags
+        const tags = this.parseTags(line);
+
+        // Look ahead to see if tags belong to Feature or Scenario
+        if (i + 1 < lines.length && lines[i + 1].startsWith('Feature:')) {
+          // Tags belong to Feature
+          pendingFeatureTags = tags;
+        } else if (i + 1 < lines.length && lines[i + 1].startsWith('Scenario:')) {
+          // Tags belong to Scenario
+          pendingScenarioTags = tags;
+        }
+      } else if (line.startsWith('Feature:')) {
+        // Parse Feature
+        const description = this.parseMultiLineDescription(lines, i + 1);
+        currentFeature = this.parseFeature(line, description);
+        testSuite.name = currentFeature.name;
+        testSuite.tags = pendingFeatureTags.map(tag => tag.name);
+        pendingFeatureTags = [];
+        i += description.split('\n').length; // Skip all description lines
+      } else if (line.startsWith('Background:')) {
+        // Parse Background
+        currentBackground = this.parseBackground();
+        testSuite.beforeEach.push(currentBackground);
+      } else if (line.startsWith('Scenario:')) {
+        // Parse Scenario
+        currentScenario = this.parseScenario(line);
+        currentScenario.tags = pendingScenarioTags.map(tag => tag.name);
+        testSuite.cases.push(currentScenario);
+        pendingScenarioTags = [];
+        currentBackground = null; // Reset Background context when Scenario starts
+      } else if (this.isStep(line)) {
+        // Parse Step
+        const step = this.parseStep(line);
+
+        // Determine where to add the step based on current context
+        if (currentBackground && currentBackground.steps) {
+          // Add step to Background
+          currentBackground.steps.push(step);
+        } else if (currentScenario && currentScenario.steps) {
+          // Add step to Scenario
+          currentScenario.steps.push(step);
+        }
+      }
+    }
+
+    return testSuite;
+  }
+
+  /**
+   * Parse tags from a line
+   * @param {string} line
+   * @returns {Array}
+   */
+  parseTags(line) {
+    const tagMatches = line.match(/@\w+/g);
+    return tagMatches ? tagMatches.map(tag => ({ name: tag })) : [];
+  }
+
+  /**
+   * Parse multi-line description starting from a given line index
+   * @param {string[]} lines
+   * @param {number} startIndex
+   * @returns {string}
+   */
+  parseMultiLineDescription(lines, startIndex) {
+    const descriptionLines = [];
+
+    for (let i = startIndex; i < lines.length; i++) {
+      const line = lines[i];
+
+      // Stop if we hit a keyword or step
+      if (line.startsWith('Background:') ||
+          line.startsWith('Scenario:') ||
+          line.startsWith('@') ||
+          this.isStep(line)) {
+        break;
+      }
+
+      // Add non-empty lines to description
+      if (line.trim().length > 0) {
+        descriptionLines.push(line.trim());
+      }
+    }
+
+    return descriptionLines.join('\n');
+  }
+
+  /**
+   * Parse Feature line
+   * @param {string} line
+   * @param {string} description
+   * @returns {Object}
+   */
+  parseFeature(line, description) {
+    const name = line.replace('Feature:', '').trim();
+    return {
+      type: 'Feature',
+      tags: [],
+      keyword: 'Feature',
+      name: name,
+      description: description.trim(),
+      children: []
+    };
+  }
+
+  /**
+   * Parse Background line
+   * @returns {Object}
+   */
+  parseBackground() {
+    return {
+      name: '',
+      type: 'background',
+      steps: []
+    };
+  }
+
+  /**
+   * Parse Scenario line
+   * @param {string} line
+   * @returns {Object}
+   */
+  parseScenario(line) {
+    const name = line.replace('Scenario:', '').trim();
+    return {
+      name: name,
+      type: 'scenario',
+      tags: [],
+      steps: []
+    };
+  }
+
+  /**
+   * Check if a line is a step
+   * @param {string} line
+   * @returns {boolean}
+   */
+  isStep(line) {
+    return this.stepKeywords.some(keyword =>
+      line.startsWith(keyword + ' ') ||
+      line.startsWith('And ') ||
+      line.startsWith('But ')
+    );
+  }
+
+  /**
+   * Parse a step line
+   * @param {string} line
+   * @returns {Object}
+   */
+  parseStep(line) {
+    return {
+      name: line.trim()
+    };
+  }
+
+  /**
+   * Parse from string content instead of file
+   * @param {string} content
+   * @returns {Object} Parsed test suite structure
+   */
+  parseString(content) {
+    try {
+      const lines = content.split('\n').map(line => line.trim()).filter(line => line.length > 0);
+      return this.parseLines(lines);
+    } catch (error) {
+      throw new Error(`Failed to parse Gherkin content: ${error.message}`);
+    }
+  }
+
+  /**
+   * Validate if the parsed document has required structure
+   * @param {Object} document
+   * @returns {boolean}
+   */
+  validate(document) {
+    return document &&
+           document.name &&
+           document.type === 'feature' &&
+           Array.isArray(document.tags) &&
+           Array.isArray(document.beforeEach) &&
+           Array.isArray(document.cases);
+  }
+}
+
+module.exports = { GherkinParser };

package/src/manual/sync.helper.js

@@ -0,0 +1,148 @@
+const fs = require('fs');
+const path = require('path');
+const hash = require('object-hash');
+const { GherkinParser } = require('./parsers/gherkin');
+
+class ManualSyncHelper {
+  constructor() {
+    this.parser = new GherkinParser();
+  }
+
+  /**
+   * Generate hash for an object
+   * @param {Object} obj - Object to hash
+   * @returns {string} Hash string
+   */
+  generateHash(obj) {
+    return hash(obj, { algorithm: 'md5' });
+  }
+
+  /**
+   * Add hash to test case
+   * @param {Object} testCase - Test case object
+   * @returns {Object} Test case with hash
+   */
+  addTestCaseHash(testCase) {
+    return {
+      ...testCase,
+      hash: this.generateHash(testCase)
+    };
+  }
+
+  /**
+   * Add hash to test suite
+   * @param {Object} testSuite - Test suite object
+   * @returns {Object} Test suite with hash
+   */
+  addTestSuiteHash(testSuite) {
+    return {
+      ...testSuite,
+      hash: this.generateHash(testSuite),
+      test_cases: testSuite.test_cases.map(testCase => this.addTestCaseHash(testCase))
+    };
+  }
+
+  /**
+   * Add hash to folder
+   * @param {Object} folder - Folder object
+   * @returns {Object} Folder with hash
+   */
+  addFolderHash(folder) {
+    return {
+      ...folder,
+      hash: this.generateHash(folder),
+      test_suites: folder.test_suites.map(testSuite => this.addTestSuiteHash(testSuite)),
+      folders: folder.folders.map(subFolder => this.addFolderHash(subFolder))
+    };
+  }
+
+  /**
+   * Scan directory recursively and build folder structure
+   * @param {string} directoryPath - Path to scan
+   * @returns {Object} Folder structure with test suites and hashes
+   */
+  async scanDirectory(directoryPath) {
+    const absolutePath = path.resolve(directoryPath);
+
+    if (!fs.existsSync(absolutePath)) {
+      throw new Error(`Directory does not exist: ${directoryPath}`);
+    }
+
+    if (!fs.statSync(absolutePath).isDirectory()) {
+      throw new Error(`Path is not a directory: ${directoryPath}`);
+    }
+
+    const structure = this.buildFolderStructure(absolutePath, directoryPath);
+    return this.addFolderHash(structure);
+  }
+
+  /**
+   * Build folder structure recursively
+   * @param {string} absolutePath - Absolute path for file operations
+   * @param {string} relativePath - Relative path for output
+   * @returns {Object} Folder structure
+   */
+  buildFolderStructure(absolutePath, relativePath) {
+    const folderName = path.basename(absolutePath);
+    const items = fs.readdirSync(absolutePath);
+
+    const structure = {
+      name: folderName,
+      path: relativePath,
+      test_suites: [],
+      folders: []
+    };
+
+    for (const item of items) {
+      const itemPath = path.join(absolutePath, item);
+      const itemRelativePath = path.join(relativePath, item);
+      const stats = fs.statSync(itemPath);
+
+      if (stats.isDirectory()) {
+        // Recursively process subdirectories
+        const subFolder = this.buildFolderStructure(itemPath, itemRelativePath);
+        structure.folders.push(subFolder);
+      } else if (this.isGherkinFile(item)) {
+        // Parse gherkin files
+        try {
+          const testSuite = this.parseGherkinFile(itemPath, itemRelativePath);
+          structure.test_suites.push(testSuite);
+        } catch (error) {
+          console.warn(`Warning: Failed to parse ${itemPath}: ${error.message}`);
+        }
+      }
+    }
+
+    return structure;
+  }
+
+  /**
+   * Check if file is a gherkin file
+   * @param {string} filename - Filename to check
+   * @returns {boolean} True if gherkin file
+   */
+  isGherkinFile(filename) {
+    return filename.endsWith('.feature');
+  }
+
+  /**
+   * Parse a gherkin file and format output
+   * @param {string} filePath - Path to gherkin file
+   * @param {string} relativePath - Relative path for output
+   * @returns {Object} Formatted test suite
+   */
+  parseGherkinFile(filePath, relativePath) {
+    const parsed = this.parser.parse(filePath);
+
+    return {
+      name: parsed.name,
+      type: parsed.type,
+      tags: parsed.tags,
+      beforeEach: parsed.beforeEach,
+      path: relativePath,
+      test_cases: parsed.cases || [] // Map 'cases' to 'test_cases' for consistency
+    };
+  }
+}
+
+module.exports = { ManualSyncHelper };