Ejecución remota con RemoteWebDriver

RemoteWebDriver con Selenium Server standalone

El Selenium Server standalone representa la forma más directa de ejecutar pruebas de Selenium de manera remota sin necesidad de configuraciones complejas. Este servidor combina el hub y los nodos en un único proceso, simplificando significativamente la configuración inicial para equipos que necesitan ejecución remota básica.

¿Qué es Selenium Server standalone?

Selenium Server standalone es un archivo JAR que actúa como un servidor intermediario entre tu código de pruebas y los navegadores web. A diferencia de la configuración distribuida de Selenium Grid, el modo standalone ejecuta todas las funcionalidades en un solo proceso, lo que lo convierte en la opción ideal para:

• Entornos de desarrollo donde necesitas separar la ejecución del navegador
• Pruebas en máquinas virtuales remotas
• Configuraciones simples que no requieren escalabilidad horizontal

Configuración del servidor

Para iniciar el servidor standalone, primero necesitas descargar el archivo JAR desde el repositorio oficial de Selenium. El comando básico para ejecutarlo es:

java -jar selenium-server-4.30.0.jar standalone

El servidor se iniciará por defecto en el puerto 4444 y estará disponible en http://localhost:4444. Puedes personalizar la configuración mediante parámetros adicionales:

java -jar selenium-server-4.30.0.jar standalone --port 4445 --max-sessions 4

Implementación con RemoteWebDriver

La implementación de RemoteWebDriver con el servidor standalone sigue un patrón claro y directo. Aquí tienes un ejemplo básico usando JUnit 5:

@Test
void testConRemoteWebDriver() throws MalformedURLException {
    var chromeOptions = new ChromeOptions();
    var driver = new RemoteWebDriver(
        new URL("http://localhost:4444"), 
        chromeOptions
    );
    
    driver.get("https://example.com");
    var title = driver.getTitle();
    
    assertThat(title).contains("Example");
    
    driver.quit();
}

Configuración avanzada de opciones

Las opciones del navegador se configuran de la misma manera que con WebDriver local, pero se envían al servidor remoto para su procesamiento:

@Test 
void testConOpcionesPersonalizadas() throws MalformedURLException {
    var chromeOptions = new ChromeOptions();
    chromeOptions.addArguments("--headless");
    chromeOptions.addArguments("--no-sandbox");
    chromeOptions.addArguments("--disable-dev-shm-usage");
    
    var driver = new RemoteWebDriver(
        new URL("http://localhost:4444"),
        chromeOptions
    );
    
    driver.get("https://httpbin.org/user-agent");
    var source = driver.getPageSource();
    
    assertThat(source).contains("HeadlessChrome");
    
    driver.quit();
}

Gestión de sesiones y recursos

El servidor standalone gestiona automáticamente las sesiones de navegador, creando y destruyendo instancias según las solicitudes. Es fundamental cerrar correctamente las sesiones para evitar acumulación de procesos:

@Test
void testGestionRecursos() throws MalformedURLException {
    RemoteWebDriver driver = null;
    
    try {
        var firefoxOptions = new FirefoxOptions();
        driver = new RemoteWebDriver(
            new URL("http://localhost:4444"),
            firefoxOptions
        );
        
        driver.get("https://selenium.dev");
        var heading = driver.findElement(By.tagName("h1"));
        
        assertThat(heading.getText()).isNotEmpty();
        
    } finally {
        if (driver != null) {
            driver.quit();
        }
    }
}

Manejo de errores de conexión

Cuando el servidor standalone no está disponible, RemoteWebDriver lanzará excepciones específicas que debes manejar apropiadamente:

@Test
void testManejoErrores() {
    assertThrows(WebDriverException.class, () -> {
        var chromeOptions = new ChromeOptions();
        var driver = new RemoteWebDriver(
            new URL("http://localhost:4444"), 
            chromeOptions
        );
        
        driver.get("https://example.com");
    });
}

Configuración con múltiples navegadores

El servidor standalone puede manejar diferentes tipos de navegadores en la misma instancia, permitiendo flexibilidad en las pruebas:

@ParameterizedTest
@ValueSource(strings = {"chrome", "firefox", "edge"})
void testMultiplesNavegadores(String browserName) throws MalformedURLException {
    Capabilities options = switch (browserName.toLowerCase()) {
        case "chrome" -> new ChromeOptions();
        case "firefox" -> new FirefoxOptions();
        case "edge" -> new EdgeOptions();
        default -> throw new IllegalArgumentException("Navegador no soportado: " + browserName);
    };
    
    var driver = new RemoteWebDriver(new URL("http://localhost:4444"), options);
    
    driver.get("https://example.com");
    assertThat(driver.getTitle()).contains("Example");
    
    driver.quit();
}

Monitorización y logs

El servidor standalone proporciona información detallada sobre las sesiones activas y los eventos del sistema. Puedes acceder a la interfaz web en http://localhost:4444 para monitorizar el estado del servidor y las sesiones en tiempo real.

Para obtener logs más detallados, puedes configurar el nivel de logging al iniciar el servidor:

java -jar selenium-server-4.30.0.jar standalone --log-level FINE

Esta configuración te permitirá diagnosticar problemas y optimizar el rendimiento de tus pruebas remotas de manera efectiva.

RemoteWebDriver con Selenium Grid en docker compose

Selenium Grid representa una evolución natural del servidor standalone, ofreciendo una arquitectura distribuida que separa claramente las responsabilidades entre el hub coordinador y los nodos ejecutores. Esta configuración permite escalabilidad horizontal y mejor gestión de recursos, especialmente cuando se combina con Docker Compose para simplificar el despliegue.

Arquitectura de Selenium Grid

A diferencia del modo standalone, Selenium Grid utiliza una arquitectura hub-node donde el hub actúa como punto central de coordinación y los nodos ejecutan las pruebas en navegadores específicos. Esta separación permite:

• Ejecución paralela de pruebas en múltiples navegadores simultáneamente
• Distribución de carga entre diferentes máquinas o contenedores
• Gestión centralizada de sesiones y capacidades de navegador

Configuración con Docker Compose

La configuración mediante Docker Compose elimina la complejidad de instalación manual de navegadores y drivers. Aquí tienes un archivo docker-compose.yml completo para un setup básico:

version: '3.8'

services:
  selenium-hub:
    image: selenium/hub:4.30.0
    container_name: selenium-hub
    ports:
      - "4444:4444"
      - "4442:4442"
      - "4443:4443"
    environment:
      - GRID_MAX_SESSION=16
      - GRID_BROWSER_TIMEOUT=300
      - GRID_TIMEOUT=300

  chrome-node:
    image: selenium/node-chrome:4.30.0
    container_name: chrome-node
    shm_size: 2gb
    depends_on:
      - selenium-hub
    environment:
      - HUB_HOST=selenium-hub
      - HUB_PORT=4444
      - NODE_MAX_INSTANCES=2
      - NODE_MAX_SESSION=2
    ports:
      - "7900:7900"

  firefox-node:
    image: selenium/node-firefox:4.30.0
    container_name: firefox-node
    shm_size: 2gb
    depends_on:
      - selenium-hub
    environment:
      - HUB_HOST=selenium-hub
      - HUB_PORT=4444
      - NODE_MAX_INSTANCES=2
      - NODE_MAX_SESSION=2
    ports:
      - "7901:7900"

Inicialización del entorno

Para levantar el entorno completo, ejecuta el siguiente comando en el directorio donde tienes el archivo docker-compose.yml:

docker-compose up -d

El parámetro -d ejecuta los contenedores en modo background, permitiéndote continuar trabajando en la terminal. Puedes verificar que todos los servicios están funcionando correctamente accediendo a http://localhost:4444/ui donde verás la consola de Selenium Grid.

Implementación con RemoteWebDriver

La conexión desde tu código Java a Selenium Grid sigue el mismo patrón que con el servidor standalone, pero ahora el hub distribuye automáticamente las pruebas entre los nodos disponibles:

@Test
void testConSeleniumGrid() throws MalformedURLException {
    var chromeOptions = new ChromeOptions();
    var driver = new RemoteWebDriver(
        new URL("http://localhost:4444"), 
        chromeOptions
    );
    
    driver.get("https://example.com");
    var title = driver.getTitle();
    
    assertThat(title).contains("Example");
    
    driver.quit();
}

Ejecución paralela de pruebas

Una de las principales ventajas de Selenium Grid es la capacidad de ejecutar pruebas en paralelo utilizando diferentes navegadores simultáneamente:

@ParameterizedTest
@ValueSource(strings = {"chrome", "firefox"})
@Execution(ExecutionMode.CONCURRENT)
void testParaleloEnGrid(String browserName) throws MalformedURLException {
    Capabilities options = switch (browserName) {
        case "chrome" -> new ChromeOptions();
        case "firefox" -> new FirefoxOptions();
        default -> throw new IllegalArgumentException("Navegador no válido: " + browserName);
    };
    
    var driver = new RemoteWebDriver(new URL("http://localhost:4444"), options);
    
    driver.get("https://selenium.dev");
    var heading = driver.findElement(By.tagName("h1"));
    
    assertThat(heading.getText()).isNotEmpty();
    
    driver.quit();
}

Configuración avanzada de nodos

Puedes personalizar el comportamiento de los nodos mediante variables de entorno específicas. Por ejemplo, para ajustar la memoria disponible y el número de sesiones concurrentes:

chrome-node:
  image: selenium/node-chrome:4.30.0
  container_name: chrome-node
  shm_size: 4gb
  environment:
    - HUB_HOST=selenium-hub
    - HUB_PORT=4444
    - NODE_MAX_INSTANCES=4
    - NODE_MAX_SESSION=4
    - START_XVFB=false
  volumes:
    - /dev/shm:/dev/shm

Gestión de volúmenes para descargas

Cuando tus pruebas necesitan manejar descargas de archivos, puedes configurar volúmenes compartidos entre el contenedor y tu sistema host:

chrome-node:
  image: selenium/node-chrome:4.30.0
  volumes:
    - ./downloads:/home/seluser/Downloads
  environment:
    - HUB_HOST=selenium-hub
    - HUB_PORT=4444

Correspondiente configuración en Java:

@Test
void testDescargaArchivos() throws MalformedURLException {
    var chromeOptions = new ChromeOptions();
    var prefs = Map.of(
        "download.default_directory", "/home/seluser/Downloads",
        "download.prompt_for_download", false
    );
    chromeOptions.setExperimentalOption("prefs", prefs);
    
    var driver = new RemoteWebDriver(new URL("http://localhost:4444"), chromeOptions);
    
    driver.get("https://file-examples.com/storage/fe68c8c24b9c7bb52b96796/2017/10/file_example_PDF_1MB.pdf");
    
    // El archivo se descargará al directorio mapeado
    driver.quit();
}

Monitorización y debugging

Selenium Grid proporciona acceso VNC a los nodos para observar la ejecución de las pruebas en tiempo real. Puedes conectarte a:

• Chrome node: http://localhost:7900 (password: secret)
• Firefox node: http://localhost:7901 (password: secret)

Limpieza del entorno

Para detener y eliminar todos los contenedores creados por Docker Compose:

docker-compose down

Si necesitas eliminar también los volúmenes asociados:

docker-compose down -v

Esta configuración con Docker Compose ofrece un entorno reproducible y escalable para tus pruebas de Selenium, eliminando las dependencias del sistema operativo host y facilitando la integración en pipelines de CI/CD.

RemoteWebDriver con LambdaTest

LambdaTest es una plataforma de testing en la nube que permite ejecutar pruebas de Selenium en una amplia variedad de navegadores y sistemas operativos sin necesidad de mantener infraestructura propia. Esta solución elimina completamente la configuración de servidores locales, ofreciendo un enfoque plug-and-play para la ejecución remota de pruebas.

Ventajas de LambdaTest

La principal diferencia con las configuraciones anteriores radica en que LambdaTest proporciona una infraestructura gestionada que incluye:

• Más de 3000 combinaciones de navegadores y sistemas operativos
• Mantenimiento automático de drivers y versiones de navegadores
• Escalabilidad instantánea sin configuración adicional
• Grabación de vídeo y capturas de pantalla automáticas
• Logs detallados y métricas de rendimiento integradas

Configuración inicial

Para utilizar LambdaTest necesitas registrarte en su plataforma y obtener tus credenciales de acceso. Una vez registrado, puedes encontrar tu username y access key en el dashboard de la plataforma, en la sección de configuración de perfil.

La URL del hub de LambdaTest sigue el patrón:

https://{username}:{accessKey}@hub.lambdatest.com/wd/hub

Implementación básica

La implementación con LambdaTest utiliza el mismo patrón de RemoteWebDriver, pero dirigiendo las peticiones hacia su infraestructura en la nube:

@Test
void testConLambdaTest() throws MalformedURLException {
    var chromeOptions = new ChromeOptions();
    chromeOptions.setPlatformName("Windows 10");
    chromeOptions.setBrowserVersion("latest");
    
    var ltOptions = Map.of(
        "username", "tu_username",
        "accessKey", "tu_access_key",
        "build", "Selenium Java Tests",
        "name", "Test básico con LambdaTest",
        "console", true,
        "video", true
    );
    chromeOptions.setCapability("LT:Options", ltOptions);
    
    var driver = new RemoteWebDriver(
        new URL("https://tu_username:tu_access_key@hub.lambdatest.com/wd/hub"),
        chromeOptions
    );
    
    driver.get("https://example.com");
    var title = driver.getTitle();
    
    assertThat(title).contains("Example");
    
    driver.quit();
}

Configuración de capacidades específicas

LambdaTest utiliza un sistema de capacidades extendidas que permite configurar aspectos específicos de la ejecución. Las opciones más importantes se agrupan bajo la clave LT:Options:

@Test
void testCapacidadesAvanzadas() throws MalformedURLException {
    var firefoxOptions = new FirefoxOptions();
    firefoxOptions.setPlatformName("macOS Monterey");
    firefoxOptions.setBrowserVersion("latest-1");
    
    var ltOptions = Map.of(
        "username", "tu_username",
        "accessKey", "tu_access_key",
        "build", "Build v1.0",
        "name", "Prueba con capacidades avanzadas",
        "console", true,
        "video", true,
        "network", true,
        "timezone", "Europe/Madrid",
        "resolution", "1920x1080"
    );
    firefoxOptions.setCapability("LT:Options", ltOptions);
    
    var driver = new RemoteWebDriver(
        new URL("https://tu_username:tu_access_key@hub.lambdatest.com/wd/hub"),
        firefoxOptions
    );
    
    driver.get("https://selenium.dev");
    var heading = driver.findElement(By.tagName("h1"));
    
    assertThat(heading.getText()).isNotEmpty();
    
    driver.quit();
}

Gestión de credenciales con variables de entorno

Para evitar hardcodear credenciales en el código, utiliza variables de entorno para almacenar de forma segura tu username y access key:

@Test
void testConVariablesEntorno() throws MalformedURLException {
    var username = System.getenv("LAMBDATEST_USERNAME");
    var accessKey = System.getenv("LAMBDATEST_ACCESS_KEY");
    
    if (username == null || accessKey == null) {
        throw new IllegalStateException("Las credenciales de LambdaTest no están configuradas");
    }
    
    var chromeOptions = new ChromeOptions();
    chromeOptions.setPlatformName("Windows 11");
    chromeOptions.setBrowserVersion("latest");
    
    var ltOptions = Map.of(
        "username", username,
        "accessKey", accessKey,
        "build", "Tests con variables de entorno",
        "name", "Test seguro",
        "console", true
    );
    chromeOptions.setCapability("LT:Options", ltOptions);
    
    var hubUrl = String.format("https://%s:%s@hub.lambdatest.com/wd/hub", username, accessKey);
    var driver = new RemoteWebDriver(new URL(hubUrl), chromeOptions);
    
    driver.get("https://httpbin.org/ip");
    var source = driver.getPageSource();
    
    assertThat(source).contains("origin");
    
    driver.quit();
}

Ejecución en múltiples navegadores

LambdaTest facilita la ejecución cross-browser permitiendo especificar diferentes combinaciones de navegador y sistema operativo:

@ParameterizedTest
@CsvSource({
    "Chrome, latest, Windows 10",
    "Firefox, latest, macOS Big Sur", 
    "Safari, latest, macOS Monterey",
    "Edge, latest, Windows 11"
})
void testMultiplesNavegadores(String browser, String version, String platform) throws MalformedURLException {
    var username = System.getenv("LAMBDATEST_USERNAME");
    var accessKey = System.getenv("LAMBDATEST_ACCESS_KEY");
    
    Capabilities options = switch (browser.toLowerCase()) {
        case "chrome" -> new ChromeOptions();
        case "firefox" -> new FirefoxOptions();
        case "safari" -> new SafariOptions();
        case "edge" -> new EdgeOptions();
        default -> throw new IllegalArgumentException("Navegador no soportado: " + browser);
    };
    
    ((MutableCapabilities) options).setPlatformName(platform);
    ((MutableCapabilities) options).setBrowserVersion(version);
    
    var ltOptions = Map.of(
        "username", username,
        "accessKey", accessKey,
        "build", "Cross-browser testing",
        "name", String.format("Test en %s %s - %s", browser, version, platform)
    );
    ((MutableCapabilities) options).setCapability("LT:Options", ltOptions);
    
    var hubUrl = String.format("https://%s:%s@hub.lambdatest.com/wd/hub", username, accessKey);
    var driver = new RemoteWebDriver(new URL(hubUrl), options);
    
    driver.get("https://example.com");
    assertThat(driver.getTitle()).contains("Example");
    
    driver.quit();
}

Marcado de resultados de pruebas

LambdaTest permite marcar automáticamente si una prueba ha pasado o fallado mediante la API de JavaScript executor:

@Test
void testConMarcadoResultados() throws MalformedURLException {
    var username = System.getenv("LAMBDATEST_USERNAME");
    var accessKey = System.getenv("LAMBDATEST_ACCESS_KEY");
    
    var chromeOptions = new ChromeOptions();
    chromeOptions.setPlatformName("Windows 10");
    chromeOptions.setBrowserVersion("latest");
    
    var ltOptions = Map.of(
        "username", username,
        "accessKey", accessKey,
        "build", "Tests con marcado de resultados",
        "name", "Test que marca su propio resultado"
    );
    chromeOptions.setCapability("LT:Options", ltOptions);
    
    var hubUrl = String.format("https://%s:%s@hub.lambdatest.com/wd/hub", username, accessKey);
    var driver = new RemoteWebDriver(new URL(hubUrl), chromeOptions);
    
    try {
        driver.get("https://example.com");
        var title = driver.getTitle();
        
        assertThat(title).contains("Example");
        
        // Marcar la prueba como exitosa
        ((JavascriptExecutor) driver).executeScript("lambda-status=passed");
        
    } catch (AssertionError e) {
        // Marcar la prueba como fallida
        ((JavascriptExecutor) driver).executeScript("lambda-status=failed");
        throw e;
        
    } finally {
        driver.quit();
    }
}

Configuración de túneles para aplicaciones locales

Para probar aplicaciones que se ejecutan en tu entorno local, LambdaTest proporciona la funcionalidad de túnel que permite acceder a localhost desde su infraestructura:

@Test
void testConTunel() throws MalformedURLException {
    var username = System.getenv("LAMBDATEST_USERNAME");
    var accessKey = System.getenv("LAMBDATEST_ACCESS_KEY");
    
    var chromeOptions = new ChromeOptions();
    chromeOptions.setPlatformName("Windows 10");
    chromeOptions.setBrowserVersion("latest");
    
    var ltOptions = Map.of(
        "username", username,
        "accessKey", accessKey,
        "build", "Tests con túnel local",
        "name", "Test aplicación local",
        "tunnel", true,
        "tunnelName", "mi-tunel-local"
    );
    chromeOptions.setCapability("LT:Options", ltOptions);
    
    var hubUrl = String.format("https://%s:%s@hub.lambdatest.com/wd/hub", username, accessKey);
    var driver = new RemoteWebDriver(new URL(hubUrl), chromeOptions);
    
    // Ahora puedes acceder a aplicaciones locales
    driver.get("http://localhost:8080/mi-aplicacion");
    
    driver.quit();
}

Optimización de tiempos de ejecución

LambdaTest permite configurar timeouts personalizados y otras optimizaciones para mejorar el rendimiento de las pruebas:

@Test
void testOptimizado() throws MalformedURLException {
    var username = System.getenv("LAMBDATEST_USERNAME");
    var accessKey = System.getenv("LAMBDATEST_ACCESS_KEY");
    
    var chromeOptions = new ChromeOptions();
    chromeOptions.setPlatformName("Windows 10");
    chromeOptions.setBrowserVersion("latest");
    
    var ltOptions = Map.of(
        "username", username,
        "accessKey", accessKey,
        "build", "Tests optimizados",
        "name", "Test con configuración optimizada",
        "idleTimeout", 300,
        "commandTimeout", 600,
        "w3c", true,
        "plugin", "java-junit"
    );
    chromeOptions.setCapability("LT:Options", ltOptions);
    
    var hubUrl = String.format("https://%s:%s@hub.lambdatest.com/wd/hub", username, accessKey);
    var driver = new RemoteWebDriver(new URL(hubUrl), chromeOptions);
    
    driver.manage().timeouts().pageLoadTimeout(Duration.ofSeconds(30));
    driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
    
    driver.get("https://example.com");
    assertThat(driver.getTitle()).contains("Example");
    
    driver.quit();
}

La integración con LambdaTest simplifica significativamente la infraestructura de testing, permitiéndote concentrarte en escribir pruebas efectivas sin preocuparte por el mantenimiento de navegadores, drivers o máquinas virtuales.