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

package/allure-report-utils/generate-allure-report.js

@@ -0,0 +1,167 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+/**
+ * Generate Allure HTML report automatically after test execution
+ * Uses BROWSERSTACK_BUILD_NAME environment variable for report naming
+ */
+
+const REPORTS_DIR = './reports/allure';
+const OUTPUT_DIR = './allure-report';
+
+function findLatestReportDir() {
+    if (!fs.existsSync(REPORTS_DIR)) {
+        console.log('❌ No Allure reports directory found.');
+        console.log('💡 Reports are generated in: ./reports/allure/');
+        return null;
+    }
+
+    const directories = fs.readdirSync(REPORTS_DIR)
+        .map(file => path.join(REPORTS_DIR, file))
+        .filter(file => {
+            const stat = fs.statSync(file);
+            return stat.isDirectory();
+        })
+        .sort((a, b) => {
+            // Sort by modification time, newest first
+            return fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs;
+        });
+
+    return directories.length > 0 ? directories[0] : null;
+}
+
+function generateAllureReport(reportDir) {
+    try {
+        console.log('🎯 Allure Report Generator');
+        console.log('================================\n');
+        console.log(`📁 Using results from: ${reportDir}`);
+        console.log(`🏷️  Build Name: ${process.env.BROWSERSTACK_BUILD_NAME || 'local-build'}\n`);
+
+        // Get directory name and extract build name (remove timestamp)
+        const dirName = path.basename(reportDir);
+        const timestampIndex = dirName.lastIndexOf('-');
+        const buildName = timestampIndex > 0 ? dirName.substring(0, timestampIndex) : dirName;
+
+        // Generate HTML report folder named after build name
+        const reportFolderName = buildName + '_report';
+        const outputDir = path.join(reportDir, reportFolderName);
+
+        // Clean existing report directory if it exists
+        if (fs.existsSync(outputDir)) {
+            console.log('🧹 Cleaning existing report directory...');
+            fs.rmSync(outputDir, { recursive: true, force: true });
+        }
+
+        // Generate Allure HTML report
+        console.log('📊 Generating Allure HTML report...');
+        console.log(`📂 Report folder: ${reportFolderName}\n`);
+        const historyPath = path.join(reportDir, 'history');
+
+        let command = `npx allure generate ${reportDir} -o ${outputDir} --clean`;
+
+        // Add history if available
+        if (fs.existsSync(historyPath)) {
+            command = `npx allure generate ${reportDir} -o ${outputDir} --clean --history ${historyPath}`;
+        }
+
+        execSync(command, { stdio: 'inherit' });
+
+        // Create a simple server start script in the report folder
+        const startScriptPath = path.join(outputDir, 'start-server.sh');
+        const startScriptContent = `#!/bin/bash
+echo "🌐 Starting Allure Report Server..."
+echo "📁 Report: ${outputDir}"
+echo "🔗 Open: http://localhost:8080"
+echo ""
+echo "Press Ctrl+C to stop the server"
+echo ""
+npx allure open "${outputDir}" --port 8080
+`;
+        fs.writeFileSync(startScriptPath, startScriptContent, { mode: 0o755 });
+
+        // Create a Windows batch file
+        const batchScriptPath = path.join(outputDir, 'start-server.bat');
+        const batchScriptContent = `@echo off
+echo 🌐 Starting Allure Report Server...
+echo 📁 Report: ${outputDir}
+echo 🔗 Open: http://localhost:8080
+echo.
+echo Press Ctrl+C to stop the server
+echo.
+npx allure open "${outputDir}" --port 8080
+`;
+        fs.writeFileSync(batchScriptPath, batchScriptContent);
+
+        // Create a README
+        const readmePath = path.join(outputDir, 'README.md');
+        const readmeContent = `# Allure Test Report
+
+## 🌐 How to View This Report
+
+### Option 1: Double-click the start script (Easiest)
+- **Mac/Linux:** Double-click \`start-server.sh\`
+- **Windows:** Double-click \`start-server.bat\`
+- Report will open at: http://localhost:8080
+
+### Option 2: Use npm script
+From the project root, run:
+\`\`\`bash
+npm run report:open
+\`\`\`
+
+### Option 3: Manual command
+\`\`\`bash
+npx allure open "${outputDir}" --port 8080
+\`\`\`
+
+## ❗ Why can't I just open index.html?
+
+Allure reports use JavaScript to dynamically load test data from JSON files.
+When you open index.html directly (file:// protocol), browsers block this for security reasons (CORS).
+
+You need a web server to view the report properly - that's what the start scripts do!
+
+## 📊 Test Results
+
+- **Build Name:** ${process.env.BROWSERSTACK_BUILD_NAME || 'local-build'}
+- **Generated:** ${new Date().toISOString()}
+- **Report Location:** ${outputDir}
+`;
+
+        fs.writeFileSync(readmePath, readmeContent);
+
+        console.log('\n✅ Allure report generated successfully!');
+        console.log(`📍 Location: ${path.resolve(outputDir)}`);
+        console.log(`📂 Results directory: ${path.resolve(reportDir)}`);
+        console.log('\n🌐 To view the report:');
+        console.log('   1. Run: npx froth-report open');
+        console.log('   2. Or double-click: start-server.sh (Mac/Linux) / start-server.bat (Windows)');
+        console.log('   3. Report opens at: http://localhost:8080');
+        console.log('\n💡 Press Ctrl+C to stop the server when done viewing.');
+
+        return true;
+    } catch (error) {
+        console.error(`❌ Error generating report: ${error.message}`);
+        return false;
+    }
+}
+
+function main() {
+    const reportDir = findLatestReportDir();
+
+    if (!reportDir) {
+        console.log('❌ No Allure results found. Please run tests first.');
+        console.log('💡 Results are saved in: ./reports/allure/');
+        process.exit(1);
+    }
+
+    generateAllureReport(reportDir);
+}
+
+// Run the script
+if (require.main === module) {
+    main();
+}
+
+module.exports = { generateAllureReport, findLatestReportDir };

package/allure-report-utils/open-allure-report.js

@@ -0,0 +1,97 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+/**
+ * Find and open the latest Allure HTML report
+ */
+
+const REPORTS_DIR = './reports/allure';
+
+function findLatestReport() {
+    if (!fs.existsSync(REPORTS_DIR)) {
+        console.log('❌ No Allure reports directory found.');
+        console.log('💡 Reports are generated in: ./reports/allure/');
+        return null;
+    }
+
+    const directories = fs.readdirSync(REPORTS_DIR)
+        .map(file => path.join(REPORTS_DIR, file))
+        .filter(file => fs.statSync(file).isDirectory())
+        .filter(file => {
+            // Check if any subdirectory ending with _report exists
+            const subdirs = fs.readdirSync(file)
+                .map(sub => path.join(file, sub))
+                .filter(sub => {
+                    const stat = fs.statSync(sub);
+                    return stat.isDirectory() && path.basename(sub).endsWith('_report');
+                });
+            return subdirs.length > 0;
+        })
+        .sort((a, b) => {
+            return fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs;
+        });
+
+    return directories.length > 0 ? directories[0] : null;
+}
+
+function openReport(reportDir) {
+    // Find the report folder ending with _report
+    const reportSubdirs = fs.readdirSync(reportDir)
+        .map(sub => path.join(reportDir, sub))
+        .filter(sub => {
+            const stat = fs.statSync(sub);
+            return stat.isDirectory() && path.basename(sub).endsWith('_report');
+        });
+
+    if (reportSubdirs.length === 0) {
+        console.log('❌ No HTML report found in:', reportDir);
+        return false;
+    }
+
+    const htmlReportPath = reportSubdirs[0];
+    const indexPath = path.join(htmlReportPath, 'index.html');
+
+    if (!fs.existsSync(indexPath)) {
+        console.log('❌ No index.html found at:', indexPath);
+        return false;
+    }
+
+    try {
+        console.log('🎯 Opening Allure Report');
+        console.log('========================\n');
+        console.log(`📁 Report location: ${htmlReportPath}`);
+        console.log(`🏷️  Build: ${path.basename(reportDir)}\n`);
+
+        // Use Allure CLI to open the report
+        console.log('🌐 Opening report in browser on http://localhost:8080');
+        console.log('💡 Press Ctrl+C to stop the server\n');
+
+        execSync(`npx allure open ${htmlReportPath} --port 8080`, { stdio: 'inherit' });
+
+        return true;
+    } catch (error) {
+        console.error(`❌ Error opening report: ${error.message}`);
+        console.log(`\n💡 To view manually, open: file://${path.resolve(indexPath)}`);
+        return false;
+    }
+}
+
+function main() {
+    const reportDir = findLatestReport();
+
+    if (!reportDir) {
+        console.log('❌ No Allure HTML reports found. Please run tests first.');
+        console.log('💡 Reports are generated in: ./reports/allure/');
+        process.exit(1);
+    }
+
+    openReport(reportDir);
+}
+
+// Run the script
+if (require.main === module) {
+    main();
+}
+
+module.exports = { findLatestReport, openReport };

package/froth_configs/base.config.js

@@ -11,13 +11,11 @@ module.exports = {
     specs: require(SUITE_FILE).tests,
     exclude: [],
 
-
     logLevel: 'info',
     coloredLogs: true,
     screenshotPath: './errorShots/',
     baseUrl: '',
 
-
     waitforTimeout: 90000,
     connectionRetryTimeout: 90000,
     connectionRetryCount: 3,
@@ -27,5 +25,51 @@ module.exports = {
     mochaOpts: {
         ui: 'bdd',
         timeout: 300000
+    },
+
+    // Enable screenshot capture for Allure (WDIO built-in)
+    screenshotOnSave: true,
+
+    // Test hooks
+    before: async function() {
+        console.log('🔧 BEFORE hook triggered in base config');
+    },
+
+    // Capture final screenshot directly in the report folder
+    after: async function(results) {
+        console.log('🔧 AFTER hook triggered in base config');
+
+        // Only process if running locally
+        if (process.env.PLATFORM === 'local') {
+            try {
+                const fs = require('fs');
+                const nodePath = require('path');
+
+                // Find the most recent Allure results directory
+                const reportsBaseDir = './reports/allure';
+                if (fs.existsSync(reportsBaseDir)) {
+                    const dirs = fs.readdirSync(reportsBaseDir)
+                        .map(file => nodePath.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}`);
+
+                        // Save final screenshot directly to the report directory
+                        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+                        const screenshotName = `Test_Suite_Completion_${timestamp}.png`;
+                        const screenshotPath = nodePath.join(latestDir, screenshotName);
+
+                        console.log(`📸 Saving final screenshot directly to report: ${screenshotName}`);
+                        await browser.saveScreenshot(screenshotPath);
+                        console.log(`✅ Screenshot saved in report folder: ${screenshotName}`);
+                    }
+                }
+            } catch (error) {
+                console.error('❌ Error saving screenshot to report folder:', error.message);
+            }
+        }
     }
-};
+};

package/froth_configs/commonhook.js

@@ -90,6 +90,52 @@ async function pushComment(msg) {
   if (!global.TEST_COMMENTS) global.TEST_COMMENTS = [];
   global.TEST_COMMENTS.push(msg);
 }
+
+/* ----------------- AUTO REPORT GENERATION ----------------- */
+async function generateLocalReport() {
+  try {
+    const buildName = process.env.BROWSERSTACK_BUILD_NAME || 'local-build';
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T')[0];
+    const reportDir = `./reports/mochawesome/${buildName}-${timestamp}`;
+    const jsonFile = path.join(process.cwd(), reportDir, 'mochawesome.json');
+
+    // Check if JSON report exists
+    if (!fs.existsSync(jsonFile)) {
+      console.log(`⚠️  No JSON report found at: ${jsonFile}`);
+      console.log('💡 Skipping report generation. Ensure tests ran successfully.');
+      return;
+    }
+
+    console.log(`📊 Generating HTML report from: ${jsonFile}`);
+
+    // Use marge to generate HTML report
+    const { execSync } = require('child_process');
+    execSync(`npx marge "${jsonFile}" -o "${reportDir}"`, {
+      stdio: 'inherit',
+      cwd: process.cwd()
+    });
+
+    const htmlFile = path.join(reportDir, 'mochawesome.html');
+    console.log(`✅ HTML report generated successfully!`);
+    console.log(`📍 Location: ${htmlFile}`);
+
+    // Auto-open report in browser
+    if (fs.existsSync(htmlFile)) {
+      console.log(`🌐 Opening report in browser...`);
+      try {
+        const openCommand = process.platform === 'darwin' ? 'open' :
+                           process.platform === 'win32' ? 'start' :
+                           'xdg-open';
+        execSync(`${openCommand} "${htmlFile}"`, { stdio: 'ignore' });
+      } catch (error) {
+        console.log(`💡 To view report manually, open: ${htmlFile}`);
+      }
+    }
+  } catch (error) {
+    console.error(`❌ Error generating local report: ${error.message}`);
+    // Don't fail the entire process if report generation fails
+  }
+}
 /* ------------------ COMMON CONFIG ------------------ */
 
 const commonHooks = {
@@ -348,6 +394,13 @@ const commonHooks = {
 
     await safeUpdateExecution();
     BUFFER.clear();
+
+    // Auto-generate HTML report for local execution
+    if (process.env.PLATFORM === 'local') {
+      console.log('📊 Generating local test report...');
+      await generateLocalReport();
+    }
+
     return exitCode;
   },
 

package/froth_configs/local/mobile.config.js

@@ -1,11 +1,59 @@
-module.exports = () => ({
-    services: ['appium'],
+module.exports = () => {
+    // Generate unique report directory using BROWSERSTACK_BUILD_NAME
+    const buildName = process.env.BROWSERSTACK_BUILD_NAME || 'local-mobile-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}`;
 
+    console.log(`📱 Mobile local execution configured`);
+    console.log(`📊 Allure results will be saved in: ${uniqueReportDir}`);
+    console.log(`💡 Report will be generated automatically after execution completes`);
 
-    capabilities: [{
-        platformName: 'Android',
-        'appium:deviceName': 'Android Emulator',
-        'appium:automationName': 'UiAutomator2',
-        'appium:app': process.env.LOCAL_APP_PATH
-    }]
-});
+    return {
+        services: [
+            'appium',
+            // Real-time screenshot capture (works even if execution stopped mid-way)
+            [require('../screenshot-service').ScreenshotService]
+        ],
+
+        capabilities: [{
+            platformName: 'Android',
+            'appium:deviceName': 'Android Emulator',
+            'appium:automationName': 'UiAutomator2',
+            'appium:app': process.env.LOCAL_APP_PATH
+        }],
+
+        // 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);
+            }
+        }
+    };
+};