Tutorial Selenium: Ejecución remota con RemoteWebDriver

¿Qué es RemoteWebDriver?

El RemoteWebDriver es una clase de Selenium que permite la ejecución de pruebas automatizadas en navegadores web ubicados en máquinas remotas. A diferencia del WebDriver tradicional que controla un navegador en la máquina local, el RemoteWebDriver se comunica con un servidor remoto empleando el Protocolo WebDriver.

Utilizar el RemoteWebDriver es esencial cuando se necesita ejecutar pruebas en entornos distribuidos o en servicios de nube que ofrecen múltiples navegadores y sistemas operativos. Esto facilita la validación de aplicaciones en diferentes plataformas, garantizando su correcto funcionamiento en diversos escenarios.

Para conectarse a un servidor remoto, como Selenium Grid o proveedores en la nube como LambdaTest, es necesario especificar la URL del servidor y las capacidades deseadas del navegador. Las capabilities son un conjunto de propiedades que definen el navegador, la versión y el sistema operativo en el que se ejecutarán las pruebas.

A continuación, se muestra un ejemplo de cómo inicializar el RemoteWebDriver en Java 23:

import org.openqa.selenium.remote.RemoteWebDriver;
import org.openqa.selenium.remote.DesiredCapabilities;
import java.net.URI;

public class PruebaRemota {
    public static void main(String[] args) throws Exception {
        var capabilities = new DesiredCapabilities();
        capabilities.setBrowserName("chrome");
        capabilities.setPlatformName("Windows 10");

        var remoteUrl = URI.create("https://usuario:clave@hub.lambdatest.com/wd/hub").toURL();
        try (var driver = new RemoteWebDriver(remoteUrl, capabilities)) {
            driver.navigate().to("https://www.ejemplo.com");
            System.out.println("Título de la página: " + driver.getTitle());
        }
    }
}

En este código, se crea una instancia de DesiredCapabilities para especificar las propiedades del navegador y sistema operativo deseados. Luego, se inicializa el RemoteWebDriver con la URL del servidor remoto y las capacidades definidas. El uso de try-with-resources garantiza que el controlador se cierre correctamente tras la ejecución.

El Protocolo WebDriver es la base de comunicación entre el cliente (nuestro código Java) y el servidor remoto. Este protocolo utiliza solicitudes HTTP para enviar comandos al servidor, que a su vez controla el navegador remoto.

Una ventaja clave del RemoteWebDriver es que permite la paralelización de pruebas. Al distribuir las pruebas en múltiples máquinas remotas, se acelera el proceso de validación y se optimiza el tiempo de ejecución.

Es fundamental configurar adecuadamente las capabilities al trabajar con entornos remotos. Además de especificar el navegador y el sistema operativo, se pueden incluir opciones adicionales como la versión del navegador, resolución de pantalla o preferencias específicas.

Al integrar el RemoteWebDriver en flujos de trabajo, es importante considerar aspectos como la latencia y posibles interrupciones en la comunicación con el servidor remoto. Implementar esperas explícitas y gestionar excepciones ayuda a mitigar estos desafíos y asegurar la fiabilidad de las pruebas.

Creación cuenta y api keys en Lambda Test

Para poder ejecutar pruebas de Selenium en la nube utilizando LambdaTest, es necesario crear una cuenta y obtener las claves API que permitirán la autenticación. A continuación, se detallan los pasos para realizar este proceso:

En primer lugar, accede al sitio web oficial de LambdaTest (https://www.lambdatest.com) y selecciona la opción de registrarse. Completa el formulario de registro con tus datos personales, como nombre, correo electrónico y contraseña. Es crucial utilizar una dirección de correo electrónico válida, ya que recibirás un enlace para verificar tu cuenta.

Una vez confirmada la cuenta, inicia sesión en el portal de LambdaTest. En el panel de control, encontrarás diversas opciones y funcionalidades. Para obtener tus claves API, dirige el cursor hacia tu nombre de usuario en la esquina superior derecha y selecciona la opción "Configuración" del menú desplegable.

Dentro de la sección de configuración, ubica y haz clic en "Acceso API" o "Credenciales de API". Aquí se mostrarán tus datos de "Username" y "Access Key". Estos identificadores son esenciales para la comunicación segura con el servidor remoto de LambdaTest mediante el RemoteWebDriver.

Es recomendable almacenar estas claves de forma segura y no compartirlas con terceros. Una práctica común es utilizarlas a través de variables de entorno en lugar de escribirlas directamente en el código fuente. De esta manera, se mejora la seguridad y la flexibilidad al cambiar las credenciales sin modificar el código.

Para configurar las variables de entorno en tu sistema operativo, puedes seguir estos pasos:

En Windows:

Accede a las Propiedades del sistema.

Navega a "Variables de entorno".

Crea nuevas variables con los nombres LT_USERNAME y LT_ACCESS_KEY, asignando los valores correspondientes.

En macOS o Linux:

Abre el terminal.

Edita el archivo .bash_profile, .bashrc o .zshrc, dependiendo de tu shell.

Añade las líneas:

Guarda los cambios y ejecuta source ~/.bash_profile (o el archivo que hayas editado) para aplicar las variables.

En tu código Java, puedes acceder a estas variables de entorno de la siguiente manera:

var username = System.getenv("LT_USERNAME");
var accessKey = System.getenv("LT_ACCESS_KEY");

Al utilizar System.getenv(), evitas exponer directamente las credenciales en el código, lo que es una buena práctica de seguridad.

Con el username y accessKey, construye la URL remota para conectar con LambdaTest:

var remoteUrl = URI.create("https://" + username + ":" + accessKey + "@hub.lambdatest.com/wd/hub").toURL();

Esta URL incluye las credenciales necesarias para autenticar las solicitudes al servidor de LambdaTest. Asegúrate de que los datos son correctos para evitar errores de autenticación.

Además, es posible que desees personalizar tus pruebas especificando el navegador, versión y sistema operativo. LambdaTest proporciona una amplia variedad de opciones que puedes configurar mediante las capabilities. Por ejemplo:

var capabilities = new HashMap<String, Object>();
capabilities.put("browserName", "Chrome");
capabilities.put("browserVersion", "latest");
capabilities.put("platformName", "Windows 10");

También puedes añadir opciones adicionales, como el nombre del test o ajustar el nivel de registro:

var ltOptions = new HashMap<String, Object>();
ltOptions.put("build", "Java Selenium Test");
ltOptions.put("name", "Test de ejecución remota");
ltOptions.put("selenium_version", "4.26.0");
capabilities.put("LT:Options", ltOptions);

Recuerda consultar la documentación oficial de LambdaTest para conocer todas las capabilities disponibles y así ajustar tus pruebas según tus necesidades.

Para finalizar, es aconsejable realizar una prueba de conexión para verificar que todo esté configurado correctamente. Esto garantizará que puedas ejecutar tus pruebas de forma fluida y sin contratiempos en el entorno remoto de LambdaTest.

Configuración RemoteWebDriver para Lambda Test

Para ejecutar pruebas en LambdaTest utilizando RemoteWebDriver, es imprescindible configurar correctamente las capacidades y opciones específicas del entorno en la nube. A continuación, se detallan los pasos necesarios para establecer esta configuración en Java 23 con JUnit 5 y Selenium 4.26.

En primer lugar, se deben definir las capacidades deseadas que especifican el navegador, su versión y el sistema operativo donde se ejecutarán las pruebas:

var capabilities = new HashMap<String, Object>();
capabilities.put("browserName", "Chrome");
capabilities.put("browserVersion", "latest");

Es vital incluir las opciones específicas de LambdaTest bajo la clave "LT:Options":

var ltOptions = new HashMap<String, Object>();
ltOptions.put("platformName", "Windows 11");
ltOptions.put("project", "Proyecto de Automatización");
ltOptions.put("build", "Build 1.0.0");
ltOptions.put("name", "Prueba Selenium Remota");
ltOptions.put("selenium_version", "4.26.0");
ltOptions.put("w3c", true); // Para asegurar compatibilidad con W3C WebDriver protocol

capabilities.put("LT:Options", ltOptions);

Con las capacidades definidas, es momento de construir la URL remota utilizando las variables de entorno para las credenciales:

var username = System.getenv("LT_USERNAME");
var accessKey = System.getenv("LT_ACCESS_KEY");

var remoteUrl = URI.create("https://" + username + ":" + accessKey + "@hub.lambdatest.com/wd/hub").toURL();

Es fundamental mantener las credenciales seguras utilizando variables de entorno y no incluirlas directamente en el código.

A continuación, se inicializa el RemoteWebDriver con las capacidades establecidas:

try (var driver = new RemoteWebDriver(remoteUrl, capabilities)) {
    driver.navigate().to("https://www.example.com");
    System.out.println("Título de la página: " + driver.getTitle());
    // Añadir aquí las acciones adicionales de la prueba
}

El uso de try con recursos garantiza que el driver se cerrará adecuadamente al finalizar.

Si se requieren opciones específicas del navegador, como deshabilitar extensiones o iniciar en modo incógnito, se pueden agregar utilizando las Browser Options:

var chromeOptions = new ChromeOptions();
chromeOptions.addArguments("--incognito");
chromeOptions.setExperimentalOption("excludeSwitches", List.of("enable-automation"));

capabilities.put("goog:chromeOptions", chromeOptions);

Para integrar estas opciones con las capacidades existentes:

capabilities.putAll(chromeOptions.asMap());

Al utilizar LambdaTest, es posible aprovechar su infraestructura para ejecutar pruebas en múltiples plataformas y navegadores de forma paralela. Esto permite validar la aplicación en diferentes entornos y garantiza una mayor cobertura.

Integrando todo en una estructura de prueba con JUnit 5:

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.AfterEach;

public class PruebaLambdaTest {

    private RemoteWebDriver driver;

    @BeforeEach
    public void configurar() throws Exception {
        var capabilities = new HashMap<String, Object>();
        capabilities.put("browserName", "Chrome");
        capabilities.put("browserVersion", "latest");

        var ltOptions = new HashMap<String, Object>();
        ltOptions.put("platformName", "Windows 11");
        ltOptions.put("project", "Proyecto de Automatización");
        ltOptions.put("build", "Build 1.0.0");
        ltOptions.put("name", "Prueba Selenium Remota");
        ltOptions.put("selenium_version", "4.26.0");
        ltOptions.put("w3c", true);

        capabilities.put("LT:Options", ltOptions);

        var username = System.getenv("LT_USERNAME");
        var accessKey = System.getenv("LT_ACCESS_KEY");
        var remoteUrl = URI.create("https://" + username + ":" + accessKey + "@hub.lambdatest.com/wd/hub").toURL();

        driver = new RemoteWebDriver(remoteUrl, capabilities);
    }

    @Test
    public void ejecutarPrueba() {
        driver.get("https://www.example.com");
        var titulo = driver.getTitle();
        assertEquals("Título de Ejemplo", titulo);
    }

    @AfterEach
    public void finalizar() {
        if (driver != null) {
            driver.quit();
        }
    }
}

Es recomendable utilizar asserts para validar el comportamiento esperado de la aplicación durante la prueba.

Para mejorar la eficiencia en la ejecución de pruebas y aprovechar las nuevas características de Java, se pueden utilizar funciones lambda y métodos de streaming:

var enlaces = driver.findElements(By.tagName("a"))
                    .stream()
                    .filter(elemento -> elemento.getText().contains("Contacto"))
                    .toList();

enlaces.forEach(WebElement::click);

Además, es importante manejar las esperas dinámicas para asegurar la sincronización con la carga de elementos en la página:

var wait = new WebDriverWait(driver, Duration.ofSeconds(10));
var elemento = wait.until(drv -> drv.findElement(By.id("boton-enviar")));
elemento.click();

  export LT_USERNAME="tu_username"
  export LT_ACCESS_KEY="tu_access_key"