wdio-lambdatest-service-sdk 5.0.0

package/README.md

@@ -0,0 +1,80 @@
+# WDIO LambdaTest Service
+
+This WebdriverIO service provides seamless integration with LambdaTest. It automatically handles:
+
+1.  **Authentication**: Pass `username` and `accessKey` in the service options.
+2.  **Test Status Updates**: Automatically marks tests as Passed/Failed on the LambdaTest dashboard using Lambda Hooks.
+3.  **Logs**: Provides clean, colorful status logs in the terminal.
+
+## Installation
+
+```bash
+npm install wdio-lambdatest-service --save-dev
+```
+
+*(For local development, you can link the package or use the setup script described below)*
+
+## Automated Setup
+
+You can automatically update your existing WebdriverIO configuration files (`*.conf.js`) to use this SDK using the included setup script.
+
+Run the following command, providing the path to your project or test folder:
+
+```bash
+# If installed via npm
+npx wdio-lambdatest-setup ./path/to/your/project
+
+# If running locally from source
+node wdio-lambdatest-service/bin/setup.js ./android-sample
+```
+
+This script will:
+-   Scan for `.conf.js` files recursively.
+-   Inject the service configuration.
+-   Set `logLevel` to `error` for cleaner output.
+-   Comment out hardcoded credentials (so the SDK handles them).
+
+## Manual Configuration
+
+Add the service to your `wdio.conf.js`:
+
+```javascript
+const path = require('path');
+
+exports.config = {
+    // ...
+    // user: process.env.LT_USERNAME, // handled by SDK
+    // key: process.env.LT_ACCESS_KEY, // handled by SDK
+    
+    logLevel: 'error', // Recommended to reduce noise
+    
+    services: [
+        ['lambdatest', {
+            username: process.env.LT_USERNAME,
+            accessKey: process.env.LT_ACCESS_KEY
+        }]
+    ],
+    // ...
+};
+```
+
+If you are using the SDK locally (without npm install), use the absolute path:
+
+```javascript
+    services: [
+        [path.join(__dirname, '../../wdio-lambdatest-service'), {
+            username: process.env.LT_USERNAME,
+            accessKey: process.env.LT_ACCESS_KEY
+        }]
+    ],
+```
+
+## Features
+
+-   **Automatic Status Updates**: Checks test results in `afterTest` (Mocha/Jasmine) or `afterScenario` (Cucumber) and updates the LambdaTest job status.
+-   **Credential Management**: Can inject credentials if not already present in the main config.
+-   **Async Support**: Works seamlessly with both Sync and Async WebdriverIO execution modes.
+
+## Development
+
+This package exports a **Service** (worker) and a **Launcher** (main process).

package/bin/generate-config.js

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+
+const config = {
+    testName: '',
+    filename: '',
+    username: '',
+    key: '',
+    type: '', // 'app' or 'browser'
+    subType: '', // 'real', 'virtual', 'desktop', 'mobile-virtual', 'mobile-real'
+    parallel: 0,
+    specPath: ''
+};
+
+const outputDir = path.resolve(process.cwd(), 'LT_Test');
+
+// Ensure output dir exists
+if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+}
+
+function ask(question, defaultVal) {
+    return new Promise((resolve) => {
+        rl.question(`${question}${defaultVal ? ` (${defaultVal})` : ''}: `, (answer) => {
+            resolve(answer.trim() || defaultVal);
+        });
+    });
+}
+
+async function run() {
+    console.log('\n--- LambdaTest WDIO Config Generator ---\n');
+
+    config.testName = await ask('Enter Test Name (e.g. AndroidAppTest)', 'AndroidAppTest');
+    config.filename = `${config.testName}.conf.js`;
+
+    config.username = await ask('Enter LambdaTest Username', process.env.LT_USERNAME || 'YOUR_USERNAME');
+    config.key = await ask('Enter LambdaTest Access Key', process.env.LT_ACCESS_KEY || 'YOUR_ACCESS_KEY');
+
+    const typeInput = await ask('Test Type (1: App, 2: Browser)', '1');
+    config.type = typeInput === '1' || typeInput.toLowerCase() === 'app' ? 'app' : 'browser';
+
+    if (config.type === 'app') {
+        const subTypeInput = await ask('Device Type (1: Real Device, 2: Virtual Device)', '1');
+        config.subType = subTypeInput === '1' ? 'real' : 'virtual';
+    } else {
+        console.log('Browser Options: 1: Desktop, 2: Mobile Browser (Virtual), 3: Mobile Browser (Real)');
+        const subTypeInput = await ask('Select Option', '1');
+        if (subTypeInput === '2') config.subType = 'mobile-virtual';
+        else if (subTypeInput === '3') config.subType = 'mobile-real';
+        else config.subType = 'desktop';
+    }
+
+    const parallelInput = await ask('Number of Parallel Threads (0 or empty for no parallel)', '0');
+    config.parallel = parseInt(parallelInput) || 0;
+
+    config.specPath = await ask('Path to Spec File (e.g. ./specs/test.js)', './specs/android-test.js');
+
+    // Generate Config Content
+    let capabilities = [];
+    const commonCaps = {
+        build: `LT_WDIO_${config.testName}_${new Date().toISOString().split('T')[0]}`,
+        name: config.testName,
+        visual: true,
+        console: true
+    };
+
+    if (config.type === 'app') {
+        const cap = {
+            "lt:options": {
+                w3c: true,
+                platformName: "Android",
+                deviceName: config.subType === 'real' ? ".*" : "Pixel 4",
+                platformVersion: config.subType === 'real' ? undefined : "11",
+                isRealMobile: config.subType === 'real',
+                app: process.env.LT_APP_ID || "lt://proverbial-android", // Default app
+            }
+        };
+        capabilities.push(cap);
+    } else {
+        if (config.subType === 'desktop') {
+            capabilities.push({
+                browserName: "chrome",
+                browserVersion: "latest",
+                "lt:options": {
+                    platformName: "Windows 10"
+                }
+            });
+        } else {
+            // Mobile Browser
+            capabilities.push({
+                "lt:options": {
+                    w3c: true,
+                    platformName: "Android",
+                    deviceName: config.subType === 'mobile-real' ? ".*" : "Pixel 4",
+                    platformVersion: config.subType === 'mobile-real' ? undefined : "11",
+                    isRealMobile: config.subType === 'mobile-real',
+                }
+            });
+        }
+    }
+
+    // Prepare template
+    const template = `const path = require('path');
+
+exports.config = {
+    // Authentication handled by SDK
+    // user: "${config.username}",
+    // key: "${config.key}",
+
+    updateJob: false,
+    specs: ["${config.specPath}"],
+    exclude: [],
+
+    maxInstances: ${config.parallel > 0 ? config.parallel : 1},
+
+    commonCapabilities: ${JSON.stringify(commonCaps, null, 4)},
+
+    capabilities: ${JSON.stringify(capabilities, null, 4)},
+
+    logLevel: 'error',
+    coloredLogs: true,
+    screenshotPath: "./errorShots/",
+    baseUrl: "https://mobile-hub.lambdatest.com",
+    waitforTimeout: 10000,
+    connectionRetryTimeout: 90000,
+    connectionRetryCount: 3,
+    path: "/wd/hub",
+    hostname: "mobile-hub.lambdatest.com",
+    port: 80,
+
+    services: [
+        [path.join(__dirname, '../wdio-lambdatest-service'), {
+            user: "${config.username}",
+            key: "${config.key}"
+        }]
+    ],
+
+    framework: "mocha",
+    mochaOpts: {
+        ui: "bdd",
+        timeout: 20000,
+    },
+};
+
+exports.config.capabilities.forEach(function (caps) {
+    for (var i in exports.config.commonCapabilities)
+        caps[i] = caps[i] || exports.config.commonCapabilities[i];
+});
+`;
+
+    const outputPath = path.join(outputDir, config.filename);
+    fs.writeFileSync(outputPath, template);
+    
+    console.log(`\nSuccessfully created configuration file at:\n${outputPath}`);
+    console.log(`\nRun it with:\n./node_modules/.bin/wdio ${path.relative(process.cwd(), outputPath)}`);
+    
+    rl.close();
+}
+
+run();

package/bin/setup.js

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const sdkPath = path.resolve(__dirname, '..'); // Absolute path to the SDK folder
+
+function start() {
+    const targetDirArg = process.argv[2];
+
+    if (targetDirArg) {
+        traverseDirectory(path.resolve(targetDirArg));
+        console.log('Done scanning directories.');
+    } else {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        rl.question('Where are your test scripts located? (e.g. ./android-sample): ', (answer) => {
+            if (!answer || answer.trim() === '') {
+                console.error('No directory provided. Exiting.');
+                process.exit(1);
+            }
+            
+            const resolvedPath = path.resolve(answer.trim());
+            console.log(`Scanning: ${resolvedPath}`);
+            
+            traverseDirectory(resolvedPath);
+            console.log('Done scanning directories.');
+            rl.close();
+        });
+    }
+}
+
+function traverseDirectory(dir) {
+    if (!fs.existsSync(dir)) {
+        console.error(`Directory not found: ${dir}`);
+        return;
+    }
+
+    const files = fs.readdirSync(dir);
+
+    files.forEach(file => {
+        const fullPath = path.join(dir, file);
+        const stat = fs.statSync(fullPath);
+
+        if (stat.isDirectory()) {
+            if (file !== 'node_modules' && file !== '.git') {
+                traverseDirectory(fullPath);
+            }
+        } else if (file.endsWith('.conf.js')) {
+            updateConfigFile(fullPath);
+        }
+    });
+}
+
+function updateConfigFile(filePath) {
+    let content = fs.readFileSync(filePath, 'utf8');
+    
+    console.log(`Processing: ${filePath}`);
+
+    // Extract credentials (either active or commented out)
+    let userVal = "process.env.LT_USERNAME";
+    let keyVal = "process.env.LT_ACCESS_KEY";
+
+    const userMatch = content.match(/^\s*\/{0,2}\s*user:\s*(.*?),/m);
+    if (userMatch) userVal = userMatch[1].trim();
+
+    const keyMatch = content.match(/^\s*\/{0,2}\s*key:\s*(.*?),/m);
+    if (keyMatch) keyVal = keyMatch[1].trim();
+
+    // Calculate relative path
+    let relativeSdkPath = path.relative(path.dirname(filePath), sdkPath);
+    relativeSdkPath = relativeSdkPath.replace(/\\/g, '/');
+    
+    // Construct the correct service entry with credentials
+    const serviceEntry = `[path.join(__dirname, '${relativeSdkPath}'), { user: ${userVal}, key: ${keyVal} }]`;
+
+    // Check if already updated (but maybe with missing credentials)
+    if (content.includes('wdio-lambdatest-service')) {
+        // Fix empty options if present: [path..., {}]
+        const emptyOptionsRegex = /\[path\.join\(__dirname, '.*?wdio-lambdatest-service'\), \{\}\]/;
+        if (emptyOptionsRegex.test(content)) {
+            console.log(`Fixing missing credentials in: ${filePath}`);
+            content = content.replace(emptyOptionsRegex, serviceEntry);
+            
+            // Ensure logLevel is error
+            content = content.replace(/logLevel: ['"]info['"]/, "logLevel: 'error'");
+            
+            fs.writeFileSync(filePath, content);
+            console.log(`Successfully repaired ${filePath}`);
+        } else {
+            console.log(`Skipping (already correct): ${filePath}`);
+        }
+        return;
+    }
+
+    console.log(`Updating: ${filePath}`);
+
+    // 1. Ensure 'path' module is required
+    if (!content.includes("require('path')")) {
+        content = "const path = require('path');\n" + content;
+    }
+
+    // 3. Inject Services
+    if (content.includes('services: [')) {
+        content = content.replace('services: [', `services: [\n        ${serviceEntry},`);
+    } else {
+        content = content.replace('exports.config = {', `exports.config = {\n    services: [\n        ${serviceEntry}\n    ],`);
+    }
+
+    // 4. Set logLevel to 'error'
+    if (content.includes('logLevel:')) {
+        content = content.replace(/logLevel:.*,/, "logLevel: 'error',");
+    } else {
+        content = content.replace('exports.config = {', `exports.config = {\n    logLevel: 'error',`);
+    }
+
+    // 5. Comment out hardcoded user/key
+    // Use replace with callback to avoid re-commenting
+    content = content.replace(/^(\s*)user:/gm, '$1// user:');
+    content = content.replace(/^(\s*)key:/gm, '$1// key:');
+
+    fs.writeFileSync(filePath, content);
+    console.log(`Successfully updated ${filePath}`);
+}
+
+start();

package/index.js

@@ -0,0 +1,11 @@
+const LambdaTestService = require('./src/service');
+const LambdaTestLauncher = require('./src/launcher');
+
+// Export the Service class as the main module export
+module.exports = LambdaTestService;
+
+// Also export as 'default' for compatibility with some WDIO loaders
+module.exports.default = LambdaTestService;
+
+// Export the Launcher
+module.exports.launcher = LambdaTestLauncher;

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "wdio-lambdatest-service-sdk",
+  "version": "5.0.0",
+  "description": "WebdriverIO service for LambdaTest integration",
+  "main": "index.js",
+  "bin": {
+    "wdio-lambdatest-setup": "bin/setup.js",
+    "wdio-lambdatest-generator": "bin/generate-config.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "webdriverio",
+    "wdio",
+    "lambdatest",
+    "service",
+    "sdk"
+  ],
+  "author": "",
+  "license": "ISC",
+  "peerDependencies": {
+    "@wdio/cli": ">=5.0.0",
+    "webdriverio": ">=5.0.0"
+  },
+  "engines": {
+    "node": ">=10.0.0"
+  }
+}

package/src/launcher.js

@@ -0,0 +1,45 @@
+
+module.exports = class LambdaTestLauncher {
+    constructor(serviceOptions, capabilities, config) {
+        this.options = serviceOptions || {};
+        console.log('[LambdaTest Service] Launcher initialized with options:', JSON.stringify(this.options));
+    }
+
+    onPrepare(config, capabilities) {
+        console.log('[LambdaTest Service] Processing credentials...');
+
+        // 1. Update Main Config (for WDIO Basic Auth)
+        if (this.options.username) config.user = this.options.username;
+        if (this.options.accessKey) config.key = this.options.accessKey;
+        if (this.options.user) config.user = this.options.user;
+        if (this.options.key) config.key = this.options.key;
+
+        // Fallback to Env Vars
+        if (!config.user) config.user = process.env.LT_USERNAME;
+        if (!config.key) config.key = process.env.LT_ACCESS_KEY;
+
+        // 2. Update Capabilities (Explicitly pass credentials to caps)
+        // This ensures that even if Basic Auth fails or is missed, 
+        // the grid sees them in the capabilities.
+        const user = config.user;
+        const key = config.key;
+
+        if (user && key) {
+            const capsList = Array.isArray(capabilities) ? capabilities : [capabilities];
+            capsList.forEach(cap => {
+                // Legacy JSONWP
+                if (!cap.user) cap.user = user;
+                if (!cap.accessKey) cap.accessKey = key;
+
+                // W3C Support (lt:options)
+                if (cap['lt:options']) {
+                    if (!cap['lt:options'].username) cap['lt:options'].username = user;
+                    if (!cap['lt:options'].accessKey) cap['lt:options'].accessKey = key;
+                }
+            });
+            console.log('[LambdaTest Service] Credentials injected into config and capabilities.');
+        } else {
+            console.error('[LambdaTest Service] Credentials not found! Please check service options or env vars.');
+        }
+    }
+};

package/src/service.js

@@ -0,0 +1,97 @@
+
+module.exports = class LambdaTestService {
+    constructor(serviceOptions, capabilities, config) {
+        this.options = serviceOptions || {};
+        this.isEnabled = true;
+    }
+
+    before(capabilities, specs) {
+        console.log('[LambdaTest Service] Service initialized in worker process.');
+    }
+
+    /**
+     * Triggered after each test (Mocha/Jasmine)
+     */
+    async afterTest(test, context, result) {
+        // Handle WDIO v5/v6/v7 differences
+        let passed = false;
+        let error = undefined;
+        let title = 'Test';
+
+        // Check if result is the object { error, result, duration, passed, retries }
+        if (result && typeof result.passed === 'boolean') {
+            passed = result.passed;
+            error = result.error;
+        } 
+        // Fallback for older/different versions where result might be the passed boolean or different structure
+        else if (test && typeof test.passed === 'boolean') {
+            passed = test.passed;
+            error = test.error;
+        }
+        
+        if (test && test.title) title = test.title;
+
+        await this.updateStatus(passed, error ? (error.message || error) : undefined, title);
+    }
+
+    /**
+     * Triggered after each scenario (Cucumber)
+     */
+    async afterScenario(uri, feature, scenario, result) {
+        const isPassed = result.status === 'passed' || result === 'passed' || result.passed === true;
+        const errorMessage = result.error ? result.error : (isPassed ? undefined : 'Scenario Failed');
+        const title = scenario.name || 'Scenario';
+        await this.updateStatus(isPassed, errorMessage, title);
+    }
+
+    /**
+     * Updates the test status on LambdaTest
+     * @param {boolean} passed 
+     * @param {string} errorMessage 
+     * @param {string} testTitle
+     */
+    async updateStatus(passed, errorMessage, testTitle) {
+        if (!this.isEnabled) return;
+
+        const status = passed ? 'passed' : 'failed';
+        const remark = errorMessage || (passed ? 'Test Passed' : 'Test Failed');
+
+        // ANSI Color Codes
+        const reset = "\x1b[0m";
+        const green = "\x1b[32m";
+        const red = "\x1b[31m";
+        const cyan = "\x1b[36m";
+        const gray = "\x1b[90m";
+
+        const color = passed ? green : red;
+        const icon = passed ? '✔' : '✖';
+        
+        console.log(`\n${cyan}[LambdaTest SDK]${reset} ${gray}Updating Status...${reset}`);
+        console.log(`${cyan}[LambdaTest SDK]${reset} Test:   ${testTitle}`);
+        console.log(`${cyan}[LambdaTest SDK]${reset} Status: ${color}${status.toUpperCase()} ${icon}${reset}`);
+        if (!passed) {
+            console.log(`${cyan}[LambdaTest SDK]${reset} Reason: ${red}${remark}${reset}`);
+        }
+        console.log(''); // Empty line
+
+        try {
+            // Using browser.execute to trigger the Lambda Hook
+            const script = `lambda-hook: ${JSON.stringify({
+                action: 'setTestStatus',
+                arguments: {
+                    status: status,
+                    remark: remark
+                }
+            })}`;
+            
+            // Await the execution in case we are in async mode
+            await browser.execute(script);
+            
+            // Add a small pause to ensure the hook is processed before session ends
+            await browser.pause(1000);
+            
+        } catch (e) {
+            console.error(`${red}[LambdaTest SDK] Failed to update test status via hook.${reset}`, e);
+        }
+    }
+};