@appliqation/automation-sdk 2.1.10 → 2.2.0

package/src/services/ResultService.js

@@ -2,8 +2,9 @@ const logger = require('../utils/logger');
 const { normalizeBrowser } = require('../utils/RunDataNormalizer');
 
 class ResultService {
-  constructor(httpClient) {
+  constructor(httpClient, config = { options: {} }) {
     this.http = httpClient;
+    this.config = config;
   }
 
   /**
@@ -15,7 +16,15 @@ class ResultService {
    */
   async submitSingle(runId, result, runMetadata = {}) {
     try {
-      const payload = [this.buildLegacyResultPayload(result, runMetadata)];
+      if (this.config?.options?.enableAppq === false) {
+        logger.info('Appq disabled - skipping single result submission', {
+          runId,
+          uuid: result.uuid
+        });
+        return { success: true, skipped: true, reason: 'Appq disabled' };
+      }
+
+      const payload = this.buildAutomationResultPayload(runId, result, runMetadata);
 
       logger.debug('Submitting single result', {
         runId,
@@ -23,15 +32,26 @@ class ResultService {
         status: result.status
       });
 
-      // Use existing /api/insert/scenario/result endpoint (expects array)
-      const response = await this.http.post('/api/insert/scenario/result', payload);
+      // Use automation endpoint to enable project validation
+      const response = await this.http.post('/api/automation/result/submit', payload);
+
+      // DEBUG: Show response with context
+      console.log('\n🔍 ========== SUBMIT RESULT RESPONSE ==========');
+      console.log('UUID:', result.uuid);
+      if (response.data && response.data.debug_context) {
+        console.log('Project ID (from API):', response.data.debug_context.project_id);
+        console.log('User ID (from API):', response.data.debug_context.uid);
+      }
+      console.log('Status:', response.status);
+      console.log('Success:', response.success);
+      console.log('===========================================\n');
 
       // Check if request was successful
       if (!response.success) {
         throw new Error(response.error || 'Result submission failed');
       }
 
-      return response;
+      return response.data || response;
     } catch (error) {
       logger.error('Failed to submit result', {
         error: error.message,
@@ -60,6 +80,16 @@ class ResultService {
       runMetadata = {}
     } = options;
 
+    if (this.config?.options?.enableAppq === false) {
+      logger.info(`Appq disabled - skipping batch submission of ${results?.length || 0} result(s)`);
+      return {
+        success: 0,
+        failed: 0,
+        total: results?.length || 0,
+        skipped: results?.length || 0
+      };
+    }
+
     if (!results || results.length === 0) {
       logger.warn('No results to submit');
       return {
@@ -71,53 +101,115 @@ class ResultService {
 
     logger.info(`Starting batch submission of ${results.length} results`);
 
-    // Group results by browser for efficient metadata updates
-    const grouped = this.groupByBrowser(results);
+    // Group results by runId for automation endpoint
+    const groupedByRun = this.groupByRun(results);
 
     const allResults = [];
     const failures = [];
 
-    for (const [browser, browserResults] of Object.entries(grouped)) {
-      const batches = this.chunkArray(browserResults, batchSize);
+    for (const [runId, runResults] of Object.entries(groupedByRun)) {
+      const batches = this.chunkArray(runResults, batchSize);
 
-      logger.info(`Submitting ${browserResults.length} results for ${browser} in ${batches.length} batches`);
+      logger.info(`Submitting ${runResults.length} results for run ${runId} 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));
+        const payload = {
+          run_id: runId,
+          results: batch.map(r => this.buildAutomationResultPayload(runId, r, runMetadata))
+        };
 
-        logger.debug('Batch payload', { payload: JSON.stringify(payloads, null, 2) });
+        logger.debug('Batch payload', { payload: JSON.stringify(payload, null, 2) });
+
+        // Show UUIDs being submitted (test execution status shown, NOT backend validation status)
+        console.log('\n📤 Submitting batch with UUIDs:');
+        payload.results.forEach((r, idx) => {
+          console.log(`  ${idx + 1}. ${r.test_case_uuid}`);
+        });
 
         try {
-          // Use existing /api/insert/scenario/result endpoint
-          const response = await this.http.post('/api/insert/scenario/result', payloads);
+          const response = await this.http.post('/api/automation/result/batch', payload);
+
+          // DEBUG: Show batch response with context
+          console.log('\n🔍 ========== BATCH SUBMIT RESPONSE ==========');
+          console.log('Run ID:', runId);
+          console.log('Batch:', `${i + 1}/${batches.length}`);
+          console.log('Results in batch:', batch.length);
+          if (response.data && response.data.debug_context) {
+            console.log('Project ID (from API):', response.data.debug_context.project_id);
+            console.log('User ID (from API):', response.data.debug_context.uid);
+          } else {
+            console.log('⚠️  No debug_context in response');
+          }
+          console.log('Status:', response.status);
+          console.log('Success:', response.success);
+
+          // Check for validation failures - response has nested data object
+          const failedResults = response.data?.data?.results?.failed || response.data?.results?.failed || response.data?.failed || [];
+          const submittedResults = response.data?.data?.results?.submitted || response.data?.results?.submitted || response.data?.submitted || [];
+          const submittedCount = typeof submittedResults === 'number' ? submittedResults : (Array.isArray(submittedResults) ? submittedResults.length : 0);
+
+          if (failedResults.length > 0) {
+            console.log('\n❌ ========== VALIDATION FAILURES ==========');
+            console.log(`   ✅ ACCEPTED: ${submittedCount} result(s)`);
+            console.log(`   ❌ REJECTED: ${failedResults.length} result(s)\n`);
+            failedResults.forEach((fail, idx) => {
+              const uuid = fail.test_case_uuid || fail.uuid;
+              const error = fail.error || fail.message;
+              const code = fail.code;
+
+              console.log(`   ${idx + 1}. UUID: ${uuid}`);
+              console.log(`      ❌ Reason: ${error}`);
+              if (code) {
+                console.log(`      🚫 HTTP Code: ${code}`);
+              }
+              console.log('');
+            });
+            console.log('===========================================');
+          }
+          console.log('============================================\n');
 
-          // Check if request was successful
           if (!response.success) {
             throw new Error(response.error || 'Batch submission failed');
           }
 
-          // Track successful submissions
-          allResults.push(...batch);
+          // Only count results that were actually accepted by backend
+          // Backend may reject some results due to validation (e.g., project mismatch)
+          if (failedResults.length > 0) {
+            // Some results were rejected - need to filter based on UUIDs
+            const rejectedUuids = new Set(failedResults.map(f => f.test_case_uuid || f.uuid));
+
+            batch.forEach(result => {
+              if (rejectedUuids.has(result.uuid)) {
+                // This result was rejected by backend validation
+                failures.push(result);
+              } else {
+                // This result was accepted
+                allResults.push(result);
+              }
+            });
+          } else {
+            // All results accepted
+            allResults.push(...batch);
+          }
 
-          // Call progress callback
           if (onProgress) {
             onProgress({
-              browser,
+              runId,
               batchIndex: i + 1,
               totalBatches: batches.length,
-              completed: (i + 1) * batchSize,
-              total: browserResults.length
+              completed: Math.min((i + 1) * batchSize, runResults.length),
+              total: runResults.length
             });
           }
 
-          logger.debug(`Batch ${i + 1}/${batches.length} submitted for ${browser}`, {
+          logger.debug(`Batch ${i + 1}/${batches.length} submitted for run ${runId}`, {
             count: batch.length
           });
         } catch (error) {
-          logger.error(`Batch ${i + 1}/${batches.length} failed for ${browser}`, {
+          logger.error(`Batch ${i + 1}/${batches.length} failed for run ${runId}`, {
             error: error.message,
+            status: error.status,
             count: batch.length
           });
           failures.push(...batch);
@@ -211,6 +303,33 @@ class ResultService {
     };
   }
 
+  /**
+   * Build result payload for automation endpoints
+   * @private
+   */
+  buildAutomationResultPayload(runId, result, runMetadata = {}) {
+    const statusMap = {
+      passed: 'passed',
+      failed: 'failed',
+      skipped: 'skipped',
+      timedOut: 'failed',
+      interrupted: 'skipped'
+    };
+
+    return {
+      run_id: runId || result.runId,
+      test_case_uuid: result.uuid,
+      status: statusMap[result.status] || result.status,
+      duration: result.duration || 0,
+      error_message: result.error || result.comment || '',
+      browser: normalizeBrowser(result.browser || 'Unknown Browser'),
+      device: result.device || runMetadata.device || 'Desktop',
+      os: result.os || runMetadata.os || '',
+      environment: runMetadata.environment || 'Local',
+      timestamp: result.timestamp || Math.floor(Date.now() / 1000)
+    };
+  }
+
   /**
    * Group results by browser
    * @private
@@ -238,6 +357,21 @@ class ResultService {
     return chunks;
   }
 
+  /**
+   * Group results by runId
+   * @private
+   */
+  groupByRun(results) {
+    return results.reduce((acc, result) => {
+      const runId = result.runId || result.run_id || 'unknown';
+      if (!acc[runId]) {
+        acc[runId] = [];
+      }
+      acc[runId].push(result);
+      return acc;
+    }, {});
+  }
+
   /**
    * Extract NID from UUID
    * @private

package/src/services/RunMatrixService.js

@@ -22,6 +22,22 @@ class RunMatrixService {
    */
   async create(options) {
     try {
+      if (this.config?.options?.enableAppq === false) {
+        logger.info('Appq disabled - returning local demo run (no Appq entry created)');
+        const now = Math.floor(Date.now() / 1000);
+        return {
+          runId: `demo-run-${now}`,
+          token: null,
+          timestamp: now,
+          metadata: {
+            appqEnabled: false,
+            mode: 'demo',
+            environment: options.environment || 'Local',
+            browsers: options.browsers || ['Chrome']
+          }
+        };
+      }
+
       // Validate required fields
       this.validateCreateOptions(options);
 

package/src/services/TaggingService.js

@@ -0,0 +1,44 @@
+const logger = require('../utils/logger');
+
+class TaggingService {
+  constructor(httpClient, config = { options: {} }) {
+    this.http = httpClient;
+    this.config = config;
+  }
+
+  /**
+   * Fire-and-forget tagging for accepted UUIDs.
+   * Does not throw; logs warnings on failure.
+   * @param {string[]} uuids
+   * @param {string} tagName
+   */
+  async tagAccepted(uuids = [], tagName) {
+    if (!uuids || uuids.length === 0) return;
+
+    if (this.config?.options?.enableAppq === false) {
+      return;
+    }
+
+    const unique = Array.from(new Set(uuids.filter(Boolean)));
+    if (unique.length === 0) return;
+
+    const tag = tagName || this.config?.options?.autoTagName || process.env.APPLIQATION_TAG_NAME || 'Appq_automated';
+    const endpoint = this.config?.options?.autoTagEndpoint || process.env.APPLIQATION_TAG_ENDPOINT || '/api/automation/testcase/tag';
+
+    try {
+      await this.http.post(endpoint, {
+        uuids: unique,
+        tag
+      });
+      logger.debug('Tagging submitted for accepted results', { count: unique.length, tag });
+    } catch (error) {
+      logger.warn('Failed to tag accepted results (non-blocking)', {
+        error: error.message,
+        count: unique.length,
+        tag
+      });
+    }
+  }
+}
+
+module.exports = TaggingService;