Espera implícita e explícita em Selenium com sintaxe

In SeleniumOs comandos "wait" desempenham um papel importante na execução de testes confiáveis. Neste tutorial, você aprenderá os principais aspectos e diferenças entre os comandos "wait" implícitos e explícitos. Selenium, juntamente com o uso prático do Fluent Wait.

Por que precisamos de espera Selenium?

A maioria das aplicações web modernas são desenvolvidas usando Ajax e JavaScriptQuando uma página é carregada pelo navegador, os elementos com os quais queremos interagir podem ser carregados em intervalos de tempo diferentes.

Isso não só dificulta a identificação do elemento, como também, se o elemento não for localizado a tempo, Selenium vai lançar um ElementNotVisibleException. Selenium As esperas resolvem esse problema de sincronização, fornecendo ao WebDriver um intervalo definido para encontrar um elemento antes de falhar.

Considere um cenário em que esperas implícitas e explícitas são usadas no mesmo teste. Suponha que a espera implícita esteja definida para 20 segundos e a espera explícita para 10 segundos.

Se estivermos procurando por um elemento regido por certas regras, Condições esperadas (Espera Explícita) e o elemento não estiver localizado dentro da janela explícita de 10 segundos, o WebDriver recorre à janela implícita de 20 segundos antes de lançar uma exceção. ElementNotVisibleException.

Selenium WebDriver aguarda

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

Espera Implícita Selenium

O Espera Implícita Selenium Instrui o WebDriver a aguardar um período definido antes de lançar uma exceção NoSuchElementException. O valor padrão é 0. Uma vez configurado, o WebDriver consulta o DOM durante esse período antes de falhar. Selenium O WebDriver herdou o conceito de esperas implícitas de Watir.

No exemplo abaixo, declaramos uma espera implícita com duração de 10 segundos. Se o elemento não estiver localizado dentro desse intervalo, uma exceção será lançada.

Sintaxe 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();
    }
}

Explicação de Code

No exemplo acima, considere a seguinte afirmação:

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

Selenium A versão 4 substituiu a antiga assinatura de dois argumentos (inteiro mais TimeUnit) por um único argumento Duration. A classe Duration suporta segundos, minutos, milissegundos e outras unidades de tempo por meio de funções auxiliares estáticas como Duration.ofSeconds, Duration.ofMillis e Duration.ofMinutes.

Espera explícita Selenium

O Espera explícita Selenium Instrui o WebDriver a aguardar condições específicas (Condições Esperadas) ou um período máximo antes de lançar uma exceção ElementNotVisibleException. É uma espera mais inteligente porque se aplica apenas ao elemento especificado. A espera explícita é preferível à espera implícita sempre que o teste precisar lidar com conteúdo Ajax carregado dinamicamente.

Uma vez que uma espera explícita seja declarada, você deve usar Condições esperadasOu você pode configurar a frequência de sondagem usando Espera Fluente. Evite usar Thread.sleep ()pois interrompe a execução incondicionalmente e geralmente é considerada uma má prática.

No exemplo abaixo, criamos uma referência do WebDriverEspere classe, instancie-a com o webdriver consulte a referência e configure uma janela máxima de 20 segundos.

Sintaxe 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();
    }
}

Explicação de Code

Considere o seguinte 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();

Neste exemplo de WebDriverWait, o script aguarda até 20 segundos, conforme definido pelo... WebDriverEspere aula, até o Condições esperadas estão satisfeitos — o que ocorrer primeiro.

O referido Java O código aguarda até 20 segundos pela condição. visibilidadeDoElementoLocalizado para ser verdade.

As seguintes Condições Esperadas podem ser usadas em Selenium Aguarde explicitamente:

1. alertIsPresent()
2. elementSelectionStateToBe()
3. elementToBeClickable()
4. elementToBeSelected()
5. frameToBeAvailableAndSwitchToIt()
6. invisibilidadeOfTheElementLocated()
7. invisibilidadeOfElementWithText()
8. presençaOfAllElementsLocatedBy()
9. presençaOfElementLocated()
10. textToBePresentInElement()
11. textToBePresentInElementLocated()
12. textToBePresentInElementValue()
13. títuloIs()
14. títuloContém()
15. visibilidadeOf()
16. visibilidadeOfAllElements()
17. visibilidadeOfAllElementsLocatedBy()
18. visibilidadeOfElementLocated()

Espera Fluente Selenium

O Espera Fluente Selenium Define a duração máxima que o WebDriver aguarda por uma condição, juntamente com a frequência de verificação dessa condição antes de lançar uma exceção ElementNotVisibleException. O Fluent Wait verifica o elemento em intervalos regulares até que o objeto seja encontrado ou o tempo limite expire.

Frequência: O ciclo de repetição serve para avaliar a condição em intervalos regulares.

Considere um cenário em que um elemento carrega em intervalos imprevisíveis. O elemento pode carregar em 10 segundos, 20 segundos ou mais. Se declararmos uma espera explícita de 20 segundos, o script aguardará o tempo total antes de falhar. Nesses casos, o Fluent Wait é a escolha ideal, pois realiza polling na frequência especificada até que o elemento seja localizado ou o temporizador final expire.

Sintaxe de espera fluente (Selenium 4):

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

A assinatura antiga que aceitava valores inteiros mais TimeUnit foi descontinuada em Selenium 3.11 e removido em Selenium 4. A API baseada em duração mostrada acima é a abordagem atualmente recomendada.

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();
    }
}

Explicação de Code

Considere o seguinte código:

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

No exemplo acima, declaramos uma espera fluente com um tempo limite de 30 segundos, uma frequência de verificação de 5 segundos e ignoramos NoSuchElementException.

Considere o seguinte 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 função identifica o WebElement na página (aqui, o Selenium link na página inicial). Com um intervalo de verificação de 5 segundos e um tempo limite de 30 segundos, a espera verifica o elemento a cada 5 segundos, por um máximo de 30 segundos. Se o elemento estiver localizado dentro dessa janela, o script prossegue. Caso contrário, um ElementNotVisibleException é lançado.

Verifique também: Selenium Tutorial IDE para iniciantes

Diferença entre espera implícita e espera explícita

A tabela abaixo destaca as principais diferenças entre Espera Implícita e Espera Explícita em Selenium.

Espera implícita	Espera explícita
O tempo de espera implícito é aplicado a todos os elementos do script.	O tempo de espera explícito é aplicado apenas aos elementos especificamente selecionados.
Na espera implícita, as condições esperadas não são especificadas para o elemento.	Na espera explícita, as condições esperadas (ExpectedConditions) devem ser definidas para o elemento.
Recomendado quando os elementos são carregados dentro do período de espera implícito configurado.	Recomendado quando os elementos demoram mais para carregar e ao validar estados de elementos como visibilityOfElementLocated, elementToBeClickable ou elementToBeSelected.
Definido uma única vez e aplicado ao ciclo de vida da instância do WebDriver.	Defina por elemento ou por verificação, proporcionando um controle mais preciso.

Como escolher a estratégia de espera correta

A escolha do comando de espera correto afeta diretamente a estabilidade do script e o tempo de execução. Utilize esta estrutura de decisão para selecionar a opção apropriada para cada cenário.

1. Identifique o padrão de carga: Verifique se o elemento aparece em um horário fixo, após uma resposta Ajax, ou em intervalos imprevisíveis. Carregamentos fixos são adequados para Espera Implícita, enquanto carregamentos imprevisíveis exigem Espera Fluente.
2. Evite misturar esperas implícitas e explícitas: A combinação dos dois pode causar atrasos inesperados, pois a espera mais longa pode se tornar predominante. Selenium A documentação recomenda o uso de apenas uma estratégia por sessão do WebDriver.
3. Por padrão, aguarde explicitamente o conteúdo dinâmico: Quando as páginas dependem de Ajax, renderização condicional ou animações, a Espera Explícita com ExpectedConditions direciona exatamente o elemento que importa.
4. Use o Fluent Wait para tempos variáveis: Quando o tempo de carregamento de elementos varia entre execuções, configure o Fluent Wait com um intervalo de sondagem. A sondagem reduz o tempo total de espera em comparação com um único tempo limite longo.
5. Substitua Thread.sleep: Os tempos de espera fixos (sleeps) tornam os conjuntos de testes mais lentos e ocultam problemas reais de temporização. Substitua-os por esperas condicionais para manter a execução rápida e determinística.
6. Ajuste os valores de tempo limite: Comece com tempos limite curtos (5 a 10 segundos) e aumente-os somente quando as falhas demonstrarem uma carga realmente lenta. Tempos limite padrão longos mascaram regressões de desempenho.
7. Manter esperas em utilitários auxiliares: Centralize a lógica de espera em uma classe auxiliar para que as alterações na política de tempo limite se apliquem a todo o conjunto de testes.

Seguindo essa estrutura, os engenheiros de automação podem criar scripts resilientes que se adaptam ao tempo real da aplicação sem se tornarem lentos ou instáveis.

Erros comuns a evitar com Selenium Espera

Até mesmo os testadores mais experientes caem em algumas armadilhas recorrentes ao trabalhar com Selenium esperas. Evitar esses problemas mantém os scripts rápidos, determinísticos e fáceis de manter em diferentes equipes e ambientes.

O primeiro erro comum é o uso excessivo de `Thread.sleep`. Uma pausa codificada força o script a esperar pela duração completa, independentemente da disponibilidade real do elemento, o que aumenta o tempo total de execução. Substitua essas pausas por `Explicit Wait` ou `Fluent Wait` para que o script prossiga assim que a condição for atendida.

O segundo erro é misturar esperas implícitas e explícitas no mesmo teste. Os dois mecanismos podem se combinar, criando timeouts imprevisíveis e difíceis de depurar. Escolha uma estratégia por sessão do WebDriver e aplique-a de forma consistente.

Um terceiro erro é definir tempos limite muito longos "por precaução". Janelas padrão longas ocultam problemas reais de desempenho e atrasam o feedback em pipelines de integração contínua. Comece com tempos limite curtos e aumente-os somente quando os registros de falhas comprovarem a existência de um problema real de sincronização.

Verifique também: Selenium Tutorial para iniciantes: Aprenda WebDriver em 7 dias

Perguntas Frequentes