Espera implícita y explícita en Selenium con sintaxis

In SeleniumLas "esperas" juegan un papel importante en la ejecución de pruebas confiables. En este tutorial, aprenderá los aspectos clave y las diferencias entre los comandos de espera implícitos y explícitos en Selenium, junto con el uso práctico de Fluent Wait.

¿Por qué necesitamos esperas? Selenium?

La mayoría de las aplicaciones web modernas se desarrollan utilizando Ajax y JavaScriptCuando el navegador carga una página, los elementos con los que queremos interactuar pueden cargarse en diferentes intervalos de tiempo.

Esto no solo dificulta la identificación del elemento, sino que si el elemento no se localiza a tiempo, Selenium lanzará un ElementoNotVisibleException. Selenium Las esperas resuelven este problema de sincronización al proporcionar al WebDriver un intervalo de tiempo definido para encontrar un elemento antes de que se produzca un fallo.

Consideremos un escenario en el que se utilizan tanto esperas implícitas como explícitas en la misma prueba. Supongamos que la espera implícita se establece en 20 segundos y la espera explícita en 10 segundos.

Si buscamos un elemento regido por ciertas condiciones Condiciones esperadas (Espera explícita) y el elemento no se encuentra dentro de la ventana explícita de 10 segundos, el WebDriver recurre a la ventana implícita de 20 segundos antes de lanzar una excepción. ElementoNotVisibleException.

Selenium WebDriver espera

1. Espera implícita
2. Espera explícita
3. Espera fluida

Espera implícita Selenium

El Espera implícita Selenium Indica al WebDriver que espere un tiempo determinado antes de lanzar una excepción NoSuchElementException. El valor predeterminado es 0. Una vez configurado, el WebDriver consulta el DOM durante ese tiempo antes de fallar. Selenium WebDriver heredó el concepto de esperas implícitas de Watir.

En el ejemplo siguiente, declaramos una espera implícita con una duración de 10 segundos. Si el elemento no se encuentra dentro de ese intervalo, se genera una excepción.

Sintaxis de espera implícita (Selenium 4):

driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));

package guru.test99;
import java.time.Duration;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.Test;

public class AppTest {

    protected WebDriver driver;

    @Test
    public void guru99tutorials() throws InterruptedException {
        driver = new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
        String eTitle = "Demo Guru99 Page";
        String aTitle = "";
        // launch Chrome and redirect it to the Base URL
        driver.get("https://demo.guru99.com/test/guru99home/");
        // Maximize the browser window
        driver.manage().window().maximize();
        // get the actual value of the title
        aTitle = driver.getTitle();
        // compare the actual title with the expected title
        if (aTitle.equals(eTitle)) {
            System.out.println("Test Passed");
        } else {
            System.out.println("Test Failed");
        }
        // close browser
        driver.close();
    }
}

Explicación de Code

En el ejemplo anterior, considere la siguiente afirmación:

driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));

Selenium La versión 4 reemplazó la firma anterior de dos argumentos (entero más TimeUnit) por un único argumento Duration. La clase Duration admite segundos, minutos, milisegundos y otras unidades de tiempo mediante funciones auxiliares estáticas como Duration.ofSeconds, Duration.ofMillis y Duration.ofMinutes.

Espera explícita Selenium

El Espera explícita Selenium Indica al WebDriver que espere a que se cumplan ciertas condiciones (Condiciones esperadas) o a que transcurra un tiempo máximo antes de lanzar una excepción ElementNotVisibleException. Esta espera es más inteligente porque se aplica únicamente al elemento especificado. Se prefiere la espera explícita a la implícita cuando la prueba necesita gestionar contenido Ajax cargado dinámicamente.

Una vez que se declara una espera explícita, debe usar Condiciones esperadaso puede configurar la frecuencia de sondeo usando Espera fluida. Evitar el uso de Thread.sleep (), ya que detiene la ejecución incondicionalmente y generalmente se considera una mala práctica.

En el siguiente ejemplo, creamos una referencia de la WebDriverEsperar clase, instanciarla con el Controlador web Consulte la referencia y configure una ventana máxima de 20 segundos.

Sintaxis de espera explícita (Selenium 4):

WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(20));

package guru.test99;

import java.time.Duration;
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.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.testng.annotations.Test;

public class AppTest2 {
    protected WebDriver driver;

    @Test
    public void guru99tutorials() throws InterruptedException {
        driver = new ChromeDriver();
        WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(20));
        String eTitle = "Demo Guru99 Page";
        String aTitle = "";
        // launch Chrome and redirect it to the Base URL
        driver.get("https://demo.guru99.com/test/guru99home/");
        // Maximize the browser window
        driver.manage().window().maximize();
        // get the actual value of the title
        aTitle = driver.getTitle();
        // compare the actual title with the expected title
        if (aTitle.contentEquals(eTitle)) {
            System.out.println("Test Passed");
        } else {
            System.out.println("Test Failed");
        }
        WebElement guru99seleniumlink;
        guru99seleniumlink = wait.until(ExpectedConditions.visibilityOfElementLocated(
            By.xpath("/html/body/div[1]/section/div[2]/div/div[1]/div/div[1]/div/div/div/div[2]/div[2]/div/div/div/div/div[1]/div/div/a/i")));
        guru99seleniumlink.click();
    }
}

Explicación de Code

Considere el siguiente código:

WebElement guru99seleniumlink;
guru99seleniumlink = wait.until(ExpectedConditions.visibilityOfElementLocated(
    By.xpath("/html/body/div[1]/section/div[2]/div/div[1]/div/div[1]/div/div/div/div[2]/div[2]/div/div/div/div/div[1]/div/div/a/i")));
guru99seleniumlink.click();

En este ejemplo de WebDriverWait, el script espera hasta 20 segundos, como se define en el WebDriverEsperar clase, hasta que Condiciones esperadas están satisfechos, lo que ocurra primero.

Lo anterior Java El código espera hasta 20 segundos para que se cumpla la condición. visibilidadDelElementoUbicado para ser verdad.

Las siguientes condiciones esperadas se pueden utilizar en Selenium Espera explícita:

1. alertaEstáPresente()
2. elementoSelectionStateToBe()
3. elementoToBeClickable()
4. elementoToBeSelected()
5. marcoToBeAvailableAndSwitchToIt()
6. invisibilidaddelelementoubicado()
7. invisibilidadDeElementoConTexto()
8. presencia de todos los elementos ubicados por ()
9. presenciaDeElementoUbicado()
10. textoToBePresentInElement()
11. textoToBePresentInElementLocated()
12. textoToBePresentInElementValue()
13. títuloEs()
14. títuloContiene()
15. visibilidad de()
16. visibilidad de todos los elementos()
17. visibilidad de todos los elementos ubicados por ()
18. visibilidad del elemento ubicado()

Esperar con fluidez Selenium

El Esperar con fluidez Selenium Define la duración máxima que WebDriver debe esperar a que se cumpla una condición, junto con la frecuencia de sondeo para verificar dicha condición antes de lanzar una excepción ElementNotVisibleException. Fluent Wait comprueba la existencia del elemento a intervalos regulares hasta que se encuentra el objeto o expira el tiempo de espera.

Frecuencia: El ciclo de repetición para evaluar la condición a intervalos regulares.

Consideremos un escenario donde un elemento se carga a intervalos impredecibles. Puede tardar 10 segundos, 20 segundos o más. Si declaramos una espera explícita de 20 segundos, el script esperará ese tiempo antes de fallar. En estos casos, Fluent Wait es la opción ideal, ya que realiza sondeos con la frecuencia especificada hasta que se localiza el elemento o expira el temporizador.

Sintaxis de espera fluida (Selenium 4):

Wait<WebDriver> wait = new FluentWait<>(driver)
    .withTimeout(Duration.ofSeconds(30))
    .pollingEvery(Duration.ofSeconds(5))
    .ignoring(NoSuchElementException.class);

La firma anterior que aceptaba valores enteros más TimeUnit quedó obsoleta en Selenium 3.11 y eliminado en Selenium 4. La API basada en duración que se muestra arriba es el enfoque recomendado actualmente.

package guru.test99;

import java.time.Duration;
import java.util.NoSuchElementException;
import java.util.function.Function;

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.FluentWait;
import org.openqa.selenium.support.ui.Wait;
import org.testng.annotations.Test;

public class AppTest3 {
    protected WebDriver driver;

    @Test
    public void guru99tutorials() throws InterruptedException {
        String eTitle = "Demo Guru99 Page";
        String aTitle = "";
        driver = new ChromeDriver();
        // launch Chrome and redirect it to the Base URL
        driver.get("https://demo.guru99.com/test/guru99home/");
        // Maximize the browser window
        driver.manage().window().maximize();
        // get the actual value of the title
        aTitle = driver.getTitle();
        // compare the actual title with the expected title
        if (aTitle.contentEquals(eTitle)) {
            System.out.println("Test Passed");
        } else {
            System.out.println("Test Failed");
        }

        Wait<WebDriver> wait = new FluentWait<>(driver)
            .withTimeout(Duration.ofSeconds(30))
            .pollingEvery(Duration.ofSeconds(5))
            .ignoring(NoSuchElementException.class);

        WebElement clickseleniumlink = wait.until(new Function<WebDriver, WebElement>() {
            public WebElement apply(WebDriver driver) {
                return driver.findElement(By.xpath("/html/body/div[1]/section/div[2]/div/div[1]/div/div[1]/div/div/div/div[2]/div[2]/div/div/div/div/div[1]/div/div/a/i"));
            }
        });
        // click on the selenium link
        clickseleniumlink.click();
        // close browser
        driver.close();
    }
}

Explicación de Code

Considere el siguiente código:

Wait<WebDriver> wait = new FluentWait<>(driver)
    .withTimeout(Duration.ofSeconds(30))
    .pollingEvery(Duration.ofSeconds(5))
    .ignoring(NoSuchElementException.class);

En el ejemplo anterior, declaramos una Fluent Wait con un tiempo de espera de 30 segundos, una frecuencia de sondeo de 5 segundos e ignoramos Ninguna excepción de elemento tal.

Considere el siguiente código:

public WebElement apply(WebDriver driver) {
    return driver.findElement(By.xpath("/html/body/div[1]/section/div[2]/div/div[1]/div/div[1]/div/div/div/div[2]/div[2]/div/div/div/div/div[1]/div/div/a/i"));
}

Esta función identifica el elemento web en la página (aquí, el Selenium enlace en la página de inicio). Con un intervalo de sondeo de 5 segundos y un tiempo de espera de 30 segundos, la espera comprueba el elemento cada 5 segundos durante un máximo de 30 segundos. Si el elemento se encuentra dentro de ese intervalo, el script continúa. De lo contrario, ElementoNotVisibleException es aventado.

También verifique: Selenium Tutorial IDE para principiantes

Diferencia entre espera implícita y espera explícita

La tabla a continuación destaca las diferencias clave entre la espera implícita y la espera explícita en Selenium.

Espera implícita	Espera explícita
El tiempo de espera implícito se aplica a todos los elementos del script.	El tiempo de espera explícito se aplica únicamente a los elementos específicamente seleccionados.
En la espera implícita, no se especifican las condiciones esperadas para el elemento.	En la espera explícita, se deben definir las condiciones esperadas para el elemento.
Se recomienda su uso cuando los elementos se cargan dentro del período de espera implícito configurado.	Se recomienda cuando los elementos tardan más en cargarse y cuando se validan estados de elementos como visibilityOfElementLocated, elementToBeClickable o elementToBeSelected.
Se configura una sola vez y se aplica durante todo el ciclo de vida de la instancia de WebDriver.	Configurable por elemento o por comprobación, lo que proporciona un control más preciso.

Cómo elegir la estrategia de espera adecuada

Elegir el comando de espera correcto afecta directamente la estabilidad y el tiempo de ejecución del script. Utilice este marco de decisión para seleccionar la opción adecuada para cada escenario.

1. Identifique el patrón de carga: Comprueba si el elemento aparece en un momento fijo, tras la respuesta de Ajax, o a intervalos impredecibles. Las cargas fijas se adaptan bien a la espera implícita, mientras que las cargas impredecibles requieren la espera fluida.
2. Evite mezclar esperas implícitas y explícitas: La combinación de ambos puede provocar retrasos inesperados, ya que la espera más larga puede predominar. Selenium La documentación recomienda utilizar solo una estrategia por sesión de WebDriver.
3. Por defecto, se utiliza la espera explícita para el contenido dinámico: Cuando las páginas dependen de Ajax, renderizado condicional o animaciones, Explicit Wait con ExpectedConditions se dirige exactamente al elemento que importa.
4. Utilice Fluent Wait para tiempos variables: Cuando el tiempo de carga de los elementos varía entre ejecuciones, configure Fluent Wait con un intervalo de sondeo. El sondeo reduce el tiempo total de espera en comparación con un único tiempo de espera prolongado.
5. Reemplazar Thread.sleep: Las pausas programadas ralentizan las suites de pruebas y ocultan problemas de sincronización reales. Sustitúyalas por esperas condicionales para mantener una ejecución rápida y determinista.
6. Ajuste los valores de tiempo de espera: Comience con tiempos de espera cortos (5-10 segundos) y auméntelos solo cuando los fallos demuestren una carga realmente lenta. Los tiempos de espera predeterminados prolongados enmascaran las regresiones de rendimiento.
7. Mantener esperas en utilidades auxiliares: Centralice la lógica de espera en una clase auxiliar para que los cambios en la política de tiempo de espera se apliquen a todo el conjunto de pruebas.

Siguiendo este marco, los ingenieros de automatización pueden crear scripts robustos que se adapten a los tiempos reales de la aplicación sin volverse lentos ni frágiles.

Errores comunes que debe evitar con Selenium Murga

Incluso los evaluadores experimentados caen en una pequeña serie de trampas recurrentes cuando trabajan con Selenium esperas. Evitar estos problemas mantiene los scripts rápidos, deterministas y fáciles de mantener en diferentes equipos y entornos.

El primer error común es abusar de Thread.sleep. Una pausa predefinida obliga al script a esperar el tiempo completo, independientemente de la disponibilidad real del elemento, lo que aumenta el tiempo total de ejecución. Reemplace estas pausas con Explicit o Fluent Wait para que el script continúe en cuanto se cumpla la condición.

El segundo error consiste en mezclar esperas implícitas y explícitas en la misma prueba. Ambos mecanismos pueden combinarse, generando tiempos de espera impredecibles y difíciles de depurar. Elija una estrategia por sesión de WebDriver y aplíquela de forma consistente.

Un tercer error consiste en establecer tiempos de espera demasiado largos «por si acaso». Los tiempos de espera predeterminados prolongados ocultan problemas de rendimiento reales y ralentizan la retroalimentación en los procesos de integración continua. Comience con tiempos de espera cortos y extiéndalos solo cuando los registros de errores demuestren que existe un problema de sincronización real.

También verifique: Selenium Tutorial para principiantes: aprenda WebDriver en 7 días

Preguntas Frecuentes