@appliqation/automation-sdk 2.1.0

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

@@ -0,0 +1,435 @@
+const os = require('os');
+const { normalizeBrowser, normalizeOS, normalizeDevice } = require('../../../utils/RunDataNormalizer');
+
+/**
+ * Device and OS Detector for Playwright Tests
+ * Detects device type and operating system from Playwright project configuration
+ */
+class DeviceOsDetector {
+  /**
+   * Detect device type from Playwright project
+   * @param {Object} project - Playwright project object
+   * @returns {string} Device type (Desktop, Mobile, Tablet)
+   */
+  static detectDevice(project) {
+    if (!project) return this.getDefaultDevice();
+
+    const name = (project.name || '').toLowerCase();
+    const userAgent = (project.use?.userAgent || '').toLowerCase();
+    const viewport = project.use?.viewport;
+    const isMobile = project.use?.isMobile;
+    const hasTouch = project.use?.hasTouch;
+
+    // Explicit mobile flag
+    if (isMobile === true) {
+      return normalizeDevice(this.detectMobileType(name, viewport));
+    }
+
+    // Check project name for device indicators
+    if (this.isMobileDevice(name)) {
+      return normalizeDevice(this.detectMobileType(name, viewport));
+    }
+
+    if (this.isTabletDevice(name)) {
+      return normalizeDevice('Tablet');
+    }
+
+    // Check user agent
+    if (userAgent) {
+      if (this.isMobileUserAgent(userAgent)) {
+        return normalizeDevice(this.detectMobileType(userAgent, viewport));
+      }
+      if (this.isTabletUserAgent(userAgent)) {
+        return normalizeDevice('Tablet');
+      }
+    }
+
+    // Check viewport size
+    if (viewport) {
+      if (this.isTabletViewport(viewport)) {
+        return normalizeDevice('Tablet');
+      }
+      if (this.isMobileViewport(viewport)) {
+        return normalizeDevice('Mobile');
+      }
+    }
+
+    // Check touch capability
+    if (hasTouch === true && viewport && this.isMobileViewport(viewport)) {
+      return normalizeDevice('Mobile');
+    }
+
+    return normalizeDevice('Desktop');
+  }
+
+  /**
+   * Detect mobile type (Mobile vs Tablet)
+   * @param {string} identifier - Name or user agent
+   * @param {Object} viewport - Viewport dimensions
+   * @returns {string} 'Mobile' or 'Tablet'
+   */
+  static detectMobileType(identifier, viewport) {
+    const lower = (identifier || '').toLowerCase();
+
+    // Explicit tablet indicators
+    if (lower.includes('tablet') || lower.includes('ipad')) {
+      return 'Tablet';
+    }
+
+    // Check viewport if available
+    if (viewport) {
+      if (this.isTabletViewport(viewport)) {
+        return 'Tablet';
+      }
+    }
+
+    return 'Mobile';
+  }
+
+  /**
+   * Check if name indicates mobile device
+   * @param {string} name - Project name
+   * @returns {boolean} True if mobile
+   */
+  static isMobileDevice(name) {
+    const mobileKeywords = [
+      'mobile', 'iphone', 'android', 'pixel', 'galaxy',
+      'xiaomi', 'huawei', 'moto', 'nexus', 'oneplus'
+    ];
+
+    return mobileKeywords.some(keyword => name.includes(keyword));
+  }
+
+  /**
+   * Check if name indicates tablet device
+   * @param {string} name - Project name
+   * @returns {boolean} True if tablet
+   */
+  static isTabletDevice(name) {
+    const tabletKeywords = [
+      'tablet', 'ipad', 'galaxy tab', 'kindle', 'surface'
+    ];
+
+    return tabletKeywords.some(keyword => name.includes(keyword));
+  }
+
+  /**
+   * Check if user agent indicates mobile
+   * @param {string} userAgent - User agent string
+   * @returns {boolean} True if mobile
+   */
+  static isMobileUserAgent(userAgent) {
+    const mobilePatterns = [
+      /mobile/i,
+      /android/i,
+      /iphone/i,
+      /ipod/i,
+      /blackberry/i,
+      /windows phone/i
+    ];
+
+    return mobilePatterns.some(pattern => pattern.test(userAgent));
+  }
+
+  /**
+   * Check if user agent indicates tablet
+   * @param {string} userAgent - User agent string
+   * @returns {boolean} True if tablet
+   */
+  static isTabletUserAgent(userAgent) {
+    const tabletPatterns = [
+      /ipad/i,
+      /tablet/i,
+      /kindle/i,
+      /playbook/i
+    ];
+
+    return tabletPatterns.some(pattern => pattern.test(userAgent));
+  }
+
+  /**
+   * Check if viewport is mobile size
+   * @param {Object} viewport - Viewport object with width/height
+   * @returns {boolean} True if mobile size
+   */
+  static isMobileViewport(viewport) {
+    if (!viewport || !viewport.width) return false;
+
+    // Typical mobile viewport width: 320-480px
+    return viewport.width >= 320 && viewport.width <= 480;
+  }
+
+  /**
+   * Check if viewport is tablet size
+   * @param {Object} viewport - Viewport object with width/height
+   * @returns {boolean} True if tablet size
+   */
+  static isTabletViewport(viewport) {
+    if (!viewport || !viewport.width) return false;
+
+    // Typical tablet viewport width: 768-1024px
+    return viewport.width >= 600 && viewport.width <= 1024;
+  }
+
+  /**
+   * Detect OS from Playwright project
+   * @param {Object} project - Playwright project object
+   * @returns {string} Operating system name
+   */
+  static detectOS(project) {
+    if (!project) return normalizeOS(this.getSystemOS());
+
+    // Priority 1: Check metadata.os for explicit OS specification
+    const explicitOS = project.use?.metadata?.os;
+    if (explicitOS && typeof explicitOS === 'string') {
+      return normalizeOS(explicitOS);
+    }
+
+    const name = (project.name || '').toLowerCase();
+    const userAgent = (project.use?.userAgent || '').toLowerCase();
+
+    // Priority 2: Check project name for OS indicators
+    const osFromName = this.extractOSFromName(name);
+    if (osFromName) return normalizeOS(osFromName);
+
+    // Priority 3: Check user agent for OS indicators
+    const osFromUA = this.extractOSFromUserAgent(userAgent);
+    if (osFromUA) return normalizeOS(osFromUA);
+
+    // Fallback to system OS
+    return normalizeOS(this.getSystemOS());
+  }
+
+  /**
+   * Extract OS from project name
+   * @param {string} name - Project name
+   * @returns {string|null} OS name or null
+   */
+  static extractOSFromName(name) {
+    const osMap = {
+      'windows7': 'Windows',
+      'win7': 'Windows',
+      'windows11': 'Windows',
+      'win11': 'Windows',
+      'windows10': 'Windows',
+      'win10': 'Windows',
+      'windows': 'Windows',
+      'macos': 'macOS',
+      'mac': 'macOS',
+      'darwin': 'macOS',
+      'linux': 'Linux',
+      'ubuntu': 'Ubuntu',
+      'android': 'Android',
+      'ios': 'macOS',
+      'iphone': 'macOS',
+      'ipad': 'macOS'
+    };
+
+    for (const [keyword, os] of Object.entries(osMap)) {
+      if (name.includes(keyword)) {
+        return os;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Extract OS from user agent
+   * @param {string} userAgent - User agent string
+   * @returns {string|null} OS name or null
+   */
+  static extractOSFromUserAgent(userAgent) {
+    if (!userAgent) return null;
+
+    if (/windows/i.test(userAgent)) return 'Windows';
+    if (/mac os x/i.test(userAgent)) return 'macOS';
+    if (/macintosh/i.test(userAgent)) return 'macOS';
+    if (/android/i.test(userAgent)) return 'Android';
+    if (/ipad|iphone|ipod/i.test(userAgent)) return 'macOS';
+    if (/linux/i.test(userAgent)) return 'Linux';
+    if (/ubuntu/i.test(userAgent)) return 'Ubuntu';
+
+    return null;
+  }
+
+  /**
+   * Get system OS
+   * @returns {string} Current system OS
+   */
+  static getSystemOS() {
+    const platform = os.platform();
+    const release = os.release();
+
+    const osMap = {
+      'win32': this.getWindowsVersion(release),
+      'darwin': 'macOS',
+      'linux': 'Linux'
+    };
+
+    return osMap[platform] || 'Unknown';
+  }
+
+  /**
+   * Get Windows version from release
+   * @param {string} release - OS release string
+   * @returns {string} Windows version (generic, will be normalized)
+   */
+  static getWindowsVersion(release) {
+    // Return generic Windows - let normalizer handle version details
+    return 'Windows';
+  }
+
+  /**
+   * Get default device type
+   * @returns {string} Default device type
+   */
+  static getDefaultDevice() {
+    return normalizeDevice('Desktop');
+  }
+
+  /**
+   * Detect browser from Playwright project
+   * @param {Object} project - Playwright project object
+   * @param {Object} browserInstance - Optional Playwright browser instance for version detection
+   * @returns {string} Browser name (normalized)
+   */
+  static detectBrowser(project, browserInstance = null) {
+    if (!project) return normalizeBrowser('Chromium');
+
+    // Check browserName property FIRST (takes precedence over project name)
+    // This allows explicit browser version strings like "chrome142" or "safari 18.7.2"
+    const browserName = project.use?.browserName;
+    let browserVersion = project.use?.metadata?.browserVersion;
+
+    // Auto-detect browser version if browser instance provided and no manual version
+    if (!browserVersion && browserInstance) {
+      browserVersion = this.extractBrowserVersion(browserInstance);
+    }
+
+    if (browserName) {
+      const browserMap = {
+        'chromium': 'Chrome',
+        'firefox': 'Firefox',
+        'webkit': 'Safari'
+      };
+      // Map standard Playwright names to browser names
+      const mapped = browserMap[browserName.toLowerCase()] || browserName;
+
+      // If metadata.browserVersion is provided OR auto-detected, append it before normalization
+      // This allows: { browserName: 'chromium', metadata: { browserVersion: '142' } }
+      // or auto-detected from browser.version()
+      // to become "Chrome 142"
+      const browserWithVersion = browserVersion ? `${mapped} ${browserVersion}` : mapped;
+
+      return normalizeBrowser(browserWithVersion);
+    }
+
+    // Fallback: Check project name for browser
+    const name = (project.name || '').toLowerCase();
+    if (name.includes('chrome') || name.includes('chromium')) {
+      return normalizeBrowser('Chrome');
+    }
+    if (name.includes('firefox') || name.includes('ff')) {
+      return normalizeBrowser('Firefox');
+    }
+    if (name.includes('webkit') || name.includes('safari')) {
+      return normalizeBrowser('Safari');
+    }
+    if (name.includes('edge')) {
+      return normalizeBrowser('Edge');
+    }
+
+    // Default
+    return normalizeBrowser('Chrome');
+  }
+
+  /**
+   * Extract browser version from Playwright browser instance
+   * @param {Object} browserInstance - Playwright browser instance
+   * @returns {string|null} Major version number or null
+   */
+  static extractBrowserVersion(browserInstance) {
+    try {
+      // Check if browser instance has version() method
+      if (!browserInstance || typeof browserInstance.version !== 'function') {
+        return null;
+      }
+
+      // Note: browser.version() is synchronous in Playwright
+      const fullVersion = browserInstance.version();
+
+      if (!fullVersion || typeof fullVersion !== 'string') {
+        return null;
+      }
+
+      // Extract major version (e.g., "140.0.6778.44" -> "140")
+      const versionMatch = fullVersion.match(/^(\d+)/);
+      if (versionMatch && versionMatch[1]) {
+        return versionMatch[1];
+      }
+
+      return null;
+    } catch (error) {
+      // Silently fail - version detection is optional
+      return null;
+    }
+  }
+
+  /**
+   * Get complete device info from Playwright project
+   * @param {Object} project - Playwright project object
+   * @param {Object} browserInstance - Optional Playwright browser instance for version detection
+   * @returns {Object} { device, os, browser }
+   */
+  static getDeviceInfo(project, browserInstance = null) {
+    return {
+      device: this.detectDevice(project),
+      os: this.detectOS(project),
+      browser: this.detectBrowser(project, browserInstance)
+    };
+  }
+
+  /**
+   * Get device/OS matrix configurations from Playwright config
+   * Splits multi-project configs into separate run matrices
+   * @param {Array} projects - Array of Playwright project objects
+   * @returns {Array} Array of unique device/OS combinations
+   */
+  static getMatrixConfigurations(projects) {
+    if (!Array.isArray(projects) || projects.length === 0) {
+      return [{
+        device: this.getDefaultDevice(),
+        os: this.getSystemOS(),
+        browsers: ['Chrome']
+      }];
+    }
+
+    const configurations = new Map();
+
+    for (const project of projects) {
+      const device = this.detectDevice(project);
+      const os = this.detectOS(project);
+      const browser = this.detectBrowser(project);
+
+      const key = `${device}-${os}`;
+
+      if (!configurations.has(key)) {
+        configurations.set(key, {
+          device,
+          os,
+          browsers: []
+        });
+      }
+
+      const config = configurations.get(key);
+      if (!config.browsers.includes(browser)) {
+        config.browsers.push(browser);
+      }
+    }
+
+    return Array.from(configurations.values());
+  }
+}
+
+module.exports = DeviceOsDetector;