4-Esperas.md

Esperas e Sincronização

Um dos maiores desafios em automação mobile é a sincronização: o app pode demorar para carregar uma tela, exibir um elemento ou completar uma animação. Usar esperas adequadas evita testes frágeis e falhas intermitentes.

Tipos de Espera

1. Implicit Wait (Espera Implícita)

Define um tempo máximo de espera global para toda tentativa de localização de elemento. Se o elemento não aparecer dentro desse tempo, lança NoSuchElementException.

// Configurar na inicialização do driver (faz efeito em toda a sessão)
driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));

Cuidado: O implicit wait interage de forma imprevisível com explicit waits — use apenas um dos dois por projeto.

2. Explicit Wait (Espera Explícita) — Recomendado

Aguarda por uma condição específica ser verdadeira antes de prosseguir. É mais preciso e eficiente.

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

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

// Esperar o elemento ficar visível
WebElement elemento = wait.until(
    ExpectedConditions.visibilityOfElementLocated(By.id("com.app:id/titulo"))
);

// Esperar o elemento ficar clicável
wait.until(ExpectedConditions.elementToBeClickable(By.id("com.app:id/btn_confirmar")));

// Esperar o texto aparecer no elemento
wait.until(ExpectedConditions.textToBePresentInElementLocated(
    By.id("com.app:id/status"),
    "Carregado"
));

// Esperar o elemento desaparecer (ex: loading spinner)
wait.until(ExpectedConditions.invisibilityOfElementLocated(
    By.id("com.app:id/loading")
));

3. FluentWait — Espera com Polling Customizado

Permite definir o intervalo de verificação e ignorar exceções específicas:

import org.openqa.selenium.support.ui.FluentWait;
import org.openqa.selenium.NoSuchElementException;

FluentWait<AndroidDriver> fluentWait = new FluentWait<>(driver)
    .withTimeout(Duration.ofSeconds(20))
    .pollingEvery(Duration.ofMillis(500))
    .ignoring(NoSuchElementException.class);

WebElement elemento = fluentWait.until(d ->
    d.findElement(By.id("com.app:id/titulo"))
);

Condições de Espera Úteis

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

// Elemento presente no DOM (mesmo que não visível)
wait.until(ExpectedConditions.presenceOfElementLocated(locator));

// Elemento visível
wait.until(ExpectedConditions.visibilityOfElementLocated(locator));

// Elemento clicável (visível + habilitado)
wait.until(ExpectedConditions.elementToBeClickable(locator));

// Elemento invisível
wait.until(ExpectedConditions.invisibilityOfElementLocated(locator));

// Número de elementos na lista
wait.until(ExpectedConditions.numberOfElementsToBeMoreThan(locator, 3));

// Atributo com valor específico
wait.until(ExpectedConditions.attributeToBe(locator, "checked", "true"));

Criando um Helper de Espera

Centralize as esperas em um utilitário:

package utils;

import io.appium.java_client.android.AndroidDriver;
import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import java.time.Duration;

public class WaitHelper {

    private final WebDriverWait wait;

    public WaitHelper(AndroidDriver driver) {
        this.wait = new WebDriverWait(driver, Duration.ofSeconds(15));
    }

    public WebElement esperarVisivel(By locator) {
        return wait.until(ExpectedConditions.visibilityOfElementLocated(locator));
    }

    public WebElement esperarClicavel(By locator) {
        return wait.until(ExpectedConditions.elementToBeClickable(locator));
    }

    public void esperarDesaparecer(By locator) {
        wait.until(ExpectedConditions.invisibilityOfElementLocated(locator));
    }

    public void esperarTexto(By locator, String texto) {
        wait.until(ExpectedConditions.textToBePresentInElementLocated(locator, texto));
    }
}

Uso no Page Object:

public class HomePage {
    private final AndroidDriver driver;
    private final WaitHelper wait;

    private final By loading = By.id("com.app:id/loading");
    private final By titulo  = By.id("com.app:id/titulo_home");

    public HomePage(AndroidDriver driver) {
        this.driver = driver;
        this.wait = new WaitHelper(driver);
    }

    public boolean estaCarregada() {
        wait.esperarDesaparecer(loading);
        return wait.esperarVisivel(titulo).isDisplayed();
    }
}

Boas Práticas

• Prefira Explicit Wait ao Implicit Wait — mais previsível e configurável
• Nunca use Thread.sleep() — bloqueia o thread e deixa os testes lentos
• Defina um tempo padrão de espera (ex: 15s) para a maioria dos elementos e ajuste pontualmente quando necessário
• Use esperarDesaparecer(loading) para aguardar spinners de carregamento antes de interagir

---

Ir para: Organização de Testes