@appliqation/automation-sdk 2.1.0

package/src/reporters/jest/JestReporter.js

@@ -0,0 +1,361 @@
+const AppliqationClient = require('../../AppliqationClient');
+const UuidExtractor = require('./UuidExtractor');
+const logger = require('../../utils/logger');
+
+/**
+ * Appliqation Reporter for Jest
+ *
+ * Custom Jest reporter that automatically reports test results
+ * to the Appliqation platform.
+ *
+ * @example
+ * // jest.config.js
+ * const { JestReporter } = require('@appliqation/automation-sdk/jest');
+ *
+ * module.exports = {
+ *   reporters: [
+ *     'default',
+ *     [JestReporter, {
+ *       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 JestReporter {
+  constructor(globalConfig, options) {
+    this.globalConfig = globalConfig;
+    this.config = {
+      baseUrl: options.baseUrl,
+      apiKey: options.apiKey,
+      projectKey: options.projectKey,
+      scenarioId: options.scenarioId,
+      testSetId: options.testSetId,
+      environment: options.environment || 'Local',
+      title: options.title || process.env.APPLIQATION_RUN_TITLE,
+      autoCreateRun: options.autoCreateRun !== false,
+      logLevel: options.logLevel || 'info',
+      submitOrphans: options.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 Jest Reporter initialized', {
+      environment: this.config.environment,
+      scenarioId: this.config.scenarioId,
+      autoCreateRun: this.config.autoCreateRun
+    });
+  }
+
+  /**
+   * Called once at the start of the test run
+   */
+  async onRunStart(results, options) {
+    try {
+      logger.info('Jest test run starting...', {
+        numTotalTestSuites: results.numTotalTestSuites
+      });
+
+      if (this.config.autoCreateRun) {
+        await this.createRun();
+      }
+    } catch (error) {
+      logger.error('Error in onRunStart', { error: error.message });
+    }
+  }
+
+  /**
+   * Create Appliqation run matrix
+   */
+  async createRun() {
+    try {
+      const os = this.detectOS();
+
+      const runOptions = {
+        scenarioId: this.config.scenarioId,
+        testSetId: this.config.testSetId,
+        environment: this.config.environment,
+        browsers: ['Node.js'],
+        device: 'Server',
+        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
+      });
+    } catch (error) {
+      logger.error('Failed to create run matrix', { error: error.message });
+      throw error;
+    }
+  }
+
+  /**
+   * Called after each test file completes
+   */
+  async onTestFileResult(test, testResult, results) {
+    try {
+      logger.debug('Processing test file results', {
+        testFilePath: testResult.testFilePath,
+        numTests: testResult.testResults.length
+      });
+
+      // Process all tests in this file
+      for (const result of testResult.testResults) {
+        await this.processTestResult(result, testResult);
+      }
+    } catch (error) {
+      logger.error('Error processing test file results', {
+        error: error.message,
+        file: testResult.testFilePath
+      });
+    }
+  }
+
+  /**
+   * Process individual test result
+   */
+  async processTestResult(testResult, fileResult) {
+    try {
+      // Extract UUID from test
+      const uuid = UuidExtractor.extractUuid(testResult);
+
+      if (!uuid) {
+        // Track orphan test
+        this.orphanTests.push({
+          title: testResult.fullName || testResult.title,
+          status: this.mapJestStatus(testResult.status),
+          file: fileResult.testFilePath,
+          timestamp: new Date().toISOString()
+        });
+
+        logger.warn('No UUID found for test', {
+          title: testResult.fullName || testResult.title
+        });
+        return;
+      }
+
+      // Prepare result
+      const result = {
+        uuid: uuid,
+        runId: this.runId,
+        status: this.mapJestStatus(testResult.status),
+        browser: 'Jest',
+        environment: this.config.environment,
+        comment: this.buildComment(testResult),
+        parent_uuid: null // Jest doesn't have nested tests in the same way
+      };
+
+      this.testResults.push(result);
+
+      logger.debug('Test result prepared', {
+        uuid: uuid,
+        status: result.status,
+        title: testResult.fullName
+      });
+    } catch (error) {
+      logger.error('Error processing test result', {
+        title: testResult.fullName,
+        error: error.message
+      });
+    }
+  }
+
+  /**
+   * Called after all tests complete
+   */
+  async onRunComplete(contexts, results) {
+    try {
+      logger.info('Jest test run completed', {
+        tests: this.testResults.length,
+        orphans: this.orphanTests.length,
+        numTotalTests: results.numTotalTests,
+        numPassedTests: results.numPassedTests,
+        numFailedTests: results.numFailedTests
+      });
+
+      // 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 onRunComplete', { 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 Jest test status to Appliqation status
+   */
+  mapJestStatus(jestStatus) {
+    const statusMap = {
+      'passed': 'passed',
+      'failed': 'failed',
+      'skipped': 'skipped',
+      'pending': 'skipped',
+      'todo': 'skipped',
+      'disabled': 'skipped'
+    };
+
+    return statusMap[jestStatus] || 'skipped';
+  }
+
+  /**
+   * Build comment from test details
+   */
+  buildComment(testResult) {
+    const comments = [];
+
+    if (testResult.failureMessages && testResult.failureMessages.length > 0) {
+      // Get first failure message (Jest can have multiple)
+      const errorMsg = testResult.failureMessages[0];
+      // Truncate to first 200 chars to avoid too long comments
+      const truncated = errorMsg.substring(0, 200);
+      comments.push(`Error: ${truncated}${errorMsg.length > 200 ? '...' : ''}`);
+    }
+
+    if (testResult.duration) {
+      comments.push(`Duration: ${testResult.duration}ms`);
+    }
+
+    if (testResult.numPassingAsserts) {
+      comments.push(`Assertions: ${testResult.numPassingAsserts}`);
+    }
+
+    return comments.length > 0 ? comments.join(' | ') : null;
+  }
+
+  /**
+   * Detect OS
+   */
+  detectOS() {
+    const platform = process.platform;
+
+    if (platform === 'darwin') return 'macOS';
+    if (platform === 'win32') return 'Windows';
+    if (platform === 'linux') return 'Linux';
+
+    return platform;
+  }
+
+  /**
+   * Print test summary
+   */
+  printSummary(results) {
+    console.log('\n' + '='.repeat(60));
+    console.log('📊 Appliqation Jest 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.numTotalTests}`);
+    console.log(`Passed:          ${results.numPassedTests}`);
+    console.log(`Failed:          ${results.numFailedTests}`);
+    console.log(`Skipped:         ${results.numPendingTests}`);
+    console.log(`Duration:        ${(results.startTime && ((Date.now() - results.startTime) / 1000).toFixed(2))}s`);
+    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
+  }
+
+  /**
+   * Get last error (Jest API requirement)
+   */
+  getLastError() {
+    return this.lastError;
+  }
+}
+
+module.exports = JestReporter;

package/src/reporters/jest/UuidExtractor.js

@@ -0,0 +1,174 @@
+const UuidValidator = require('../../utils/UuidValidator');
+const logger = require('../../utils/logger');
+
+/**
+ * UUID Extractor for Jest Tests
+ *
+ * Extracts Appliqation test case UUIDs from Jest tests.
+ * Supports multiple UUID assignment methods.
+ */
+class UuidExtractor {
+  /**
+   * Extract UUID from Jest test result
+   *
+   * Supports multiple UUID formats:
+   * 1. Test title with UUID prefix: test('1154-... - should login', () => {})
+   * 2. Docblock with @uuid tag: /** @uuid 1154-... *\/
+   * 3. Custom test metadata (if available)
+   *
+   * @param {Object} testResult - Jest test result object
+   * @returns {string|null} - Extracted UUID or null
+   */
+  static extractUuid(testResult) {
+    try {
+      // Method 1: Extract from test title/fullName
+      const fullName = testResult.fullName || testResult.title;
+      if (fullName) {
+        const uuidFromTitle = this.extractUuidFromString(fullName);
+        if (uuidFromTitle) {
+          logger.debug('UUID extracted from test title', { uuid: uuidFromTitle });
+          return uuidFromTitle;
+        }
+      }
+
+      // Method 2: Extract from ancestorTitles + title
+      if (testResult.ancestorTitles && testResult.title) {
+        const combinedTitle = [...testResult.ancestorTitles, testResult.title].join(' ');
+        const uuidFromCombined = this.extractUuidFromString(combinedTitle);
+        if (uuidFromCombined) {
+          logger.debug('UUID extracted from combined titles', { uuid: uuidFromCombined });
+          return uuidFromCombined;
+        }
+      }
+
+      // Method 3: Check each ancestor title individually
+      if (testResult.ancestorTitles) {
+        for (const ancestorTitle of testResult.ancestorTitles) {
+          const uuidFromAncestor = this.extractUuidFromString(ancestorTitle);
+          if (uuidFromAncestor) {
+            logger.debug('UUID extracted from ancestor title', { uuid: uuidFromAncestor });
+            return uuidFromAncestor;
+          }
+        }
+      }
+
+      // Method 4: Check test title alone
+      if (testResult.title) {
+        const uuidFromTestTitle = this.extractUuidFromString(testResult.title);
+        if (uuidFromTestTitle) {
+          logger.debug('UUID extracted from test title alone', { uuid: uuidFromTestTitle });
+          return uuidFromTestTitle;
+        }
+      }
+
+      // No UUID found
+      return null;
+    } catch (error) {
+      logger.error('Error extracting UUID from Jest test', {
+        error: error.message,
+        test: testResult.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 UUID from Jest docblock comment
+   *
+   * Example: /** @uuid 1154-7a17b809-0ff9-4ba1-9322-4eb2a49abfc5 *\/
+   *
+   * @param {string} docblock - Docblock comment string
+   * @returns {string|null} - Extracted UUID or null
+   */
+  static extractUuidFromDocblock(docblock) {
+    if (!docblock || typeof docblock !== 'string') {
+      return null;
+    }
+
+    // Pattern: @uuid tag in docblock
+    const docblockPattern = /@uuid\s+(\d+-[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})/i;
+    const match = docblock.match(docblockPattern);
+
+    if (match && match[1]) {
+      const uuid = match[1];
+      if (UuidValidator.validate(uuid)) {
+        return uuid;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Extract all UUIDs from a collection of tests
+   *
+   * @param {Array} testResults - Array of Jest test result objects
+   * @returns {Object} - { uuids: [...], orphans: [...] }
+   */
+  static extractFromTests(testResults) {
+    const results = {
+      uuids: [],
+      orphans: []
+    };
+
+    if (!Array.isArray(testResults)) {
+      return results;
+    }
+
+    for (const testResult of testResults) {
+      const uuid = this.extractUuid(testResult);
+
+      if (uuid) {
+        results.uuids.push({
+          uuid: uuid,
+          test: testResult
+        });
+      } else {
+        results.orphans.push({
+          title: testResult.fullName || testResult.title,
+          test: testResult
+        });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Validate if test has a valid UUID
+   *
+   * @param {Object} testResult - Jest test result object
+   * @returns {boolean} - True if test has valid UUID
+   */
+  static hasValidUuid(testResult) {
+    const uuid = this.extractUuid(testResult);
+    return uuid !== null;
+  }
+}
+
+module.exports = UuidExtractor;

package/src/reporters/jest/index.js

@@ -0,0 +1,28 @@
+/**
+ * Appliqation Jest Reporter
+ *
+ * @example
+ * // jest.config.js
+ * const { JestReporter } = require('@appliqation/automation-sdk/jest');
+ *
+ * module.exports = {
+ *   reporters: [
+ *     'default',
+ *     [JestReporter, {
+ *       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 JestReporter = require('./JestReporter');
+const UuidExtractor = require('./UuidExtractor');
+
+module.exports = JestReporter;
+module.exports.JestReporter = JestReporter;
+module.exports.UuidExtractor = UuidExtractor;