Tutorial Selenium: Interacción con formularios

Rellenar campos input y textarea en formularios

Al realizar pruebas automatizadas con Selenium, es común interactuar con campos de texto input y textarea para simular la entrada de datos por parte del usuario. Estos elementos permiten introducir y enviar información en formularios web, por lo que es esencial saber cómo manipularlos correctamente.

Para localizar un campo de texto, podemos utilizar distintos selectores como By.id, By.name, By.className, By.cssSelector o By.xpath. Una vez localizado, utilizamos el método sendKeys() para ingresar el texto deseado.

A continuación, se muestra un ejemplo de cómo rellenar un campo input y un textarea en un test con JUnit 5:

import org.junit.jupiter.api.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

class FormularioTest {

    @Test
    void rellenarCamposTexto() {
        WebDriver driver = new ChromeDriver();
        driver.get("https://www.ejemplo.com/formulario");

        WebElement campoInput = driver.findElement(By.id("campo-input"));
        campoInput.sendKeys("Texto de ejemplo");

        WebElement campoTextarea = driver.findElement(By.id("campo-textarea"));
        campoTextarea.sendKeys("Texto largo de ejemplo para el textarea.");

        driver.quit();
    }
}

En este ejemplo:

• Creamos una instancia de WebDriver para controlar el navegador.
• Navegamos a la URL del formulario con driver.get().
• Localizamos el campo input mediante By.id("campo-input") y enviamos texto con sendKeys("Texto de ejemplo").
• Hacemos lo mismo con el campo textarea.
• Finalmente, cerramos el navegador con driver.quit().

Es importante asegurarse de que los elementos estén visibles y habilitados antes de interactuar con ellos. En algunos casos, puede ser necesario esperar a que el elemento esté presente en el DOM. Para ello, podemos utilizar esperas explícitas:

import org.junit.jupiter.api.Test;
import org.openqa.selenium.*;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.openqa.selenium.support.ui.ExpectedConditions;

import java.time.Duration;

class FormularioTest {

    @Test
    void rellenarCamposTextoConEspera() {
        WebDriver driver = new ChromeDriver();
        driver.get("https://www.ejemplo.com/formulario");

        WebDriverWait espera = new WebDriverWait(driver, Duration.ofSeconds(10));

        WebElement campoInput = espera.until(
            ExpectedConditions.visibilityOfElementLocated(By.id("campo-input"))
        );
        campoInput.sendKeys("Texto de ejemplo");

        WebElement campoTextarea = espera.until(
            ExpectedConditions.visibilityOfElementLocated(By.id("campo-textarea"))
        );
        campoTextarea.sendKeys("Texto largo de ejemplo para el textarea.");

        driver.quit();
    }
}

En este caso, utilizamos WebDriverWait y ExpectedConditions para esperar hasta que los campos estén visibles antes de interactuar con ellos.

Si deseamos limpiar un campo antes de introducir texto, podemos utilizar el método clear():

campoInput.clear();
campoInput.sendKeys("Nuevo texto");

Este método es útil cuando los campos pueden contener texto prellenado y queremos asegurarnos de que contienen únicamente la información que introducimos durante la prueba.

Además, para simular acciones del teclado, como presionar teclas especiales, podemos utilizar la clase Keys:

campoInput.sendKeys("Texto inicial");
campoInput.sendKeys(Keys.CONTROL, "a"); // Seleccionar todo el texto
campoInput.sendKeys(Keys.BACK_SPACE);   // Borrar el texto seleccionado
campoInput.sendKeys("Texto reemplazado");

Con esta técnica, podemos realizar manipulaciones más avanzadas en los campos de texto, como copiar, cortar o pegar contenido.

En resumen, para interactuar eficazmente con campos input y textarea en formularios con Selenium:

• Localiza los elementos correctamente utilizando selectores apropiados.
• Utiliza sendKeys() para enviar texto a los campos.
• Emplea clear() si necesitas limpiar el campo antes de introducir nuevo texto.
• Aplica esperas explícitas cuando sea necesario para asegurar que los elementos estén listos para la interacción.

Siguiendo estas prácticas, tus pruebas serán más robustas y reflejarán de manera fiel el comportamiento del usuario en la aplicación web.

Manejo de selectores simples y múltiples

Los elementos selectores de opciones en formularios web permiten a los usuarios elegir entre varias opciones predefinidas. En Selenium, es esencial saber cómo interactuar con estos elementos, ya sean selectores simples (que permiten seleccionar una única opción) o selectores múltiples (que permiten seleccionar varias opciones al mismo tiempo).

Para manipular un elemento select, Selenium proporciona la clase **Select**, que ofrece métodos específicos para seleccionar y deseleccionar opciones. Primero, debemos localizar el elemento select en la página y crear una instancia de Select a partir de él.

import org.junit.jupiter.api.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.Select;

class FormularioTest {

    @Test
    void seleccionarOpcionSimple() {
        WebDriver driver = new ChromeDriver();
        driver.get("https://www.ejemplo.com/formulario");

        WebElement elementoSelect = driver.findElement(By.id("mi-select"));
        Select seleccion = new Select(elementoSelect);

        seleccion.selectByVisibleText("Opción 1");

        driver.quit();
    }
}

En este ejemplo:

• Creamos una instancia de WebDriver para controlar el navegador.
• Navegamos a la URL del formulario con driver.get().
• Localizamos el elemento select mediante By.id("mi-select").
• Creamos una instancia de Select pasando el elemento localizado.
• Utilizamos selectByVisibleText("Opción 1") para seleccionar una opción específica.
• Cerramos el navegador con driver.quit().

La clase Select ofrece varios métodos para interactuar con las opciones:

• selectByVisibleText(String text): selecciona la opción cuyo texto visible coincide con el proporcionado.
• selectByValue(String value): selecciona la opción cuyo atributo value coincide con el valor dado.
• selectByIndex(int index): selecciona la opción ubicada en el índice especificado (comenzando desde 0).

Para gestionar selectores múltiples, que permiten seleccionar varias opciones, es importante verificar si el elemento permite múltiples selecciones utilizando isMultiple().

import org.junit.jupiter.api.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.Select;

class FormularioTest {

    @Test
    void seleccionarOpcionesMultiples() {
        WebDriver driver = new ChromeDriver();
        driver.get("https://www.ejemplo.com/formulario");

        WebElement elementoSelectMultiple = driver.findElement(By.id("mi-select-multiple"));
        Select seleccionMultiple = new Select(elementoSelectMultiple);

        if (seleccionMultiple.isMultiple()) {
            seleccionMultiple.selectByVisibleText("Opción A");
            seleccionMultiple.selectByVisibleText("Opción B");
            seleccionMultiple.selectByValue("valor_c");
        }

        driver.quit();
    }
}

En este caso:

• Verificamos si el select permite múltiples selecciones con isMultiple().
• Si es así, utilizamos selectByVisibleText() y selectByValue() para seleccionar varias opciones.
• Podemos seleccionar tantas opciones como necesitemos.

Para deseleccionar opciones en un selector múltiple, la clase Select proporciona métodos como deselectByVisibleText(), deselectByValue() y deselectAll(). Esto es útil cuando necesitamos cambiar las opciones seleccionadas durante una prueba.

// Deseleccionar una opción específica
seleccionMultiple.deselectByVisibleText("Opción A");

// Deseleccionar todas las opciones seleccionadas
seleccionMultiple.deselectAll();

Es fundamental recordar que estos métodos de deselección solo funcionan con selectores múltiples. Intentar deseleccionar opciones en un selector simple generará una excepción.

Para obtener las opciones actualmente seleccionadas, podemos utilizar:

• getFirstSelectedOption(): devuelve la primera opción seleccionada.
• getAllSelectedOptions(): devuelve una lista de todas las opciones seleccionadas.

WebElement primeraOpcion = seleccionMultiple.getFirstSelectedOption();
System.out.println("Primera opción seleccionada: " + primeraOpcion.getText());

List<WebElement> opcionesSeleccionadas = seleccionMultiple.getAllSelectedOptions();
opcionesSeleccionadas.forEach(opcion -> System.out.println("Opción seleccionada: " + opcion.getText()));

Ejemplo utilizando streams de Java:

opcionesSeleccionadas.stream()
    .map(WebElement::getText)
    .forEach(texto -> System.out.println("Opción seleccionada: " + texto));

Si necesitamos esperar a que el elemento select esté disponible o a que se carguen sus opciones, podemos emplear esperas explícitas con WebDriverWait y ExpectedConditions.

import org.openqa.selenium.support.ui.WebDriverWait;
import org.openqa.selenium.support.ui.ExpectedConditions;
import java.time.Duration;

...

WebDriverWait espera = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement elementoSelect = espera.until(
    ExpectedConditions.elementToBeClickable(By.id("mi-select"))
);
Select seleccion = new Select(elementoSelect);

En este fragmento:

• Utilizamos WebDriverWait para esperar hasta que el elemento sea interactuable.
• ExpectedConditions.elementToBeClickable() espera a que el elemento esté visible y habilitado para interactuar.

Al manipular selectores en formularios con Selenium:

• Localiza siempre el elemento antes de crear la instancia de Select.
• Utiliza los métodos apropiados de la clase Select según tus necesidades.
• Verifica si el selector es múltiple con isMultiple() antes de deseleccionar opciones.
• Emplea esperas explícitas cuando sea necesario para asegurar una interacción fluida.

Dominar el manejo de selectores simples y múltiples te permitirá automatizar pruebas más complejas y garantizar que tus scripts interactúen correctamente con los formularios de tu aplicación web.

Casillas de verificación checkbox y botones radio

Las casillas de verificación (checkboxes) y los botones de opción (radio buttons) son elementos de formulario que permiten al usuario seleccionar opciones. En Selenium, es fundamental saber cómo interactuar con estos elementos para simular el comportamiento real de un usuario en pruebas automatizadas.

Para comenzar, es necesario localizar estos elementos en la página web. Podemos utilizar diversos métodos de localización como By.id, By.name, By.className, By.cssSelector o By.xpath. Una vez localizado el elemento, podemos utilizar métodos de Selenium para interactuar con él.

Una casilla de verificación permite al usuario seleccionar o deseleccionar una opción. Para marcar o desmarcar una casilla, podemos utilizar el método click() sobre el elemento correspondiente. Por ejemplo, en un test de JUnit 5:

import org.junit.jupiter.api.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

class CasillasVerificacionTest {

    @Test
    void marcarCasillaVerificacion() {
        WebDriver driver = new ChromeDriver();
        driver.get("https://www.ejemplo.com/formulario");

        WebElement casilla = driver.findElement(By.id("aceptar-terminos"));
        if (!casilla.isSelected()) {
            casilla.click();
        }

        driver.quit();
    }
}

En este ejemplo, localizamos la casilla de verificación mediante By.id("aceptar-terminos"), verificamos si está marcada usando isSelected() y, si no lo está, la marcamos con click(). Es importante utilizar isSelected() para verificar el estado actual de la casilla, evitando interacciones innecesarias.

Los botones de opción permiten seleccionar una única opción dentro de un grupo. Al seleccionar un botón de radio, las otras opciones del grupo se deseleccionan automáticamente. A continuación, un ejemplo de selección de un botón de radio:

import org.junit.jupiter.api.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

class BotonesRadioTest {

    @Test
    void seleccionarBotonRadio() {
        WebDriver driver = new ChromeDriver();
        driver.get("https://www.ejemplo.com/formulario");

        WebElement opcionMasculino = driver.findElement(By.id("genero-masculino"));
        if (!opcionMasculino.isSelected()) {
            opcionMasculino.click();
        }

        driver.quit();
    }
}

En este caso, localizamos el botón de radio correspondiente al género masculino, verificamos si ya está seleccionado y, si no lo está, lo seleccionamos con click().

A veces es necesario seleccionar una opción dentro de un grupo dinámicamente. Podemos obtener todos los botones de radio de un grupo y seleccionar el que cumpla cierta condición. Por ejemplo:

import org.junit.jupiter.api.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

import java.util.List;

class GrupoBotonesRadioTest {

    @Test
    void seleccionarBotonRadioPorValor() {
        WebDriver driver = new ChromeDriver();
        driver.get("https://www.ejemplo.com/formulario");

        List<WebElement> opcionesGenero = driver.findElements(By.name("genero"));
        opcionesGenero.stream()
            .filter(opcion -> opcion.getAttribute("value").equals("femenino"))
            .findFirst()
            .ifPresent(opcion -> {
                if (!opcion.isSelected()) {
                    opcion.click();
                }
            });

        driver.quit();
    }
}

Aquí, obtenemos la lista de botones de radio del grupo genero utilizando findElements(By.name("genero")). Utilizamos una expresión lambda para filtrar la opción cuyo atributo value es "femenino". Si la encontramos y no está seleccionada, hacemos click() para seleccionarla.

Es esencial comprobar el estado de estos elementos durante las pruebas. Podemos usar isSelected() para determinar si están seleccionados. Por ejemplo:

boolean casillaMarcada = casilla.isSelected();
boolean opcionSeleccionada = opcionMasculino.isSelected();

Este enfoque permite validar el comportamiento de la aplicación y asegurar que las interacciones producen los resultados esperados.

Cuando tenemos múltiples casillas que pueden ser seleccionadas independientemente, podemos recorrer la lista y marcar o desmarcar según sea necesario. Por ejemplo:

import org.junit.jupiter.api.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

import java.util.List;

class CasillasMultiplesTest {

    @Test
    void marcarVariasCasillasVerificacion() {
        WebDriver driver = new ChromeDriver();
        driver.get("https://www.ejemplo.com/formulario");

        List<WebElement> intereses = driver.findElements(By.name("intereses"));
        intereses.forEach(casilla -> {
            if (!casilla.isSelected()) {
                casilla.click();
            }
        });

        driver.quit();
    }
}

En este caso, obtenemos todas las casillas de verificación con findElements(By.name("intereses")) y utilizamos forEach para recorrerlas y marcarlas si no están seleccionadas.

Es importante asegurar que los elementos están visibles y habilitados antes de interactuar con ellos. Podemos utilizar esperas explícitas si los elementos tardan en cargarse:

import org.openqa.selenium.support.ui.WebDriverWait;
import org.openqa.selenium.support.ui.ExpectedConditions;
import java.time.Duration;

...

WebDriverWait espera = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement casilla = espera.until(ExpectedConditions.elementToBeClickable(By.id("aceptar-terminos")));

De esta manera, evitamos errores al interactuar con elementos que aún no están listos.

Ejemplo con programación funcional de Java:

opcionesGenero.stream()
    .filter(opcion -> opcion.getAttribute("value").equals("no-binario"))
    .findFirst()
    .ifPresentOrElse(
        opcion -> {
            if (!opcion.isSelected()) opcion.click();
        },
        () -> {
            // Manejar el caso en que no se encuentre la opción
        }
    );

Este código utiliza stream() y ifPresentOrElse para mejorar la fluidez y claridad del código.

Envío y limpieza de formularios

Al trabajar con formularios en pruebas automatizadas con Selenium, es fundamental saber cómo enviar y limpiar formularios para simular correctamente la interacción del usuario. Estas acciones permiten verificar que la aplicación procesa y gestiona la información introducida de manera adecuada.

Para enviar un formulario, la forma más directa es simular el clic en el botón de envío. Esto se logra localizando el botón, que suele ser un elemento input con type="submit" o un elemento button, y utilizando el método click(). A continuación, se muestra un ejemplo en un test de JUnit 5:

import org.junit.jupiter.api.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

class EnvioFormularioTest {

    @Test
    void enviarFormulario() {
        WebDriver driver = new ChromeDriver();
        driver.get("https://www.ejemplo.com/formulario");

        // Rellenar los campos del formulario
        driver.findElement(By.id("nombre")).sendKeys("Ana López");
        driver.findElement(By.id("correo")).sendKeys("ana.lopez@example.com");

        // Localizar y hacer clic en el botón de envío
        WebElement botonEnviar = driver.findElement(By.id("enviar"));
        botonEnviar.click();

        // Añadir una verificación si es necesario
        // Por ejemplo, comprobar que se muestra un mensaje de éxito

        driver.quit();
    }
}

En este ejemplo:

• Localizamos el botón de envío con By.id("enviar").
• Utilizamos botonEnviar.click() para simular el clic del usuario.
• Después del envío, es recomendable verificar que la acción ha sido exitosa, como comprobar la presencia de un mensaje de confirmación.

Alternativamente, podemos utilizar el método submit() sobre un elemento dentro del formulario. Sin embargo, este enfoque es menos común y puede ser menos fiable debido a las variaciones en la estructura de los formularios:

WebElement formulario = driver.findElement(By.id("formulario-contacto"));
formulario.submit();

Para limpiar un formulario, podemos usar el método clear() en cada campo de entrada para eliminar su contenido. Esto es útil cuando necesitamos restablecer el formulario antes de realizar nuevas interacciones. Ejemplo:

driver.findElement(By.id("nombre")).clear();
driver.findElement(By.id("correo")).clear();

Si tenemos varios campos, podemos optimizar el proceso utilizando una lista y aplicando una función lambda:

import java.util.List;

List<By> campos = List.of(
    By.id("nombre"),
    By.id("correo"),
    By.id("telefono"),
    By.id("direccion")
);

campos.forEach(campo -> driver.findElement(campo).clear());

En este fragmento:

• Creamos una lista con los localizadores de los campos.
• Aplicamos forEach para iterar y limpiar cada campo con clear().

Además de los campos de texto, es posible que necesitemos restablecer otros elementos como casillas de verificación o selectores. Por ejemplo, para deseleccionar una casilla de verificación marcada:

WebElement casillaAcepto = driver.findElement(By.id("acepto-terminos"));
if (casillaAcepto.isSelected()) {
    casillaAcepto.click();
}

Y para restablecer un selector a su valor predeterminado:

import org.openqa.selenium.support.ui.Select;

Select selectorPais = new Select(driver.findElement(By.id("pais")));
selectorPais.selectByIndex(0); // Selecciona la primera opción

Es crucial asegurarse de que los elementos del formulario están disponibles y listos para interactuar. Podemos utilizar esperas explícitas para esperar hasta que un elemento sea interactuable:

import org.openqa.selenium.support.ui.WebDriverWait;
import org.openqa.selenium.support.ui.ExpectedConditions;
import java.time.Duration;

// ...

WebDriverWait espera = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement botonEnviar = espera.until(
    ExpectedConditions.elementToBeClickable(By.id("enviar"))
);
botonEnviar.click();

En este código:

• Utilizamos WebDriverWait para esperar hasta que el botón sea clicable.
• Esto evita errores al interactuar con elementos que aún no están disponibles.

Si el formulario incluye validaciones en tiempo real, es posible que necesitemos disparar eventos adicionales para que la aplicación reconozca los cambios. Por ejemplo, podemos simular la pulsación de la tecla Tab para mover el foco y activar la validación:

import org.openqa.selenium.Keys;

// ...

driver.findElement(By.id("correo")).sendKeys(Keys.TAB);

Sin embargo, es preferible simular acciones reales del usuario, como el clic en el botón de envío, para mantener las pruebas consistentes.

Para garantizar que el formulario se ha enviado correctamente, es recomendable comprobar el resultado esperado. Por ejemplo, verificar que la URL ha cambiado o que aparece un mensaje de éxito:

String mensajeExito = driver.findElement(By.id("mensaje-exito")).getText();
assertEquals("Formulario enviado correctamente", mensajeExito);

Al limpiar el formulario antes de una nueva entrada de datos, nos aseguramos de que las pruebas son independientes y no se ven afectadas por datos residuales de pruebas anteriores.

En resumen:

• Simula el envío del formulario haciendo clic en el botón de envío.
• Limpia los campos necesarios utilizando clear() y restablece otros elementos si es necesario.
• Utiliza esperas explícitas para interactuar con elementos de forma segura.
• Verifica los resultados para confirmar que las acciones han sido exitosas.

Aplicando estas prácticas, tus pruebas con Selenium serán más fiables y reflejarán con precisión el comportamiento esperado de la aplicación web.

Subida de archivos en formularios

La subida de archivos en formularios web es una funcionalidad común que permite a los usuarios cargar documentos, imágenes u otros tipos de archivos en una aplicación. Al automatizar pruebas con Selenium 4.26, es esencial saber cómo interactuar con estos elementos para asegurar que el proceso de carga se realiza correctamente.

En los formularios HTML, los campos para subir archivos se definen mediante un elemento <input> con el atributo type="file". Para automatizar la subida, Selenium proporciona una forma sencilla y efectiva.

Para subir un archivo utilizando Selenium, es suficiente con enviar la ruta absoluta del archivo al campo de entrada. A continuación, se muestra un ejemplo en un test de JUnit 5:

import org.junit.jupiter.api.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

class SubidaArchivoTest {

    @Test
    void subirArchivo() {
        WebDriver driver = new ChromeDriver();
        driver.get("https://www.ejemplo.com/formulario-subida");

        WebElement campoArchivo = driver.findElement(By.id("archivo"));
        String rutaArchivo = "/ruta/absoluta/al/archivo.pdf";
        campoArchivo.sendKeys(rutaArchivo);

        WebElement botonEnviar = driver.findElement(By.id("enviar"));
        botonEnviar.click();

        // Añadir verificación de que la subida fue exitosa
        // ...

        driver.quit();
    }
}

En este ejemplo:

• Localizamos el campo de entrada de archivo con By.id("archivo").
• Obtenemos la ruta absoluta del archivo que deseamos subir.
• Utilizamos sendKeys(rutaArchivo) para enviar la ruta al campo.
• Simulamos el clic en el botón de envío para procesar el formulario.

Es importante asegurarse de que la ruta al archivo es correcta y accesible desde el sistema donde se ejecuta la prueba. En entornos multiplataforma, podemos utilizar Paths de Java para construir la ruta de manera portable:

import java.nio.file.Paths;

String rutaArchivo = Paths.get("src", "test", "resources", "archivo.pdf").toAbsolutePath().toString();

De esta forma, garantizamos que la ruta es válida independientemente del sistema operativo.

Es posible que necesitemos esperar a que el campo de entrada de archivo esté disponible antes de interactuar con él. Podemos utilizar esperas explícitas con WebDriverWait y ExpectedConditions:

import org.openqa.selenium.support.ui.WebDriverWait;
import org.openqa.selenium.support.ui.ExpectedConditions;
import java.time.Duration;

WebDriverWait espera = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement campoArchivo = espera.until(
    ExpectedConditions.elementToBeClickable(By.id("archivo"))
);

Esto asegura que el campo está interactable antes de enviar la ruta del archivo.

En ocasiones, es necesario verificar que el archivo se ha subido correctamente. Esto puede implicar confirmar la presencia de un mensaje de éxito o verificar que el archivo aparece en una lista. Por ejemplo:

WebElement mensajeExito = driver.findElement(By.id("mensaje-exito"));
assertTrue(mensajeExito.isDisplayed());

Para mantener nuestras pruebas robustas y evitar datos dependientes del entorno, es recomendable utilizar archivos de prueba incluidos en el directorio de recursos del proyecto. De esta manera, los archivos están siempre disponibles y controlados por el equipo.

Si necesitamos subir múltiples archivos, el proceso es similar. Algunos formularios permiten seleccionar varios archivos con el atributo multiple en el elemento <input>. Para subir varios archivos:

WebElement campoArchivos = driver.findElement(By.id("archivos"));
String rutasArchivos = String.join(
    "\n",
    "/ruta/absoluta/al/archivo1.pdf",
    "/ruta/absoluta/al/archivo2.jpg"
);
campoArchivos.sendKeys(rutasArchivos);

En este caso, concatenamos las rutas de los archivos separándolas con una nueva línea \n.

Es esencial tener en cuenta que Selenium no puede interactuar con ventanas del sistema operativo, como los diálogos de selección de archivos. Por ello, debemos utilizar sendKeys() para enviar la ruta del archivo directamente al campo de entrada.

En formularios donde el elemento <input> está oculto, y se utiliza un botón personalizado para abrir el diálogo de archivos, es posible que necesitemos remover el atributo hidden o establecer display: block mediante JavaScript para poder interactuar con el campo. Sin embargo, modificar el DOM de la página puede llevar a resultados no deseados. Una alternativa más segura es utilizar JavaScript para establecer el valor del campo:

JavascriptExecutor js = (JavascriptExecutor) driver;
js.executeScript("document.getElementById('archivo').setAttribute('value', arguments[0])", rutaArchivo);

No obstante, este enfoque debe ser usado con precaución y solo si no hay otra opción.

Al trabajar con archivos, es buena práctica verificar que el archivo existe antes de intentar subirlo:

import java.nio.file.Files;
import java.nio.file.Paths;

assertTrue(Files.exists(Paths.get(rutaArchivo)), "El archivo no existe");

Esto evita errores en tiempo de ejecución y mejora la confiabilidad de las pruebas.

Resumen de pasos:

• Localiza el campo <input type="file"> en el formulario.
• Utiliza sendKeys() para enviar la ruta absoluta del archivo.
• Asegura que el archivo existe y que la ruta es correcta.
• Evita interactuar con diálogos del sistema operativo; usa sendKeys() en su lugar.
• Verifica que la subida ha sido exitosa comprobando mensajes o elementos resultantes.