@appliqation/automation-sdk 2.1.0

package/src/services/ResultService.js

@@ -0,0 +1,252 @@
+const logger = require('../utils/logger');
+const { normalizeBrowser } = require('../utils/RunDataNormalizer');
+
+class ResultService {
+  constructor(httpClient) {
+    this.http = httpClient;
+  }
+
+  /**
+   * Submit a single test result
+   * @param {string} runId - Run ID
+   * @param {Object} result - Test result
+   * @param {Object} runMetadata - Run metadata (nid, run_timestamp, environment)
+   * @returns {Promise<Object>} Response from server
+   */
+  async submitSingle(runId, result, runMetadata = {}) {
+    try {
+      const payload = [this.buildLegacyResultPayload(result, runMetadata)];
+
+      logger.debug('Submitting single result', {
+        runId,
+        uuid: result.uuid,
+        status: result.status
+      });
+
+      // Use existing /api/insert/scenario/result endpoint (expects array)
+      const response = await this.http.post('/api/insert/scenario/result', payload);
+
+      // Check if request was successful
+      if (!response.success) {
+        throw new Error(response.error || 'Result submission failed');
+      }
+
+      return response;
+    } catch (error) {
+      logger.error('Failed to submit result', {
+        error: error.message,
+        runId,
+        uuid: result.uuid
+      });
+      throw new Error(`Failed to submit result: ${error.message}`);
+    }
+  }
+
+  /**
+   * Submit batch of results with smart grouping
+   * @param {Array} results - Array of test results
+   * @param {Object} options - Batch options
+   * @param {number} options.batchSize - Number of results per batch (default: 50)
+   * @param {Function} options.onProgress - Progress callback
+   * @param {boolean} options.retryFailures - Retry failed submissions (default: true)
+   * @param {Object} options.runMetadata - Run metadata (nid, run_timestamp, environment)
+   * @returns {Promise<Object>} Submission summary
+   */
+  async submitBatch(results, options = {}) {
+    const {
+      batchSize = 50,
+      onProgress = null,
+      retryFailures = true,
+      runMetadata = {}
+    } = options;
+
+    if (!results || results.length === 0) {
+      logger.warn('No results to submit');
+      return {
+        success: 0,
+        failed: 0,
+        total: 0
+      };
+    }
+
+    logger.info(`Starting batch submission of ${results.length} results`);
+
+    // Group results by browser for efficient metadata updates
+    const grouped = this.groupByBrowser(results);
+
+    const allResults = [];
+    const failures = [];
+
+    for (const [browser, browserResults] of Object.entries(grouped)) {
+      const batches = this.chunkArray(browserResults, batchSize);
+
+      logger.info(`Submitting ${browserResults.length} results for ${browser} in ${batches.length} batches`);
+
+      for (let i = 0; i < batches.length; i++) {
+        const batch = batches[i];
+        // Transform results to legacy format for existing endpoint
+        const payloads = batch.map(r => this.buildLegacyResultPayload(r, runMetadata));
+
+        logger.debug('Batch payload', { payload: JSON.stringify(payloads, null, 2) });
+
+        try {
+          // Use existing /api/insert/scenario/result endpoint
+          const response = await this.http.post('/api/insert/scenario/result', payloads);
+
+          // Check if request was successful
+          if (!response.success) {
+            throw new Error(response.error || 'Batch submission failed');
+          }
+
+          // Track successful submissions
+          allResults.push(...batch);
+
+          // Call progress callback
+          if (onProgress) {
+            onProgress({
+              browser,
+              batchIndex: i + 1,
+              totalBatches: batches.length,
+              completed: (i + 1) * batchSize,
+              total: browserResults.length
+            });
+          }
+
+          logger.debug(`Batch ${i + 1}/${batches.length} submitted for ${browser}`, {
+            count: batch.length
+          });
+        } catch (error) {
+          logger.error(`Batch ${i + 1}/${batches.length} failed for ${browser}`, {
+            error: error.message,
+            count: batch.length
+          });
+          failures.push(...batch);
+        }
+      }
+    }
+
+    // Retry failures individually
+    if (retryFailures && failures.length > 0) {
+      logger.info(`Retrying ${failures.length} failed results...`);
+
+      for (const result of failures) {
+        try {
+          await this.submitSingle(result.runId, result, runMetadata);
+          allResults.push(result);
+        } catch (error) {
+          logger.error(`Failed to submit result on retry`, {
+            uuid: result.uuid,
+            error: error.message
+          });
+        }
+      }
+    }
+
+    const summary = {
+      success: allResults.length,
+      failed: results.length - allResults.length,
+      total: results.length
+    };
+
+    logger.info('Batch submission completed', summary);
+
+    return summary;
+  }
+
+  /**
+   * Build result payload for API (single submission)
+   * @private
+   */
+  buildResultPayload(runId, result) {
+    return {
+      run_id: runId,
+      test_case_uuid: result.uuid,
+      status: result.status,
+      duration: result.duration || 0,
+      browser: result.browser,
+      device: result.device || 'Desktop',
+      os: result.os || '',
+      error_message: result.error || result.comment || '',
+      timestamp: result.timestamp || Math.floor(Date.now() / 1000)
+    };
+  }
+
+  /**
+   * Build result payload for batch submission (no run_id)
+   * @private
+   */
+  buildBatchResultPayload(result) {
+    return {
+      test_case_uuid: result.uuid,
+      status: result.status,
+      duration: result.duration || 0,
+      browser: result.browser,
+      device: result.device || 'Desktop',
+      os: result.os || '',
+      error_message: result.error || result.comment || ''
+    };
+  }
+
+  /**
+   * Build result payload for legacy /api/insert/scenario/result endpoint
+   * @private
+   */
+  buildLegacyResultPayload(result, runMetadata = {}) {
+    // Map status to legacy format (Pass/Fail capitalized)
+    const statusMap = {
+      'passed': 'Pass',
+      'failed': 'Fail',
+      'skipped': 'Skipped'
+    };
+
+    return {
+      run_id: result.runId,
+      nid: runMetadata.nid || 0,
+      run_timestamp: runMetadata.run_timestamp || Math.floor(Date.now() / 1000),
+      uuid: result.uuid,
+      parent_uuid: result.parent_uuid || '',
+      status: statusMap[result.status] || result.status,
+      browserName: normalizeBrowser(result.browser || 'Unknown Browser'),
+      environment: runMetadata.environment || 'Local'
+    };
+  }
+
+  /**
+   * Group results by browser
+   * @private
+   */
+  groupByBrowser(results) {
+    return results.reduce((acc, result) => {
+      const browser = result.browser || 'unknown';
+      if (!acc[browser]) {
+        acc[browser] = [];
+      }
+      acc[browser].push(result);
+      return acc;
+    }, {});
+  }
+
+  /**
+   * Split array into chunks
+   * @private
+   */
+  chunkArray(array, size) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+      chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+  }
+
+  /**
+   * Extract NID from UUID
+   * @private
+   */
+  extractNid(uuid) {
+    if (!uuid || typeof uuid !== 'string') return null;
+    const parts = uuid.split('-');
+    return parseInt(parts[0]);
+  }
+}
+
+module.exports = ResultService;

package/src/services/RunMatrixService.js

@@ -0,0 +1,309 @@
+const logger = require('../utils/logger');
+const { normalizeBrowser, normalizeOS, normalizeDevice } = require('../utils/RunDataNormalizer');
+
+class RunMatrixService {
+  constructor(httpClient, config) {
+    this.http = httpClient;
+    this.config = config;
+  }
+
+  /**
+   * Create a new test run matrix
+   * @param {Object} options - Run configuration
+   * @param {number} options.scenarioId - Scenario node ID
+   * @param {number} options.testSetId - Test Set node ID (alternative to scenarioId)
+   * @param {string} options.type - 'scenario' or 'testset'
+   * @param {string} options.environment - Environment name
+   * @param {string[]} options.browsers - Array of browser strings
+   * @param {string} options.device - Device type (Desktop, Mobile, Tablet)
+   * @param {string} options.os - Operating system
+   * @param {string} options.title - Custom run title
+   * @returns {Promise<Object>} { runId, token, timestamp, metadata }
+   */
+  async create(options) {
+    try {
+      // Validate required fields
+      this.validateCreateOptions(options);
+
+      // Build payload for unified endpoint
+      // Support both numeric project IDs and base64-encoded project keys
+      // Numeric IDs are sent as-is (temporary workaround for duplicate key issues)
+      // Base64 keys are double-encoded for transmission
+      const projectKeyValue = /^\d+$/.test(this.config.projectKey)
+        ? this.config.projectKey // Numeric ID - send as-is
+        : Buffer.from(this.config.projectKey).toString('base64'); // Base64 key - encode for transmission
+
+      // Normalize browsers array
+      const browsers = options.browsers || ['Chrome'];
+      const normalizedBrowsers = browsers.map(browser => normalizeBrowser(browser));
+
+      const payload = {
+        project_key: projectKeyValue,
+        environment: options.environment || 'Local',
+        browsers: normalizedBrowsers,
+        device: normalizeDevice(options.device || this.detectDevice()),
+        os: normalizeOS(options.os || this.detectOS()),
+        title: options.title || this.config.runTitle || `Automation Run - ${new Date().toISOString()}`
+      };
+
+      // Add scenario_id, testset_id, or default to 0 for generic automation runs
+      if (options.scenarioId) {
+        payload.scenario_id = parseInt(options.scenarioId);
+        payload.type = options.type || 'scenario';
+      } else if (options.testSetId) {
+        payload.testset_id = parseInt(options.testSetId);
+        payload.type = 'testset';
+      } else {
+        // No scenario or test set - use 0 for generic automation run
+        payload.scenario_id = 0;
+        payload.type = options.type || 'automation';
+      }
+
+      logger.info('Creating run matrix...', {
+        type: payload.type,
+        id: payload.scenario_id || payload.testset_id,
+        environment: payload.environment,
+        browsers: payload.browsers
+      });
+
+      // Call unified endpoint with detailed timing logs
+      const startTime = Date.now();
+      logger.info('Sending POST request to /api/automation/run/create...', {
+        timestamp: new Date().toISOString()
+      });
+
+      const response = await this.http.post('/api/automation/run/create', payload);
+
+      const duration = Date.now() - startTime;
+      logger.info('POST request completed', {
+        duration: `${duration}ms`,
+        timestamp: new Date().toISOString()
+      });
+
+      // Debug logging to understand response structure
+      logger.debug('Raw response from HttpClient:', {
+        success: response.success,
+        hasData: !!response.data,
+        dataKeys: response.data ? Object.keys(response.data) : [],
+        fullResponse: JSON.stringify(response)
+      });
+
+      // HttpClient wraps response in {success, data} - extract the actual API response
+      const apiResponse = response.data || response;
+
+      logger.debug('Extracted API response:', {
+        hasRunId: !!apiResponse.run_id,
+        apiResponseKeys: Object.keys(apiResponse),
+        runId: apiResponse.run_id
+      });
+
+      // Validate: HttpClient success + API response exists + API has run_id
+      if (!response.success || !apiResponse || !apiResponse.run_id) {
+        logger.error('Validation failed:', {
+          responseSuccess: response.success,
+          hasApiResponse: !!apiResponse,
+          hasRunId: !!apiResponse?.run_id,
+          response: JSON.stringify(response, null, 2)
+        });
+        throw new Error('Run creation failed: Invalid response from server');
+      }
+
+      // Store JWT token in auth manager for subsequent requests
+      if (apiResponse.jwt_token && this.http.auth) {
+        this.http.auth.setJwtToken(apiResponse.jwt_token);
+      }
+
+      logger.info('Run matrix created successfully', {
+        runId: apiResponse.run_id,
+        timestamp: apiResponse.run_timestamp
+      });
+
+      return {
+        runId: apiResponse.run_id,
+        token: apiResponse.jwt_token,
+        timestamp: apiResponse.run_timestamp,
+        metadata: apiResponse.metadata
+      };
+    } catch (error) {
+      // Extract API validation error details if available
+      let errorMessage = error.message;
+      let errorDetails = null;
+
+      // Check if this is an HTTP error with response data (API validation errors)
+      if (error.response && error.response.data) {
+        errorDetails = error.response.data;
+
+        // Use API error message if available
+        if (errorDetails.message) {
+          errorMessage = errorDetails.message;
+        }
+
+        logger.error('API validation error', {
+          status: error.response.status,
+          error_code: errorDetails.error_code,
+          message: errorDetails.message,
+          details: errorDetails
+        });
+      } else {
+        logger.error('Failed to create run matrix', {
+          error: error.message,
+          options
+        });
+      }
+
+      // Create enhanced error with details for upstream handlers
+      const enhancedError = new Error(errorMessage);
+      enhancedError.details = errorDetails;
+      enhancedError.statusCode = error.response?.status;
+
+      throw enhancedError;
+    }
+  }
+
+  /**
+   * Create multiple runs for device/OS matrix
+   * @param {Array} configs - Array of run configurations
+   * @returns {Promise<Array>} Array of created runs
+   */
+  async createMultiple(configs) {
+    const runs = [];
+    const errors = [];
+
+    logger.info(`Creating ${configs.length} run matrices...`);
+
+    for (let i = 0; i < configs.length; i++) {
+      const config = configs[i];
+      try {
+        const run = await this.create(config);
+        runs.push({
+          ...run,
+          device: config.device,
+          os: config.os,
+          config: config
+        });
+        logger.info(`Run ${i + 1}/${configs.length} created: ${run.runId}`);
+      } catch (error) {
+        const errorInfo = {
+          index: i,
+          config,
+          error: error.message
+        };
+        errors.push(errorInfo);
+        logger.error(`Failed to create run ${i + 1}/${configs.length}`, errorInfo);
+      }
+    }
+
+    if (errors.length > 0) {
+      logger.warn(`${errors.length} out of ${configs.length} runs failed to create`);
+    }
+
+    return {
+      runs,
+      errors,
+      summary: {
+        total: configs.length,
+        success: runs.length,
+        failed: errors.length
+      }
+    };
+  }
+
+  /**
+   * Add browser to existing run matrix dynamically
+   * @param {string} runId - Run ID
+   * @param {string} browser - Browser name
+   * @returns {Promise<Object>} Response from server
+   */
+  async addBrowser(runId, browser, nid = 0) {
+    try {
+      logger.info('Adding browser to run matrix', { runId, browser, nid });
+
+      const response = await this.http.post('/api/run-matrix/update', {
+        run_id: runId,
+        nid: nid,
+        operation: 'add_browser',
+        data: {
+          browser: normalizeBrowser(browser)
+        }
+      });
+
+      logger.info('Browser added successfully', { runId, browser });
+      return response;
+    } catch (error) {
+      logger.error('Failed to add browser', {
+        error: error.message,
+        runId,
+        browser
+      });
+      throw new Error(`Failed to add browser: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get run matrix data
+   * @param {string} runId - Run ID
+   * @returns {Promise<Object>} Run matrix data
+   */
+  async get(runId) {
+    try {
+      const response = await this.http.get(`/api/result/${runId}`);
+      return response;
+    } catch (error) {
+      logger.error('Failed to get run matrix', {
+        error: error.message,
+        runId
+      });
+      throw new Error(`Failed to get run matrix: ${error.message}`);
+    }
+  }
+
+  /**
+   * Validate create options
+   * @private
+   */
+  validateCreateOptions(options) {
+    if (!options) {
+      throw new Error('Options are required');
+    }
+
+    // Note: scenarioId and testSetId are now optional
+    // If neither is provided, defaults to 0 for generic automation runs
+    if (!options.scenarioId && !options.testSetId) {
+      logger.info('No scenarioId or testSetId provided, using default (0) for generic automation run');
+    }
+
+    if (!options.environment) {
+      logger.warn('No environment specified, using "Local"');
+    }
+
+    if (!options.browsers || options.browsers.length === 0) {
+      logger.warn('No browsers specified, using ["Chrome"]');
+    }
+  }
+
+  /**
+   * Auto-detect device type
+   * @private
+   * @returns {string} Normalized device type
+   */
+  detectDevice() {
+    return normalizeDevice('Desktop');
+  }
+
+  /**
+   * Auto-detect operating system
+   * @private
+   * @returns {string} Normalized OS name
+   */
+  detectOS() {
+    const platform = process.platform;
+    const osMap = {
+      'win32': 'Windows',
+      'darwin': 'macOS',
+      'linux': 'Linux'
+    };
+    return normalizeOS(osMap[platform] || 'Unknown');
+  }
+}
+
+module.exports = RunMatrixService;