froth-webdriverio-framework 7.0.119-dev1.0 → 7.0.119-dev1.10

package/froth_configs/local/web.config.js

@@ -1,58 +1,163 @@
 module.exports = (bsCaps) => {
     const browserName = (bsCaps.browserName || 'chrome').toLowerCase();
-    //const browserVersion = bsCaps.browserVersion;
-
-    // Map browser names to their WebdriverIO services
-    const browserServiceMap = {
-        chrome: 'chromedriver',
-        firefox: 'geckodriver',
-        edge: 'edgedriver',
-        ie: 'iedriver',
-        'internet explorer': 'iedriver',
-        safari: 'safaridriver'
+
+    // Generate unique report directory using BROWSERSTACK_BUILD_NAME
+    const buildName = process.env.BROWSERSTACK_BUILD_NAME || 'local-build';
+    // Remove spaces and special characters from build name for folder name - use underscores
+    const cleanBuildName = buildName.replace(/[^a-zA-Z0-9_]/g, '_');
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T')[0]; // YYYY-MM-DD format
+    const uniqueReportDir = `./reports/allure/${cleanBuildName}-${timestamp}`;
+    
+    // Normalize browser names for WebDriver
+    const browserNameMap = {
+        chrome: 'chrome',
+        chromium: 'chrome',
+        firefox: 'firefox',
+        edge: 'MicrosoftEdge',
+        msedge: 'MicrosoftEdge',
+        'microsoft edge': 'MicrosoftEdge',
+        safari: 'safari',
+        ie: 'internet explorer',
+        'internet explorer': 'internet explorer',
+        'internet-explorer': 'internet explorer'
     };
 
-    const service = browserServiceMap[browserName] || 'chromedriver';
+    const normalizedBrowserName = browserNameMap[browserName] || 'chrome';
 
-    const config = {
-        services: [service]
-    };
+    // Configure browser-specific capabilities
+    let capabilities;
+    let service;
 
-    // Add browser-specific capabilities
-    if (browserName === 'chrome') {
-        config.capabilities = [{
+    if (normalizedBrowserName === 'chrome') {
+        capabilities = [{
             browserName: 'chrome',
             'goog:chromeOptions': {
-               // args: browserVersion ? [`--version=${browserVersion}`] : []
+                args: [
+                    '--no-sandbox',
+                    '--disable-dev-shm-usage',
+                    '--disable-gpu',
+                    '--disable-web-security',
+                    '--disable-features=VizDisplayCompositor'
+                ]
             }
         }];
-    } else if (browserName === 'firefox') {
-        config.capabilities = [{
+
+        // Use wdio-chromedriver-service - auto-downloads ChromeDriver at runtime
+        // No admin permission needed - downloads to node_modules/
+        service = ['chromedriver', {
+            // Automatically download ChromeDriver if not present
+            chromedriverOptions: {
+                // Check for ChromeDriver updates (set to false for faster startup)
+                checkForUpdates: true,
+                // Use latest ChromeDriver compatible with installed Chrome
+                // If false, uses version specified in package.json chromedriver dependency
+                autoDownload: true
+            }
+        }]
+
+    } else if (normalizedBrowserName === 'firefox') {
+        capabilities = [{
             browserName: 'firefox',
             'moz:firefoxOptions': {
-                // Add Firefox-specific options if needed
+                //args: ['-headless'],
+                prefs: {
+                    'dom.webdriver.enabled': false,
+                    'useAutomationExtension': false
+                }
             }
         }];
-    } else if (browserName === 'edge') {
-        config.capabilities = [{
-            browserName: 'MicrosoftEdge'
-        }];
-    } else if (browserName === 'safari') {
-        config.capabilities = [{
-            browserName: 'safari'
+
+        // Use wdio-geckodriver-service for Firefox
+        service = ['geckodriver', {
+            // Auto-download geckodriver if not present
+            geckodriverOptions: {
+                // Use the geckodriver from node_modules
+                // No need to download separately
+            }
         }];
-    } else if (browserName === 'ie' || browserName === 'internet explorer') {
-        config.capabilities = [{
-            browserName: 'internet explorer'
+    } else if (normalizedBrowserName === 'MicrosoftEdge') {
+        capabilities = [{
+            browserName: 'MicrosoftEdge',
+            'ms:edgeOptions': {
+                args: [
+                    '--no-sandbox',
+                    '--disable-dev-shm-usage',
+                    '--disable-gpu'
+                ]
+            }
         }];
+
+        // EdgeDriver is included with Edge browser - no download needed
+        service = ['edgedriver'];
+
     } else {
         // Default to Chrome for unsupported browsers
-        config.capabilities = [{
-            browserName: 'chrome'
+        capabilities = [{
+            browserName: 'chrome',
+            'goog:chromeOptions': {
+                args: ['--no-sandbox', '--disable-dev-shm-usage', '--disable-gpu']
+            }
+        }];
+
+        service = ['chromedriver', {
+            chromedriverOptions: {
+                checkForUpdates: true,
+                autoDownload: true
+            }
         }];
     }
 
-    console.log(`🌐 Local execution configured for: ${browserName}${browserVersion ? ` (v${browserVersion})` : ''} using service: ${service}`);
+    const config = {
+        // Use direct WebDriver connection without Selenium Grid/Hub
+        // Opens Chrome/Firefox directly - no selenium-server
+        protocol: 'webdriver',
+
+        // Auto-download drivers service + real-time screenshot service
+        services: [
+            ...(service.length > 0 ? [service] : []),
+            // Real-time screenshot capture (works even if execution stopped mid-way)
+            [require('../screenshot-service').ScreenshotService]
+        ],
+
+        capabilities: capabilities,
+
+        // Allure Reporter Configuration
+        reporters: [
+            ['allure', {
+                outputDir: uniqueReportDir,
+                disableWebdriverStepsReporting: false,  // Enable step reporting
+                disableWebdriverScreenshotsReporting: false,  // Enable automatic screenshot capture
+                useCucumberStepReporter: false,
+                disableMochaHooks: false,
+                allureCode: true,
+                captureAllureScreenshots: true
+            }]
+        ],
+
+        // Auto-generate report after execution completes
+        onComplete: async function(exitCode, config, capabilities, results) {
+            const { execSync } = require('child_process');
+            const nodePath = require('path');
+            try {
+                // Add a small delay to ensure Allure finishes writing all files
+                await new Promise(resolve => setTimeout(resolve, 1000));
+
+                // Resolve script path relative to framework package (works from any CWD)
+                const scriptPath = nodePath.resolve(__dirname, '../../allure-report-utils/generate-allure-report.js');
+
+                console.log('\n🎯 Generating Allure report...');
+                execSync(`node "${scriptPath}"`, { stdio: 'inherit', cwd: process.cwd() });
+                console.log('✅ Report generation complete!');
+            } catch (error) {
+                console.error('❌ Error generating report:', error.message);
+            }
+        }
+    };
+
+    console.log(`🌐 Local execution configured for: ${normalizedBrowserName}`);
+    console.log(`📦 Browser drivers will auto-download to node_modules/ (no admin permission needed)`);
+    console.log(`📊 Allure results will be saved in: ${uniqueReportDir}`);
+    console.log(`💡 Report will be generated automatically after execution completes`);
 
     return config;
-};
+};

package/froth_configs/screenshot-service.js

@@ -0,0 +1,157 @@
+/**
+ * Froth Screenshot Service for WebDriverIO
+ * Captures screenshots in REAL-TIME:
+ * - After each KEY ACTION (click, input, navigation) - no duplicates
+ * - After each TEST (afterTest) - final state per test
+ * - Works even if execution is stopped mid-way
+ * - Deduplicates identical screenshots to avoid clutter
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+class ScreenshotService {
+    constructor(options = {}) {
+        this.options = options;
+        this.screenshotDir = './allure-screenshots';
+        this.actionCounter = 0;
+        this.lastScreenshotHash = null;
+        this.lastActionTime = 0;
+    }
+
+    // Runs before test execution starts
+    async onPrepare() {
+        if (!fs.existsSync(this.screenshotDir)) {
+            fs.mkdirSync(this.screenshotDir, { recursive: true });
+        }
+        console.log('📸 Screenshot Service initialized - deduplicated real-time capture');
+    }
+
+    // Runs after EACH KEY ACTION - captures screenshot (with deduplication)
+    async afterCommand(commandName, args, result, error) {
+        // Only capture for local platform
+        if (process.env.PLATFORM !== 'local') {
+            return;
+        }
+
+        // Skip screenshot commands to avoid recursion
+        if (commandName === 'saveScreenshot' || commandName === 'takeScreenshot') {
+            return;
+        }
+
+        // ONLY capture these 3 key actions: navigation, click, input
+        const captureCommands = ['url', 'click', 'setValue'];
+
+        if (!captureCommands.includes(commandName)) {
+            return;
+        }
+
+        // Throttle: skip if last screenshot was less than 500ms ago (rapid commands)
+        const now = Date.now();
+        if (now - this.lastActionTime < 500) {
+            return;
+        }
+        this.lastActionTime = now;
+
+        try {
+            const allure = require('@wdio/allure-reporter').default;
+
+            // Take screenshot to memory (buffer) instead of file for dedup check
+            const screenshotBase64 = await browser.takeScreenshot();
+            const imageBuffer = Buffer.from(screenshotBase64, 'base64');
+
+            // Generate hash to detect duplicates
+            const hash = crypto.createHash('md5').update(imageBuffer).digest('hex');
+
+            // Skip if identical to last screenshot (duplicate)
+            if (hash === this.lastScreenshotHash) {
+                return;
+            }
+            this.lastScreenshotHash = hash;
+
+            this.actionCounter++;
+            const actionDesc = this.formatActionDescription(commandName, args);
+
+            // Save unique screenshot to file
+            const screenshotName = `action_${String(this.actionCounter).padStart(3, '0')}_${commandName}`;
+            const screenshotPath = path.join(this.screenshotDir, `${screenshotName}.png`);
+            fs.writeFileSync(screenshotPath, imageBuffer);
+
+            // Attach to Allure IMMEDIATELY (real-time)
+            allure.addAttachment(`📸 ${commandName} ${actionDesc}`.trim(), imageBuffer, 'image/png');
+        } catch (err) {
+            // Silent fail to avoid breaking tests
+        }
+    }
+
+    // Format action description for screenshot name
+    formatActionDescription(commandName, args) {
+        try {
+            if (commandName === 'url' && args && args[0]) {
+                const url = args[0].toString();
+                return `→ ${url.substring(0, 40)}`;
+            }
+            if (commandName === 'setValue' && args && args[1] !== undefined) {
+                return `(input "${args[1].toString().substring(0, 25)}")`;
+            }
+            if (commandName === 'addValue' && args && args[1] !== undefined) {
+                return `(added "${args[1].toString().substring(0, 25)}")`;
+            }
+            if (commandName === 'click' && args && args[0]) {
+                return `(${args[0].toString().substring(0, 40)})`;
+            }
+            return '';
+        } catch (e) {
+            return '';
+        }
+    }
+
+    // Runs after each test - captures final test screenshot
+    async afterTest(test, context, { error, result, passed, retries }) {
+        if (process.env.PLATFORM !== 'local') {
+            return;
+        }
+
+        try {
+            const allure = require('@wdio/allure-reporter').default;
+            const cleanTitle = test.title.replace(/[^a-zA-Z0-9]/g, '_');
+            const cleanParent = test.parent ? test.parent.replace(/[^a-zA-Z0-9]/g, '_') : 'test';
+
+            const status = passed ? 'success' : 'failure';
+
+            // Take screenshot to buffer
+            const screenshotBase64 = await browser.takeScreenshot();
+            const imageBuffer = Buffer.from(screenshotBase64, 'base64');
+
+            // Check for duplicate
+            const hash = crypto.createHash('md5').update(imageBuffer).digest('hex');
+            if (hash === this.lastScreenshotHash) {
+                // Reset for next test and skip
+                this.actionCounter = 0;
+                this.lastScreenshotHash = null;
+                return;
+            }
+
+            const screenshotName = `${cleanParent}_${cleanTitle}_${status}`;
+            const screenshotPath = path.join(this.screenshotDir, `${screenshotName}.png`);
+            fs.writeFileSync(screenshotPath, imageBuffer);
+
+            const attachmentName = passed ? '✅ Test Passed' : '❌ Test Failed';
+            allure.addAttachment(attachmentName, imageBuffer, 'image/png');
+            console.log(`📸 [Real-time] Test screenshot attached: ${status}`);
+
+            // Reset for next test
+            this.actionCounter = 0;
+            this.lastScreenshotHash = null;
+        } catch (error) {
+            console.error('❌ [Real-time] Error capturing test screenshot:', error.message);
+        }
+    }
+}
+
+// Export both as class and factory function
+module.exports = {
+    ScreenshotService,
+    default: () => new ScreenshotService()
+};

package/froth_configs/wdio.common.conf.js

@@ -63,5 +63,116 @@ if (PLATFORM === 'browserstack' || PLATFORM === 'browserstacklocal') {
 }
 
 
-exports.config = deepmerge(baseConfig, envConfig(bsCaps));
+// Debug logging
+console.log('=== CONFIG MERGE DEBUG ===');
+console.log('PLATFORM value:', PLATFORM);
+console.log('baseConfig.afterEach exists:', !!baseConfig.afterEach);
+console.log('envConfig type:', typeof envConfig);
+
+// Get the env config but don't merge yet
+const envConfigResult = envConfig(bsCaps);
+console.log('envConfigResult.afterEach exists:', !!envConfigResult.afterEach);
+
+// Merge the configs
+const finalConfig = deepmerge(baseConfig, envConfigResult);
+
+// Always preserve base config hooks for local platform
+if (PLATFORM === 'local' && baseConfig.afterEach) {
+  console.log('Preserving baseConfig.afterEach for local platform');
+  finalConfig.afterEach = baseConfig.afterEach;
+} else if (finalConfig.afterEach) {
+  console.log('Using envConfig afterEach');
+} else {
+  console.log('No afterEach hook found in any config');
+}
+
+console.log('finalConfig.afterEach type:', typeof finalConfig.afterEach);
+console.log('=== END CONFIG MERGE DEBUG ===');
+
+// Add onComplete hook to attach screenshots to test results
+const originalOnComplete = finalConfig.onComplete;
+finalConfig.onComplete = async function(exitCode, config, capabilities, results) {
+  console.log('🎯 Attaching screenshots to test results...');
+
+  try {
+    const fs = require('fs');
+    const path = require('path');
+
+    // Find the most recent Allure results directory (where screenshots are saved)
+    const reportsBaseDir = './reports/allure';
+    if (fs.existsSync(reportsBaseDir)) {
+      const dirs = fs.readdirSync(reportsBaseDir)
+        .map(file => path.join(reportsBaseDir, file))
+        .filter(file => fs.statSync(file).isDirectory())
+        .sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
+
+      if (dirs.length > 0) {
+        const latestDir = dirs[0];
+        console.log(`📁 Report directory: ${latestDir}`);
+
+        // Find screenshots saved directly in the report directory
+        const screenshots = fs.readdirSync(latestDir)
+          .filter(file => file.endsWith('.png'))
+          .map(file => path.join(latestDir, file));
+
+        console.log(`📸 Found ${screenshots.length} screenshots in report folder`);
+
+        // Find test result files
+        const resultFiles = fs.readdirSync(latestDir)
+          .filter(file => file.endsWith('-result.json'));
+
+        console.log(`📋 Found ${resultFiles.length} test result files`);
+
+          // Attach a screenshot to each test result
+          resultFiles.forEach((resultFile, index) => {
+            try {
+              const resultPath = path.join(latestDir, resultFile);
+              const resultData = JSON.parse(fs.readFileSync(resultPath, 'utf8'));
+
+              // Add screenshot attachment
+              if (screenshots.length > 0) {
+                const screenshotIndex = Math.min(index, screenshots.length - 1);
+                const screenshotPath = screenshots[screenshotIndex];
+                const screenshotBuffer = fs.readFileSync(screenshotPath);
+
+                // Create attachment in the Allure directory
+                const attachmentName = `screenshot-${index}.png`;
+                const attachmentPath = path.join(latestDir, attachmentName);
+
+                fs.writeFileSync(attachmentPath, screenshotBuffer);
+
+                // Add attachment reference to test result
+                if (!resultData.attachments) {
+                  resultData.attachments = [];
+                }
+
+                resultData.attachments.push({
+                  name: 'Screenshot',
+                  source: attachmentName,
+                  type: 'image/png'
+                });
+
+                // Write updated result file
+                fs.writeFileSync(resultPath, JSON.stringify(resultData, null, 2));
+                console.log(`✅ Attached screenshot to: ${resultFile}`);
+              }
+            } catch (error) {
+              console.error(`❌ Error processing ${resultFile}:`, error.message);
+            }
+          });
+
+          console.log(`✅ Attached ${resultFiles.length} screenshots to test results`);
+        }
+      }
+  } catch (error) {
+    console.error('❌ Error in onComplete screenshot attachment:', error.message);
+  }
+
+  // Call original onComplete if it exists
+  if (typeof originalOnComplete === 'function') {
+    await originalOnComplete(exitCode, config, capabilities, results);
+  }
+};
+
+exports.config = finalConfig;
 

package/package.json

@@ -1,51 +1,63 @@
-{ "name": "froth-webdriverio-framework",
-  "version": "7.0.119-dev1.0",
-  "readme": "WebdriverIO Integration",
-  "description": "WebdriverIO and BrowserStack App Automate",
-  "license": "MIT",
- 
-  "scripts": {
-    "lint": "eslint ."
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/RoboticoDigitalProjects/froth-webdriverio.git"
-  },
-  "keywords": [
-    "webdriverio",
-    "browserstack",
-    "appium"
-  ],
-  "dependencies": {
-
-    "@wdio/appium-service": "9.23.0",
-    "@wdio/browserstack-service": "9.23.0",
-    "@wdio/cli": "9.23.0",
-    "@wdio/local-runner": "9.23.0",
-    "@wdio/mocha-framework": "9.23.0",
-    "@wdio/spec-reporter": "^9.20.0",
-    "appium": "^3.1.2",
-    "appium-uiautomator2-driver": "^6.7.8",
-    "assert": "^2.1.0",
-    "axios": "1.14.0",
-    "browserstack-local": "^1.5.8",
-    "chai": "^6.2.2",
-    "crypto-js": "^4.2.0",
-    "deepmerge": "^4.3.1",
-    "ejs": "^4.0.1",
-    "expect-webdriverio": "^4.13.0",
-    "express": "^5.2.1",
-    "form-data": "^4.0.5",
-    "fs": "^0.0.1-security",
-    "js-yaml": "^4.1.1",
-    "mysql2": "^3.16.0",
-    "node-fetch": "^3.3.2",
-    "node-localstorage": "^3.0.5",
-    "randexp": "^0.5.3",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.9.3",
-
-    "vm": "^0.1.0"
-
-  }
+{
+    "name": "froth-webdriverio-framework",
+    "version": "7.0.119-dev1.10",
+    "readme": "WebdriverIO Integration",
+    "description": "WebdriverIO and BrowserStack App Automate",
+    "license": "MIT",
+    "bin": {
+        "froth-report": "allure-report-utils/froth-report.js"
+    },
+    "scripts": {
+        "lint": "eslint .",
+        "test": "npm run test:allure && npm run report:generate",
+        "test:allure": "wdio run froth_configs/local/web.config.js",
+        "report:generate": "node allure-report-utils/generate-allure-report.js",
+        "report:open": "node allure-report-utils/open-allure-report.js"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/RoboticoDigitalProjects/froth-webdriverio.git"
+    },
+    "keywords": [
+        "webdriverio",
+        "browserstack",
+        "appium"
+    ],
+    "dependencies": {
+        "@wdio/appium-service": "9.23.0",
+        "@wdio/browserstack-service": "9.23.0",
+        "@wdio/cli": "9.23.0",
+        "@wdio/local-runner": "9.23.0",
+        "@wdio/mocha-framework": "9.23.0",
+        "@wdio/selenium-standalone-service": "^8.14.0",
+        "@wdio/spec-reporter": "^9.20.0",
+        "@wdio/allure-reporter": "^9.20.0",
+        "allure-commandline": "^2.30.0",
+        "appium": "^3.1.2",
+        "appium-uiautomator2-driver": "^6.7.8",
+        "assert": "^2.1.0",
+        "axios": "1.14.0",
+        "browserstack-local": "^1.5.8",
+        "chai": "^6.2.2",
+        "chromedriver": "^149.0.4",
+        "crypto-js": "^4.2.0",
+        "deepmerge": "^4.3.1",
+        "ejs": "^4.0.1",
+        "expect-webdriverio": "^4.13.0",
+        "express": "^5.2.1",
+        "form-data": "^4.0.5",
+        "fs": "^0.0.1-security",
+        "geckodriver": "^4.5.0",
+        "js-yaml": "^4.1.1",
+        "mysql2": "^3.16.0",
+        "node-fetch": "^3.3.2",
+        "node-localstorage": "^3.0.5",
+        "randexp": "^0.5.3",
+        "ts-node": "^10.9.2",
+        "typescript": "^5.9.3",
+        "vm": "^0.1.0",
+        "wdio-chromedriver-service": "^8.1.1",
+        "wdio-geckodriver-service": "^5.0.2"
+    }
+   
 }