testbeats 2.4.2 → 2.5.0

package/src/manual/synchronizer.js

@@ -0,0 +1,329 @@
+const logger = require('../utils/logger');
+
+/**
+ * Result of a synchronization operation
+ * @typedef {Object} SyncResult
+ * @property {boolean} success - Overall success status
+ * @property {number} foldersProcessed - Number of folders processed
+ * @property {number} testSuitesProcessed - Number of test suites processed
+ * @property {Array<{type: string, name: string, error: string}>} errors - List of errors encountered
+ */
+
+/**
+ * Synchronizes manual test resources with the server
+ */
+class ManualTestSynchronizer {
+  /**
+   * @param {import('../beats/beats.api').BeatsApi} beatsApi
+   */
+  constructor(beatsApi) {
+    this.beatsApi = beatsApi;
+  }
+
+  /**
+   * Sync the manual resources
+   * @param {import('../types').IManualTestFolder} structure - Local folder structure
+   * @param {import('../types').IManualSyncCompareResponse} compareResult - Comparison result from server
+   * @param {string} projectId - Project ID
+   * @returns {Promise<SyncResult>} Synchronization result
+   */
+  async sync(structure, compareResult, projectId) {
+    const errors = [];
+    let foldersProcessed = 0;
+    let testSuitesProcessed = 0;
+
+    const enrichedStructure = this.#mergeStructure(structure, compareResult);
+    const syncResult = await this.#syncFolders(enrichedStructure.folders, projectId, errors);
+    foldersProcessed = syncResult.foldersProcessed;
+    testSuitesProcessed = syncResult.testSuitesProcessed;
+
+    return {
+      success: errors.length === 0,
+      foldersProcessed,
+      testSuitesProcessed,
+      errors
+    };
+  }
+
+  /**
+   * Merge the structure with the compare result (returns new structure)
+   * @param {import('../types').IManualTestFolder} structure
+   * @param {import('../types').IManualSyncCompareResponse} compareResult
+   * @returns {import('../types').IManualTestFolder} Enriched structure
+   */
+  #mergeStructure(structure, compareResult) {
+    const enrichedFolders = [];
+
+    for (const localFolder of structure.folders) {
+      const serverFolder = compareResult.folders.find(f => f.name === localFolder.name);
+      if (serverFolder) {
+        enrichedFolders.push(this.#mergeFolder(localFolder, serverFolder));
+      } else {
+        enrichedFolders.push(localFolder);
+      }
+    }
+
+    for (const serverFolder of compareResult.folders) {
+      const localFolder = structure.folders.find(f => f.name === serverFolder.name);
+      if (!localFolder) {
+        enrichedFolders.push(this.#convertServerFolderToLocal(serverFolder));
+      }
+    }
+
+    return {
+      ...structure,
+      folders: enrichedFolders
+    };
+  }
+
+  /**
+   * Merge server folder metadata into local folder (returns new folder)
+   * @param {import('../types').IManualTestFolder} localFolder - Local folder with full data
+   * @param {import('../types').IManualSyncCompareResponseFolder} serverFolder - Server folder with metadata
+   * @returns {import('../types').IManualTestFolder} Merged folder
+   */
+  #mergeFolder(localFolder, serverFolder) {
+    const enrichedTestSuites = [];
+    const enrichedSubFolders = [];
+    const serverTestSuites = serverFolder.test_suites || [];
+    const serverFolders = serverFolder.folders || [];
+
+    for (const localSuite of localFolder.test_suites) {
+      const serverSuite = serverTestSuites.find(s => s.name === localSuite.name);
+      if (serverSuite) {
+        enrichedTestSuites.push(this.#mergeTestSuite(localSuite, serverSuite));
+      } else {
+        enrichedTestSuites.push(localSuite);
+      }
+    }
+
+    for (const serverSuite of serverTestSuites) {
+      const localSuite = localFolder.test_suites.find(s => s.name === serverSuite.name);
+      if (!localSuite) {
+        enrichedTestSuites.push(this.#convertServerSuiteToLocal(serverSuite));
+      }
+    }
+
+    for (const localSubFolder of localFolder.folders) {
+      const serverSubFolder = serverFolders.find(f => f.name === localSubFolder.name);
+      if (serverSubFolder) {
+        enrichedSubFolders.push(this.#mergeFolder(localSubFolder, serverSubFolder));
+      } else {
+        enrichedSubFolders.push(localSubFolder);
+      }
+    }
+
+    for (const serverSubFolder of serverFolders) {
+      const localSubFolder = localFolder.folders.find(f => f.name === serverSubFolder.name);
+      if (!localSubFolder) {
+        enrichedSubFolders.push(this.#convertServerFolderToLocal(serverSubFolder));
+      }
+    }
+
+    return {
+      ...localFolder,
+      id: serverFolder.id,
+      type: serverFolder.type,
+      test_suites: enrichedTestSuites,
+      folders: enrichedSubFolders
+    };
+  }
+
+  /**
+   * Merge server test suite metadata into local test suite (returns new suite)
+   * @param {import('../types').IManualTestSuite} localSuite - Local test suite with full data
+   * @param {import('../types').IManualSyncCompareResponseTestSuite} serverSuite - Server suite with metadata
+   * @returns {import('../types').IManualTestSuite} Merged test suite
+   */
+  #mergeTestSuite(localSuite, serverSuite) {
+    return {
+      ...localSuite,
+      id: serverSuite.id,
+      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
+    };
+  }
+
+  /**
+   * Sync folders recursively
+   * @param {Array<import('../types').IManualTestFolder>} folders
+   * @param {string} projectId
+   * @param {Array} errors - Array to collect errors
+   * @returns {Promise<{foldersProcessed: number, testSuitesProcessed: number}>}
+   */
+  async #syncFolders(folders, projectId, errors) {
+    let foldersProcessed = 0;
+    let testSuitesProcessed = 0;
+
+    if (folders.length === 0) {
+      return { foldersProcessed, testSuitesProcessed };
+    }
+
+    const payload = {
+      project_id: projectId,
+      folders: folders.map(folder => ({
+        type: folder.type,
+        id: folder.id,
+        name: folder.name,
+        hash: folder.hash,
+        parent_folder_id: folder.parent_folder_id,
+      })),
+    };
+
+    try {
+      const response = await this.beatsApi.syncManualFolders(payload);
+      const results = response.results;
+
+      for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        const folder = folders[i];
+
+        if (result.success) {
+          logger.info(`✅ Folder '${result.name}' synced successfully`);
+          foldersProcessed++;
+
+          folder.id = folder.id || result.id;
+
+          if (folder.test_suites && folder.test_suites.length > 0) {
+            const testSuitesWithFolderId = folder.test_suites.map(ts => ({
+              ...ts,
+              folder_id: folder.id
+            }));
+
+            const suiteResult = await this.#syncTestSuites(testSuitesWithFolderId, projectId, errors);
+            testSuitesProcessed += suiteResult.testSuitesProcessed;
+          }
+
+          if (folder.folders && folder.folders.length > 0) {
+            const subfoldersWithParent = folder.folders.map(sf => ({
+              ...sf,
+              parent_folder_id: folder.id
+            }));
+
+            const subResult = await this.#syncFolders(subfoldersWithParent, projectId, errors);
+            foldersProcessed += subResult.foldersProcessed;
+            testSuitesProcessed += subResult.testSuitesProcessed;
+          }
+        } else {
+          const error = {
+            type: 'folder',
+            name: result.name,
+            error: result.error || 'Unknown error'
+          };
+          errors.push(error);
+          logger.error(`❌ Folder '${result.name}' failed to sync: ${error.error}`);
+        }
+      }
+    } catch (error) {
+      const syncError = {
+        type: 'folder_batch',
+        name: 'batch',
+        error: error.message
+      };
+      errors.push(syncError);
+      logger.error(`❌ Failed to sync folder batch: ${error.message}`);
+    }
+
+    return { foldersProcessed, testSuitesProcessed };
+  }
+
+  /**
+   * Sync test suites
+   * @param {Array<import('../types').IManualTestSuite>} testSuites
+   * @param {string} projectId
+   * @param {Array} errors - Array to collect errors
+   * @returns {Promise<{testSuitesProcessed: number}>}
+   */
+  async #syncTestSuites(testSuites, projectId, errors) {
+    let testSuitesProcessed = 0;
+
+    if (testSuites.length === 0) {
+      return { testSuitesProcessed };
+    }
+
+    const payload = {
+      project_id: projectId,
+      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 => ({
+          name: tc.name,
+          type: tc.type,
+          tags: tc.tags,
+          steps: tc.steps.map(step => step.name),
+          hash: tc.hash,
+        })),
+      })),
+    };
+
+    try {
+      const response = await this.beatsApi.syncManualTestSuites(payload);
+      const results = response.results;
+
+      for (const result of results) {
+        if (result.success) {
+          logger.info(`✅ Test Suite '${result.name}' synced successfully`);
+          testSuitesProcessed++;
+        } else {
+          const error = {
+            type: 'test_suite',
+            name: result.name,
+            error: result.error || 'Unknown error'
+          };
+          errors.push(error);
+          logger.error(`❌ Test Suite '${result.name}' failed to sync: ${error.error}`);
+        }
+      }
+    } catch (error) {
+      const syncError = {
+        type: 'test_suite_batch',
+        name: 'batch',
+        error: error.message
+      };
+      errors.push(syncError);
+      logger.error(`❌ Failed to sync test suite batch: ${error.message}`);
+    }
+
+    return { testSuitesProcessed };
+  }
+}
+
+module.exports = { ManualTestSynchronizer };
+

package/src/utils/config.builder.js

@@ -1,47 +1,122 @@
 const path = require('path');
 const logger = require('./logger');
 
+const DEFAULT_PROJECT = 'demo-project';
+
 class ConfigBuilder {
 
   /**
    * @param {import('../index').CommandLineOptions} opts
+   * @param {import('../helpers/ci').ICIInfo} ci
+   * @param {Record<string, string | undefined>} env
    */
-  constructor(opts) {
+  constructor(opts, ci, env = process.env) {
     this.opts = opts;
+    this.ci = ci;
+    this.env = env;
+    /** @type {import('../index').PublishConfig}  */
+    this.config = {};
   }
 
   build() {
     if (!this.opts) {
       return;
     }
-    if (typeof this.opts.config === 'object') {
-      return
+    logger.info('🏗 Building config...')
+    switch (typeof this.opts.config) {
+      case 'object':
+        this.#buildFromConfigFile();
+        break;
+      case 'string':
+        this.#buildFromConfigFilePath();
+        break;
+      default:
+        this.#buildFromCommandLineOptions();
+        break;
     }
-    if (this.opts.config && typeof this.opts.config === 'string') {
-      return;
+  }
+
+  #buildFromConfigFile() {
+    this.config = this.opts.config;
+    this.#buildBeats();
+  }
+
+  #buildFromConfigFilePath() {
+    const cwd = process.cwd();
+    const file_path = path.join(cwd, this.opts.config);
+    try {
+      const config_json = require(file_path);
+      this.opts.config = config_json;
+      this.#buildFromConfigFile();
+    } catch (error) {
+      throw new Error(`Failed to read config file: '${file_path}' with error: '${error.message}'`);
     }
+  }
 
-    logger.info('🏗 Building config...')
-    this.#buildConfig();
+
+
+  #buildFromCommandLineOptions() {
+    this.opts.config = {};
+    this.config = this.opts.config;
     this.#buildBeats();
     this.#buildResults();
     this.#buildTargets();
     this.#buildExtensions();
+  }
 
-    logger.debug(`🛠️ Generated Config: \n${JSON.stringify(this.config, null, 2)}`);
+  #buildBeats() {
+    this.#setProject();
+    this.#setRun();
+    this.#setApiKey();
+  }
 
-    this.opts.config = this.config;
+  #setProject() {
+    if (this.opts.project) {
+      this.config.project = this.opts.project;
+      return;
+    }
+    if (this.env.TEST_BEATS_PROJECT || this.env.TESTBEATS_PROJECT) {
+      this.config.project = this.env.TEST_BEATS_PROJECT || this.env.TESTBEATS_PROJECT;
+      return;
+    }
+    if (this.config.project) {
+      return;
+    }
+    if (this.ci && this.ci.repository_name) {
+      this.config.project = this.ci.repository_name;
+      return;
+    }
+
+    this.config.project = DEFAULT_PROJECT;
   }
 
-  #buildConfig() {
-    /** @type {import('../index').PublishConfig}  */
-    this.config = {};
+  #setRun() {
+    if (this.opts.run) {
+      this.config.run = this.opts.run;
+      return;
+    }
+    if (this.env.TEST_BEATS_RUN || this.env.TESTBEATS_RUN) {
+      this.config.run = this.env.TEST_BEATS_RUN || this.env.TESTBEATS_RUN;
+      return;
+    }
+    if (this.config.run) {
+      return;
+    }
+    if (this.ci && this.ci.build_name) {
+      this.config.run = this.ci.build_name;
+      return;
+    }
   }
 
-  #buildBeats() {
-    this.config.project = this.opts.project || this.config.project;
-    this.config.run = this.opts.run || this.config.run;
-    this.config.api_key = this.opts['api-key'] || this.config.api_key;
+  #setApiKey() {
+    if (this.opts['api-key']) {
+      this.config.api_key = this.opts['api-key'];
+      return;
+    }
+    if (this.env.TEST_BEATS_API_KEY || this.env.TESTBEATS_API_KEY) {
+      this.config.api_key = this.env.TEST_BEATS_API_KEY || this.env.TESTBEATS_API_KEY;
+      return;
+    }
   }
 
   #buildResults() {

package/src/manual/sync.helper.js

@@ -1,193 +0,0 @@
-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))
-    };
-  }
-
-  /**
-   * Hash a folder
-   * @param {import('../types').IManualTestFolder} folder
-   * @returns {string} Hash string
-   */
-  hashFolder(folder) {
-    return this.generateHash({
-      name: folder.name,
-      path: folder.path,
-      test_suites: folder.test_suites.map(testSuite => testSuite.hash),
-      folders: folder.folders.map(subFolder => subFolder.hash)
-    });
-  }
-
-  /**
-   * Hash a test suite
-   * @param {import('../types').IManualTestSuite} testSuite
-   * @returns {string} Hash string
-   */
-  hashTestSuite(testSuite) {
-    return this.generateHash({
-      name: testSuite.name,
-      tags: testSuite.tags,
-      before_each: testSuite.before_each,
-      test_cases: testSuite.test_cases.map(testCase => testCase.hash)
-    });
-  }
-
-
-  /**
-   * 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}`);
-    }
-
-    return this.buildFolderStructure(absolutePath, directoryPath);
-  }
-
-  /**
-   * Build folder structure recursively
-   * @param {string} absolutePath - Absolute path for file operations
-   * @param {string} relativePath - Relative path for output
-   * @returns {import('../types').IManualTestFolder} Folder structure
-   */
-  buildFolderStructure(absolutePath, relativePath) {
-    const folderName = path.basename(absolutePath);
-    const items = fs.readdirSync(absolutePath);
-
-    /**
-     * @type {import('../types').IManualTestFolder}
-     */
-    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);
-          testSuite.hash = this.hashTestSuite(testSuite);
-          structure.test_suites.push(testSuite);
-        } catch (error) {
-          console.warn(`Warning: Failed to parse ${itemPath}: ${error.message}`);
-        }
-      }
-    }
-    structure.hash = this.hashFolder(structure);
-    if (structure.test_suites.length > 0) {
-      const defaultFolder = {
-        name: 'default',
-        path: 'default',
-        hash: '',
-        test_suites: structure.test_suites,
-        folders: []
-      };
-      defaultFolder.hash = this.hashFolder(defaultFolder);
-      structure.folders.push(defaultFolder);
-      structure.test_suites = [];
-    }
-
-    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 {import('../types').IManualTestSuite} Formatted test suite
-   */
-  parseGherkinFile(filePath, relativePath) {
-    const parsed = this.parser.parse(filePath);
-
-    return {
-      name: parsed.name,
-      type: parsed.type,
-      tags: parsed.tags,
-      before_each: parsed.before_each,
-      path: relativePath,
-      test_cases: parsed.test_cases || [] // Map 'cases' to 'test_cases' for consistency
-    };
-  }
-}
-
-module.exports = { ManualSyncHelper };