testbeats 2.4.2 → 2.5.0

package/src/manual/index.js

@@ -0,0 +1,18 @@
+const { ManualTestScanner } = require('./scanner');
+const { ManualTestComparator } = require('./comparator');
+const { ManualTestSynchronizer } = require('./synchronizer');
+const { ManualSyncOrchestrator } = require('./orchestrator');
+const { ManualSyncServiceFactory } = require('./factory');
+const { ProjectResolver } = require('./project-resolver');
+const { ManualTestHasher } = require('./hasher');
+
+module.exports = {
+  ManualTestScanner,
+  ManualTestComparator,
+  ManualTestSynchronizer,
+  ManualSyncOrchestrator,
+  ManualSyncServiceFactory,
+  ProjectResolver,
+  ManualTestHasher,
+};
+

package/src/manual/orchestrator.js

@@ -0,0 +1,124 @@
+const logger = require('../utils/logger');
+
+/**
+ * Orchestrates the manual sync pipeline
+ * Implements the Template Method pattern to coordinate the sync workflow
+ */
+class ManualSyncOrchestrator {
+  /**
+   * @param {import('./scanner').ManualTestScanner} scanner
+   * @param {import('./comparator').ManualTestComparator} comparator
+   * @param {import('./synchronizer').ManualTestSynchronizer} synchronizer
+   * @param {import('./project-resolver').ProjectResolver} projectResolver
+   * @param {import('./hasher').ManualTestHasher} hasher
+   */
+  constructor(scanner, comparator, synchronizer, projectResolver, hasher) {
+    this.scanner = scanner;
+    this.comparator = comparator;
+    this.synchronizer = synchronizer;
+    this.projectResolver = projectResolver;
+    this.hasher = hasher;
+  }
+
+  /**
+   * Execute the complete manual sync pipeline
+   * @param {string} directoryPath - Path to scan for manual tests
+   * @param {string} projectName - Project name to sync to
+   * @returns {Promise<Object>} Sync result with statistics and errors
+   */
+  async execute(directoryPath, projectName) {
+    const result = {
+      success: false,
+      projectId: null,
+      statistics: {
+        totalTestCases: 0,
+        totalTestSuites: 0,
+        totalFolders: 0,
+        foldersProcessed: 0,
+        testSuitesProcessed: 0
+      },
+      errors: []
+    };
+
+    try {
+      logger.info(`📋 Resolving project: ${projectName}`);
+      result.projectId = await this.projectResolver.resolveProject(projectName);
+      logger.info(`✅ Project resolved: ${result.projectId}`);
+
+      logger.info(`📁 Scanning directory: ${directoryPath}`);
+      const scannedStructure = await this.scanner.scanDirectory(directoryPath);
+
+      logger.debug('🔐 Adding hashes to structure...');
+      this.hasher.hashStructure(scannedStructure);
+
+      const stats = this.#calculateStatistics(scannedStructure);
+      result.statistics.totalTestCases = stats.totalTestCases;
+      result.statistics.totalTestSuites = stats.totalTestSuites;
+      result.statistics.totalFolders = stats.totalFolders;
+
+      logger.info(`📊 Found ${stats.totalTestCases} test cases, ${stats.totalTestSuites} test suites, and ${stats.totalFolders} folders`);
+
+      logger.info('🔍 Comparing with server...');
+      const comparisonResult = await this.comparator.compare(scannedStructure, result.projectId);
+      logger.info('✅ Comparison completed');
+
+      logger.info('🔄 Synchronizing resources...');
+      const syncResult = await this.synchronizer.sync(scannedStructure, comparisonResult, result.projectId);
+
+      result.statistics.foldersProcessed = syncResult.foldersProcessed;
+      result.statistics.testSuitesProcessed = syncResult.testSuitesProcessed;
+      result.errors = syncResult.errors;
+      result.success = syncResult.success;
+
+      if (result.success) {
+        logger.info('✅ Synchronization completed successfully');
+      } else {
+        logger.warn(`⚠️ Synchronization completed with ${result.errors.length} error(s)`);
+      }
+
+      return result;
+    } catch (error) {
+      logger.error(`❌ Manual sync failed: ${error.message}`);
+      result.errors.push({
+        type: 'pipeline',
+        name: 'execution',
+        error: error.message
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * Calculate statistics from scanned structure
+   * @param {import('../types').IManualTestFolder} structure
+   * @returns {{totalTestCases: number, totalTestSuites: number, totalFolders: number}}
+   */
+  #calculateStatistics(structure) {
+    const stats = {
+      totalTestCases: 0,
+      totalTestSuites: 0,
+      totalFolders: 0
+    };
+
+    const processFolder = (folder) => {
+      for (const suite of folder.test_suites) {
+        stats.totalTestCases += suite.test_cases.length;
+        stats.totalTestSuites++;
+      }
+
+      stats.totalFolders += folder.folders.length;
+      for (const subFolder of folder.folders) {
+        processFolder(subFolder);
+      }
+    };
+
+    for (const folder of structure.folders) {
+      processFolder(folder);
+    }
+
+    return stats;
+  }
+}
+
+module.exports = { ManualSyncOrchestrator };
+

package/src/manual/parsers/base.js

@@ -1,38 +1,16 @@
-const hash = require('object-hash');
-
+/**
+ * Base class for manual test parsers
+ * Provides common functionality for parsing test files
+ */
 class BaseParser {
-  hash(obj) {
-    return hash(obj, { algorithm: 'md5' });
-  }
-
-  /**
-   * Hash a test case
-   * @param {import('../../types').IManualTestCase} testCase
-   * @returns {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}
+   * @param {import('fs')} fs
    */
-  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(testCase => testCase.hash)
-    });
+  constructor(fs) {
+    /**
+     * @type {import('fs')}
+     */
+    this.fs = fs;
   }
 }
 

package/src/manual/parsers/gherkin.js

@@ -1,4 +1,3 @@
-const fs = require('fs');
 const { BaseParser } = require('./base');
 
 /**
@@ -6,8 +5,8 @@ const { BaseParser } = require('./base');
  * Parses .feature files and returns structured test suite objects
  */
 class GherkinParser extends BaseParser {
-  constructor() {
-    super();
+  constructor(fs) {
+    super(fs);
     /** @type {string[]} Supported step keywords */
     this.stepKeywords = ['Given', 'When', 'Then', 'And', 'But'];
   }
@@ -18,7 +17,7 @@ class GherkinParser extends BaseParser {
    */
   parse(file_path) {
     try {
-      const content = fs.readFileSync(file_path, 'utf8');
+      const content = this.fs.readFileSync(file_path, 'utf8');
       const lines = content.split('\n').map(line => line.trim()).filter(line => line.length > 0);
 
       return this.parseLines(lines);
@@ -54,25 +53,37 @@ class GherkinParser extends BaseParser {
       const line = lines[i];
 
       if (line.startsWith('@')) {
-        // Handle tags
+        // Handle tags - accumulate from consecutive @ lines
         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;
+          // Tags belong to Feature - accumulate instead of replace
+          pendingFeatureTags.push(...tags);
         } else if (i + 1 < lines.length && lines[i + 1].startsWith('Scenario:')) {
-          // Tags belong to Scenario
-          pendingScenarioTags = tags;
+          // Tags belong to Scenario - accumulate instead of replace
+          pendingScenarioTags.push(...tags);
+        } else if (i + 1 < lines.length && lines[i + 1].startsWith('@')) {
+          // Next line is also a tag line - determine which pending array to use
+          // Look further ahead to find Feature or Scenario
+          let j = i + 1;
+          while (j < lines.length && lines[j].startsWith('@')) {
+            j++;
+          }
+          if (j < lines.length && lines[j].startsWith('Feature:')) {
+            pendingFeatureTags.push(...tags);
+          } else if (j < lines.length && lines[j].startsWith('Scenario:')) {
+            pendingScenarioTags.push(...tags);
+          }
         }
       } else if (line.startsWith('Feature:')) {
         // Parse Feature
-        const description = this.parseMultiLineDescription(lines, i + 1);
-        currentFeature = this.parseFeature(line, description);
+        const descriptionResult = this.parseMultiLineDescription(lines, i + 1);
+        currentFeature = this.parseFeature(line, descriptionResult.description);
         testSuite.name = currentFeature.name;
         testSuite.tags = pendingFeatureTags.map(tag => tag.name);
         pendingFeatureTags = [];
-        i += description.split('\n').length; // Skip all description lines
+        i += descriptionResult.linesConsumed; // Skip only actual description lines
       } else if (line.startsWith('Background:')) {
         // Parse Background
         currentBackground = this.parseBackground();
@@ -99,11 +110,6 @@ class GherkinParser extends BaseParser {
       }
     }
 
-    for (const testCase of testSuite.test_cases) {
-      testCase.hash = this.hashTestCase(testCase);
-    }
-    testSuite.hash = this.hashTestSuite(testSuite);
-
     return testSuite;
   }
 
@@ -121,10 +127,11 @@ class GherkinParser extends BaseParser {
    * Parse multi-line description starting from a given line index
    * @param {string[]} lines
    * @param {number} startIndex
-   * @returns {string}
+   * @returns {{description: string, linesConsumed: number}}
    */
   parseMultiLineDescription(lines, startIndex) {
     const descriptionLines = [];
+    let linesConsumed = 0;
 
     for (let i = startIndex; i < lines.length; i++) {
       const line = lines[i];
@@ -137,13 +144,18 @@ class GherkinParser extends BaseParser {
         break;
       }
 
+      linesConsumed++;
+
       // Add non-empty lines to description
       if (line.trim().length > 0) {
         descriptionLines.push(line.trim());
       }
     }
 
-    return descriptionLines.join('\n');
+    return {
+      description: descriptionLines.join('\n'),
+      linesConsumed: linesConsumed
+    };
   }
 
   /**

package/src/manual/project-resolver.js

@@ -0,0 +1,33 @@
+class ProjectResolver {
+  /**
+   * @param {import('../beats/beats.api').BeatsApi} beatsApi
+   */
+  constructor(beatsApi) {
+    this.beatsApi = beatsApi;
+  }
+
+  /**
+   * Resolve project name to project ID
+   * @param {string} projectName - Project name to resolve
+   * @returns {Promise<string>} Project ID
+   * @throws {Error} If project is not found
+   */
+  async resolveProject(projectName) {
+    const projectsResponse = await this.beatsApi.searchProjects(projectName);
+
+    if (!projectsResponse || !projectsResponse.values) {
+      throw new Error(`Project ${projectName} not found`);
+    }
+
+    const project = projectsResponse.values.find(p => p.name === projectName);
+
+    if (!project) {
+      throw new Error(`Project ${projectName} not found`);
+    }
+
+    return project.id;
+  }
+}
+
+module.exports = { ProjectResolver };
+

package/src/manual/scanner.js

@@ -0,0 +1,127 @@
+const path = require('path');
+const logger = require('../utils/logger');
+
+const DEFAULT_FOLDER_NAME = 'default';
+
+/**
+ * Scans directories for manual test cases and builds folder structures
+ */
+class ManualTestScanner {
+  constructor(fs, parser) {
+    /**
+     * @type {import('fs')}
+     */
+    this.fs = fs;
+    /**
+     * @type {import('./parsers/gherkin').GherkinParser}
+     */
+    this.parser = parser;
+  }
+
+  /**
+   * Scan directory recursively and build folder structure
+   * @param {string} directoryPath - Path to scan
+   * @returns {Promise<import('../types').IManualTestFolder>} Folder structure with test suites and hashes
+   * @throws {Error} If directory doesn't exist or is not a directory
+   */
+  async scanDirectory(directoryPath) {
+    const absolutePath = path.resolve(directoryPath);
+
+    if (!this.fs.existsSync(absolutePath)) {
+      throw new Error(`Directory ${directoryPath} does not exist`);
+    }
+
+    if (!this.fs.statSync(absolutePath).isDirectory()) {
+      throw new Error(`Path ${directoryPath} is not a directory`);
+    }
+
+    const structure = this.buildFolderStructure(absolutePath, directoryPath);
+    this.moveTestSuitesToDefaultFolder(structure);
+    return structure;
+  }
+
+  /**
+   * 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 = this.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 = this.fs.statSync(itemPath);
+
+      if (stats.isDirectory()) {
+        const subFolder = this.buildFolderStructure(itemPath, itemRelativePath);
+        structure.folders.push(subFolder);
+      } else if (this.isGherkinFile(item)) {
+        try {
+          const testSuite = this.parseGherkinFile(itemPath, itemRelativePath);
+          structure.test_suites.push(testSuite);
+        } catch (error) {
+          logger.warn(`Warning: Failed to parse ${itemPath}: ${error.message}`);
+        }
+      }
+    }
+
+    return structure;
+  }
+
+  moveTestSuitesToDefaultFolder(structure) {
+    if (structure.test_suites.length > 0) {
+      const defaultFolder = {
+        name: DEFAULT_FOLDER_NAME,
+        path: DEFAULT_FOLDER_NAME,
+        test_suites: structure.test_suites,
+        folders: []
+      };
+      structure.folders.push(defaultFolder);
+      structure.test_suites = [];
+    }
+  }
+
+  /**
+   * 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 || []
+    };
+  }
+}
+
+module.exports = { ManualTestScanner };
+