wdio-lambdatest-service-sdk 5.0.0 → 5.1.1

package/index.js

@@ -1,11 +1,10 @@
+/**
+ * WDIO LambdaTest service entry point.
+ * Exposes the service class and launcher for WebdriverIO.
+ */
 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/lib/cli/generate.js

@@ -0,0 +1,526 @@
+/**
+ * Generate command logic: Interactively create a WDIO config for LambdaTest.
+ */
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+
+/** Safe filename: non-empty, no path separators or reserved chars. */
+function toSafeFilename(value, fallback) {
+    if (!value || typeof value !== 'string') return fallback;
+    const sanitized = value.replace(/[/\\?*:|<>"]/g, '').trim();
+    return sanitized || fallback;
+}
+
+/**
+ * Find wdio binary path relative to outputDir. Checks root node_modules then android-sample.
+ * @param {string} outDir - Absolute path to LT_Test (output dir)
+ * @returns {string} Relative path to wdio binary
+ */
+function findWdioBinRelative(outDir) {
+    const rootWdio = path.resolve(outDir, '../node_modules/.bin/wdio');
+    const androidSampleWdio = path.resolve(outDir, '../android-sample/node_modules/.bin/wdio');
+    if (fs.existsSync(rootWdio)) return '../node_modules/.bin/wdio';
+    if (fs.existsSync(androidSampleWdio)) return '../android-sample/node_modules/.bin/wdio';
+    return '../node_modules/.bin/wdio';
+}
+
+/**
+ * Device configuration defaults for LambdaTest.
+ */
+const DEVICE_DEFAULTS = {
+    // Virtual Device defaults
+    virtual: {
+        android: {
+            deviceName: 'Galaxy S24 Ultra',
+            platformVersion: '14',
+            appiumVersion: '2.16.2'
+        },
+        ios: {
+            deviceName: 'iPad (10th generation)',
+            platformVersion: '16',
+            appiumVersion: '2.1.3'
+        }
+    },
+    // Real Device defaults
+    real: {
+        android: {
+            deviceName: 'Pixel 8',
+            platformVersion: '14'
+        },
+        ios: {
+            deviceName: 'iPhone 15',
+            platformVersion: '17'
+        }
+    }
+};
+
+/**
+ * Get default App ID based on platform.
+ */
+function getDefaultAppId(platform) {
+    const envAppId = process.env.LT_APP_ID;
+    if (envAppId) return envAppId;
+    return platform === 'ios' ? 'lt://proverbial-ios' : 'lt://proverbial-android';
+}
+
+/**
+ * Build a single capability object.
+ */
+function buildSingleCapability(deviceType, platform, testingType, appId) {
+    const isReal = deviceType === 'real';
+    const platformName = platform === 'ios' ? 'ios' : 'android';
+    const defaults = DEVICE_DEFAULTS[deviceType][platform];
+
+    if (testingType === 'app') {
+        // Native Application Testing
+        if (isReal) {
+            return {
+                'lt:options': {
+                    platformName: platformName,
+                    deviceName: defaults.deviceName,
+                    platformVersion: defaults.platformVersion,
+                    app: appId,
+                    isRealMobile: true
+                }
+            };
+        } else {
+            return {
+                'lt:options': {
+                    platformName: platformName,
+                    deviceName: defaults.deviceName,
+                    appiumVersion: defaults.appiumVersion,
+                    platformVersion: defaults.platformVersion,
+                    app: appId,
+                    isRealMobile: false
+                }
+            };
+        }
+    } else {
+        // Website (Mobile Browser) Testing
+        const browserName = platform === 'ios' ? 'Safari' : 'Chrome';
+        if (isReal) {
+            return {
+                browserName: browserName,
+                'lt:options': {
+                    platformName: platformName,
+                    deviceName: defaults.deviceName,
+                    platformVersion: defaults.platformVersion,
+                    isRealMobile: true
+                }
+            };
+        } else {
+            return {
+                browserName: browserName,
+                'lt:options': {
+                    platformName: platformName,
+                    deviceName: defaults.deviceName,
+                    appiumVersion: defaults.appiumVersion,
+                    platformVersion: defaults.platformVersion,
+                    isRealMobile: false
+                }
+            };
+        }
+    }
+}
+
+/**
+ * Build capabilities array from multi-select config.
+ * Generates all combinations of selected options.
+ */
+function buildCapabilitiesMulti(config) {
+    const capabilities = [];
+
+    // App Testing combinations
+    if (config.testTypes.includes('app')) {
+        for (const deviceType of config.deviceTypes) {
+            for (const platform of config.platforms) {
+                for (const testingType of config.testingTypes) {
+                    const appId = testingType === 'app' ? (config.appIds[platform] || getDefaultAppId(platform)) : null;
+                    capabilities.push(buildSingleCapability(deviceType, platform, testingType, appId));
+                }
+            }
+        }
+    }
+
+    // Browser Testing (Desktop Website)
+    if (config.testTypes.includes('browser')) {
+        capabilities.push({
+            browserName: 'Chrome',
+            browserVersion: 'latest',
+            'LT:Options': {
+                username: config.username,
+                accessKey: config.key,
+                platformName: 'Windows 10',
+                project: config.testName,
+                w3c: true,
+                plugin: 'node_js-webdriverio'
+            }
+        });
+    }
+
+    return capabilities;
+}
+
+/**
+ * Build config file template string.
+ */
+function buildConfigTemplate(config, commonCaps, capabilities) {
+    return `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,
+    },
+};
+
+// Merge commonCapabilities into each capability
+exports.config.capabilities.forEach(function (caps) {
+    for (const i in exports.config.commonCapabilities) {
+        caps[i] = caps[i] || exports.config.commonCapabilities[i];
+    }
+});
+`;
+}
+
+function printBanner() {
+    console.log();
+    console.log(chalk.cyan.bold('╭────────────────────────────────────────────╮'));
+    console.log(chalk.cyan.bold('│') + '   🛠️  ' + chalk.bold('LambdaTest WDIO Config Generator') + '   ' + chalk.cyan.bold('│'));
+    console.log(chalk.cyan.bold('╰────────────────────────────────────────────╯'));
+    console.log();
+}
+
+/**
+ * Run the generate command interactively.
+ * @returns {Promise<void>}
+ */
+async function runGenerate() {
+    const outputDir = path.resolve(process.cwd(), 'LT_Test');
+
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+
+    printBanner();
+
+    const defaultUsername = process.env.LT_USERNAME || '';
+    const defaultKey = process.env.LT_ACCESS_KEY || '';
+
+    // Basic Info
+    console.log(chalk.dim('─'.repeat(40)));
+    console.log(chalk.cyan.bold(' 📋 Basic Info'));
+    console.log(chalk.dim('─'.repeat(40)));
+    console.log();
+
+    const basicAnswers = await inquirer.default.prompt([
+        {
+            type: 'input',
+            name: 'testName',
+            message: 'Test name:',
+            default: 'LambdaTest',
+            validate: (input) => input.trim() !== '' || 'Test name is required'
+        }
+    ]);
+
+    const config = {
+        testName: toSafeFilename(basicAnswers.testName, 'LambdaTest'),
+        filename: '',
+        username: '',
+        key: '',
+        testTypes: [],       // ['app', 'browser']
+        deviceTypes: [],     // ['real', 'virtual']
+        platforms: [],       // ['android', 'ios']
+        testingTypes: [],    // ['app', 'website']
+        appIds: {},          // { android: 'lt://...', ios: 'lt://...' }
+        parallel: 0,
+        specPath: ''
+    };
+    config.filename = `${config.testName}.conf.js`;
+
+    // Credentials
+    console.log();
+    console.log(chalk.dim('─'.repeat(40)));
+    console.log(chalk.cyan.bold(' 🔐 LambdaTest Credentials'));
+    console.log(chalk.dim('─'.repeat(40)));
+    console.log();
+
+    const credAnswers = await inquirer.default.prompt([
+        {
+            type: 'input',
+            name: 'username',
+            message: 'LambdaTest Username:',
+            default: defaultUsername || undefined,
+            validate: (input) => input.trim() !== '' || 'Username is required'
+        },
+        {
+            type: 'password',
+            name: 'key',
+            message: 'LambdaTest Access Key:',
+            default: defaultKey || undefined,
+            mask: '*',
+            validate: (input) => input.trim() !== '' || 'Access key is required'
+        }
+    ]);
+
+    config.username = credAnswers.username;
+    config.key = credAnswers.key;
+
+    // Test Configuration
+    console.log();
+    console.log(chalk.dim('─'.repeat(40)));
+    console.log(chalk.cyan.bold(' ⚙️  Test Configuration'));
+    console.log(chalk.dim('─' .repeat(40)));
+    console.log(chalk.dim('   (Use space to select, enter to confirm)'));
+    console.log();
+
+    // Step 1: Test Type (Multi-select)
+    const testTypeAnswer = await inquirer.default.prompt([
+        {
+            type: 'checkbox',
+            name: 'testTypes',
+            message: 'Test type(s):',
+            choices: [
+                { name: '📱 Mobile Testing ', value: 'app', checked: true },
+                { name: '🌐 Browser Testing (Desktop)', value: 'browser' }
+            ],
+            validate: (input) => input.length > 0 || 'Please select at least one test type'
+        }
+    ]);
+    config.testTypes = testTypeAnswer.testTypes;
+
+    // If App Testing is selected, ask for more details
+    if (config.testTypes.includes('app')) {
+        console.log();
+        console.log(chalk.dim('─'.repeat(40)));
+        console.log(chalk.cyan.bold(' 📱 App Testing Configuration'));
+        console.log(chalk.dim('─'.repeat(40)));
+        console.log();
+
+        // Step 2: Device Type (Multi-select)
+        const deviceAnswer = await inquirer.default.prompt([
+            {
+                type: 'checkbox',
+                name: 'deviceTypes',
+                message: 'Device type(s):',
+                choices: [
+                    { name: '📲 Mobile Device', value: 'real', checked: true },
+                    { name: '💻 Website (Desktop)', value: 'virtual' }
+                ],
+                validate: (input) => input.length > 0 || 'Please select at least one device type'
+            }
+        ]);
+        config.deviceTypes = deviceAnswer.deviceTypes;
+
+        // Step 3: Platform (Multi-select)
+        const platformAnswer = await inquirer.default.prompt([
+            {
+                type: 'checkbox',
+                name: 'platforms',
+                message: 'Platform(s):',
+                choices: [
+                    { name: '🤖 Android', value: 'android', checked: true },
+                    { name: '🍎 iOS', value: 'ios' }
+                ],
+                validate: (input) => input.length > 0 || 'Please select at least one platform'
+            }
+        ]);
+        config.platforms = platformAnswer.platforms;
+
+        // Step 4: What to test (Multi-select)
+        const testingTypeAnswer = await inquirer.default.prompt([
+            {
+                type: 'checkbox',
+                name: 'testingTypes',
+                message: 'What do you want to test?',
+                choices: [
+                    { name: '📦 Application (Native App)', value: 'app', checked: true },
+                    { name: '🌐 Website (Mobile Browser)', value: 'website' }
+                ],
+                validate: (input) => input.length > 0 || 'Please select at least one testing type'
+            }
+        ]);
+        config.testingTypes = testingTypeAnswer.testingTypes;
+
+        // Step 5: App IDs (only if testing native applications)
+        if (config.testingTypes.includes('app')) {
+            console.log();
+            console.log(chalk.dim('─'.repeat(40)));
+            console.log(chalk.cyan.bold(' 📦 App Configuration'));
+            console.log(chalk.dim('─'.repeat(40)));
+            console.log();
+
+            // Ask for App ID for each selected platform
+            for (const platform of config.platforms) {
+                const platformLabel = platform === 'ios' ? 'iOS' : 'Android';
+                const defaultAppId = getDefaultAppId(platform);
+                
+                const appIdAnswer = await inquirer.default.prompt([
+                    {
+                        type: 'input',
+                        name: 'appId',
+                        message: `${platformLabel} App ID (e.g. lt://APP123456789):`,
+                        default: defaultAppId,
+                        validate: (input) => input.trim() !== '' || 'App ID is required'
+                    }
+                ]);
+                config.appIds[platform] = appIdAnswer.appId.trim();
+            }
+        }
+    }
+
+    // Parallel threads
+    console.log();
+    console.log(chalk.dim('─'.repeat(40)));
+    console.log(chalk.cyan.bold(' 🚀 Execution Settings'));
+    console.log(chalk.dim('─'.repeat(40)));
+    console.log();
+
+    const parallelAnswer = await inquirer.default.prompt([
+        {
+            type: 'number',
+            name: 'parallel',
+            message: 'Parallel threads (0 for sequential):',
+            default: 0,
+            validate: (input) => {
+                const num = parseInt(input, 10);
+                return (!isNaN(num) && num >= 0) || 'Please enter a valid number (0 or greater)';
+            }
+        }
+    ]);
+    config.parallel = parallelAnswer.parallel || 0;
+
+    // Spec file path
+    const specAnswer = await inquirer.default.prompt([
+        {
+            type: 'input',
+            name: 'specPath',
+            message: 'Spec file path:',
+            default: './specs/test.js'
+        }
+    ]);
+
+    let rawSpec = specAnswer.specPath.trim() || './specs/test.js';
+
+    // Smart resolve spec path relative to LT_Test
+    if (fs.existsSync(path.resolve(outputDir, rawSpec))) {
+        config.specPath = rawSpec;
+    } else {
+        const rootPath = path.resolve(outputDir, '..');
+        const relativeToRoot = rawSpec.replace(/^\.\//, '');
+        const pathFromRoot = path.join(rootPath, relativeToRoot);
+
+        if (fs.existsSync(pathFromRoot)) {
+            config.specPath = path.relative(outputDir, pathFromRoot).replace(/\\/g, '/');
+        } else {
+            if (!path.isAbsolute(rawSpec) && !rawSpec.startsWith('../')) {
+                config.specPath = '../' + relativeToRoot;
+            } else {
+                config.specPath = rawSpec;
+            }
+        }
+    }
+
+    const commonCaps = {
+        build: `LT_WDIO_${config.testName}_${new Date().toISOString().split('T')[0]}`,
+        name: config.testName,
+        visual: true,
+        console: true
+    };
+
+    const capabilities = buildCapabilitiesMulti(config);
+    const template = buildConfigTemplate(config, commonCaps, capabilities);
+
+    const outputPath = path.join(outputDir, config.filename);
+    fs.writeFileSync(outputPath, template);
+
+    const packageJsonPath = path.join(outputDir, 'package.json');
+    let pkg = { name: 'lt-generated-tests', version: '1.0.0', scripts: {} };
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        } catch (e) {
+            // Ignore parse errors, use default
+        }
+    }
+    if (!pkg.scripts || typeof pkg.scripts !== 'object') {
+        pkg.scripts = {};
+    }
+
+    const wdioBin = findWdioBinRelative(outputDir);
+    pkg.scripts[`test:${config.testName}`] = `${wdioBin} ${config.filename}`;
+    fs.writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2));
+
+    // Success output
+    console.log();
+    console.log(chalk.dim('─'.repeat(40)));
+    console.log(chalk.green.bold(' ✔ Configuration Created Successfully!'));
+    console.log(chalk.dim('─'.repeat(40)));
+    console.log();
+    
+    // Show summary of selected options
+    console.log(chalk.cyan('  Summary:'));
+    console.log(chalk.dim('  ─────────────────────────'));
+    console.log(`  ${chalk.bold('Test Types:')}    ${config.testTypes.map(t => t === 'app' ? 'App Testing' : 'Browser Testing').join(', ')}`);
+    
+    if (config.testTypes.includes('app')) {
+        console.log(`  ${chalk.bold('Device Types:')}  ${config.deviceTypes.map(d => d === 'real' ? 'Real Device' : 'Virtual Device').join(', ')}`);
+        console.log(`  ${chalk.bold('Platforms:')}     ${config.platforms.map(p => p === 'ios' ? 'iOS' : 'Android').join(', ')}`);
+        console.log(`  ${chalk.bold('Testing:')}       ${config.testingTypes.map(t => t === 'app' ? 'Native App' : 'Website').join(', ')}`);
+        
+        if (config.testingTypes.includes('app')) {
+            for (const platform of config.platforms) {
+                const platformLabel = platform === 'ios' ? 'iOS' : 'Android';
+                console.log(`  ${chalk.bold(`${platformLabel} App ID:`)}  ${chalk.dim(config.appIds[platform])}`);
+            }
+        }
+    }
+    
+    console.log(`  ${chalk.bold('Capabilities:')}  ${chalk.yellow(capabilities.length)} configuration(s) generated`);
+    console.log();
+    
+    console.log(chalk.cyan('  Config file:  ') + chalk.dim(outputPath));
+    console.log(chalk.cyan('  Package.json: ') + chalk.dim(packageJsonPath));
+    console.log();
+    console.log(chalk.bold('  To run your test:'));
+    console.log();
+    console.log(chalk.green(`    cd LT_Test && npm run test:${config.testName}`));
+    console.log();
+}
+
+module.exports = { runGenerate };