@appliqation/automation-sdk 2.1.11 → 2.3.0

package/src/reporters/playwright/helpers/UuidExtractor.js

@@ -120,16 +120,21 @@ class UuidExtractor {
     for (const annotation of annotations) {
       if (!annotation || typeof annotation !== 'object') continue;
 
-      // Check annotation type
+      // Check annotation type - STRICT validation for explicit UUID annotations
       if (annotation.type === 'uuid' || annotation.type === 'appliqation' || annotation.type === 'appliqation-uuid') {
         const uuid = annotation.description || annotation.value;
         if (uuid && UuidValidator.validate(uuid)) {
           return uuid;
         }
+        // If UUID type annotation exists but invalid, do NOT try pattern extraction
+        // This ensures invalid UUIDs are treated as orphans, not auto-corrected
+        if (uuid) {
+          return null; // Invalid UUID explicitly provided -> treat as orphan
+        }
       }
 
-      // Check annotation description for UUID
-      if (annotation.description) {
+      // Check annotation description for UUID (only for non-UUID-type annotations)
+      if (annotation.description && annotation.type !== 'uuid' && annotation.type !== 'appliqation' && annotation.type !== 'appliqation-uuid') {
         const uuid = this.extractFromTitle(annotation.description);
         if (uuid) return uuid;
       }

package/src/services/ResultService.js

@@ -2,8 +2,10 @@ const logger = require('../utils/logger');
 const { normalizeBrowser } = require('../utils/RunDataNormalizer');
 
 class ResultService {
-  constructor(httpClient) {
+  constructor(httpClient, taggingService = null, config = { options: {} }) {
     this.http = httpClient;
+    this.tagging = taggingService;
+    this.config = config;
   }
 
   /**
@@ -15,7 +17,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 +33,38 @@ 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;
+      // Auto-tag accepted result (await to ensure completion)
+      if (this.tagging && this.tagging.isEnabled()) {
+        try {
+          await this.tagging.autoTagAcceptedResults([result.uuid]);
+        } catch (err) {
+          logger.debug('Background tagging failed', {
+            error: err.message,
+            uuid: result.uuid
+          });
+        }
+      }
+
+      return response.data || response;
     } catch (error) {
       logger.error('Failed to submit result', {
         error: error.message,
@@ -60,6 +93,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 +114,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);
@@ -150,6 +255,28 @@ class ResultService {
 
     logger.info('Batch submission completed', summary);
 
+    // Auto-tag accepted results (await to ensure completion before reporter exits)
+    if (this.tagging && this.tagging.isEnabled() && allResults.length > 0) {
+      const acceptedUuids = allResults.map(r => r.uuid).filter(Boolean);
+
+      try {
+        const tagResult = await this.tagging.autoTagAcceptedResults(acceptedUuids);
+        if (tagResult.tagged > 0) {
+          console.log(`✅ Auto-tagged ${tagResult.tagged} test case(s) with "${this.tagging.tagName}"`);
+          if (tagResult.skipped > 0) {
+            console.log(`ℹ️  Skipped ${tagResult.skipped} test case(s) - already tagged with "${this.tagging.tagName}"`);
+          }
+        } else if (tagResult.skipped > 0) {
+          console.log(`ℹ️  All ${tagResult.skipped} test case(s) already tagged with "${this.tagging.tagName}" - skipping`);
+        }
+      } catch (err) {
+        logger.warn('Auto-tagging failed (non-blocking)', {
+          error: err.message,
+          count: acceptedUuids.length
+        });
+      }
+    }
+
     return summary;
   }
 
@@ -211,6 +338,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 +392,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);
 
@@ -304,6 +320,34 @@ class RunMatrixService {
     };
     return normalizeOS(osMap[platform] || 'Unknown');
   }
+
+  /**
+   * Delete a test run
+   * @param {string} runId - Run ID to delete
+   * @param {string} reason - Deletion reason
+   * @returns {Promise<Object>} Deletion result
+   */
+  async delete(runId, reason = 'orphan_cleanup') {
+    try {
+      logger.info('Deleting run...', { runId, reason });
+
+      const response = await this.http.deleteRun(runId, reason);
+
+      if (!response.success) {
+        throw new Error(response.error || 'Failed to delete run');
+      }
+
+      logger.info('Run deleted successfully', { runId });
+
+      return response.data || response;
+    } catch (error) {
+      logger.error('Failed to delete run', {
+        error: error.message,
+        runId
+      });
+      throw error;
+    }
+  }
 }
 
 module.exports = RunMatrixService;

package/src/services/TaggingService.js

@@ -0,0 +1,241 @@
+const logger = require('../utils/logger');
+
+/**
+ * Service for auto-tagging test cases after successful runs
+ */
+class TaggingService {
+  constructor(httpClient, config = { options: {} }) {
+    this.http = httpClient;
+    this.config = config;
+
+    // Configuration resolution: Runtime options > Env vars > Defaults
+    this.enabled = this.config?.options?.autoTag !== false &&
+                   process.env.APPLIQATION_AUTO_TAG_ENABLED !== 'false';
+    this.tagName = this.config?.options?.autoTagName ||
+                   process.env.APPLIQATION_AUTO_TAG_NAME ||
+                   'Appq_automated';
+    this.batchSize = this.config?.options?.autoTagBatchSize || 50;
+    this.retries = this.config?.options?.autoTagRetries || 2;
+  }
+
+  /**
+   * Check if tagging is enabled
+   * @returns {boolean}
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+
+  /**
+   * Check which UUIDs already have the tag
+   *
+   * @param {string[]} uuids - Array of test case UUIDs
+   * @param {string} tagName - Tag name (optional, uses config default)
+   * @returns {Promise<Object>} { needsTagging: [], alreadyTagged: [], errors: [] }
+   */
+  async checkTagStatus(uuids, tagName = null) {
+    if (!uuids || uuids.length === 0) {
+      return { needsTagging: [], alreadyTagged: [], errors: [] };
+    }
+
+    const tag = tagName || this.tagName;
+    const unique = Array.from(new Set(uuids.filter(Boolean)));
+
+    try {
+      // Build query string: uuids=123-xxx,124-yyy&tag=Appq_automated
+      const uuidsParam = unique.join(',');
+      const url = `/api/automation/testcases/tags/check?uuids=${encodeURIComponent(uuidsParam)}&tag=${encodeURIComponent(tag)}`;
+      const response = await this.http.get(url);
+
+      if (response.success && response.data) {
+        return {
+          needsTagging: response.data.needsTagging || [],
+          alreadyTagged: response.data.alreadyTagged || [],
+          errors: response.data.errors || []
+        };
+      }
+
+      throw new Error(response.error || 'Failed to check tag status');
+    } catch (error) {
+      logger.error('Failed to check tag status', {
+        error: error.message,
+        count: unique.length,
+        tag
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * Tag test cases
+   *
+   * @param {string[]} uuids - Array of test case UUIDs to tag
+   * @param {string} tagName - Tag name (optional, uses config default)
+   * @returns {Promise<Object>} { tagged: 0, failed: 0, errors: [] }
+   */
+  async tagTestCases(uuids, tagName = null) {
+    if (!uuids || uuids.length === 0) {
+      return { tagged: 0, failed: 0, errors: [] };
+    }
+
+    const tag = tagName || this.tagName;
+    const unique = Array.from(new Set(uuids.filter(Boolean)));
+
+    try {
+      const response = await this.http.post('/api/automation/testcases/tag', {
+        uuids: unique,
+        tag
+      });
+
+      if (response.success && response.data) {
+        return {
+          tagged: response.data.tagged || 0,
+          failed: response.data.failed || 0,
+          errors: response.data.errors || []
+        };
+      }
+
+      throw new Error(response.error || 'Failed to tag test cases');
+    } catch (error) {
+      logger.error('Failed to tag test cases', {
+        error: error.message,
+        count: unique.length,
+        tag
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * Auto-tag accepted results (main entry point)
+   *
+   * This is a fire-and-forget operation:
+   * 1. Check which UUIDs need tagging
+   * 2. Tag only those that don't have the tag yet
+   * 3. Process in batches for performance
+   * 4. Never throws - logs warnings on failure
+   *
+   * @param {string[]} acceptedUuids - UUIDs of accepted results
+   * @param {Object} options - Optional overrides
+   * @param {string} options.tagName - Custom tag name
+   * @returns {Promise<Object>} { tagged: 0, skipped: 0, failed: 0 }
+   */
+  async autoTagAcceptedResults(acceptedUuids = [], options = {}) {
+    // Safety checks
+    if (!this.enabled) {
+      logger.debug('Auto-tagging disabled');
+      return { tagged: 0, skipped: 0, failed: 0 };
+    }
+
+    if (!acceptedUuids || acceptedUuids.length === 0) {
+      return { tagged: 0, skipped: 0, failed: 0 };
+    }
+
+    // Deduplicate and filter
+    const unique = Array.from(new Set(acceptedUuids.filter(Boolean)));
+    if (unique.length === 0) {
+      return { tagged: 0, skipped: 0, failed: 0 };
+    }
+
+    const tag = options.tagName || this.tagName;
+
+    try {
+      logger.debug('Starting auto-tag process', { count: unique.length, tag });
+
+      // Step 1: Check which UUIDs need tagging
+      const statusCheck = await this.checkTagStatus(unique, tag);
+      const needsTagging = statusCheck.needsTagging || [];
+      const alreadyTagged = statusCheck.alreadyTagged || [];
+      logger.debug('Tag status check complete', {
+        needsTagging: needsTagging.length,
+        alreadyTagged: alreadyTagged.length,
+        errors: statusCheck.errors.length
+      });
+
+      if (needsTagging.length === 0) {
+        logger.debug('No test cases need tagging (all already tagged)');
+        return {
+          tagged: 0,
+          skipped: alreadyTagged.length,
+          failed: statusCheck.errors.length
+        };
+      }
+
+      // Step 2: Tag test cases (in batches if needed)
+      let totalTagged = 0;
+      let totalFailed = statusCheck.errors.length;
+
+      const batches = this.chunkArray(needsTagging, this.batchSize);
+
+      for (let i = 0; i < batches.length; i++) {
+        const batch = batches[i];
+
+        try {
+          const result = await this.tagTestCases(batch, tag);
+          totalTagged += result.tagged;
+          totalFailed += result.failed;
+
+          logger.debug(`Tagged batch ${i + 1}/${batches.length}`, {
+            tagged: result.tagged,
+            failed: result.failed
+          });
+        } catch (error) {
+          logger.warn(`Batch ${i + 1} tagging failed`, {
+            error: error.message,
+            batchSize: batch.length
+          });
+          totalFailed += batch.length;
+        }
+      }
+
+      const summary = {
+        tagged: totalTagged,
+        skipped: alreadyTagged.length,
+        failed: totalFailed
+      };
+
+      logger.info('Auto-tagging complete', summary);
+
+      return summary;
+    } catch (error) {
+      // Non-blocking: Log warning and continue
+      logger.warn('Auto-tagging failed (non-blocking)', {
+        error: error.message,
+        count: unique.length,
+        tag
+      });
+
+      return {
+        tagged: 0,
+        skipped: 0,
+        failed: unique.length
+      };
+    }
+  }
+
+  /**
+   * Fire-and-forget tagging for accepted UUIDs.
+   * Does not throw; logs warnings on failure.
+   *
+   * @deprecated Use autoTagAcceptedResults() instead
+   * @param {string[]} uuids
+   * @param {string} tagName
+   */
+  async tagAccepted(uuids = [], tagName) {
+    return this.autoTagAcceptedResults(uuids, { tagName });
+  }
+
+  /**
+   * 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;
+  }
+}
+
+module.exports = TaggingService;