Cloud Testing Platforms: Complete Guide to BrowserStack, Sauce Labs, AWS Device Farm & More

// Java example with BrowserStack capabilities
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import java.net.URL;

public class BrowserStackTest {
    public static final String USERNAME = "your_username";
    public static final String AUTOMATE_KEY = "your_access_key";
    public static final String URL = "https://" + USERNAME + ":" + AUTOMATE_KEY + "@hub-cloud.browserstack.com/wd/hub";

    public static void main(String[] args) throws Exception {
        DesiredCapabilities caps = new DesiredCapabilities();
        
        // Browser and OS configuration
        caps.setCapability("os", "Windows");
        caps.setCapability("os_version", "11");
        caps.setCapability("browser", "Chrome");
        caps.setCapability("browser_version", "latest");
        
        // BrowserStack specific capabilities
        caps.setCapability("name", "Cloud Testing Platform Test");
        caps.setCapability("build", "browserstack-build-1");
        caps.setCapability("project", "Cloud Testing Project");
        
        // Debugging capabilities
        caps.setCapability("browserstack.debug", "true");
        caps.setCapability("browserstack.console", "verbose");
        caps.setCapability("browserstack.networkLogs", "true");
        
        // Local testing
        caps.setCapability("browserstack.local", "true");
        caps.setCapability("browserstack.localIdentifier", "Test123");
        
        WebDriver driver = new RemoteWebDriver(new URL(URL), caps);
        driver.get("https://www.example.com");
        
        System.out.println("Page title: " + driver.getTitle());
        
        driver.quit();
    }
}

// cypress.config.js for BrowserStack
const { defineConfig } = require('cypress');

module.exports = defineConfig({
  e2e: {
    baseUrl: 'https://www.example.com',
    setupNodeEvents(on, config) {
      // BrowserStack specific configuration
      require('cypress-browserstack')(on, config);
      return config;
    },
  },
});

// browserstack.json
{
  "auth": {
    "username": "YOUR_USERNAME",
    "access_key": "YOUR_ACCESS_KEY"
  },
  "browsers": [
    {
      "browser": "chrome",
      "os": "Windows 11",
      "versions": ["latest", "latest-1"]
    },
    {
      "browser": "edge",
      "os": "Windows 10",
      "versions": ["latest"]
    },
    {
      "browser": "safari",
      "os": "OS X Monterey",
      "versions": ["latest"]
    }
  ],
  "run_settings": {
    "cypress_config_file": "./cypress.config.js",
    "project_name": "Cloud Testing Project",
    "build_name": "build-1",
    "parallels": 5,
    "specs": ["cypress/e2e/**/*.cy.js"]
  },
  "connection_settings": {
    "local": false,
    "local_identifier": null
  }
}

// playwright.config.js for BrowserStack
const { defineConfig, devices } = require('@playwright/test');
const cp = require('child_process');
const clientPlaywrightVersion = cp.execSync('npx playwright --version').toString().trim().split(' ')[1];

module.exports = defineConfig({
  testDir: './tests',
  timeout: 30000,
  retries: 2,
  workers: 5,
  
  use: {
    baseURL: 'https://www.example.com',
    trace: 'on-first-retry',
    screenshot: 'only-on-failure',
  },

  projects: [
    {
      name: 'chrome-win11',
      use: {
        ...devices['Desktop Chrome'],
        browserName: 'chromium',
        connectOptions: {
          wsEndpoint: `wss://cdp.browserstack.com/playwright?caps=${encodeURIComponent(JSON.stringify({
            'browser': 'chrome',
            'browser_version': 'latest',
            'os': 'Windows',
            'os_version': '11',
            'name': 'Cloud Testing Playwright Test',
            'build': 'playwright-build-1',
            'project': 'Cloud Testing Project',
            'browserstack.username': process.env.BROWSERSTACK_USERNAME,
            'browserstack.accessKey': process.env.BROWSERSTACK_ACCESS_KEY,
            'browserstack.local': process.env.BROWSERSTACK_LOCAL || false,
            'browserstack.debug': true,
            'client.playwrightVersion': clientPlaywrightVersion
          }))}`
        }
      }
    },
    {
      name: 'safari-monterey',
      use: {
        browserName: 'webkit',
        connectOptions: {
          wsEndpoint: `wss://cdp.browserstack.com/playwright?caps=${encodeURIComponent(JSON.stringify({
            'browser': 'safari',
            'browser_version': 'latest',
            'os': 'OS X',
            'os_version': 'Monterey',
            'name': 'Safari Playwright Test',
            'build': 'playwright-build-1',
            'browserstack.username': process.env.BROWSERSTACK_USERNAME,
            'browserstack.accessKey': process.env.BROWSERSTACK_ACCESS_KEY,
            'client.playwrightVersion': clientPlaywrightVersion
          }))}`
        }
      }
    }
  ]
});

// Node.js Appium example for BrowserStack
const { remote } = require('webdriverio');

const capabilities = {
  'platformName': 'Android',
  'platformVersion': '13.0',
  'deviceName': 'Google Pixel 7',
  'app': 'bs://your_app_id_here', // Upload app first
  'automationName': 'UiAutomator2',
  
  // BrowserStack capabilities
  'bstack:options': {
    'userName': process.env.BROWSERSTACK_USERNAME,
    'accessKey': process.env.BROWSERSTACK_ACCESS_KEY,
    'projectName': 'Mobile App Testing',
    'buildName': 'Android Build 1',
    'sessionName': 'Pixel 7 Test',
    'debug': true,
    'networkLogs': true,
    'deviceLogs': true,
    'appiumLogs': true,
    'video': true,
    'geoLocation': 'US'
  }
};

async function runTest() {
  const driver = await remote({
    protocol: 'https',
    hostname: 'hub-cloud.browserstack.com',
    port: 443,
    path: '/wd/hub',
    capabilities: capabilities
  });

  try {
    // Your test code here
    const element = await driver.$('~loginButton');
    await element.click();
    
    console.log('Test executed successfully');
  } catch (error) {
    console.error('Test failed:', error);
  } finally {
    await driver.deleteSession();
  }
}

runTest();

# Python example with Sauce Labs capabilities
from selenium import webdriver
from selenium.webdriver.remote.remote_connection import RemoteConnection
import os

username = os.environ.get('SAUCE_USERNAME')
access_key = os.environ.get('SAUCE_ACCESS_KEY')

# Sauce Labs capabilities
sauce_options = {
    'username': username,
    'accessKey': access_key,
    'name': 'Cloud Testing Platform Test',
    'build': 'sauce-build-1',
    'tags': ['cloud-testing', 'selenium'],
    
    # Recording and debugging
    'recordVideo': True,
    'recordScreenshots': True,
    'recordLogs': True,
    'extendedDebugging': True,
    'capturePerformance': True,
    
    # Timeouts
    'maxDuration': 3600,
    'commandTimeout': 300,
    'idleTimeout': 90
}

capabilities = {
    'browserName': 'chrome',
    'browserVersion': 'latest',
    'platformName': 'Windows 11',
    'sauce:options': sauce_options
}

# Data center selection
sauce_url = f'https://{username}:{access_key}@ondemand.us-west-1.saucelabs.com:443/wd/hub'
# For EU: ondemand.eu-central-1.saucelabs.com
# For US East: ondemand.us-east-4.saucelabs.com

driver = webdriver.Remote(
    command_executor=sauce_url,
    desired_capabilities=capabilities
)

try:
    driver.get('https://www.example.com')
    print(f'Page title: {driver.title}')
    
    # Mark test as passed
    driver.execute_script('sauce:job-result=passed')
except Exception as e:
    print(f'Test failed: {e}')
    driver.execute_script('sauce:job-result=failed')
finally:
    driver.quit()

// cypress.config.js for Sauce Labs
const { defineConfig } = require('cypress');

module.exports = defineConfig({
  e2e: {
    baseUrl: 'https://www.example.com',
    setupNodeEvents(on, config) {
      // Sauce Labs configuration
    },
  },
});

// sauce-config.yml
apiVersion: v1alpha
kind: cypress
sauce:
  region: us-west-1
  metadata:
    name: Cloud Testing Cypress Suite
    build: Build $BUILD_ID
    tags:
      - cloud-testing
      - cypress
  concurrency: 5
  
docker:
  image: saucelabs/stt-cypress-mocha-node:v8.7.0
  
cypress:
  configFile: cypress.config.js
  version: 12.5.0
  
suites:
  - name: "Chrome Desktop Tests"
    browser: chrome
    config:
      env:
        environment: production
    platformName: "Windows 11"
    screenResolution: "1920x1080"
    
  - name: "Firefox Desktop Tests"
    browser: firefox
    platformName: "Windows 10"
    screenResolution: "1920x1080"
    
  - name: "Safari Desktop Tests"
    browser: webkit
    platformName: "macOS 13"
    screenResolution: "1920x1080"

artifacts:
  download:
    when: always
    match:
      - console.log
      - "*.mp4"
    directory: ./artifacts

// playwright.config.js for Sauce Labs
const { defineConfig, devices } = require('@playwright/test');

module.exports = defineConfig({
  testDir: './tests',
  timeout: 30000,
  retries: 2,
  
  use: {
    baseURL: 'https://www.example.com',
    trace: 'on-first-retry',
  },

  projects: [
    {
      name: 'saucelabs-chrome',
      use: {
        ...devices['Desktop Chrome'],
        connectOptions: {
          wsEndpoint: {
            url: 'wss://ondemand.us-west-1.saucelabs.com/v1/playwright',
            headers: {
              'Authorization': `Basic ${Buffer.from(
                `${process.env.SAUCE_USERNAME}:${process.env.SAUCE_ACCESS_KEY}`
              ).toString('base64')}`
            }
          },
          options: {
            browserName: 'chromium',
            browserVersion: 'latest',
            platformName: 'Windows 11',
            'sauce:options': {
              name: 'Playwright Cloud Test',
              build: 'playwright-build-1',
              tags: ['cloud-testing'],
              extendedDebugging: true,
              capturePerformance: true
            }
          }
        }
      }
    }
  ]
});

# Ruby Appium example for Sauce Labs
require 'appium_lib'
require 'selenium-webdriver'

caps = {
  platformName: 'Android',
  'appium:platformVersion' => '13',
  'appium:deviceName' => 'Google Pixel 7 GoogleAPI Emulator',
  'appium:automationName' => 'UiAutomator2',
  'appium:app' => 'storage:filename=YourApp.apk',
  'appium:autoGrantPermissions' => true,
  'appium:noReset' => false,
  
  'sauce:options' => {
    username: ENV['SAUCE_USERNAME'],
    accessKey: ENV['SAUCE_ACCESS_KEY'],
    name: 'Android Mobile App Test',
    build: 'android-build-1',
    deviceOrientation: 'portrait',
    appiumVersion: '2.0.0',
    recordVideo: true,
    recordScreenshots: true
  }
}

appium_lib = {
  server_url: 'https://ondemand.us-west-1.saucelabs.com:443/wd/hub',
  wait_timeout: 30,
  wait_interval: 1
}

driver = Appium::Driver.new({ caps: caps, appium_lib: appium_lib }, true)

begin
  driver.start_driver
  
  # Your test code
  element = driver.find_element(:accessibility_id, 'loginButton')
  element.click
  
  puts 'Test passed'
  driver.execute_script('sauce:job-result=passed')
rescue => e
  puts "Test failed: #{e.message}"
  driver.execute_script('sauce:job-result=failed')
ensure
  driver.quit
end

// C# example with LambdaTest capabilities
using OpenQA.Selenium;
using OpenQA.Selenium.Remote;
using System;

namespace CloudTestingPlatform
{
    class LambdaTestExample
    {
        static void Main(string[] args)
        {
            string username = Environment.GetEnvironmentVariable("LT_USERNAME");
            string accessKey = Environment.GetEnvironmentVariable("LT_ACCESS_KEY");
            string gridUrl = $"https://{username}:{accessKey}@hub.lambdatest.com/wd/hub";

            var capabilities = new DesiredCapabilities();
            
            // Browser configuration
            capabilities.SetCapability("browserName", "Chrome");
            capabilities.SetCapability("browserVersion", "latest");
            capabilities.SetCapability("platform", "Windows 11");
            
            // LambdaTest specific options
            var ltOptions = new Dictionary<string, object>
            {
                {"username", username},
                {"accessKey", accessKey},
                {"name", "Cloud Testing Platform Test"},
                {"build", "lambdatest-build-1"},
                {"project", "Cloud Testing Project"},
                {"selenium_version", "4.15.0"},
                {"driver_version", "latest"},
                
                // Debugging options
                {"video", true},
                {"visual", true},
                {"network", true},
                {"console", true},
                {"terminal", true},
                
                // Performance options
                {"w3c", true},
                {"plugin", "c#-nunit"}
            };
            
            capabilities.SetCapability("LT:Options", ltOptions);

            var driver = new RemoteWebDriver(new Uri(gridUrl), capabilities);

            try
            {
                driver.Navigate().GoToUrl("https://www.example.com");
                Console.WriteLine($"Page title: {driver.Title}");
                
                // Mark test as passed
                ((IJavaScriptExecutor)driver).ExecuteScript("lambda-status=passed");
            }
            catch (Exception e)
            {
                Console.WriteLine($"Test failed: {e.Message}");
                ((IJavaScriptExecutor)driver).ExecuteScript("lambda-status=failed");
            }
            finally
            {
                driver.Quit();
            }
        }
    }
}

// lambdatest-config.json
{
  "lambdatest_auth": {
    "username": "YOUR_USERNAME",
    "access_key": "YOUR_ACCESS_KEY"
  },
  "browsers": [
    {
      "browser": "Chrome",
      "platform": "Windows 11",
      "versions": ["latest", "latest-1"]
    },
    {
      "browser": "MicrosoftEdge",
      "platform": "Windows 10",
      "versions": ["latest"]
    },
    {
      "browser": "Safari",
      "platform": "macOS Monterey",
      "versions": ["latest"]
    }
  ],
  "run_settings": {
    "cypress_config_file": "cypress.config.js",
    "reporter_config_file": "base_reporter_config.json",
    "build_name": "Cloud Testing Build",
    "parallels": 5,
    "specs": ["cypress/e2e/**/*.cy.js"],
    "ignore_files": [],
    "network": true,
    "headless": false,
    "npm_dependencies": {
      "cypress": "12.5.0"
    },
    "feature_file_suppport": false
  },
  "tunnel_settings": {
    "tunnel": false,
    "tunnel_name": null
  }
}

// package.json script
{
  "scripts": {
    "test:lambdatest": "lambdatest-cypress run --config-file lambdatest-config.json"
  }
}

// playwright.config.js for LambdaTest
const { defineConfig, devices } = require('@playwright/test');

const capabilities = {
  'browserName': 'Chrome',
  'browserVersion': 'latest',
  'LT:Options': {
    'platform': 'Windows 11',
    'build': 'Playwright Cloud Testing Build',
    'name': 'Playwright Test',
    'user': process.env.LT_USERNAME,
    'accessKey': process.env.LT_ACCESS_KEY,
    'network': true,
    'video': true,
    'console': true,
    'tunnel': false,
    'tunnelName': '',
    'geoLocation': 'US'
  }
};

module.exports = defineConfig({
  testDir: './tests',
  timeout: 60000,
  retries: 2,
  workers: 5,
  
  use: {
    baseURL: 'https://www.example.com',
    trace: 'retain-on-failure',
    connectOptions: {
      wsEndpoint: `wss://cdp.lambdatest.com/playwright?capabilities=${encodeURIComponent(JSON.stringify(capabilities))}`
    }
  },

  projects: [
    {
      name: 'chrome-windows',
      use: { 
        ...devices['Desktop Chrome'],
        capabilities
      }
    },
    {
      name: 'webkit-mac',
      use: {
        ...devices['Desktop Safari'],
        capabilities: {
          ...capabilities,
          'browserName': 'pw-webkit',
          'LT:Options': {
            ...capabilities['LT:Options'],
            'platform': 'macOS Monterey'
          }
        }
      }
    }
  ]
});

# hyperexecute.yaml
version: 0.1
globalTimeout: 90
testSuiteTimeout: 90
testSuiteStep: 90

runson: windows

autosplit: true
retryOnFailure: true
maxRetries: 2
concurrency: 5

pre:
  - npm install

cacheKey: '{{ checksum "package-lock.json" }}'
cacheDirectories:
  - node_modules

testDiscovery:
  type: raw
  mode: dynamic
  command: grep -rni 'describe' tests -ir --include=\*.spec.js | sed 's/:.*//'

testRunnerCommand: npm test $test

env:
  ENVIRONMENT: production
  HYPEREXECUTE: true

jobLabel: ['cloud-testing', 'hyperexecute', 'playwright']

# AWS CLI - Create a device pool
aws devicefarm create-device-pool \
  --project-arn "arn:aws:devicefarm:us-west-2:123456789012:project:a1b2c3d4" \
  --name "Android High-End Devices" \
  --description "Latest flagship Android devices" \
  --rules '[
    {
      "attribute": "PLATFORM",
      "operator": "EQUALS",
      "value": "ANDROID"
    },
    {
      "attribute": "OS_VERSION",
      "operator": "GREATER_THAN_OR_EQUALS",
      "value": "12"
    },
    {
      "attribute": "FORM_FACTOR",
      "operator": "EQUALS",
      "value": "PHONE"
    }
  ]'

// Node.js example for AWS Device Farm with Appium
const { remote } = require('webdriverio');
const AWS = require('aws-sdk');

// AWS Device Farm uses local Appium server
const capabilities = {
  platformName: 'Android',
  'appium:automationName': 'UiAutomator2',
  'appium:deviceName': 'Android Device',
  'appium:app': process.env.APP_PATH, // Uploaded app path
  'appium:autoGrantPermissions': true,
  'appium:noReset': false,
  'appium:newCommandTimeout': 300
};

async function runDeviceFarmTest() {
  const driver = await remote({
    hostname: 'localhost',
    port: 4723,
    path: '/wd/hub',
    logLevel: 'info',
    capabilities: capabilities
  });

  try {
    // Wait for app to load
    await driver.pause(3000);
    
    // Example test interactions
    const loginButton = await driver.$('~loginButton');
    await loginButton.waitForDisplayed({ timeout: 5000 });
    await loginButton.click();
    
    const usernameField = await driver.$('~usernameField');
    await usernameField.setValue('testuser@example.com');
    
    const passwordField = await driver.$('~passwordField');
    await passwordField.setValue('SecurePassword123');
    
    const submitButton = await driver.$('~submitButton');
    await submitButton.click();
    
    // Verify successful login
    const welcomeMessage = await driver.$('~welcomeMessage');
    await welcomeMessage.waitForDisplayed({ timeout: 10000 });
    
    const text = await welcomeMessage.getText();
    console.log(`Welcome message: ${text}`);
    
    // Test passed
    console.log('Test completed successfully');
  } catch (error) {
    console.error('Test failed:', error);
    throw error;
  } finally {
    await driver.deleteSession();
  }
}

// Entry point for Device Farm
if (require.main === module) {
  runDeviceFarmTest()
    .then(() => process.exit(0))
    .catch((error) => {
      console.error(error);
      process.exit(1);
    });
}

module.exports = { runDeviceFarmTest };

// Android Espresso test for AWS Device Farm
package com.example.cloudtesting;

import androidx.test.ext.junit.rules.ActivityScenarioRule;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import androidx.test.espresso.Espresso;
import androidx.test.espresso.action.ViewActions;
import androidx.test.espresso.assertion.ViewAssertions;
import androidx.test.espresso.matcher.ViewMatchers;

import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;

@RunWith(AndroidJUnit4.class)
public class DeviceFarmEspressoTest {
    
    @Rule
    public ActivityScenarioRule<MainActivity> activityRule = 
        new ActivityScenarioRule<>(MainActivity.class);

    @Test
    public void testLoginFlow() {
        // Enter username
        Espresso.onView(ViewMatchers.withId(R.id.username_field))
            .perform(ViewActions.typeText("testuser@example.com"));
        
        // Enter password
        Espresso.onView(ViewMatchers.withId(R.id.password_field))
            .perform(ViewActions.typeText("SecurePassword123"));
        
        // Close keyboard
        Espresso.closeSoftKeyboard();
        
        // Click login button
        Espresso.onView(ViewMatchers.withId(R.id.login_button))
            .perform(ViewActions.click());
        
        // Verify we're on the home screen
        Espresso.onView(ViewMatchers.withId(R.id.welcome_message))
            .check(ViewAssertions.matches(
                ViewMatchers.withText("Welcome, Test User!")
            ));
    }
    
    @Test
    public void testNavigationDrawer() {
        // Open navigation drawer
        Espresso.onView(ViewMatchers.withContentDescription("Open navigation drawer"))
            .perform(ViewActions.click());
        
        // Click on settings
        Espresso.onView(ViewMatchers.withText("Settings"))
            .perform(ViewActions.click());
        
        // Verify settings screen is displayed
        Espresso.onView(ViewMatchers.withId(R.id.settings_title))
            .check(ViewAssertions.matches(ViewMatchers.isDisplayed()));
    }
}

// iOS XCUITest for AWS Device Farm
import XCTest

class DeviceFarmXCUITest: XCTestCase {
    
    var app: XCUIApplication!
    
    override func setUp() {
        super.setUp()
        continueAfterFailure = false
        app = XCUIApplication()
        app.launch()
    }
    
    override func tearDown() {
        super.tearDown()
    }
    
    func testLoginFlow() {
        // Enter username
        let usernameField = app.textFields["usernameField"]
        XCTAssertTrue(usernameField.waitForExistence(timeout: 5))
        usernameField.tap()
        usernameField.typeText("testuser@example.com")
        
        // Enter password
        let passwordField = app.secureTextFields["passwordField"]
        XCTAssertTrue(passwordField.exists)
        passwordField.tap()
        passwordField.typeText("SecurePassword123")
        
        // Tap login button
        let loginButton = app.buttons["loginButton"]
        XCTAssertTrue(loginButton.exists)
        loginButton.tap()
        
        // Verify welcome message
        let welcomeMessage = app.staticTexts["welcomeMessage"]
        XCTAssertTrue(welcomeMessage.waitForExistence(timeout: 10))
        XCTAssertEqual(welcomeMessage.label, "Welcome, Test User!")
    }
    
    func testNavigationFlow() {
        // Tap profile tab
        let profileTab = app.tabBars.buttons["Profile"]
        XCTAssertTrue(profileTab.waitForExistence(timeout: 5))
        profileTab.tap()
        
        // Verify profile screen
        let profileTitle = app.navigationBars["Profile"]
        XCTAssertTrue(profileTitle.exists)
        
        // Tap settings button
        let settingsButton = app.buttons["settingsButton"]
        settingsButton.tap()
        
        // Verify settings screen
        let settingsTitle = app.navigationBars["Settings"]
        XCTAssertTrue(settingsTitle.waitForExistence(timeout: 5))
    }
    
    func testPerformanceScenario() {
        measure {
            // Launch app multiple times to measure performance
            app.launch()
            
            let mainView = app.otherElements["mainView"]
            XCTAssertTrue(mainView.waitForExistence(timeout: 5))
            
            app.terminate()
        }
    }
}

# .github/workflows/device-farm-tests.yml
name: AWS Device Farm Mobile Tests

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

jobs:
  device-farm-android:
    runs-on: ubuntu-latest
    
    steps:
      - uses: actions/checkout@v3
      
      - name: Set up JDK 11
        uses: actions/setup-java@v3
        with:
          java-version: '11'
          distribution: 'temurin'
      
      - name: Build Android App
        run: |
          cd android
          ./gradlew assembleDebug
          ./gradlew assembleAndroidTest
      
      - name: Configure AWS Credentials
        uses: aws-actions/configure-aws-credentials@v2
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws-region: us-west-2
      
      - name: Upload App to Device Farm
        id: upload-app
        run: |
          APP_ARN=$(aws devicefarm create-upload \
            --project-arn ${{ secrets.DEVICE_FARM_PROJECT_ARN }} \
            --name app-debug.apk \
            --type ANDROID_APP \
            --query 'upload.arn' \
            --output text)
          
          aws devicefarm put-upload \
            --arn $APP_ARN \
            --file android/app/build/outputs/apk/debug/app-debug.apk
          
          echo "app_arn=$APP_ARN" >> $GITHUB_OUTPUT
      
      - name: Upload Test Package
        id: upload-tests
        run: |
          TEST_ARN=$(aws devicefarm create-upload \
            --project-arn ${{ secrets.DEVICE_FARM_PROJECT_ARN }} \
            --name app-debug-androidTest.apk \
            --type INSTRUMENTATION_TEST_PACKAGE \
            --query 'upload.arn' \
            --output text)
          
          aws devicefarm put-upload \
            --arn $TEST_ARN \
            --file android/app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk
          
          echo "test_arn=$TEST_ARN" >> $GITHUB_OUTPUT
      
      - name: Schedule Test Run
        id: schedule-run
        run: |
          RUN_ARN=$(aws devicefarm schedule-run \
            --project-arn ${{ secrets.DEVICE_FARM_PROJECT_ARN }} \
            --app-arn ${{ steps.upload-app.outputs.app_arn }} \
            --device-pool-arn ${{ secrets.DEVICE_FARM_POOL_ARN }} \
            --name "GitHub Actions Run - ${{ github.run_number }}" \
            --test type=INSTRUMENTATION,testPackageArn=${{ steps.upload-tests.outputs.test_arn }} \
            --query 'run.arn' \
            --output text)
          
          echo "run_arn=$RUN_ARN" >> $GITHUB_OUTPUT
      
      - name: Wait for Test Results
        run: |
          while true; do
            STATUS=$(aws devicefarm get-run \
              --arn ${{ steps.schedule-run.outputs.run_arn }} \
              --query 'run.status' \
              --output text)
            
            echo "Current status: $STATUS"
            
            if [ "$STATUS" = "COMPLETED" ]; then
              break
            elif [ "$STATUS" = "ERRORED" ] || [ "$STATUS" = "FAILED" ]; then
              echo "Test run failed with status: $STATUS"
              exit 1
            fi
            
            sleep 30
          done
      
      - name: Get Test Results
        run: |
          aws devicefarm get-run \
            --arn ${{ steps.schedule-run.outputs.run_arn }} \
            --query 'run.counters' \
            --output table
          
          RESULT=$(aws devicefarm get-run \
            --arn ${{ steps.schedule-run.outputs.run_arn }} \
            --query 'run.result' \
            --output text)
          
          if [ "$RESULT" != "PASSED" ]; then
            echo "Tests failed with result: $RESULT"
            exit 1
          fi

// Jenkinsfile for AWS Device Farm
pipeline {
    agent any
    
    environment {
        AWS_REGION = 'us-west-2'
        DEVICE_FARM_PROJECT_ARN = credentials('device-farm-project-arn')
        DEVICE_FARM_POOL_ARN = credentials('device-farm-pool-arn')
    }
    
    stages {
        stage('Build Android App') {
            steps {
                dir('android') {
                    sh './gradlew clean assembleDebug assembleAndroidTest'
                }
            }
        }
        
        stage('Upload to Device Farm') {
            steps {
                script {
                    // Upload app
                    def appUpload = sh(
                        script: """
                            aws devicefarm create-upload \
                                --project-arn ${DEVICE_FARM_PROJECT_ARN} \
                                --name app-debug.apk \
                                --type ANDROID_APP \
                                --query 'upload.[arn,url]' \
                                --output text
                        """,
                        returnStdout: true
                    ).trim().split()
                    
                    env.APP_ARN = appUpload[0]
                    env.APP_URL = appUpload[1]
                    
                    sh "curl -T android/app/build/outputs/apk/debug/app-debug.apk '${APP_URL}'"
                    
                    // Upload test package
                    def testUpload = sh(
                        script: """
                            aws devicefarm create-upload \
                                --project-arn ${DEVICE_FARM_PROJECT_ARN} \
                                --name app-debug-androidTest.apk \
                                --type INSTRUMENTATION_TEST_PACKAGE \
                                --query 'upload.[arn,url]' \
                                --output text
                        """,
                        returnStdout: true
                    ).trim().split()
                    
                    env.TEST_ARN = testUpload[0]
                    env.TEST_URL = testUpload[1]
                    
                    sh "curl -T android/app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk '${TEST_URL}'"
                }
            }
        }
        
        stage('Run Tests on Device Farm') {
            steps {
                script {
                    env.RUN_ARN = sh(
                        script: """
                            aws devicefarm schedule-run \
                                --project-arn ${DEVICE_FARM_PROJECT_ARN} \
                                --app-arn ${APP_ARN} \
                                --device-pool-arn ${DEVICE_FARM_POOL_ARN} \
                                --name "Jenkins Build ${BUILD_NUMBER}" \
                                --test type=INSTRUMENTATION,testPackageArn=${TEST_ARN} \
                                --query 'run.arn' \
                                --output text
                        """,
                        returnStdout: true
                    ).trim()
                    
                    echo "Test run scheduled: ${RUN_ARN}"
                }
            }
        }
        
        stage('Wait for Results') {
            steps {
                script {
                    timeout(time: 60, unit: 'MINUTES') {
                        waitUntil {
                            def status = sh(
                                script: """
                                    aws devicefarm get-run \
                                        --arn ${RUN_ARN} \
                                        --query 'run.status' \
                                        --output text
                                """,
                                returnStdout: true
                            ).trim()
                            
                            echo "Current status: ${status}"
                            
                            return status == 'COMPLETED' || status == 'ERRORED' || status == 'FAILED'
                        }
                    }
                    
                    def result = sh(
                        script: """
                            aws devicefarm get-run \
                                --arn ${RUN_ARN} \
                                --query 'run.result' \
                                --output text
                        """,
                        returnStdout: true
                    ).trim()
                    
                    if (result != 'PASSED') {
                        error("Tests failed with result: ${result}")
                    }
                }
            }
        }
        
        stage('Download Artifacts') {
            steps {
                script {
                    sh """
                        aws devicefarm list-artifacts \
                            --arn ${RUN_ARN} \
                            --type FILE \
                            --query 'artifacts[*].[name,url]' \
                            --output text | while read name url; do
                                curl -o "artifacts/\${name}" "\${url}"
                            done
                    """
                }
                archiveArtifacts artifacts: 'artifacts/**', allowEmptyArchive: true
            }
        }
    }
    
    post {
        always {
            echo "Test run details: https://us-west-2.console.aws.amazon.com/devicefarm/home"
        }
    }
}

# Run Robo test via gcloud CLI
gcloud firebase test android run \
  --type robo \
  --app app/build/outputs/apk/debug/app-debug.apk \
  --device model=Pixel7,version=33,locale=en,orientation=portrait \
  --device model=galaxys23,version=33,locale=en,orientation=portrait \
  --timeout 5m \
  --results-bucket=gs://your-bucket-name \
  --results-dir=robo-test-results

{
  "robo_script": [
    {
      "action_type": "WAIT_FOR_ELEMENT",
      "optional": false,
      "resource_name": "username_field"
    },
    {
      "action_type": "ENTER_TEXT",
      "resource_name": "username_field",
      "input_text": "testuser@example.com"
    },
    {
      "action_type": "ENTER_TEXT",
      "resource_name": "password_field",
      "input_text": "TestPassword123"
    },
    {
      "action_type": "CLICK",
      "resource_name": "login_button"
    },
    {
      "action_type": "WAIT_FOR_ELEMENT",
      "optional": false,
      "resource_name": "home_screen",
      "timeout": 10000
    }
  ]
}

# Run with Robo script
gcloud firebase test android run \
  --type robo \
  --app app-debug.apk \
  --robo-script robo_script.json \
  --device model=Pixel7,version=33

# Run Espresso instrumentation tests
gcloud firebase test android run \
  --type instrumentation \
  --app app/build/outputs/apk/debug/app-debug.apk \
  --test app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk \
  --device model=Pixel7,version=33,locale=en,orientation=portrait \
  --device model=Pixel6,version=32,locale=en,orientation=portrait \
  --device model=galaxys22,version=32,locale=en,orientation=landscape \
  --timeout 30m \
  --results-bucket=gs://your-bucket-name \
  --results-dir=espresso-test-results \
  --environment-variables coverage=true,coverageFile="/sdcard/coverage.ec" \
  --directories-to-pull /sdcard

# Test matrix with multiple dimensions
gcloud firebase test android run \
  --type instrumentation \
  --app app-debug.apk \
  --test app-debug-androidTest.apk \
  --device-ids Pixel7,Pixel6,galaxys22 \
  --os-version-ids 33,32 \
  --locales en,es,ru \
  --orientations portrait,landscape

# Build iOS app for testing
xcodebuild build-for-testing \
  -workspace YourApp.xcworkspace \
  -scheme YourApp \
  -sdk iphoneos \
  -configuration Debug \
  -derivedDataPath build

# Create test archive
cd build/Build/Products
zip -r YourApp.zip Debug-iphoneos/*.app
zip -r YourAppTests.zip Debug-iphoneos/*.xctestrun

# Run on Firebase Test Lab
gcloud firebase test ios run \
  --test YourAppTests.zip \
  --device model=iphone14pro,version=16.6,locale=en,orientation=portrait \
  --device model=iphone13,version=16.6,locale=en,orientation=portrait \
  --timeout 30m \
  --results-bucket=gs://your-bucket-name \
  --results-dir=ios-test-results

// app/build.gradle
android {
    defaultConfig {
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }
    
    testOptions {
        execution 'ANDROIDX_TEST_ORCHESTRATOR'
    }
}

dependencies {
    androidTestImplementation 'androidx.test.ext:junit:1.1.5'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
    androidTestUtil 'androidx.test:orchestrator:1.4.2'
}

// Add Firebase Test Lab configuration
// Create testlab.yml in project root

# testlab.yml
gcloud:
  test: |
    gcloud firebase test android run \
      --type instrumentation \
      --app app/build/outputs/apk/debug/app-debug.apk \
      --test app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk \
      --device model=Pixel7,version=33 \
      --device model=Pixel6,version=32 \
      --timeout 20m

# Device matrix configuration
devices:
  - model: Pixel7
    version: 33
    locale: en
    orientation: portrait
  
  - model: Pixel6
    version: 32
    locale: en
    orientation: portrait
  
  - model: galaxys22
    version: 32
    locale: en
    orientation: portrait

# Test configuration
test_configuration:
  timeout: 20m
  results_bucket: gs://your-bucket-name
  environment_variables:
    - key: coverage
      value: true
    - key: clearPackageData
      value: true

# .github/workflows/firebase-test-lab.yml
name: Firebase Test Lab

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    
    steps:
      - uses: actions/checkout@v3
      
      - name: Set up JDK 17
        uses: actions/setup-java@v3
        with:
          java-version: '17'
          distribution: 'temurin'
      
      - name: Build App and Tests
        run: |
          chmod +x gradlew
          ./gradlew assembleDebug assembleDebugAndroidTest
      
      - name: Authenticate to Google Cloud
        uses: google-github-actions/auth@v1
        with:
          credentials_json: ${{ secrets.GCP_SA_KEY }}
      
      - name: Set up Cloud SDK
        uses: google-github-actions/setup-gcloud@v1
      
      - name: Run Tests on Firebase Test Lab
        run: |
          gcloud firebase test android run \
            --type instrumentation \
            --app app/build/outputs/apk/debug/app-debug.apk \
            --test app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk \
            --device model=Pixel7,version=33,locale=en,orientation=portrait \
            --device model=Pixel6,version=32,locale=en,orientation=portrait \
            --timeout 30m \
            --results-bucket=gs://${{ secrets.GCS_BUCKET }} \
            --results-dir=github-actions-${GITHUB_RUN_NUMBER} \
            --format=json \
            --no-record-video \
            --no-performance-metrics
      
      - name: Download Test Results
        if: always()
        run: |
          gsutil -m cp -r \
            gs://${{ secrets.GCS_BUCKET }}/github-actions-${GITHUB_RUN_NUMBER} \
            ./test-results
      
      - name: Upload Test Results
        if: always()
        uses: actions/upload-artifact@v3
        with:
          name: firebase-test-results
          path: test-results/

# .gitlab-ci.yml
stages:
  - build
  - test

variables:
  ANDROID_COMPILE_SDK: "33"
  ANDROID_BUILD_TOOLS: "33.0.2"

build:
  stage: build
  image: openjdk:17-jdk
  before_script:
    - apt-get update && apt-get install -y wget unzip
    - wget -q https://dl.google.com/android/repository/commandlinetools-linux-9477386_latest.zip
    - unzip -q commandlinetools-linux-9477386_latest.zip -d android-sdk
    - export ANDROID_HOME=$PWD/android-sdk
    - export PATH=$PATH:$ANDROID_HOME/cmdline-tools/bin:$ANDROID_HOME/platform-tools
  script:
    - chmod +x gradlew
    - ./gradlew assembleDebug assembleDebugAndroidTest
  artifacts:
    paths:
      - app/build/outputs/apk/debug/
      - app/build/outputs/apk/androidTest/debug/

firebase_test:
  stage: test
  image: google/cloud-sdk:alpine
  dependencies:
    - build
  before_script:
    - echo $GCP_SA_KEY | base64 -d > ${HOME}/gcp-key.json
    - gcloud auth activate-service-account --key-file ${HOME}/gcp-key.json
    - gcloud config set project $GCP_PROJECT_ID
  script:
    - |
      gcloud firebase test android run \
        --type instrumentation \
        --app app/build/outputs/apk/debug/app-debug.apk \
        --test app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk \
        --device model=Pixel7,version=33 \
        --device model=Pixel6,version=32 \
        --timeout 30m \
        --results-bucket=gs://$GCS_BUCKET \
        --results-dir=gitlab-ci-${CI_PIPELINE_ID}
  after_script:
    - gsutil -m cp -r gs://$GCS_BUCKET/gitlab-ci-${CI_PIPELINE_ID} ./test-results
  artifacts:
    when: always
    paths:
      - test-results/

# fastlane/Fastfile
platform :android do
  desc "Run tests on Firebase Test Lab"
  lane :firebase_test do
    gradle(task: "assembleDebug assembleDebugAndroidTest")
    
    firebase_test_lab_android(
      project_id: ENV['GCP_PROJECT_ID'],
      model: "Pixel7,Pixel6,galaxys22",
      version: "33,32",
      locale: "en",
      orientation: "portrait",
      timeout: "30m",
      app_apk: "app/build/outputs/apk/debug/app-debug.apk",
      android_test_apk: "app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk",
      results_bucket: ENV['GCS_BUCKET'],
      results_dir: "fastlane-#{Time.now.to_i}"
    )
  end
end

platform :ios do
  desc "Run tests on Firebase Test Lab"
  lane :firebase_test do
    build_for_testing(
      workspace: "YourApp.xcworkspace",
      scheme: "YourApp",
      configuration: "Debug"
    )
    
    firebase_test_lab_ios(
      project_id: ENV['GCP_PROJECT_ID'],
      model: "iphone14pro,iphone13",
      version: "16.6",
      locale: "en",
      orientation: "portrait",
      timeout: "30m",
      app_path: "build/Build/Products/Debug-iphoneos/YourApp.app",
      test_path: "build/Build/Products/Debug-iphoneos/YourAppTests.xctestrun",
      results_bucket: ENV['GCS_BUCKET'],
      results_dir: "fastlane-ios-#{Time.now.to_i}"
    )
  end
end

// Calculate optimal parallelization
function calculateOptimalParallels(totalTests, avgTestDuration, targetDuration, costPerMinute) {
  // Sequential execution time
  const sequentialTime = totalTests * avgTestDuration;
  
  // Required parallels for target duration
  const requiredParallels = Math.ceil(sequentialTime / targetDuration);
  
  // Cost comparison
  const sequentialCost = sequentialTime * costPerMinute;
  const parallelCost = targetDuration * requiredParallels * costPerMinute;
  
  return {
    sequentialTime: sequentialTime,
    sequentialCost: sequentialCost.toFixed(2),
    optimalParallels: requiredParallels,
    parallelTime: targetDuration,
    parallelCost: parallelCost.toFixed(2),
    savings: (sequentialTime - targetDuration).toFixed(2),
    additionalCost: (parallelCost - sequentialCost).toFixed(2)
  };
}

// Example calculation
const result = calculateOptimalParallels(
  500,    // total tests
  2,      // 2 minutes per test
  20,     // target: complete in 20 minutes
  0.10    // $0.10 per minute (platform rate)
);

console.log(result);
// Output:
// {
//   sequentialTime: 1000,
//   sequentialCost: "100.00",
//   optimalParallels: 50,
//   parallelTime: 20,
//   parallelCost: "100.00",
//   savings: "980.00",
//   additionalCost: "0.00"
// }

# Session optimization decorator
import time
from functools import wraps

def optimize_session(func):
    """
    Decorator to track and optimize session duration
    """
    @wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        
        try:
            result = func(*args, **kwargs)
            return result
        finally:
            end_time = time.time()
            duration = end_time - start_time
            
            print(f"Session duration: {duration:.2f} seconds")
            
            # Alert if session exceeds threshold
            if duration > 300:  # 5 minutes
                print(f"WARNING: Session exceeded 5 minutes - optimize test!")
    
    return wrapper

# Apply to test functions
@optimize_session
def test_user_login(driver):
    driver.get("https://example.com/login")
    # ... test implementation
    driver.quit()

# Batch operations to reduce session time
class OptimizedTestExecution:
    def __init__(self, driver):
        self.driver = driver
        self.results = []
    
    def execute_test_batch(self, test_urls):
        """
        Execute multiple related tests in single session
        """
        for url in test_urls:
            try:
                self.driver.get(url)
                # Perform assertions
                self.results.append({
                    'url': url,
                    'status': 'passed',
                    'duration': time.time()
                })
            except Exception as e:
                self.results.append({
                    'url': url,
                    'status': 'failed',
                    'error': str(e)
                })
        
        return self.results

# Example usage
test_urls = [
    "https://example.com/page1",
    "https://example.com/page2",
    "https://example.com/page3"
]

executor = OptimizedTestExecution(driver)
results = executor.execute_test_batch(test_urls)

# Download and start BrowserStack Local
./BrowserStackLocal --key YOUR_ACCESS_KEY --force-local

# Start with custom configuration
./BrowserStackLocal \
  --key YOUR_ACCESS_KEY \
  --local-identifier "my-tunnel-123" \
  --force-local \
  --only-automate \
  --verbose 3

# Test configuration with local testing
capabilities = {
    'browserstack.local': 'true',
    'browserstack.localIdentifier': 'my-tunnel-123'
}

# Download and start Sauce Connect
./sc -u YOUR_USERNAME -k YOUR_ACCESS_KEY

# Start with tunnel identifier
./sc -u YOUR_USERNAME -k YOUR_ACCESS_KEY \
  --tunnel-identifier my-tunnel-123 \
  --readyfile /tmp/sc_ready \
  --logfile /tmp/sc.log

# Test configuration
sauce_options = {
    'tunnelIdentifier': 'my-tunnel-123'
}

# Start LambdaTest tunnel
./LT --user YOUR_USERNAME --key YOUR_ACCESS_KEY

# With tunnel name
./LT --user YOUR_USERNAME --key YOUR_ACCESS_KEY \
  --tunnelName my-tunnel-123 \
  --verbose

# Test configuration
lt_options = {
    'tunnel': True,
    'tunnelName': 'my-tunnel-123'
}

// BrowserStack - Disable video for faster execution
const capabilities = {
    'browserstack.video': false,          // Disable video recording
    'browserstack.debug': false,          // Disable console logs
    'browserstack.networkLogs': false,    // Disable network logs
    'browserstack.console': 'disable',    // Disable console capture
};

// Enable only on failure
const capabilitiesConditional = {
    'browserstack.video': process.env.TEST_FAILED === 'true',
};

// Sauce Labs - Video only on failure
const sauceOptions = {
    'recordVideo': false,               // Don't record by default
    'recordScreenshots': false,         // No screenshots
    'recordLogs': false,                // No logs
    'videoUploadOnPass': false,         // Upload video only on failure
};

// LambdaTest - Optimized settings
const ltOptions = {
    'video': false,                     // Disable video
    'visual': false,                    // Disable visual logs
    'network': false,                   // Disable network logs
    'console': false,                   // Disable console logs
    'terminal': false,                  // Disable terminal logs
};

// Conditional recording based on test result
class ConditionalRecordingTest {
    constructor(driver, capabilities) {
        this.driver = driver;
        this.capabilities = capabilities;
        this.testFailed = false;
    }
    
    async runTest() {
        try {
            // Execute test
            await this.executeTestSteps();
        } catch (error) {
            this.testFailed = true;
            
            // Enable recording for failed test
            if (this.capabilities.platform === 'browserstack') {
                await this.driver.executeScript('browserstack_executor: {"action": "setDebug", "arguments": {"value": true}}');
            }
            
            throw error;
        }
    }
    
    async executeTestSteps() {
        // Your test implementation
    }
}

# device-pools.yml
# Define device pools by priority

tier1_critical:
  description: "Critical devices for every test run"
  devices:
    - Chrome Latest / Windows 11
    - Safari Latest / macOS Monterey
    - Chrome Latest / Android 13
    - Safari Latest / iOS 16
  frequency: "every commit"
  cost_per_run: "$5"

tier2_important:
  description: "Important devices for daily regression"
  devices:
    - Firefox Latest / Windows 11
    - Edge Latest / Windows 11
    - Chrome Latest / Android 12
    - Safari Latest / iOS 15
  frequency: "daily"
  cost_per_run: "$5"

tier3_extended:
  description: "Extended coverage for weekly testing"
  devices:
    - Chrome Latest-1 / Windows 10
    - Safari Latest-1 / macOS Big Sur
    - Firefox Latest / macOS
    - Various mobile devices (10+)
  frequency: "weekly"
  cost_per_run: "$20"

tier4_comprehensive:
  description: "Full coverage for pre-release"
  devices:
    - All browsers
    - All OS versions
    - All mobile devices
  frequency: "before release"
  cost_per_run: "$100"

// Dynamic device selection based on context
class SmartDeviceSelector {
    constructor(testType, branch, changeSize) {
        this.testType = testType;
        this.branch = branch;
        this.changeSize = changeSize;
    }
    
    selectDevicePool() {
        // Critical path changes - full testing
        if (this.isCriticalPath()) {
            return 'tier4_comprehensive';
        }
        
        // Production branch - extended testing
        if (this.branch === 'main' || this.branch === 'production') {
            return 'tier2_important';
        }
        
        // Large changes - important devices
        if (this.changeSize > 500) {
            return 'tier2_important';
        }
        
        // Small changes - critical devices only
        return 'tier1_critical';
    }
    
    isCriticalPath() {
        const criticalPaths = [
            'checkout', 'payment', 'authentication',
            'registration', 'search', 'cart'
        ];
        
        return criticalPaths.some(path => 
            this.testType.toLowerCase().includes(path)
        );
    }
    
    estimateCost() {
        const costs = {
            'tier1_critical': 5,
            'tier2_important': 10,
            'tier3_extended': 20,
            'tier4_comprehensive': 100
        };
        
        return costs[this.selectDevicePool()];
    }
}

// Usage in CI/CD
const selector = new SmartDeviceSelector(
    process.env.TEST_TYPE,
    process.env.BRANCH_NAME,
    parseInt(process.env.FILES_CHANGED)
);

const devicePool = selector.selectDevicePool();
const estimatedCost = selector.estimateCost();

console.log(`Selected device pool: ${devicePool}`);
console.log(`Estimated cost: $${estimatedCost}`);

# test_selector.py
import json
import subprocess
from typing import List, Dict

class TestSelector:
    def __init__(self):
        self.test_history = self.load_test_history()
        self.changed_files = self.get_changed_files()
    
    def get_changed_files(self) -> List[str]:
        """Get list of changed files from git"""
        result = subprocess.run(
            ['git', 'diff', '--name-only', 'HEAD^', 'HEAD'],
            capture_output=True,
            text=True
        )
        return result.stdout.strip().split('\n')
    
    def load_test_history(self) -> Dict:
        """Load historical test data"""
        try:
            with open('test_history.json', 'r') as f:
                return json.load(f)
        except FileNotFoundError:
            return {}
    
    def calculate_priority(self, test_name: str) -> int:
        """
        Calculate test priority based on multiple factors:
        - Failure rate (higher = more priority)
        - Execution time (lower = more priority)
        - Last run time (longer ago = more priority)
        - Business criticality
        """
        if test_name not in self.test_history:
            return 100  # New tests get high priority
        
        test_data = self.test_history[test_name]
        
        failure_rate = test_data.get('failure_rate', 0) * 40
        time_factor = (1 / test_data.get('avg_duration', 1)) * 20
        staleness = test_data.get('days_since_run', 0) * 2
        criticality = test_data.get('criticality', 5) * 10
        
        priority = failure_rate + time_factor + staleness + criticality
        return int(priority)
    
    def select_tests(self, max_tests: int = 50) -> List[str]:
        """Select most important tests to run"""
        # Get all tests
        all_tests = self.get_all_tests()
        
        # Calculate priorities
        test_priorities = [
            (test, self.calculate_priority(test))
            for test in all_tests
        ]
        
        # Sort by priority
        test_priorities.sort(key=lambda x: x[1], reverse=True)
        
        # Select top N tests
        selected = [test for test, priority in test_priorities[:max_tests]]
        
        return selected
    
    def get_affected_tests(self) -> List[str]:
        """Get tests affected by changed files"""
        affected_tests = set()
        
        for changed_file in self.changed_files:
            # Map source files to test files
            if changed_file.startswith('src/'):
                # Simple mapping: src/components/Login.js -> tests/Login.test.js
                test_file = changed_file.replace('src/', 'tests/').replace('.js', '.test.js')
                affected_tests.add(test_file)
            
            # Check test coverage mapping
            if changed_file in self.test_history.get('coverage_map', {}):
                affected_tests.update(
                    self.test_history['coverage_map'][changed_file]
                )
        
        return list(affected_tests)
    
    def get_all_tests(self) -> List[str]:
        """Get list of all test files"""
        result = subprocess.run(
            ['find', 'tests', '-name', '*.test.js'],
            capture_output=True,
            text=True
        )
        return result.stdout.strip().split('\n')

# Usage
selector = TestSelector()

# Strategy 1: Run only affected tests
affected_tests = selector.get_affected_tests()
print(f"Running {len(affected_tests)} affected tests")

# Strategy 2: Run top priority tests
priority_tests = selector.select_tests(max_tests=50)
print(f"Running top 50 priority tests")

# Strategy 3: Hybrid approach
if len(affected_tests) > 0:
    tests_to_run = affected_tests
else:
    tests_to_run = priority_tests[:20]  # Run top 20 if no affected tests

print(f"Selected tests: {tests_to_run}")

// Selenium WebDriver - Headless Chrome
const { Builder } = require('selenium-webdriver');
const chrome = require('selenium-webdriver/chrome');

// Headless configuration
const options = new chrome.Options();
options.addArguments('--headless=new');
options.addArguments('--disable-gpu');
options.addArguments('--no-sandbox');
options.addArguments('--disable-dev-shm-usage');
options.addArguments('--window-size=1920,1080');

const driver = await new Builder()
    .forBrowser('chrome')
    .setChromeOptions(options)
    .build();

// Playwright - Headless mode (default)
const { chromium } = require('playwright');

const browser = await chromium.launch({
    headless: true,  // Default
    args: ['--no-sandbox', '--disable-dev-shm-usage']
});

const context = await browser.newContext({
    viewport: { width: 1920, height: 1080 }
});

# GitHub Actions with caching
name: Optimized Cloud Tests

on: [push]

jobs:
  test:
    runs-on: ubuntu-latest
    
    steps:
      - uses: actions/checkout@v3
      
      # Cache node modules
      - name: Cache Node Modules
        uses: actions/cache@v3
        with:
          path: node_modules
          key: ${{ runner.os }}-node-${{ hashFiles('package-lock.json') }}
          restore-keys: |
            ${{ runner.os }}-node-
      
      # Cache Playwright browsers
      - name: Cache Playwright Browsers
        uses: actions/cache@v3
        with:
          path: ~/.cache/ms-playwright
          key: ${{ runner.os }}-playwright-${{ hashFiles('package-lock.json') }}
      
      # Install dependencies (uses cache if available)
      - name: Install Dependencies
        run: npm ci
      
      # Run tests
      - name: Run Tests
        run: npm test