testbeats 2.4.2 → 2.5.0

package/package.json

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

package/src/beats/beats.js

@@ -20,14 +20,11 @@ class Beats {
   }
 
   async publish() {
-    this.#setApiKey();
     if (!this.config.api_key) {
       logger.warn('😿 No API key provided, skipping publishing results to TestBeats Portal...');
       return;
     }
     this.#setCIInfo();
-    this.#setProjectName();
-    this.#setRunName();
     await this.#publishTestResults();
     await this.#uploadAttachments();
     this.#updateTitleLink();
@@ -38,19 +35,6 @@ class Beats {
     this.ci = getCIInformation();
   }
 
-  #setProjectName() {
-    this.config.project = this.config.project || process.env.TEST_BEATS_PROJECT || (this.ci && this.ci.repository_name) || 'demo-project';
-  }
-
-  #setApiKey() {
-    this.config.api_key = this.config.api_key || process.env.TEST_BEATS_API_KEY;
-  }
-
-  #setRunName() {
-    this.config.run = this.config.run || process.env.TEST_BEATS_RUN || (this.ci && this.ci.build_name) || 'demo-run';
-    this.result.name = this.config.run;
-  }
-
   async #publishTestResults() {
     logger.info("🚀 Publishing results to TestBeats Portal...");
     try {

package/src/commands/base.command.js

@@ -3,9 +3,13 @@ const { MIN_NODE_VERSION } = require('../helpers/constants');
 const { ConfigBuilder } = require('../utils/config.builder');
 const logger = require('../utils/logger');
 const os = require('os');
+const { getCIInformation } = require('../helpers/ci');
 
 class BaseCommand {
   constructor(opts) {
+    /**
+     * @type {import('../index').CommandLineOptions}
+     */
     this.opts = opts;
   }
 
@@ -38,7 +42,7 @@ class BaseCommand {
   }
 
   buildConfig() {
-    const config_builder = new ConfigBuilder(this.opts);
+    const config_builder = new ConfigBuilder(this.opts, getCIInformation(), process.env);
     config_builder.build();
   }
 

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

@@ -1,6 +1,5 @@
-const { ManualSyncHelper } = require('../manual/sync.helper');
+const { ManualSyncServiceFactory } = require('../manual');
 const logger = require('../utils/logger');
-const { BeatsApi } = require('../beats/beats.api');
 const { BaseCommand } = require('./base.command');
 
 class ManualSyncCommand extends BaseCommand {
@@ -9,7 +8,6 @@ class ManualSyncCommand extends BaseCommand {
    */
   constructor(opts) {
     super(opts);
-    this.syncHelper = new ManualSyncHelper();
   }
 
   /**
@@ -24,288 +22,53 @@ class ManualSyncCommand extends BaseCommand {
       logger.info('🔄 Starting manual test case sync...');
 
       const targetPath = this.opts.path || '.';
-      logger.info(`📁 Scanning directory: ${targetPath}`);
+      const projectName = this.opts.config.project;
 
-      const result = await this.syncHelper.scanDirectory(targetPath);
+      // Create orchestrator with all dependencies wired
+      const orchestrator = ManualSyncServiceFactory.create(this.opts.config);
 
-      const counts = this.getCounts(result);
-      logger.info(`📊 Found ${counts.totalTestCases} test cases, ${counts.totalTestSuites} test suites, and ${counts.totalFolders} folders`);
+      // Execute the complete pipeline
+      const result = await orchestrator.execute(targetPath, projectName);
 
-      // Format output as specified in requirements
-      const output = {
-        folders: result.folders
-      };
-
-
-
-      const beats = new BeatsApi(this.opts.config);
-      const projectsResponse = await beats.searchProjects(this.opts.config.project);
-      const project = projectsResponse.values.find(p => p.name === this.opts.config.project);
-      if (!project) {
-        throw new Error(`Project ${this.opts.config.project} not found`);
-      }
-      this.opts.config.project = project.id;
-
-      const compare = new ManualSyncCompare(this.opts.config);
-      const compareResult = await compare.compare(output);
-
-      const resources = new ManualSyncResources(this.opts.config);
-      await resources.sync(output, compareResult);
+      // Log final results
+      this.#logResults(result);
 
+      return result;
     } catch (error) {
       logger.error(`❌ Manual sync failed: ${error.message}`);
       throw error;
     }
   }
 
-  getCounts(result, counts = { totalTestCases: 0, totalTestSuites: 0, totalFolders: 0 }) {
-    // return the total number of test cases, test suites, and folders
-    for (const folder of result.folders) {
-      counts.totalTestCases += folder.test_suites.reduce((acc, suite) => acc + suite.test_cases.length, 0);
-      counts.totalTestSuites += folder.test_suites.length;
-      counts.totalFolders += folder.folders.length;
-      this.getCounts(folder, counts);
-    }
-    return counts;
-  }
-}
-
-class ManualSyncCompare {
-
-  constructor(config) {
-    this.config = config;
-    this.beats = new BeatsApi(this.config);
-  }
-
-  /**
-   * @param {import('../types').IManualTestFolder} structure
-   */
-  async compare(structure) {
-    const payload = this.#buildPayload(structure);
-    const response = await this.beats.compareManualTests(payload);
-    return response;
-  }
-
-
-  /**
-   * Build the payload for the compare manual tests API
-   * @param {import('../types').IManualTestFolder} structure
-   * @returns {import('../types').IManualSyncComparePayload}
-   */
-  #buildPayload(structure) {
-    const payload = {
-      project_id: this.config.project,
-      folders: [],
-    };
-    for (const folder of structure.folders) {
-      payload.folders.push(this.#buildPayloadFolder(folder));
-    }
-    return payload;
-  }
-
-  /**
-   * Build the payload for a folder
-   * @param {import('../types').IManualTestFolder} folder
-   * @returns {import('../types').IManualSyncCompareFolder}
-   */
-  #buildPayloadFolder(folder) {
-    return {
-      name: folder.name,
-      hash: folder.hash,
-      test_suites: folder.test_suites.map(testSuite => this.#buildPayloadTestSuite(testSuite)),
-      folders: folder.folders.map(subFolder => this.#buildPayloadFolder(subFolder))
-    };
-  }
-
-  /**
-   * Build the payload for a test suite
-   * @param {import('../types').IManualTestSuite} testSuite
-   * @returns {import('../types').IManualSyncCompareTestSuite}
-   */
-  #buildPayloadTestSuite(testSuite) {
-    return {
-      name: testSuite.name,
-      hash: testSuite.hash,
-    };
-  }
-}
-
-class ManualSyncResources {
-  constructor(config) {
-    this.config = config;
-    this.beats = new BeatsApi(this.config);
-  }
-
-  /**
-   * Sync the manual resources
-   * @param {import('../types').IManualTestFolder} structure
-   * @param {import('../types').IManualSyncCompareResponse} compareResult
-   */
-  async sync(structure, compareResult) {
-    this.#mergeStructure(structure, compareResult);
-    await this.#syncFolders(structure.folders);
-  }
-
-  /**
-   * Merge the structure with the compare result
-   * @param {import('../types').IManualTestFolder} structure
-   * @param {import('../types').IManualSyncCompareResponse} compareResult
-   */
-  #mergeStructure(structure, compareResult) {
-    // Iterate through all folders from compare result and merge with local structure
-    for (const serverFolder of compareResult.folders) {
-      const localFolder = structure.folders.find(f => f.name === serverFolder.name);
-      if (localFolder) {
-        this.#mergeFolder(localFolder, serverFolder);
-      } else {
-        structure.folders.push(this.#convertServerFolderToLocal(serverFolder));
-      }
-    }
-  }
-
-  /**
-   * Merge server folder metadata into local folder
-   * @param {import('../types').IManualTestFolder} localFolder - Local folder with full data
-   * @param {import('../types').IManualSyncCompareResponseFolder} serverFolder - Server folder with metadata
-   */
-  #mergeFolder(localFolder, serverFolder) {
-    // Enrich local folder with server metadata
-    localFolder.id = serverFolder.id;
-    localFolder.type = serverFolder.type;
-
-    // Ensure server folder has test suites and folders
-    serverFolder.test_suites = serverFolder.test_suites || [];
-    serverFolder.folders = serverFolder.folders || [];
-
-    for (const serverSuite of serverFolder.test_suites) {
-      const localSuite = localFolder.test_suites.find(s => s.name === serverSuite.name);
-      if (localSuite) {
-        this.#mergeTestSuite(localSuite, serverSuite);
-      } else {
-        localFolder.test_suites.push(this.#convertServerSuiteToLocal(serverSuite));
-      }
-    }
-
-    for (const serverSubFolder of serverFolder.folders) {
-      const localSubFolder = localFolder.folders.find(f => f.name === serverSubFolder.name);
-      if (localSubFolder) {
-        this.#mergeFolder(localSubFolder, serverSubFolder);
-      } else {
-        localFolder.folders.push(this.#convertServerFolderToLocal(serverSubFolder));
-      }
-    }
-  }
-
   /**
-   * Merge server test suite metadata into local test suite
-   * @param {import('../types').IManualTestSuite} localSuite - Local test suite with full data
-   * @param {import('../types').IManualSyncCompareResponseTestSuite} serverSuite - Server suite with metadata
+   * Log the final sync results
+   * @param {Object} result - Sync result from orchestrator
    */
-  #mergeTestSuite(localSuite, serverSuite) {
-    localSuite.id = serverSuite.id;
-    localSuite.type = serverSuite.type;
-  }
-
-  /**
-   * Convert server folder to local folder structure (for delete operations)
-   * @param {import('../types').IManualSyncCompareResponseFolder} serverFolder - Server folder
-   * @returns {import('../types').IManualTestFolder} Local folder structure
-   */
-  #convertServerFolderToLocal(serverFolder) {
-    return {
-      name: serverFolder.name,
-      path: '',
-      hash: serverFolder.hash,
-      id: serverFolder.id,
-      type: serverFolder.type,
-      test_suites: serverFolder.test_suites?.map(s => this.#convertServerSuiteToLocal(s)) || [],
-      folders: serverFolder.folders?.map(f => this.#convertServerFolderToLocal(f)) || []
-    };
-  }
-
-  /**
-   * Convert server test suite to local test suite structure (for delete operations)
-   * @param {import('../types').IManualSyncCompareResponseTestSuite} serverSuite - Server suite
-   * @returns {import('../types').IManualTestSuite} Local test suite structure
-   */
-  #convertServerSuiteToLocal(serverSuite) {
-    return {
-      name: serverSuite.name,
-      tags: [],
-      before_each: [],
-      test_cases: [],
-      hash: serverSuite.hash,
-      id: serverSuite.id,
-      type: serverSuite.type
-    };
-  }
-
-  async #syncFolders(folders) {
-    const payload = {
-      project_id: this.config.project,
-      folders: folders.map(folder => ({
-        type: folder.type,
-        id: folder.id,
-        name: folder.name,
-        hash: folder.hash,
-        parent_folder_id: folder.parent_folder_id,
-      })),
-    };
-    const response = await this.beats.syncManualFolders(payload);
-    const results = response.results;
-    for (const result of results) {
-      if (result.success) {
-        logger.info(`✅ Folder '${result.name}' synced successfully`);
-        const folder = folders.find(f => f.name === result.name);
-        if (!folder) {
-          console.log(`❌ Folder ${result.name} not found in local structure`);
-          continue;
-        }
-        folder.id = folder.id || result.id;
-        for (const testSuite of folder.test_suites) {
-          testSuite.folder_id = folder.id;
-        }
-        await this.#syncTestSuites(folder.test_suites);
-        for (const subFolder of folder.folders) {
-          subFolder.parent_folder_id = folder.id;
-        }
-        await this.#syncFolders(folder.folders);
+  #logResults(result) {
+    logger.info('');
+    logger.info('📊 Sync Summary:');
+    logger.info(`   • Test Cases Found: ${result.statistics.totalTestCases}`);
+    logger.info(`   • Test Suites Found: ${result.statistics.totalTestSuites}`);
+    logger.info(`   • Folders Found: ${result.statistics.totalFolders}`);
+    logger.info(`   • Folders Synced: ${result.statistics.foldersProcessed}`);
+    logger.info(`   • Test Suites Synced: ${result.statistics.testSuitesProcessed}`);
+
+    if (result.errors.length > 0) {
+      logger.info('');
+      logger.warn(`⚠️ Encountered ${result.errors.length} error(s):`);
+      for (const error of result.errors) {
+        logger.warn(`   • [${error.type}] ${error.name}: ${error.error}`);
       }
     }
-  }
 
-  async #syncTestSuites(testSuites) {
-    const payload = {
-      project_id: this.config.project,
-      suites: testSuites.map(testSuite => ({
-        type: testSuite.type,
-        name: testSuite.name,
-        folder_id: testSuite.folder_id,
-        hash: testSuite.hash,
-        tags: testSuite.tags,
-        before_each: testSuite.before_each.map(step => step.name),
-        test_cases: testSuite.test_cases.map(tc => {
-          return {
-            name: tc.name,
-            type: tc.type,
-            tags: tc.tags,
-            steps: tc.steps.map(step => step.name),
-            hash: tc.hash,
-          };
-        }),
-      })),
-    };
-    const response = await this.beats.syncManualTestSuites(payload);
-    const results = response.results;
-    for (const result of results) {
-      if (result.success) {
-        logger.info(`✅ Test Suite '${result.name}' synced successfully`);
-      } else {
-        logger.error(`❌ Test Suite '${result.name}' failed to sync: ${result.error}`);
-      }
+    if (result.success) {
+      logger.info('');
+      logger.info('✅ Manual sync completed successfully!');
+    } else {
+      logger.info('');
+      logger.warn('⚠️ Manual sync completed with errors');
     }
   }
-
 }
 
-module.exports = { ManualSyncCommand, ManualSyncCompare };
+module.exports = { ManualSyncCommand };

package/src/commands/publish.command.js

@@ -1,4 +1,3 @@
-const path = require('path');
 const trp = require('test-results-parser');
 const prp = require('performance-results-parser');
 
@@ -25,8 +24,6 @@ class PublishCommand extends BaseCommand {
     this.validateEnvDetails();
     this.buildConfig();
     this.#validateOptions();
-    this.#setConfigFromFile();
-    this.#mergeConfigOptions();
     this.#processConfig();
     this.#validateConfig();
     this.#processResults();
@@ -44,27 +41,6 @@ class PublishCommand extends BaseCommand {
     }
   }
 
-  #setConfigFromFile() {
-    if (typeof this.opts.config === 'string') {
-      const cwd = process.cwd();
-      const file_path = path.join(cwd, this.opts.config);
-      try {
-        const config_json = require(path.join(cwd, this.opts.config));
-        this.opts.config = config_json;
-      } catch (error) {
-        throw new Error(`Failed to read config file: '${file_path}' with error: '${error.message}'`);
-      }
-    }
-  }
-
-  #mergeConfigOptions() {
-    if (this.opts.config && typeof this.opts.config === 'object') {
-      this.opts.config.project = this.opts.project || this.opts.config.project;
-      this.opts.config.run = this.opts.run || this.opts.config.run;
-      this.opts.config.api_key = this.opts['api-key'] || this.opts.config.api_key;
-    }
-  }
-
   #processConfig() {
     const processed_config = processData(this.opts.config);
     /**@type {import('../index').PublishConfig[]} */
@@ -230,6 +206,9 @@ class PublishCommand extends BaseCommand {
     for (const config of this.configs) {
       for (let i = 0; i < this.results.length; i++) {
         const result = this.results[i];
+        if (config.api_key) {
+          result.name = config.run || result.name || 'demo-run';
+        }
         config.extensions = config.extensions || [];
         await beats.run(config, result);
         if (config.targets) {

package/src/index.d.ts

@@ -345,6 +345,8 @@ export interface CommandLineOptions {
   nunit?: string;
   xunit?: string;
   mstest?: string;
+  // Manual sync command options
+  path?: string;
 }
 
 export type IExtensionDefaultOptions = {

package/src/manual/comparator.js

@@ -0,0 +1,71 @@
+class ManualTestComparator {
+  /**
+   * @param {import('../beats/beats.api').BeatsApi} beatsApi
+   */
+  constructor(beatsApi) {
+    this.beatsApi = beatsApi;
+  }
+
+  /**
+   * Compare local structure with server
+   * @param {import('../types').IManualTestFolder} structure - Local folder structure
+   * @param {string} projectId - Project ID
+   * @returns {Promise<import('../types').IManualSyncCompareResponse>} Comparison result
+   * @throws {Error} If comparison fails
+   */
+  async compare(structure, projectId) {
+    try {
+      const payload = this.#buildPayload(structure, projectId);
+      const response = await this.beatsApi.compareManualTests(payload);
+      return response;
+    } catch (error) {
+      throw new Error(error.message);
+    }
+  }
+
+  /**
+   * Build the payload for the compare manual tests API
+   * @param {import('../types').IManualTestFolder} structure
+   * @param {string} projectId
+   * @returns {import('../types').IManualSyncComparePayload}
+   */
+  #buildPayload(structure, projectId) {
+    const payload = {
+      project_id: projectId,
+      folders: [],
+    };
+    for (const folder of structure.folders) {
+      payload.folders.push(this.#buildPayloadFolder(folder));
+    }
+    return payload;
+  }
+
+  /**
+   * Build the payload for a folder
+   * @param {import('../types').IManualTestFolder} folder
+   * @returns {import('../types').IManualSyncCompareFolder}
+   */
+  #buildPayloadFolder(folder) {
+    return {
+      name: folder.name,
+      hash: folder.hash,
+      test_suites: folder.test_suites.map(testSuite => this.#buildPayloadTestSuite(testSuite)),
+      folders: folder.folders.map(subFolder => this.#buildPayloadFolder(subFolder))
+    };
+  }
+
+  /**
+   * Build the payload for a test suite
+   * @param {import('../types').IManualTestSuite} testSuite
+   * @returns {import('../types').IManualSyncCompareTestSuite}
+   */
+  #buildPayloadTestSuite(testSuite) {
+    return {
+      name: testSuite.name,
+      hash: testSuite.hash,
+    };
+  }
+}
+
+module.exports = { ManualTestComparator };
+

package/src/manual/factory.js

@@ -0,0 +1,60 @@
+const fs = require('fs');
+const { BeatsApi } = require('../beats/beats.api');
+const { ManualTestScanner } = require('./scanner');
+const { ManualTestComparator } = require('./comparator');
+const { ManualTestSynchronizer } = require('./synchronizer');
+const { ProjectResolver } = require('./project-resolver');
+const { ManualSyncOrchestrator } = require('./orchestrator');
+const { ManualTestHasher } = require('./hasher');
+const { GherkinParser } = require('./parsers/gherkin');
+
+/**
+ * Factory for creating properly wired manual sync services
+ * Implements dependency injection and ensures single BeatsApi instance
+ */
+class ManualSyncServiceFactory {
+  /**
+   * Create a fully configured orchestrator with all dependencies
+   * @param {Object} config - Configuration object for BeatsApi
+   * @returns {ManualSyncOrchestrator} Configured orchestrator
+   */
+  static create(config) {
+    const beatsApi = new BeatsApi(config);
+    const hasher = new ManualTestHasher();
+    const parser = new GherkinParser(fs);
+    const scanner = new ManualTestScanner(fs, parser);
+    const comparator = new ManualTestComparator(beatsApi);
+    const synchronizer = new ManualTestSynchronizer(beatsApi);
+    const projectResolver = new ProjectResolver(beatsApi);
+
+    return new ManualSyncOrchestrator(
+      scanner,
+      comparator,
+      synchronizer,
+      projectResolver,
+      hasher
+    );
+  }
+
+  /**
+   * Create individual services for testing or custom workflows
+   * @param {Object} config - Configuration object for BeatsApi
+   * @returns {Object} Object containing all services
+   */
+  static createServices(config) {
+    const beatsApi = new BeatsApi(config);
+    const hasher = new ManualTestHasher();
+
+    return {
+      beatsApi,
+      hasher,
+      scanner: new ManualTestScanner(),
+      comparator: new ManualTestComparator(beatsApi),
+      synchronizer: new ManualTestSynchronizer(beatsApi),
+      projectResolver: new ProjectResolver(beatsApi)
+    };
+  }
+}
+
+module.exports = { ManualSyncServiceFactory };
+

package/src/manual/hasher.js

@@ -0,0 +1,93 @@
+const hash = require('object-hash');
+
+/**
+ * Handles all hashing operations for manual test entities
+ * Centralizes hashing logic with configurable algorithm
+ */
+class ManualTestHasher {
+  /**
+   * @param {string} algorithm - Hashing algorithm (default: 'md5')
+   */
+  constructor(algorithm = 'md5') {
+    this.algorithm = algorithm;
+  }
+
+  /**
+   * Generate hash for any object
+   * @param {Object} obj - Object to hash
+   * @returns {string} Hash string
+   */
+  hash(obj) {
+    return hash(obj, { algorithm: this.algorithm });
+  }
+
+  /**
+   * Hash a test case
+   * @param {import('../types').IManualTestCase} testCase
+   * @returns {string} Hash string
+   */
+  hashTestCase(testCase) {
+    return this.hash({
+      name: testCase.name,
+      type: testCase.type,
+      tags: testCase.tags,
+      steps: testCase.steps,
+      path: testCase.path
+    });
+  }
+
+  /**
+   * Hash a test suite
+   * @param {import('../types').IManualTestSuite} testSuite
+   * @returns {string} Hash string
+   */
+  hashTestSuite(testSuite) {
+    return this.hash({
+      name: testSuite.name,
+      type: testSuite.type,
+      tags: testSuite.tags,
+      before_each: testSuite.before_each,
+      test_cases: testSuite.test_cases.map(tc => tc.hash)
+    });
+  }
+
+  /**
+   * Hash a folder
+   * @param {import('../types').IManualTestFolder} folder
+   * @returns {string} Hash string
+   */
+  hashFolder(folder) {
+    return this.hash({
+      name: folder.name,
+      path: folder.path,
+      test_suites: folder.test_suites.map(ts => ts.hash),
+      folders: folder.folders.map(f => f.hash)
+    });
+  }
+
+  /**
+   * Recursively hash an entire folder structure
+   * Adds hash properties to all test cases, test suites, and folders
+   * @param {import('../types').IManualTestFolder} structure - Folder structure to hash
+   * @returns {import('../types').IManualTestFolder} Same structure with hashes added (mutates in place)
+   */
+  hashStructure(structure) {
+    for (const testSuite of structure.test_suites) {
+      for (const testCase of testSuite.test_cases) {
+        testCase.hash = this.hashTestCase(testCase);
+      }
+      testSuite.hash = this.hashTestSuite(testSuite);
+    }
+
+    for (const subFolder of structure.folders) {
+      this.hashStructure(subFolder);
+    }
+
+    structure.hash = this.hashFolder(structure);
+
+    return structure;
+  }
+}
+
+module.exports = { ManualTestHasher };
+