@appliqation/automation-sdk 2.1.0

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

@@ -0,0 +1,290 @@
+const UuidValidator = require('../../../utils/UuidValidator');
+
+/**
+ * UUID Extractor for Playwright Tests
+ * Extracts Appliqation test UUIDs from various locations in Playwright test metadata
+ */
+class UuidExtractor {
+  /**
+   * Extract UUID from Playwright test
+   * Searches in order: test.id, test tags, test title, test annotations
+   * @param {Object} test - Playwright test object
+   * @returns {string|null} UUID or null if not found
+   */
+  static extractFromTest(test) {
+    if (!test) return null;
+
+    // 1. Check test.id directly (if user sets it)
+    if (test.id && UuidValidator.validate(test.id)) {
+      return test.id;
+    }
+
+    // 2. Check test tags (@uuid-123-xxx-xxx-xxx)
+    const tagUuid = this.extractFromTags(test.tags || []);
+    if (tagUuid) return tagUuid;
+
+    // 3. Check test title (extract UUID from title string)
+    const titleUuid = this.extractFromTitle(test.title);
+    if (titleUuid) return titleUuid;
+
+    // 4. Check test annotations
+    const annotationUuid = this.extractFromAnnotations(test.annotations || []);
+    if (annotationUuid) return annotationUuid;
+
+    // 5. Check test location (file path or test name)
+    const locationUuid = this.extractFromLocation(test.location);
+    if (locationUuid) return locationUuid;
+
+    return null;
+  }
+
+  /**
+   * Extract UUID from test tags
+   * Supports formats:
+   * - @uuid:123-xxx-xxx-xxx
+   * - @appliqation:123-xxx-xxx-xxx
+   * - @123-xxx-xxx-xxx
+   * @param {Array<string>} tags - Array of test tags
+   * @returns {string|null} UUID or null
+   */
+  static extractFromTags(tags) {
+    if (!Array.isArray(tags) || tags.length === 0) return null;
+
+    for (const tag of tags) {
+      if (!tag || typeof tag !== 'string') continue;
+
+      // Remove @ prefix if present
+      const cleanTag = tag.startsWith('@') ? tag.substring(1) : tag;
+
+      // Check for uuid: or appliqation: prefix
+      const prefixMatch = cleanTag.match(/^(?:uuid|appliqation):(.+)$/i);
+      if (prefixMatch) {
+        const uuid = prefixMatch[1];
+        if (UuidValidator.validate(uuid)) {
+          return uuid;
+        }
+      }
+
+      // Check if tag itself is a UUID
+      if (UuidValidator.validate(cleanTag)) {
+        return cleanTag;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Extract UUID from test title
+   * Supports formats:
+   * - "Test name [123-xxx-xxx-xxx]"
+   * - "Test name (123-xxx-xxx-xxx)"
+   * - "Test name | 123-xxx-xxx-xxx"
+   * - "123-xxx-xxx-xxx | Test name"
+   * @param {string} title - Test title
+   * @returns {string|null} UUID or null
+   */
+  static extractFromTitle(title) {
+    if (!title || typeof title !== 'string') return null;
+
+    // Pattern 1: [UUID] or (UUID) at the end
+    const bracketMatch = title.match(/[\[\(](\d+-[a-f0-9-]+)[\]\)]$/i);
+    if (bracketMatch && UuidValidator.validate(bracketMatch[1])) {
+      return bracketMatch[1];
+    }
+
+    // Pattern 2: | UUID or UUID | at the beginning or end
+    const pipeMatch = title.match(/(?:^|\|)\s*(\d+-[a-f0-9-]+)\s*(?:\||$)/i);
+    if (pipeMatch && UuidValidator.validate(pipeMatch[1])) {
+      return pipeMatch[1];
+    }
+
+    // Pattern 3: UUID anywhere in the string
+    const anywhereMatch = title.match(/\b(\d+-[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})\b/i);
+    if (anywhereMatch && UuidValidator.validate(anywhereMatch[1])) {
+      return anywhereMatch[1];
+    }
+
+    return null;
+  }
+
+  /**
+   * Extract UUID from test annotations
+   * Looks for annotations with type 'uuid' or 'appliqation'
+   * @param {Array<Object>} annotations - Array of annotation objects
+   * @returns {string|null} UUID or null
+   */
+  static extractFromAnnotations(annotations) {
+    if (!Array.isArray(annotations) || annotations.length === 0) return null;
+
+    for (const annotation of annotations) {
+      if (!annotation || typeof annotation !== 'object') continue;
+
+      // Check annotation type
+      if (annotation.type === 'uuid' || annotation.type === 'appliqation' || annotation.type === 'appliqation-uuid') {
+        const uuid = annotation.description || annotation.value;
+        if (uuid && UuidValidator.validate(uuid)) {
+          return uuid;
+        }
+      }
+
+      // Check annotation description for UUID
+      if (annotation.description) {
+        const uuid = this.extractFromTitle(annotation.description);
+        if (uuid) return uuid;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Extract UUID from test location (file path or test name)
+   * @param {Object} location - Test location object
+   * @returns {string|null} UUID or null
+   */
+  static extractFromLocation(location) {
+    if (!location || typeof location !== 'object') return null;
+
+    // Check file path for UUID
+    if (location.file) {
+      const fileMatch = location.file.match(/(\d+-[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})/i);
+      if (fileMatch && UuidValidator.validate(fileMatch[1])) {
+        return fileMatch[1];
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Extract all UUIDs from test suite (for parent-child relationships)
+   * @param {Object} test - Playwright test object
+   * @returns {Array<string>} Array of UUIDs (child first, parents after)
+   */
+  static extractHierarchy(test) {
+    const uuids = [];
+
+    if (!test) return uuids;
+
+    // Get current test UUID
+    const testUuid = this.extractFromTest(test);
+    if (testUuid) {
+      uuids.push(testUuid);
+    }
+
+    // Get parent suite UUIDs
+    let currentSuite = test.parent;
+    while (currentSuite) {
+      const suiteUuid = this.extractFromTest(currentSuite);
+      if (suiteUuid) {
+        uuids.push(suiteUuid);
+      }
+      currentSuite = currentSuite.parent;
+    }
+
+    return uuids;
+  }
+
+  /**
+   * Create orphan test entry from Playwright test
+   * @param {Object} test - Playwright test object
+   * @param {Object} result - Test result object
+   * @param {string} browser - Browser name
+   * @returns {Object} Orphan test entry
+   */
+  static createOrphanEntry(test, result, browser) {
+    return {
+      test_title: test.title || 'Unknown Test',
+      test_file: test.location?.file || 'unknown',
+      browser: browser || 'unknown',
+      timestamp: Math.floor(Date.now() / 1000),
+      reason: 'No UUID annotation found',
+      framework: 'playwright',
+      additional_info: {
+        projectName: test.parent?.project?.name,
+        duration: result?.duration,
+        status: result?.status,
+        tags: test.tags
+      }
+    };
+  }
+
+  /**
+   * Validate and extract UUID with detailed error info
+   * @param {Object} test - Playwright test object
+   * @returns {Object} { uuid, found, locations }
+   */
+  static extractWithDetails(test) {
+    const locations = {
+      id: false,
+      tags: false,
+      title: false,
+      annotations: false,
+      location: false
+    };
+
+    let uuid = null;
+
+    // Check all locations
+    if (test.id && UuidValidator.validate(test.id)) {
+      uuid = test.id;
+      locations.id = true;
+    }
+
+    if (!uuid) {
+      const tagUuid = this.extractFromTags(test.tags || []);
+      if (tagUuid) {
+        uuid = tagUuid;
+        locations.tags = true;
+      }
+    }
+
+    if (!uuid) {
+      const titleUuid = this.extractFromTitle(test.title);
+      if (titleUuid) {
+        uuid = titleUuid;
+        locations.title = true;
+      }
+    }
+
+    if (!uuid) {
+      const annotationUuid = this.extractFromAnnotations(test.annotations || []);
+      if (annotationUuid) {
+        uuid = annotationUuid;
+        locations.annotations = true;
+      }
+    }
+
+    if (!uuid) {
+      const locationUuid = this.extractFromLocation(test.location);
+      if (locationUuid) {
+        uuid = locationUuid;
+        locations.location = true;
+      }
+    }
+
+    return {
+      uuid,
+      found: uuid !== null,
+      locations
+    };
+  }
+
+  /**
+   * Get extraction suggestions for test without UUID
+   * @param {Object} test - Playwright test object
+   * @returns {Array<string>} Suggestions for adding UUID
+   */
+  static getSuggestions(test) {
+    const suggestions = [];
+
+    suggestions.push(`Add UUID as tag: test('${test.title}', { tag: '@uuid:123-xxx-...' }, async ({ page }) => { ... })`);
+    suggestions.push(`Add UUID in title: test('[123-xxx-...] ${test.title}', async ({ page }) => { ... })`);
+    suggestions.push(`Add UUID as annotation: test.use({ annotation: { type: 'uuid', description: '123-xxx-...' } })`);
+
+    return suggestions;
+  }
+}
+
+module.exports = UuidExtractor;

package/src/reporters/playwright/index.d.ts

@@ -0,0 +1,96 @@
+/**
+ * TypeScript definitions for @appliqation/automation-sdk/playwright
+ * @version 2.1.0
+ */
+
+import type {
+  Reporter,
+  FullConfig,
+  Suite,
+  TestCase,
+  TestResult,
+  FullResult
+} from '@playwright/test/reporter';
+
+import type { AppliqationConfig } from '../../index';
+
+// ============================================================================
+// Playwright Reporter Configuration
+// ============================================================================
+
+/**
+ * Configuration for the Appliqation Playwright Reporter
+ */
+export interface AppliqationReporterConfig extends AppliqationConfig {
+  /** Log level for reporter (default: 'INFO') */
+  logLevel?: 'ERROR' | 'WARN' | 'INFO' | 'DEBUG';
+
+  /** Log orphan tests without UUID mappings (default: true) */
+  logOrphans?: boolean;
+}
+
+// ============================================================================
+// Appliqation Playwright Reporter
+// ============================================================================
+
+/**
+ * Playwright reporter for Appliqation integration
+ *
+ * @example
+ * ```typescript
+ * // playwright.config.ts
+ * import { AppliqationReporter } from '@appliqation/automation-sdk/playwright';
+ *
+ * export default {
+ *   reporter: [
+ *     ['list'],
+ *     [AppliqationReporter, {
+ *       baseUrl: process.env.APPLIQATION_BASE_URL,
+ *       apiKey: process.env.APPLIQATION_API_KEY,
+ *       projectKey: process.env.APPLIQATION_PROJECT_KEY,
+ *       scenarioId: 0,
+ *       environment: 'Local',
+ *       logLevel: 'INFO'
+ *     }]
+ *   ]
+ * };
+ * ```
+ */
+export class AppliqationReporter implements Reporter {
+  /**
+   * Create a new Appliqation Playwright Reporter
+   * @param config - Reporter configuration
+   */
+  constructor(config: AppliqationReporterConfig);
+
+  /**
+   * Called once before running tests
+   */
+  onBegin(config: FullConfig, suite: Suite): Promise<void>;
+
+  /**
+   * Called after a test has been started
+   */
+  onTestBegin?(test: TestCase, result: TestResult): void;
+
+  /**
+   * Called after a test has been finished
+   */
+  onTestEnd?(test: TestCase, result: TestResult): void;
+
+  /**
+   * Called after all tests have been run
+   */
+  onEnd(result: FullResult): Promise<void>;
+
+  /**
+   * Process error
+   */
+  onError?(error: Error): void;
+}
+
+// ============================================================================
+// Exports
+// ============================================================================
+
+export default AppliqationReporter;

package/src/reporters/playwright/index.js

@@ -0,0 +1,14 @@
+/**
+ * Appliqation Playwright Reporter
+ * Main export for Playwright integration
+ */
+
+const AppliqationReporter = require('./AppliqationReporter');
+const UuidExtractor = require('./helpers/UuidExtractor');
+const DeviceOsDetector = require('./helpers/DeviceOsDetector');
+
+module.exports = AppliqationReporter;
+module.exports.AppliqationReporter = AppliqationReporter;
+module.exports.UuidExtractor = UuidExtractor;
+module.exports.DeviceOsDetector = DeviceOsDetector;
+module.exports.default = AppliqationReporter;

package/src/services/OrphanTestService.js

@@ -0,0 +1,74 @@
+const logger = require('../utils/logger');
+
+class OrphanTestService {
+  constructor(httpClient) {
+    this.http = httpClient;
+  }
+
+  /**
+   * Log orphan tests (tests without UUID mappings)
+   * @param {string} runId - Run ID
+   * @param {Array} orphanTests - Array of orphan test objects
+   * @returns {Promise<Object>} Response from server
+   */
+  async log(runId, orphanTests) {
+    if (!orphanTests || orphanTests.length === 0) {
+      logger.debug('No orphan tests to log');
+      return {
+        success: true,
+        logged: 0
+      };
+    }
+
+    try {
+      logger.info(`Logging ${orphanTests.length} orphan tests for run ${runId}`);
+
+      const payload = {
+        run_id: runId,
+        orphan_tests: orphanTests.map(test => ({
+          test_title: test.test_title || test.title || 'Unknown Test',
+          test_file: test.test_file || test.file || 'unknown',
+          browser: test.browser || 'unknown',
+          timestamp: test.timestamp || Math.floor(Date.now() / 1000),
+          reason: test.reason || 'No UUID annotation found',
+          framework: test.framework || 'unknown'
+        }))
+      };
+
+      const response = await this.http.post('/api/automation/orphan-tests', payload);
+
+      logger.info('Orphan tests logged successfully', {
+        runId,
+        count: response.logged || orphanTests.length
+      });
+
+      return response;
+    } catch (error) {
+      logger.error('Failed to log orphan tests', {
+        error: error.message,
+        runId,
+        count: orphanTests.length
+      });
+      throw new Error(`Failed to log orphan tests: ${error.message}`);
+    }
+  }
+
+  /**
+   * Create formatted orphan test entry
+   * @param {Object} test - Test object
+   * @param {string} reason - Reason for being orphaned
+   * @returns {Object} Formatted orphan test
+   */
+  createOrphanEntry(test, reason = 'No UUID annotation found') {
+    return {
+      test_title: test.title || test.name || 'Unknown Test',
+      test_file: test.file || test.location?.file || 'unknown',
+      browser: test.browser || 'unknown',
+      timestamp: Math.floor(Date.now() / 1000),
+      reason: reason,
+      framework: test.framework || 'unknown'
+    };
+  }
+}
+
+module.exports = OrphanTestService;