@appliqation/automation-sdk 2.2.0 → 2.3.1

package/src/services/RunMatrixService.js

@@ -320,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

@@ -1,43 +1,240 @@
 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;
   }
 
   /**
-   * Fire-and-forget tagging for accepted UUIDs.
-   * Does not throw; logs warnings on failure.
-   * @param {string[]} uuids
-   * @param {string} tagName
+   * Check if tagging is enabled
+   * @returns {boolean}
    */
-  async tagAccepted(uuids = [], tagName) {
-    if (!uuids || uuids.length === 0) return;
+  isEnabled() {
+    return this.enabled;
+  }
 
-    if (this.config?.options?.enableAppq === false) {
-      return;
+  /**
+   * 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)));
-    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 {
+      // 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 {
-      await this.http.post(endpoint, {
+      const response = await this.http.post('/api/automation/testcases/tag', {
         uuids: unique,
         tag
       });
-      logger.debug('Tagging submitted for accepted results', { count: unique.length, 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.warn('Failed to tag accepted results (non-blocking)', {
+      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;
   }
 }