@appliqation/automation-sdk 2.1.0

package/src/reporters/cypress/CypressReporter.js

@@ -0,0 +1,387 @@
+const AppliqationClient = require('../../AppliqationClient');
+const UuidExtractor = require('./UuidExtractor');
+const logger = require('../../utils/logger');
+
+/**
+ * Appliqation Reporter for Cypress
+ *
+ * Integrates with Cypress via setupNodeEvents hooks to automatically
+ * report test results to Appliqation platform.
+ *
+ * @example
+ * // cypress.config.js
+ * const { CypressReporter } = require('@appliqation/automation-sdk/cypress');
+ *
+ * module.exports = defineConfig({
+ *   e2e: {
+ *     setupNodeEvents(on, config) {
+ *       CypressReporter(on, {
+ *         baseUrl: process.env.APPLIQATION_BASE_URL,
+ *         apiKey: process.env.APPLIQATION_API_KEY,
+ *         projectKey: process.env.APPLIQATION_PROJECT_KEY,
+ *         scenarioId: parseInt(process.env.APPLIQATION_SCENARIO_ID),
+ *         environment: process.env.APPLIQATION_ENVIRONMENT || 'Local',
+ *         title: process.env.APPLIQATION_RUN_TITLE
+ *       });
+ *     }
+ *   }
+ * });
+ */
+class CypressReporter {
+  constructor(config) {
+    this.config = {
+      baseUrl: config.baseUrl,
+      apiKey: config.apiKey,
+      projectKey: config.projectKey,
+      scenarioId: config.scenarioId,
+      testSetId: config.testSetId,
+      environment: config.environment || 'Local',
+      title: config.title || process.env.APPLIQATION_RUN_TITLE,
+      autoCreateRun: config.autoCreateRun !== false,
+      logLevel: config.logLevel || 'info',
+      submitOrphans: config.submitOrphans !== false
+    };
+
+    // Validate required config
+    this.validateConfig();
+
+    // Set logger level
+    logger.setLevel(this.config.logLevel);
+
+    // Initialize Appliqation client
+    this.client = new AppliqationClient({
+      baseUrl: this.config.baseUrl,
+      apiKey: this.config.apiKey,
+      projectKey: this.config.projectKey,
+      title: this.config.title,
+      options: {
+        logLevel: this.config.logLevel
+      }
+    });
+
+    // Test result storage
+    this.testResults = [];
+    this.orphanTests = [];
+    this.runId = null;
+    this.runCreated = false;
+
+    logger.info('Appliqation Cypress Reporter initialized', {
+      environment: this.config.environment,
+      scenarioId: this.config.scenarioId,
+      autoCreateRun: this.config.autoCreateRun
+    });
+  }
+
+  /**
+   * Register Cypress event handlers
+   * @param {Object} on - Cypress event registration function
+   */
+  register(on) {
+    // Event: Before all specs run
+    on('before:run', async (details) => {
+      await this.onBeforeRun(details);
+    });
+
+    // Event: After each spec file completes
+    on('after:spec', async (spec, results) => {
+      await this.onAfterSpec(spec, results);
+    });
+
+    // Event: After all specs complete
+    on('after:run', async (results) => {
+      await this.onAfterRun(results);
+    });
+
+    logger.debug('Cypress event handlers registered');
+  }
+
+  /**
+   * Called before test run starts
+   */
+  async onBeforeRun(details) {
+    try {
+      logger.info('Cypress test run starting...', {
+        browser: details.browser?.displayName,
+        specs: details.specs?.length
+      });
+
+      if (this.config.autoCreateRun) {
+        await this.createRun(details);
+      }
+    } catch (error) {
+      logger.error('Error in before:run hook', { error: error.message });
+    }
+  }
+
+  /**
+   * Create Appliqation run matrix
+   */
+  async createRun(details) {
+    try {
+      const browser = details.browser?.displayName || details.browser?.name || 'Cypress';
+      const platform = details.system?.platform || process.platform;
+      const os = this.detectOS(platform);
+
+      const runOptions = {
+        scenarioId: this.config.scenarioId,
+        testSetId: this.config.testSetId,
+        environment: this.config.environment,
+        browsers: [browser],
+        device: 'Desktop',
+        os: os,
+        title: this.config.title || `Automation Run - ${new Date().toISOString()}`
+      };
+
+      logger.info('Creating run matrix...', runOptions);
+
+      const run = await this.client.createRun(runOptions);
+      this.runId = run.runId;
+      this.runCreated = true;
+
+      logger.info('Run matrix created successfully', {
+        runId: this.runId,
+        browser: browser
+      });
+    } catch (error) {
+      logger.error('Failed to create run matrix', { error: error.message });
+      throw error;
+    }
+  }
+
+  /**
+   * Called after each spec file completes
+   */
+  async onAfterSpec(spec, results) {
+    try {
+      logger.debug('Processing spec results', {
+        spec: spec.relative,
+        tests: results.tests?.length
+      });
+
+      if (!results.tests || results.tests.length === 0) {
+        return;
+      }
+
+      // Extract results from all tests in this spec
+      for (const test of results.tests) {
+        await this.processTest(test, results.stats.startedAt);
+      }
+    } catch (error) {
+      logger.error('Error processing spec results', {
+        spec: spec.relative,
+        error: error.message
+      });
+    }
+  }
+
+  /**
+   * Process individual test result
+   */
+  async processTest(test, startedAt) {
+    try {
+      // Extract UUID from test
+      const uuid = UuidExtractor.extractUuid(test);
+
+      if (!uuid) {
+        // Track orphan test
+        this.orphanTests.push({
+          title: test.title.join(' > '),
+          status: this.mapCypressStatus(test.state),
+          file: test.file || 'unknown',
+          timestamp: new Date().toISOString()
+        });
+
+        logger.warn('No UUID found for test', { title: test.title.join(' > ') });
+        return;
+      }
+
+      // Prepare result
+      const result = {
+        uuid: uuid,
+        runId: this.runId,
+        status: this.mapCypressStatus(test.state),
+        browser: 'Cypress',
+        environment: this.config.environment,
+        comment: this.buildComment(test),
+        parent_uuid: null // Cypress doesn't have nested tests like Playwright
+      };
+
+      this.testResults.push(result);
+
+      logger.debug('Test result prepared', {
+        uuid: uuid,
+        status: result.status,
+        title: test.title.join(' > ')
+      });
+    } catch (error) {
+      logger.error('Error processing test', {
+        title: test.title,
+        error: error.message
+      });
+    }
+  }
+
+  /**
+   * Called after all tests complete
+   */
+  async onAfterRun(results) {
+    try {
+      logger.info('Cypress test run completed', {
+        tests: this.testResults.length,
+        orphans: this.orphanTests.length
+      });
+
+      // Submit all test results
+      if (this.testResults.length > 0 && this.runId) {
+        await this.submitResults();
+      }
+
+      // Submit orphan tests
+      if (this.orphanTests.length > 0 && this.config.submitOrphans && this.runId) {
+        await this.submitOrphanTests();
+      }
+
+      // Print summary
+      this.printSummary(results);
+    } catch (error) {
+      logger.error('Error in after:run hook', { error: error.message });
+    }
+  }
+
+  /**
+   * Submit test results to Appliqation
+   */
+  async submitResults() {
+    try {
+      logger.info(`Submitting ${this.testResults.length} test results...`);
+
+      const summary = await this.client.submitBatch(this.testResults, {
+        batchSize: 50,
+        retryFailures: true
+      });
+
+      logger.info('Results submitted successfully', {
+        success: summary.success,
+        failed: summary.failed,
+        total: summary.total
+      });
+
+      return summary;
+    } catch (error) {
+      logger.error('Failed to submit results', { error: error.message });
+      throw error;
+    }
+  }
+
+  /**
+   * Submit orphan tests
+   */
+  async submitOrphanTests() {
+    try {
+      logger.info(`Logging ${this.orphanTests.length} orphan tests...`);
+
+      await this.client.logOrphanTests(this.runId, this.orphanTests);
+
+      logger.info('Orphan tests logged successfully');
+    } catch (error) {
+      logger.error('Failed to log orphan tests', { error: error.message });
+    }
+  }
+
+  /**
+   * Map Cypress test status to Appliqation status
+   */
+  mapCypressStatus(cypressStatus) {
+    const statusMap = {
+      'passed': 'passed',
+      'failed': 'failed',
+      'pending': 'skipped',
+      'skipped': 'skipped'
+    };
+
+    return statusMap[cypressStatus] || 'skipped';
+  }
+
+  /**
+   * Build comment from test details
+   */
+  buildComment(test) {
+    const comments = [];
+
+    if (test.displayError) {
+      comments.push(`Error: ${test.displayError}`);
+    }
+
+    if (test.duration) {
+      comments.push(`Duration: ${test.duration}ms`);
+    }
+
+    if (test.attempts && test.attempts.length > 1) {
+      comments.push(`Attempts: ${test.attempts.length}`);
+    }
+
+    return comments.length > 0 ? comments.join(' | ') : null;
+  }
+
+  /**
+   * Detect OS from platform
+   */
+  detectOS(platform) {
+    if (!platform) return 'Unknown';
+
+    const platformLower = platform.toLowerCase();
+
+    if (platformLower.includes('darwin')) return 'macOS';
+    if (platformLower.includes('win')) return 'Windows';
+    if (platformLower.includes('linux')) return 'Linux';
+
+    return platform;
+  }
+
+  /**
+   * Print test summary
+   */
+  printSummary(results) {
+    console.log('\n' + '='.repeat(60));
+    console.log('📊 Appliqation Cypress Reporter Summary');
+    console.log('='.repeat(60));
+    console.log(`Environment:     ${this.config.environment}`);
+    console.log(`Run ID:          ${this.runId || 'N/A'}`);
+    console.log(`Tests Submitted: ${this.testResults.length}`);
+    console.log(`Orphan Tests:    ${this.orphanTests.length}`);
+    console.log(`Total Tests:     ${results.totalTests || 0}`);
+    console.log(`Passed:          ${results.totalPassed || 0}`);
+    console.log(`Failed:          ${results.totalFailed || 0}`);
+    console.log(`Skipped:         ${results.totalSkipped || 0}`);
+    console.log('='.repeat(60) + '\n');
+  }
+
+  /**
+   * Validate configuration
+   */
+  validateConfig() {
+    const required = ['baseUrl', 'apiKey', 'projectKey'];
+    const missing = required.filter(key => !this.config[key]);
+
+    if (missing.length > 0) {
+      throw new Error(`Missing required config: ${missing.join(', ')}`);
+    }
+
+    // Note: scenarioId and testSetId are now optional
+    // If neither is provided, will default to 0 for generic automation runs
+  }
+}
+
+/**
+ * Factory function for Cypress setupNodeEvents
+ * @param {Object} on - Cypress event registration function
+ * @param {Object} config - Reporter configuration
+ */
+function setupCypressReporter(on, config) {
+  const reporter = new CypressReporter(config);
+  reporter.register(on);
+  return reporter;
+}
+
+module.exports = setupCypressReporter;
+module.exports.CypressReporter = CypressReporter;

package/src/reporters/cypress/UuidExtractor.js

@@ -0,0 +1,139 @@
+const UuidValidator = require('../../utils/UuidValidator');
+const logger = require('../../utils/logger');
+
+/**
+ * UUID Extractor for Cypress Tests
+ *
+ * Extracts Appliqation test case UUIDs from Cypress tests.
+ * Supports multiple UUID assignment methods.
+ */
+class UuidExtractor {
+  /**
+   * Extract UUID from Cypress test
+   *
+   * Supports multiple UUID formats:
+   * 1. Test config property: it('test', { uuid: '1154-...' }, () => {})
+   * 2. Test title with UUID: it('1154-... - should login', () => {})
+   * 3. Custom metadata (if available in future Cypress versions)
+   *
+   * @param {Object} test - Cypress test object
+   * @returns {string|null} - Extracted UUID or null
+   */
+  static extractUuid(test) {
+    try {
+      // Method 1: Check test config for uuid property
+      if (test.config && test.config.uuid) {
+        const uuid = test.config.uuid;
+        if (UuidValidator.validate(uuid)) {
+          logger.debug('UUID extracted from test config', { uuid });
+          return uuid;
+        }
+      }
+
+      // Method 2: Check test title for UUID
+      // Title can be array in Cypress (suite hierarchy)
+      const fullTitle = Array.isArray(test.title) ? test.title.join(' ') : test.title;
+
+      if (fullTitle) {
+        const uuidFromTitle = this.extractUuidFromString(fullTitle);
+        if (uuidFromTitle) {
+          logger.debug('UUID extracted from test title', { uuid: uuidFromTitle });
+          return uuidFromTitle;
+        }
+      }
+
+      // Method 3: Check individual title parts if it's an array
+      if (Array.isArray(test.title)) {
+        for (const titlePart of test.title) {
+          const uuidFromPart = this.extractUuidFromString(titlePart);
+          if (uuidFromPart) {
+            logger.debug('UUID extracted from title part', { uuid: uuidFromPart });
+            return uuidFromPart;
+          }
+        }
+      }
+
+      // No UUID found
+      return null;
+    } catch (error) {
+      logger.error('Error extracting UUID from Cypress test', {
+        error: error.message,
+        test: test.title
+      });
+      return null;
+    }
+  }
+
+  /**
+   * Extract UUID from string using regex pattern
+   *
+   * @param {string} str - String to search
+   * @returns {string|null} - Extracted UUID or null
+   */
+  static extractUuidFromString(str) {
+    if (!str || typeof str !== 'string') {
+      return null;
+    }
+
+    // Pattern: nid-uuid format (e.g., "1154-7a17b809-0ff9-4ba1-9322-4eb2a49abfc5")
+    const uuidPattern = /(\d+)-([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})/i;
+    const match = str.match(uuidPattern);
+
+    if (match && match[0]) {
+      const uuid = match[0];
+      if (UuidValidator.validate(uuid)) {
+        return uuid;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Extract all UUIDs from a collection of tests
+   *
+   * @param {Array} tests - Array of Cypress test objects
+   * @returns {Object} - { uuids: [...], orphans: [...] }
+   */
+  static extractFromTests(tests) {
+    const results = {
+      uuids: [],
+      orphans: []
+    };
+
+    if (!Array.isArray(tests)) {
+      return results;
+    }
+
+    for (const test of tests) {
+      const uuid = this.extractUuid(test);
+
+      if (uuid) {
+        results.uuids.push({
+          uuid: uuid,
+          test: test
+        });
+      } else {
+        results.orphans.push({
+          title: Array.isArray(test.title) ? test.title.join(' > ') : test.title,
+          test: test
+        });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Validate if test has a valid UUID
+   *
+   * @param {Object} test - Cypress test object
+   * @returns {boolean} - True if test has valid UUID
+   */
+  static hasValidUuid(test) {
+    const uuid = this.extractUuid(test);
+    return uuid !== null;
+  }
+}
+
+module.exports = UuidExtractor;

package/src/reporters/cypress/index.js

@@ -0,0 +1,30 @@
+/**
+ * Appliqation Cypress Reporter
+ *
+ * @example
+ * // cypress.config.js
+ * const { defineConfig } = require('cypress');
+ * const { CypressReporter } = require('@appliqation/automation-sdk/cypress');
+ *
+ * module.exports = defineConfig({
+ *   e2e: {
+ *     setupNodeEvents(on, config) {
+ *       CypressReporter(on, {
+ *         baseUrl: process.env.APPLIQATION_BASE_URL,
+ *         apiKey: process.env.APPLIQATION_API_KEY,
+ *         projectKey: process.env.APPLIQATION_PROJECT_KEY,
+ *         scenarioId: parseInt(process.env.APPLIQATION_SCENARIO_ID),
+ *         environment: process.env.APPLIQATION_ENVIRONMENT || 'Local',
+ *         title: process.env.APPLIQATION_RUN_TITLE
+ *       });
+ *     }
+ *   }
+ * });
+ */
+
+const CypressReporter = require('./CypressReporter');
+const UuidExtractor = require('./UuidExtractor');
+
+module.exports = CypressReporter;
+module.exports.CypressReporter = CypressReporter;
+module.exports.UuidExtractor = UuidExtractor;