Plataformas de Pruebas en la Nube: Guía Completa de BrowserStack, Sauce Labs, AWS Device Farm y Más

// Ejemplo Java con capacidades de BrowserStack
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 = "tu_usuario";
    public static final String AUTOMATE_KEY = "tu_clave_de_acceso";
    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();
        
        // Configuración de navegador y SO
        caps.setCapability("os", "Windows");
        caps.setCapability("os_version", "11");
        caps.setCapability("browser", "Chrome");
        caps.setCapability("browser_version", "latest");
        
        // Capacidades específicas de BrowserStack
        caps.setCapability("name", "Prueba de Plataforma Cloud");
        caps.setCapability("build", "browserstack-build-1");
        caps.setCapability("project", "Proyecto de Pruebas Cloud");
        
        // Capacidades de depuración
        caps.setCapability("browserstack.debug", "true");
        caps.setCapability("browserstack.console", "verbose");
        caps.setCapability("browserstack.networkLogs", "true");
        
        // Pruebas locales
        caps.setCapability("browserstack.local", "true");
        caps.setCapability("browserstack.localIdentifier", "Test123");
        
        WebDriver driver = new RemoteWebDriver(new URL(URL), caps);
        driver.get("https://www.ejemplo.com");
        
        System.out.println("Título de página: " + driver.getTitle());
        
        driver.quit();
    }
}

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

module.exports = defineConfig({
  e2e: {
    baseUrl: 'https://www.ejemplo.com',
    setupNodeEvents(on, config) {
      // Configuración específica de BrowserStack
      require('cypress-browserstack')(on, config);
      return config;
    },
  },
});

// browserstack.json
{
  "auth": {
    "username": "TU_USUARIO",
    "access_key": "TU_CLAVE_DE_ACCESO"
  },
  "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": "Proyecto de Pruebas Cloud",
    "build_name": "build-1",
    "parallels": 5,
    "specs": ["cypress/e2e/**/*.cy.js"]
  },
  "connection_settings": {
    "local": false,
    "local_identifier": null
  }
}

// playwright.config.js para BrowserStack
const { defineConfig, devices } = require('@playwright/test') (como se discute en [TestComplete Commercial Tool: ROI Analysis and Enterprise Test Automation](/blog/testcomplete-commercial));
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.ejemplo.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': 'Prueba Playwright Cloud',
            'build': 'playwright-build-1',
            'project': 'Proyecto de Pruebas Cloud',
            '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
          }))}`
        }
      }
    }
  ]
});

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

const capabilities = {
  'platformName': 'Android',
  'platformVersion': '13.0',
  'deviceName': 'Google Pixel 7',
  'app': 'bs://tu_id_de_app_aqui', // Primero sube la app
  'automationName': 'UiAutomator2',
  
  // Capacidades de BrowserStack
  'bstack:options': {
    'userName': process.env.BROWSERSTACK_USERNAME,
    'accessKey': process.env.BROWSERSTACK_ACCESS_KEY,
    'projectName': 'Pruebas de App Móvil',
    'buildName': 'Android Build 1',
    'sessionName': 'Prueba Pixel 7',
    '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 {
    // Tu código de prueba aquí
    const element = await driver.$('~loginButton');
    await element.click();
    
    console.log('Prueba ejecutada exitosamente');
  } catch (error) {
    console.error('Prueba fallida:', error);
  } finally {
    await driver.deleteSession();
  }
}

runTest();

# Ejemplo Python con capacidades de Sauce Labs
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')

# Capacidades de Sauce Labs
sauce_options = {
    'username': username,
    'accessKey': access_key,
    'name': 'Prueba de Plataforma Cloud',
    'build': 'sauce-build-1',
    'tags': ['cloud-testing', 'selenium'],
    
    # Grabación y depuración
    'recordVideo': True,
    'recordScreenshots': True,
    'recordLogs': True,
    'extendedDebugging': True,
    'capturePerformance': True,
    
    # Tiempos de espera
    'maxDuration': 3600,
    'commandTimeout': 300,
    'idleTimeout': 90
}

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

# Selección de centro de datos
sauce_url = f'https://{username}:{access_key}@ondemand.us-west-1.saucelabs.com:443/wd/hub'
# Para EU: ondemand.eu-central-1.saucelabs.com
# Para US East: ondemand.us-east-4.saucelabs.com

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

try:
    driver.get('https://www.ejemplo.com')
    print(f'Título de página: {driver.title}')
    
    # Marcar prueba como pasada
    driver.execute_script('sauce:job-result=passed')
except Exception as e:
    print(f'Prueba fallida: {e}')
    driver.execute_script('sauce:job-result=failed')
finally:
    driver.quit()

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

module.exports = defineConfig({
  e2e: {
    baseUrl: 'https://www.ejemplo.com',
    setupNodeEvents(on, config) {
      // Configuración de Sauce Labs
    },
  },
});

// sauce-config.yml
apiVersion: v1alpha
kind: cypress
sauce:
  region: us-west-1
  metadata:
    name: Suite Cypress de Pruebas Cloud
    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: "Pruebas Chrome Desktop"
    browser: chrome
    config:
      env:
        environment: production
    platformName: "Windows 11"
    screenResolution: "1920x1080"
    
  - name: "Pruebas Firefox Desktop"
    browser: firefox
    platformName: "Windows 10"
    screenResolution: "1920x1080"
    
  - name: "Pruebas Safari Desktop"
    browser: webkit
    platformName: "macOS 13"
    screenResolution: "1920x1080"

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

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

module.exports = defineConfig({
  testDir: './tests',
  timeout: 30000,
  retries: 2,
  
  use: {
    baseURL: 'https://www.ejemplo.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: 'Prueba Cloud Playwright',
              build: 'playwright-build-1',
              tags: ['cloud-testing'],
              extendedDebugging: true,
              capturePerformance: true
            }
          }
        }
      }
    }
  ]
});

# Ejemplo Ruby Appium para 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=TuApp.apk',
  'appium:autoGrantPermissions' => true,
  'appium:noReset' => false,
  
  'sauce:options' => {
    username: ENV['SAUCE_USERNAME'],
    accessKey: ENV['SAUCE_ACCESS_KEY'],
    name: 'Prueba App Móvil Android',
    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
  
  # Tu código de prueba
  element = driver.find_element(:accessibility_id, 'loginButton')
  element.click
  
  puts 'Prueba pasada'
  driver.execute_script('sauce:job-result=passed')
rescue => e
  puts "Prueba fallida: #{e.message}"
  driver.execute_script('sauce:job-result=failed')
ensure
  driver.quit
end

// Ejemplo C# con capacidades de LambdaTest
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();
            
            // Configuración de navegador
            capabilities.SetCapability("browserName", "Chrome");
            capabilities.SetCapability("browserVersion", "latest");
            capabilities.SetCapability("platform", "Windows 11");
            
            // Opciones específicas de LambdaTest
            var ltOptions = new Dictionary<string, object>
            {
                {"username", username},
                {"accessKey", accessKey},
                {"name", "Prueba de Plataforma Cloud"},
                {"build", "lambdatest-build-1"},
                {"project", "Proyecto de Pruebas Cloud"},
                {"selenium_version", "4.15.0"},
                {"driver_version", "latest"},
                
                // Opciones de depuración
                {"video", true},
                {"visual", true},
                {"network", true},
                {"console", true},
                {"terminal", true},
                
                // Opciones de rendimiento
                {"w3c", true},
                {"plugin", "c#-nunit"}
            };
            
            capabilities.SetCapability("LT:Options", ltOptions);

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

            try
            {
                driver.Navigate().GoToUrl("https://www.ejemplo.com");
                Console.WriteLine($"Título de página: {driver.Title}");
                
                // Marcar prueba como pasada
                ((IJavaScriptExecutor)driver).ExecuteScript("lambda-status=passed");
            }
            catch (Exception e)
            {
                Console.WriteLine($"Prueba fallida: {e.Message}");
                ((IJavaScriptExecutor)driver).ExecuteScript("lambda-status=failed");
            }
            finally
            {
                driver.Quit();
            }
        }
    }
}

// lambdatest-config.json
{
  "lambdatest_auth": {
    "username": "TU_USUARIO",
    "access_key": "TU_CLAVE_DE_ACCESO"
  },
  "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
  }
}

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

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

const capabilities = {
  'browserName': 'Chrome',
  'browserVersion': 'latest',
  'LT:Options': {
    'platform': 'Windows 11',
    'build': 'Playwright Cloud Testing Build',
    'name': 'Prueba Playwright',
    '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.ejemplo.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 - Crear un pool de dispositivos
aws devicefarm create-device-pool \
  --project-arn "arn:aws:devicefarm:us-west-2:123456789012:project:a1b2c3d4" \
  --name "Dispositivos Android de Gama Alta" \
  --description "Últimos dispositivos Android insignia" \
  --rules '[
    {
      "attribute": "PLATFORM",
      "operator": "EQUALS",
      "value": "ANDROID"
    },
    {
      "attribute": "OS_VERSION",
      "operator": "GREATER_THAN_OR_EQUALS",
      "value": "12"
    },
    {
      "attribute": "FORM_FACTOR",
      "operator": "EQUALS",
      "value": "PHONE"
    }
  ]'

// Ejemplo Node.js para AWS Device Farm con Appium
const { remote } = require('webdriverio');
const AWS = require('aws-sdk');

// AWS Device Farm usa servidor Appium local
const capabilities = {
  platformName: 'Android',
  'appium:automationName': 'UiAutomator2',
  'appium:deviceName': 'Android Device',
  'appium:app': process.env.APP_PATH, // Ruta de app cargada
  '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 {
    // Esperar a que la app cargue
    await driver.pause(3000);
    
    // Ejemplo de interacciones de prueba
    const loginButton = await driver.$('~loginButton');
    await loginButton.waitForDisplayed({ timeout: 5000 });
    await loginButton.click();
    
    const usernameField = await driver.$('~usernameField');
    await usernameField.setValue('testuser@ejemplo.com');
    
    const passwordField = await driver.$('~passwordField');
    await passwordField.setValue('ContraseñaSegura123');
    
    const submitButton = await driver.$('~submitButton');
    await submitButton.click();
    
    // Verificar inicio de sesión exitoso
    const welcomeMessage = await driver.$('~welcomeMessage');
    await welcomeMessage.waitForDisplayed({ timeout: 10000 });
    
    const text = await welcomeMessage.getText();
    console.log(`Mensaje de bienvenida: ${text}`);
    
    // Prueba pasada
    console.log('Prueba completada exitosamente');
  } catch (error) {
    console.error('Prueba fallida:', error);
    throw error;
  } finally {
    await driver.deleteSession();
  }
}

// Punto de entrada para Device Farm
if (require.main === module) {
  runDeviceFarmTest()
    .then(() => process.exit(0))
    .catch((error) => {
      console.error(error);
      process.exit(1);
    });
}

module.exports = { runDeviceFarmTest };

// Prueba Espresso Android para AWS Device Farm
package com.ejemplo.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() {
        // Ingresar nombre de usuario
        Espresso.onView(ViewMatchers.withId(R.id.username_field))
            .perform(ViewActions.typeText("testuser@ejemplo.com"));
        
        // Ingresar contraseña
        Espresso.onView(ViewMatchers.withId(R.id.password_field))
            .perform(ViewActions.typeText("ContraseñaSegura123"));
        
        // Cerrar teclado
        Espresso.closeSoftKeyboard();
        
        // Hacer clic en botón de inicio de sesión
        Espresso.onView(ViewMatchers.withId(R.id.login_button))
            .perform(ViewActions.click());
        
        // Verificar que estamos en la pantalla de inicio
        Espresso.onView(ViewMatchers.withId(R.id.welcome_message))
            .check(ViewAssertions.matches(
                ViewMatchers.withText("¡Bienvenido, Usuario de Prueba!")
            ));
    }
    
    @Test
    public void testNavigationDrawer() {
        // Abrir cajón de navegación
        Espresso.onView(ViewMatchers.withContentDescription("Abrir cajón de navegación"))
            .perform(ViewActions.click());
        
        // Hacer clic en configuración
        Espresso.onView(ViewMatchers.withText("Configuración"))
            .perform(ViewActions.click());
        
        // Verificar que se muestra la pantalla de configuración
        Espresso.onView(ViewMatchers.withId(R.id.settings_title))
            .check(ViewAssertions.matches(ViewMatchers.isDisplayed()));
    }
}

// XCUITest iOS para 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() {
        // Ingresar nombre de usuario
        let usernameField = app.textFields["usernameField"]
        XCTAssertTrue(usernameField.waitForExistence(timeout: 5))
        usernameField.tap()
        usernameField.typeText("testuser@ejemplo.com")
        
        // Ingresar contraseña
        let passwordField = app.secureTextFields["passwordField"]
        XCTAssertTrue(passwordField.exists)
        passwordField.tap()
        passwordField.typeText("ContraseñaSegura123")
        
        // Tocar botón de inicio de sesión
        let loginButton = app.buttons["loginButton"]
        XCTAssertTrue(loginButton.exists)
        loginButton.tap()
        
        // Verificar mensaje de bienvenida
        let welcomeMessage = app.staticTexts["welcomeMessage"]
        XCTAssertTrue(welcomeMessage.waitForExistence(timeout: 10))
        XCTAssertEqual(welcomeMessage.label, "¡Bienvenido, Usuario de Prueba!")
    }
    
    func testNavigationFlow() {
        // Tocar pestaña de perfil
        let profileTab = app.tabBars.buttons["Perfil"]
        XCTAssertTrue(profileTab.waitForExistence(timeout: 5))
        profileTab.tap()
        
        // Verificar pantalla de perfil
        let profileTitle = app.navigationBars["Perfil"]
        XCTAssertTrue(profileTitle.exists)
        
        // Tocar botón de configuración
        let settingsButton = app.buttons["settingsButton"]
        settingsButton.tap()
        
        // Verificar pantalla de configuración
        let settingsTitle = app.navigationBars["Configuración"]
        XCTAssertTrue(settingsTitle.waitForExistence(timeout: 5))
    }
    
    func testPerformanceScenario() {
        measure {
            // Lanzar app varias veces para medir rendimiento
            app.launch()
            
            let mainView = app.otherElements["mainView"]
            XCTAssertTrue(mainView.waitForExistence(timeout: 5))
            
            app.terminate()
        }
    }
}

# .github/workflows/device-farm-tests.yml
name: Pruebas Móviles AWS Device Farm

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

jobs:
  device-farm-android:
    runs-on: ubuntu-latest
    
    steps:
      - uses: actions/checkout@v3
      
      - name: Configurar JDK 11
        uses: actions/setup-java@v3
        with:
          java-version: '11'
          distribution: 'temurin'
      
      - name: Construir App Android
        run: |
          cd android
          ./gradlew assembleDebug
          ./gradlew assembleAndroidTest
      
      - name: Configurar Credenciales AWS
        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: Subir App a 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: Subir Paquete de Pruebas
        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: Programar Ejecución de Pruebas
        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 "Ejecución GitHub Actions - ${{ 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: Esperar Resultados de Pruebas
        run: |
          while true; do
            STATUS=$(aws devicefarm get-run \
              --arn ${{ steps.schedule-run.outputs.run_arn }} \
              --query 'run.status' \
              --output text)
            
            echo "Estado actual: $STATUS"
            
            if [ "$STATUS" = "COMPLETED" ]; then
              break
            elif [ "$STATUS" = "ERRORED" ] || [ "$STATUS" = "FAILED" ]; then
              echo "Ejecución de prueba falló con estado: $STATUS"
              exit 1
            fi
            
            sleep 30
          done
      
      - name: Obtener Resultados de Pruebas
        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 "Pruebas fallidas con resultado: $RESULT"
            exit 1
          fi

// Jenkinsfile para 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('Construir App Android') {
            steps {
                dir('android') {
                    sh './gradlew clean assembleDebug assembleAndroidTest'
                }
            }
        }
        
        stage('Subir a Device Farm') {
            steps {
                script {
                    // Subir 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}'"
                    
                    // Subir paquete de pruebas
                    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('Ejecutar Pruebas en 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 "Ejecución de prueba programada: ${RUN_ARN}"
                }
            }
        }
        
        stage('Esperar Resultados') {
            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 "Estado actual: ${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("Pruebas fallidas con resultado: ${result}")
                    }
                }
            }
        }
        
        stage('Descargar Artefactos') {
            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 "Detalles de ejecución de pruebas: https://us-west-2.console.aws.amazon.com/devicefarm/home"
        }
    }
}

# Ejecutar Robo test vía gcloud CLI
gcloud firebase test android run \
  --type robo \
  --app app/build/outputs/apk/debug/app-debug.apk \
  --device model=Pixel7,version=33,locale=es,orientation=portrait \
  --device model=galaxys23,version=33,locale=es,orientation=portrait \
  --timeout 5m \
  --results-bucket=gs://tu-nombre-bucket \
  --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@ejemplo.com"
    },
    {
      "action_type": "ENTER_TEXT",
      "resource_name": "password_field",
      "input_text": "ContraseñaPrueba123"
    },
    {
      "action_type": "CLICK",
      "resource_name": "login_button"
    },
    {
      "action_type": "WAIT_FOR_ELEMENT",
      "optional": false,
      "resource_name": "home_screen",
      "timeout": 10000
    }
  ]
}

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

# Ejecutar pruebas de instrumentación Espresso
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=es,orientation=portrait \
  --device model=Pixel6,version=32,locale=es,orientation=portrait \
  --device model=galaxys22,version=32,locale=es,orientation=landscape \
  --timeout 30m \
  --results-bucket=gs://tu-nombre-bucket \
  --results-dir=espresso-test-results \
  --environment-variables coverage=true,coverageFile="/sdcard/coverage.ec" \
  --directories-to-pull /sdcard

# Matriz de pruebas con múltiples dimensiones
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 es,en,ru \
  --orientations portrait,landscape

# Construir app iOS para pruebas
xcodebuild build-for-testing \
  -workspace TuApp.xcworkspace \
  -scheme TuApp \
  -sdk iphoneos \
  -configuration Debug \
  -derivedDataPath build

# Crear archivo de prueba
cd build/Build/Products
zip -r TuApp.zip Debug-iphoneos/*.app
zip -r TuAppTests.zip Debug-iphoneos/*.xctestrun

# Ejecutar en Firebase Test Lab
gcloud firebase test ios run \
  --test TuAppTests.zip \
  --device model=iphone14pro,version=16.6,locale=es,orientation=portrait \
  --device model=iphone13,version=16.6,locale=es,orientation=portrait \
  --timeout 30m \
  --results-bucket=gs://tu-nombre-bucket \
  --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'
}

// Agregar configuración de Firebase Test Lab
// Crear testlab.yml en raíz del proyecto

# 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

# Configuración de matriz de dispositivos
devices:
  - model: Pixel7
    version: 33
    locale: es
    orientation: portrait
  
  - model: Pixel6
    version: 32
    locale: es
    orientation: portrait
  
  - model: galaxys22
    version: 32
    locale: es
    orientation: portrait

# Configuración de prueba
test_configuration:
  timeout: 20m
  results_bucket: gs://tu-nombre-bucket
  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: Configurar JDK 17
        uses: actions/setup-java@v3
        with:
          java-version: '17'
          distribution: 'temurin'
      
      - name: Construir App y Pruebas
        run: |
          chmod +x gradlew
          ./gradlew assembleDebug assembleDebugAndroidTest
      
      - name: Autenticar a Google Cloud
        uses: google-github-actions/auth@v1
        with:
          credentials_json: ${{ secrets.GCP_SA_KEY }}
      
      - name: Configurar Cloud SDK
        uses: google-github-actions/setup-gcloud@v1
      
      - name: Ejecutar Pruebas en 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=es,orientation=portrait \
            --device model=Pixel6,version=32,locale=es,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: Descargar Resultados de Pruebas
        if: always()
        run: |
          gsutil -m cp -r \
            gs://${{ secrets.GCS_BUCKET }}/github-actions-${GITHUB_RUN_NUMBER} \
            ./test-results
      
      - name: Subir Resultados de Pruebas
        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 "Ejecutar pruebas en 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: "es",
      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 "Ejecutar pruebas en Firebase Test Lab"
  lane :firebase_test do
    build_for_testing(
      workspace: "TuApp.xcworkspace",
      scheme: "TuApp",
      configuration: "Debug"
    )
    
    firebase_test_lab_ios(
      project_id: ENV['GCP_PROJECT_ID'],
      model: "iphone14pro,iphone13",
      version: "16.6",
      locale: "es",
      orientation: "portrait",
      timeout: "30m",
      app_path: "build/Build/Products/Debug-iphoneos/TuApp.app",
      test_path: "build/Build/Products/Debug-iphoneos/TuAppTests.xctestrun",
      results_bucket: ENV['GCS_BUCKET'],
      results_dir: "fastlane-ios-#{Time.now.to_i}"
    )
  end
end

// Calcular paralelización óptima
function calculateOptimalParallels(totalTests, avgTestDuration, targetDuration, costPerMinute) {
  // Tiempo de ejecución secuencial
  const sequentialTime = totalTests * avgTestDuration;
  
  // Paralelos requeridos para duración objetivo
  const requiredParallels = Math.ceil(sequentialTime / targetDuration);
  
  // Comparación de costos
  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)
  };
}

// Ejemplo de cálculo
const result = calculateOptimalParallels(
  500,    // total de pruebas
  2,      // 2 minutos por prueba
  20,     // objetivo: completar en 20 minutos
  0.10    // $0.10 por minuto (tarifa de plataforma)
);

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

# Decorador de optimización de sesión
import time
from functools import wraps

def optimize_session(func):
    """
    Decorador para rastrear y optimizar duración de sesión
    """
    @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"Duración de sesión: {duration:.2f} segundos")
            
            # Alertar si la sesión excede el umbral
            if duration > 300:  # 5 minutos
                print(f"ADVERTENCIA: La sesión excedió 5 minutos - ¡optimiza la prueba!")
    
    return wrapper

# Aplicar a funciones de prueba
@optimize_session
def test_user_login(driver):
    driver.get("https://ejemplo.com/login")
    # ... implementación de prueba
    driver.quit()

# Operaciones en lote para reducir tiempo de sesión
class OptimizedTestExecution:
    def __init__(self, driver):
        self.driver = driver
        self.results = []
    
    def execute_test_batch(self, test_urls):
        """
        Ejecutar múltiples pruebas relacionadas en una sola sesión
        """
        for url in test_urls:
            try:
                self.driver.get(url)
                # Realizar aserciones
                self.results.append({
                    'url': url,
                    'status': 'pasado',
                    'duration': time.time()
                })
            except Exception as e:
                self.results.append({
                    'url': url,
                    'status': 'fallido',
                    'error': str(e)
                })
        
        return self.results

# Ejemplo de uso
test_urls = [
    "https://ejemplo.com/pagina1",
    "https://ejemplo.com/pagina2",
    "https://ejemplo.com/pagina3"
]

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

# Descargar e iniciar BrowserStack Local
./BrowserStackLocal --key TU_CLAVE_DE_ACCESO --force-local

# Iniciar con configuración personalizada
./BrowserStackLocal \
  --key TU_CLAVE_DE_ACCESO \
  --local-identifier "mi-tunel-123" \
  --force-local \
  --only-automate \
  --verbose 3

# Configuración de prueba con pruebas locales
capabilities = {
    'browserstack.local': 'true',
    'browserstack.localIdentifier': 'mi-tunel-123'
}

# Descargar e iniciar Sauce Connect
./sc -u TU_USUARIO -k TU_CLAVE_DE_ACCESO

# Iniciar con identificador de túnel
./sc -u TU_USUARIO -k TU_CLAVE_DE_ACCESO \
  --tunnel-identifier mi-tunel-123 \
  --readyfile /tmp/sc_ready \
  --logfile /tmp/sc.log

# Configuración de prueba
sauce_options = {
    'tunnelIdentifier': 'mi-tunel-123'
}

# Iniciar túnel LambdaTest
./LT --user TU_USUARIO --key TU_CLAVE_DE_ACCESO

# Con nombre de túnel
./LT --user TU_USUARIO --key TU_CLAVE_DE_ACCESO \
  --tunnelName mi-tunel-123 \
  --verbose

# Configuración de prueba
lt_options = {
    'tunnel': True,
    'tunnelName': 'mi-tunel-123'
}

// BrowserStack - Deshabilitar video para ejecución más rápida
const capabilities = {
    'browserstack.video': false,          // Deshabilitar grabación de video
    'browserstack.debug': false,          // Deshabilitar logs de consola
    'browserstack.networkLogs': false,    // Deshabilitar logs de red
    'browserstack.console': 'disable',    // Deshabilitar captura de consola
};

// Habilitar solo en fallo
const capabilitiesConditional = {
    'browserstack.video': process.env.TEST_FAILED === 'true',
};

// Sauce Labs - Video solo en fallo
const sauceOptions = {
    'recordVideo': false,               // No grabar por defecto
    'recordScreenshots': false,         // Sin capturas de pantalla
    'recordLogs': false,                // Sin logs
    'videoUploadOnPass': false,         // Subir video solo en fallo
};

// LambdaTest - Configuración optimizada
const ltOptions = {
    'video': false,                     // Deshabilitar video
    'visual': false,                    // Deshabilitar logs visuales
    'network': false,                   // Deshabilitar logs de red
    'console': false,                   // Deshabilitar logs de consola
    'terminal': false,                  // Deshabilitar logs de terminal
};

// Grabación condicional basada en resultado de prueba
class ConditionalRecordingTest {
    constructor(driver, capabilities) {
        this.driver = driver;
        this.capabilities = capabilities;
        this.testFailed = false;
    }
    
    async runTest() {
        try {
            // Ejecutar prueba
            await this.executeTestSteps();
        } catch (error) {
            this.testFailed = true;
            
            // Habilitar grabación para prueba fallida
            if (this.capabilities.platform === 'browserstack') {
                await this.driver.executeScript('browserstack_executor: {"action": "setDebug", "arguments": {"value": true}}');
            }
            
            throw error;
        }
    }
    
    async executeTestSteps() {
        // Tu implementación de prueba
    }
}

# device-pools.yml
# Definir pools de dispositivos por prioridad

tier1_critical:
  description: "Dispositivos críticos para cada ejecución de prueba"
  devices:
    - Chrome Latest / Windows 11
    - Safari Latest / macOS Monterey
    - Chrome Latest / Android 13
    - Safari Latest / iOS 16
  frequency: "cada commit"
  cost_per_run: "$5"

tier2_important:
  description: "Dispositivos importantes para regresión diaria"
  devices:
    - Firefox Latest / Windows 11
    - Edge Latest / Windows 11
    - Chrome Latest / Android 12
    - Safari Latest / iOS 15
  frequency: "diario"
  cost_per_run: "$5"

tier3_extended:
  description: "Cobertura extendida para pruebas semanales"
  devices:
    - Chrome Latest-1 / Windows 10
    - Safari Latest-1 / macOS Big Sur
    - Firefox Latest / macOS
    - Varios dispositivos móviles (10+)
  frequency: "semanal"
  cost_per_run: "$20"

tier4_comprehensive:
  description: "Cobertura completa para pre-lanzamiento"
  devices:
    - Todos los navegadores
    - Todas las versiones de SO
    - Todos los dispositivos móviles
  frequency: "antes de lanzamiento"
  cost_per_run: "$100"

// Selección dinámica de dispositivos basada en contexto
class SmartDeviceSelector {
    constructor(testType, branch, changeSize) {
        this.testType = testType;
        this.branch = branch;
        this.changeSize = changeSize;
    }
    
    selectDevicePool() {
        // Cambios de ruta crítica - pruebas completas
        if (this.isCriticalPath()) {
            return 'tier4_comprehensive';
        }
        
        // Rama de producción - pruebas extendidas
        if (this.branch === 'main' || this.branch === 'production') {
            return 'tier2_important';
        }
        
        // Cambios grandes - dispositivos importantes
        if (this.changeSize > 500) {
            return 'tier2_important';
        }
        
        // Cambios pequeños - solo dispositivos críticos
        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()];
    }
}

// Uso en 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(`Pool de dispositivos seleccionado: ${devicePool}`);
console.log(`Costo estimado: $${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]:
        """Obtener lista de archivos cambiados de 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:
        """Cargar datos históricos de pruebas"""
        try:
            with open('test_history.json', 'r') as f:
                return json.load(f)
        except FileNotFoundError:
            return {}
    
    def calculate_priority(self, test_name: str) -> int:
        """
        Calcular prioridad de prueba basada en múltiples factores:
        - Tasa de fallos (mayor = más prioridad)
        - Tiempo de ejecución (menor = más prioridad)
        - Tiempo desde última ejecución (más tiempo = más prioridad)
        - Criticidad de negocio
        """
        if test_name not in self.test_history:
            return 100  # Nuevas pruebas obtienen alta prioridad
        
        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]:
        """Seleccionar pruebas más importantes para ejecutar"""
        # Obtener todas las pruebas
        all_tests = self.get_all_tests()
        
        # Calcular prioridades
        test_priorities = [
            (test, self.calculate_priority(test))
            for test in all_tests
        ]
        
        # Ordenar por prioridad
        test_priorities.sort(key=lambda x: x[1], reverse=True)
        
        # Seleccionar top N pruebas
        selected = [test for test, priority in test_priorities[:max_tests]]
        
        return selected
    
    def get_affected_tests(self) -> List[str]:
        """Obtener pruebas afectadas por archivos cambiados"""
        affected_tests = set()
        
        for changed_file in self.changed_files:
            # Mapear archivos fuente a archivos de prueba
            if changed_file.startswith('src/'):
                # Mapeo simple: src/components/Login.js -> tests/Login.test.js
                test_file = changed_file.replace('src/', 'tests/').replace('.js', '.test.js')
                affected_tests.add(test_file)
            
            # Verificar mapeo de cobertura de pruebas
            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]:
        """Obtener lista de todos los archivos de prueba"""
        result = subprocess.run(
            ['find', 'tests', '-name', '*.test.js'],
            capture_output=True,
            text=True
        )
        return result.stdout.strip().split('\n')

# Uso
selector = TestSelector()

# Estrategia 1: Ejecutar solo pruebas afectadas
affected_tests = selector.get_affected_tests()
print(f"Ejecutando {len(affected_tests)} pruebas afectadas")

# Estrategia 2: Ejecutar pruebas de mayor prioridad
priority_tests = selector.select_tests(max_tests=50)
print(f"Ejecutando top 50 pruebas prioritarias")

# Estrategia 3: Enfoque híbrido
if len(affected_tests) > 0:
    tests_to_run = affected_tests
else:
    tests_to_run = priority_tests[:20]  # Ejecutar top 20 si no hay pruebas afectadas

print(f"Pruebas seleccionadas: {tests_to_run}")

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

// Configuración headless
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 - Modo headless (predeterminado)
const { chromium } = require('playwright');

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

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

# GitHub Actions con almacenamiento en caché
name: Pruebas Cloud Optimizadas

on: [push]

jobs:
  test:
    runs-on: ubuntu-latest
    
    steps:
      - uses: actions/checkout@v3
      
      # Almacenar en caché módulos de node
      - 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-
      
      # Almacenar en caché navegadores Playwright
      - name: Cache Playwright Browsers
        uses: actions/cache@v3
        with:
          path: ~/.cache/ms-playwright
          key: ${{ runner.os }}-playwright-${{ hashFiles('package-lock.json') }}
      
      # Instalar dependencias (usa caché si está disponible)
      - name: Install Dependencies
        run: npm ci
      
      # Ejecutar pruebas
      - name: Run Tests
        run: npm test