froth-webdriverio-framework 7.0.119-dev1.7 → 7.0.119-dev1.9

package/README.md

@@ -0,0 +1,245 @@
+# README.md
+
+## Project Overview
+
+**Version:** 9.0.5-ytlc
+
+**Repository:** https://github.com/RoboticoDigitalProjects/froth-webdriverio.git
+
+This is a WebdriverIO test automation framework (FROTH - "froth-webdriverio-framework") that supports web, Android, and iOS testing on both BrowserStack and local environments. The framework integrates with a Froth TestOps backend API for execution tracking, reporting, and test data management.
+
+## Commands
+
+### Running Tests
+
+Tests are run using the WebdriverIO CLI. The framework uses `wdio.common.conf.js` directly without requiring platform-specific config files.
+
+```bash
+# Lint code
+npm run lint
+```
+
+### Viewing Test Results
+
+#### Local Execution Reports (Automatic)
+
+When running tests with `PLATFORM=local`, the framework **automatically generates Mochawesome HTML reports** after test execution completes:
+
+- Reports are saved in: `./reports/mochawesome/`
+- Each execution gets a **unique report directory** using `BROWSERSTACK_BUILD_NAME` and timestamp
+- Format: `./reports/mochawesome/{BUILD_NAME}-{YYYY-MM-DD}/mochawesome.html`
+- Reports **auto-open in browser** after generation
+
+**Example:**
+```bash
+# Run tests with unique build name
+BROWSERSTACK_BUILD_NAME="Web_Login_Test_20250619" \
+PLATFORM=local \
+YML_NAME="./ymls/browserstack/web/TOASTER_CHECK.yml" \
+SUITE="./web_suites/Login_RD.js" \
+npx wdio ./froth_configs/wdio.common.conf.js
+
+# ✅ Report generates automatically after execution completes!
+# 📍 Location: ./reports/mochawesome/Web_Login_Test_20250619-2025-06-19/mochawesome.html
+```
+
+**Manual report generation (if needed):**
+```bash
+# Generate latest report manually
+npm run generate:report
+
+# Generate all available reports
+npm run generate:report:all
+```
+
+#### BrowserStack Execution Reports
+
+For BrowserStack execution, test results are tracked via the Froth TestOps API. The framework automatically:
+- Updates execution status for each test script
+- Calculates total execution time
+- Posts results back to TestOps via `updateScriptExecutionStatus` and `updateExecuitonDetails`
+- Tracks BrowserStack session information
+
+View detailed results and execution logs in your Froth TestOps dashboard using the `EXECUTION_ID`.
+
+### Running Tests
+
+Tests are run by specifying environment variables and the config file:
+
+**Local execution (using BrowserStack from local machine):**
+
+```bash
+EXECUTION_ID=12995 \
+ORGANISATION_DOMAIN_URL='https://api.frothtestops.com' \
+BROWSERSTACK_BUILD_NAME="Web_Build- api-module-testing_2345_20260619" \
+PLATFORM=local \
+YML_NAME="./ymls/browserstack/web/TOASTER_CHECK.yml" \
+SUITE="./web_suites/Login_RD.js" \
+API_TOKEN="" \
+CICD_RUN_ID=1 \
+npx wdio ./froth_configs/wdio.common.conf.js
+```
+
+**BrowserStack execution:**
+
+```bash
+SUITE=./android_suites/samplesuite_x.js \
+YML_NAME=./ymls/browserstack/android/android_pixel8.yml \
+PLATFORM=browserstack \
+EXECUTION_ID=123 \
+API_TOKEN=your_token \
+ORGANISATION_DOMAIN_URL=https://api.frothtestops.com \
+npx wdio ./froth_configs/wdio.common.conf.js
+```
+
+## Architecture
+
+### Configuration Hierarchy
+
+The framework uses a multi-layered configuration system:
+
+1. __Base Configuration__ (`froth_configs/base.config.js`): Contains framework settings, specs path, timeouts, and Mocha options. Initializes a global `BUFFER` using `node-localstorage` for cross-module state sharing.
+2. __Common Configuration__ (`froth_configs/wdio.common.conf.js`): Acts as the entry point. It:
+
+   - Loads capabilities from a YAML file specified by `YML_NAME`
+   - Decodes BrowserStack credentials from base64
+   - Determines platform (web vs mobile) based on `platformName` in capabilities
+   - Merges base config with platform-specific config
+
+3. __Platform-Specific Configs__ (`froth_configs/browserstack/` and `froth_configs/local/`):
+
+   - `web.config.js`: BrowserStack web testing configuration
+   - `mobile.config.js`: BrowserStack mobile (Android/iOS) testing configuration
+   - Supports `BS_UPLOAD_MEDIA` for injecting media files into tests
+
+### Test Lifecycle and Hooks
+
+All test lifecycle hooks are defined in `froth_configs/commonhook.js`:
+
+- **onPrepare**: Initializes environment variables, execution details, suite details, and test data via `setallDatailinBuffer.js`. Registers global error handlers.
+- **beforeSession**: Validates test syntax, configures BrowserStack capabilities, sets app path for mobile testing
+- **beforeSuite**: Fetches BrowserStack session details, updates CICD run ID
+- **beforeTest/afterTest**: Updates individual script execution status via API
+- **afterSession**: Calculates total execution time, updates final execution status
+- **onComplete**: Clears the BUFFER storage
+
+### Directory Structure
+
+```ini
+froth_common_actions/     # Reusable test utilities and actions
+  ├── Utils.js            # Central export point for all utilities
+  ├── scroll.js           # Scrolling helpers (scrollToEnd, scrollDownToView, etc.)
+  ├── swipe.js            # Gesture helpers (swipeUp, swipeDown, swipeWithCoordinates)
+  ├── click.js            # Click helpers (clickIfVisible, doubleClick)
+  ├── assert.js           # Assertion helpers (assertText, assertAttributeValue)
+  ├── random.js           # Random data generators (RANDOMTEXT, RNDNUMBER, etc.)
+  ├── storeToBuffer.js    # Buffer storage helpers for runtime data
+  ├── dbValidator.js      # Database field validation
+  └── ...                 # Other common actions
+
+froth_api_calls/          # API integration layer
+  ├── loginapi.js         # Authentication token retrieval
+  ├── getexecutionDetails.js   # Fetch/update execution details via TestOps API
+  ├── getsuiteDetails.js  # Fetch test suite and script mappings
+  ├── readTestdata.js     # Fetch test data by ID
+  └── browsersatckSessionInfo.js # BrowserStack session management
+
+froth_configs/            # Configuration files
+  ├── base.config.js
+  ├── wdio.common.conf.js
+  ├── commonhook.js
+  ├── setallDatailinBuffer.js
+  ├── browserstack/       # BrowserStack-specific configs
+  └── local/              # Local execution configs
+
+android/                  # Android test scripts
+android_suites/           # Android suite definitions (array of test files)
+web/                      # Web test scripts
+web_suites/               # Web suite definitions
+ymls/browserstack/        # Capability YAML files for different devices/browsers
+```
+
+### Test Data Flow
+
+1. Environment variables are loaded in `setallDatailinBuffer.js` during `onPrepare`
+2. Global state is stored in `BUFFER` (node-localstorage at `./buffer_storage`)
+3. Execution details are fetched from the Froth TestOps API
+4. Test scripts access data via `BUFFER.getItem()` / `BUFFER.setItem()`
+5. Results are posted back to the API via `updateScriptExecutionStatus` and `updateExecuitonDetails`
+
+### Test Suite Pattern
+
+Suites are defined as simple modules exporting a `tests` array:
+
+```javascript
+// Example: android_suites/samplesuite_x.js
+module.exports = {
+    tests: [
+        '/absolute/path/to/android/test_script.js'
+    ]
+};
+```
+
+### Common Actions Usage
+
+Tests import utilities from the Utils export:
+
+```javascript
+const Util = require('../froth_common_actions/Utils');
+
+// Scrolling
+await Util.scrollToEnd(2, 3);
+await Util.scrollDownToView("Some Text");
+
+// Swiping
+await Util.swipeWithCoordinates(x1, y1, x2, y2);
+
+// Random data
+const randomText = Util.randomtext(10);
+const randomNumber = Util.randomnumber(100, 999);
+
+// Buffer storage
+Util.storetext('key', 'value');
+const value = BUFFER.getItem('key');
+```
+
+## Required Environment Variables
+
+| Variable | Description | Example |
+|----------|-------------|---------|
+| `YML_NAME` | Path to capability YAML file | `./ymls/browserstack/android/android_pixel8.yml` |
+| `SUITE` | Path to suite file | `./android_suites/samplesuite_x.js` |
+| `PLATFORM` | `local` for local execution, `browserstack` or `browserstacklocal` for BrowserStack | `local` or `browserstack` |
+| `EXECUTION_ID` | Test execution ID from TestOps | `12995` |
+| `API_TOKEN` | Authentication token for TestOps API | `eyJhbG...` |
+| `ORGANISATION_DOMAIN_URL` | Froth TestOps API base URL | `https://api.frothtestops.com` |
+| `CICD_RUN_ID` | CI/CD pipeline run ID (optional) | `1` |
+| `BROWSERSTACK_BUILD_NAME` | Build name for BrowserStack session tracking | `Web_Build- api-module-testing_2345_20260619` |
+| `BS_UPLOAD_MEDIA` | Comma-separated media URLs for BrowserStack (optional) | `url1,url2` |
+
+## Capability YAML Format
+
+YAML files define device/browser capabilities. Example for Android:
+
+```yaml
+userName: "bs_username"
+accessKey: "base64_encoded_key"
+platformName: "Android"
+deviceName: "Samsung Galaxy S22 Ultra"
+platformVersion: "12.0"
+debug: true
+networkLogs: true
+interactiveDebugging: false
+```
+
+## Important Notes
+
+- The framework uses `node-localstorage` to create a global `BUFFER` accessible across all modules
+- All API responses from TestOps are AES-decrypted via `aesEncryptionDecryption.js`
+- Test scripts map to TestOps via filename (script name must match `scriptName` in suite details)
+- Mobile tests use Appium selectors like `id:com.example:id/elementId` and `-android uiautomator:...`
+- Web tests use standard WebdriverIO selectors (`$`, `$$`)
+- Framework supports both BrowserStack App Automate (mobile) and Automate (web) sessions
+- **PLATFORM variable:**
+   - Use `PLATFORM=local` when executing tests from your local machine (even when targeting BrowserStack devices)
+   - Use `PLATFORM=browserstack` or `PLATFORM=browserstacklocal` when running from BrowserStack infrastructure

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

@@ -0,0 +1,226 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Allure Helper Utility for WebDriverIO
+ * Provides methods to add steps, screenshots, and attachments to Allure reports
+ */
+
+class AllureHelper {
+    /**
+     * Add a step to the Allure report
+     * @param {string} name - Step name
+     * @param {Function} stepFn - Step function to execute
+     */
+    static async step(name, stepFn) {
+        const allure = require('@wdio/allure-reporter').default;
+
+        console.log(`📝 Step: ${name}`);
+
+        // Create a step in Allure
+        allure.startStep(name);
+
+        try {
+            // Execute the step function
+            await stepFn();
+            allure.endStep('passed');
+        } catch (error) {
+            allure.endStep('failed');
+            throw error;
+        }
+    }
+
+    /**
+     * Add a description step
+     * @param {string} text - Description text
+     */
+    static description(text) {
+        const allure = require('@wdio/allure-reporter').default;
+        console.log(`📄 ${text}`);
+    }
+
+    /**
+     * Capture and attach screenshot to Allure report
+     * @param {string} screenshotName - Name for the screenshot
+     */
+    static async captureScreenshot(screenshotName = 'screenshot') {
+        try {
+            // Ensure screenshot directory exists
+            const screenshotDir = './allure-screenshots';
+            if (!fs.existsSync(screenshotDir)) {
+                fs.mkdirSync(screenshotDir, { recursive: true });
+            }
+
+            // Take screenshot and save to file
+            const screenshotPath = path.join(screenshotDir, `${screenshotName}.png`);
+            await browser.saveScreenshot(screenshotPath);
+
+            // Read the screenshot
+            if (fs.existsSync(screenshotPath)) {
+                const imageBuffer = fs.readFileSync(screenshotPath);
+
+                // Attach to Allure using the proper method
+                const allure = require('@wdio/allure-reporter').default;
+                allure.addAttachment(screenshotName, imageBuffer, 'image/png');
+
+                console.log(`📸 Screenshot captured: ${screenshotName}`);
+            } else {
+                console.warn(`⚠️  Screenshot file not found: ${screenshotPath}`);
+            }
+        } catch (error) {
+            console.error(`❌ Error capturing screenshot: ${error.message}`);
+        }
+    }
+
+    /**
+     * Add text attachment to Allure report
+     * @param {string} name - Attachment name
+     * @param {string} text - Text content
+     * @param {string} mimeType - MIME type (default: text/plain)
+     */
+    static addAttachment(name, text, mimeType = 'text/plain') {
+        const allure = require('@wdio/allure-reporter').default;
+        allure.addAttachment(name, text, mimeType);
+        console.log(`📎 Attachment added: ${name}`);
+    }
+
+    /**
+     * Add severity level to test
+     * @param {string} level - Severity level (blocker, critical, normal, minor, trivial)
+     */
+    static severity(level = 'normal') {
+        const allure = require('@wdio/allure-reporter').default;
+        allure.addArgument('severity', level);
+        console.log(`🔖 Severity: ${level}`);
+    }
+
+    /**
+     * Add epic label
+     * @param {string} epic - Epic name
+     */
+    static epic(epic) {
+        const allure = require('@wdio/allure-reporter').default;
+        allure.addArgument('epic', epic);
+        console.log(`📚 Epic: ${epic}`);
+    }
+
+    /**
+     * Add feature label
+     * @param {string} feature - Feature name
+     */
+    static feature(feature) {
+        const allure = require('@wdio/allure-reporter').default;
+        allure.addArgument('feature', feature);
+        console.log(`⭐ Feature: ${feature}`);
+    }
+
+    /**
+     * Add story label
+     * @param {string} story - Story name
+     */
+    static story(story) {
+        const allure = require('@wdio/allure-reporter').default;
+        allure.addArgument('story', story);
+        console.log(`📖 Story: ${story}`);
+    }
+
+    /**
+     * Add test ID/TC tag
+     * @param {string} testId - Test ID
+     */
+    static testId(testId) {
+        const allure = require('@wdio/allure-reporter').default;
+        allure.addArgument('testId', testId);
+        console.log(`🏷️  Test ID: ${testId}`);
+    }
+
+    /**
+     * Capture screenshot on test failure
+     */
+    static async captureOnFailure() {
+        const allure = require('@wdio/allure-reporter').default;
+
+        try {
+            const testName = expect.getState().currentTestName || 'test';
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const screenshotName = `${testName}-failure-${timestamp}`;
+
+            await this.captureScreenshot(screenshotName);
+        } catch (error) {
+            console.error(`❌ Error capturing failure screenshot: ${error.message}`);
+        }
+    }
+
+    /**
+     * Add environment information to report
+     * @param {object} envInfo - Environment information object
+     */
+    static addEnvironment(envInfo) {
+        const allure = require('@wdio/allure-reporter').default;
+
+        Object.entries(envInfo).forEach(([key, value]) => {
+            allure.addArgument(`env:${key}`, value);
+            console.log(`🌍 Environment: ${key} = ${value}`);
+        });
+    }
+
+    /**
+     * Log text as a step
+     * @param {string} message - Log message
+     */
+    static log(message) {
+        const allure = require('@wdio/allure-reporter').default;
+        allure.addStep(message);
+        console.log(`📝 ${message}`);
+    }
+
+    /**
+     * Take a screenshot and attach it as an attachment (simpler method)
+     * @param {string} name - Attachment name
+     */
+    static async attachScreenshot(name = 'screenshot') {
+        try {
+            // Take screenshot to buffer
+            const screenshot = await browser.takeScreenshot();
+
+            // Attach directly to Allure
+            const allure = require('@wdio/allure-reporter').default;
+            const buffer = Buffer.from(screenshot, 'base64');
+            allure.addAttachment(name, buffer, 'image/png');
+
+            console.log(`📸 Screenshot attached: ${name}`);
+        } catch (error) {
+            console.error(`❌ Error attaching screenshot: ${error.message}`);
+        }
+    }
+
+    /**
+     * Add screenshot attachment with detailed logging
+     * @param {string} stepName - Name of the current step
+     * @param {string} description - Description of what the screenshot shows
+     */
+    static async screenshot(stepName, description = 'Screenshot') {
+        try {
+            const allure = require('@wdio/allure-reporter').default;
+
+            // Start step if not already in one
+            allure.startStep(description);
+
+            // Take screenshot
+            const screenshot = await browser.takeScreenshot();
+            const buffer = Buffer.from(screenshot, 'base64');
+
+            // Attach screenshot to the step
+            allure.addAttachment(description, buffer, 'image/png');
+
+            // End the step
+            allure.endStep('passed');
+
+            console.log(`📸 Screenshot attached for step: ${stepName}`);
+        } catch (error) {
+            console.error(`❌ Error with screenshot: ${error.message}`);
+        }
+    }
+}
+
+module.exports = AllureHelper;

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. Double-click: start-server.sh (Mac/Linux) or start-server.bat (Windows)');
+        console.log('   2. Or run: npm run report:open');
+        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,55 @@
-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'],
+
+        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);
+            }
+        }
+    };
+};

package/froth_configs/local/web.config.js

@@ -1,5 +1,12 @@
 module.exports = (bsCaps) => {
     const browserName = (bsCaps.browserName || 'chrome').toLowerCase();
+
+    // 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 = {
@@ -108,11 +115,45 @@ module.exports = (bsCaps) => {
         // Auto-download drivers service - no admin permission needed
         services: service.length > 0 ? [service] : [],
 
-        capabilities: capabilities
+        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/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,11 +1,15 @@
 {
     "name": "froth-webdriverio-framework",
-    "version": "7.0.119-dev1.7",
+    "version": "7.0.119-dev1.9",
     "readme": "WebdriverIO Integration",
     "description": "WebdriverIO and BrowserStack App Automate",
     "license": "MIT",
     "scripts": {
-        "lint": "eslint ."
+        "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",
@@ -24,6 +28,8 @@
         "@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",