Selenium Esperar – Implícito e Explícito com Sintaxe
Krishna Degrau
In Selenium, “Esperas” desempenham um papel importante na execução de testes. Neste tutorial, você aprenderá vários aspectos e diferenças entre espera implícita e explícita em Selenium.
Por que precisamos de espera Selenium?
A maioria das aplicações web são desenvolvidas usando Ajax e Javascript. Quando uma página é carregada pelo navegador, os elementos com os quais queremos interagir podem carregar em intervalos de tempo diferentes.
Não só dificulta a identificação do elemento, mas também se o elemento não for localizado, será gerado um “ElementNotVisibleException”exceção. Usando Selenium Aguarde, podemos resolver esse problema.
Vamos considerar um cenário onde temos que usar esperas implícitas e explícitas em nosso teste. Suponha que o tempo de espera implícito seja definido como 20 segundos e o tempo de espera explícito seja definido como 10 segundos.
Suponha que estamos tentando encontrar um elemento que tenha alguma “Condições Esperadas “(Espera explícita), se o elemento não estiver localizado dentro do intervalo de tempo definido pela espera explícita (10 segundos), ele usará o intervalo de tempo definido pela espera implícita (20 segundos) antes de lançar um“ElementNotVisibleException".
Selenium Espera do driver da web
- Espera implícita
- Espera explícita
Neste tutorial, você aprenderá sobre diferentes tipos de espera em Selenium:
Espera Implícita Selenium
A Espera Implícita Selenium é usado para informar ao driver da web para esperar um determinado período de tempo antes de lançar uma “Exceção de não tal elemento”. A configuração padrão é 0. Depois de definir o horário, o driver da web aguardará o elemento naquele horário antes de lançar uma exceção.
Selenium O Web Driver pegou emprestada a ideia de esperas implícitas de Watir.
No exemplo abaixo declaramos uma espera implícita com intervalo de tempo de 10 segundos. Isso significa que se o elemento não estiver localizado na página da web dentro desse período, ele lançará uma exceção.
Para declarar espera implícita em Selenium WebDriver:
Sintaxe de espera implícita:
driver.manage().timeouts().implicitlyWait(TimeOut, TimeUnit.SECONDS);
package guru.test99;
import java.util.concurrent.TimeUnit;
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
{
System.setProperty ("webdriver.chrome.driver",".\\chromedriver.exe" );
driver = new ChromeDriver();
driver.manage().timeouts().implicitlyWait(10,TimeUnit.SECONDS) ;
String eTitle = "Demo Guru99 Page";
String aTitle = "" ;
// launch Chrome and redirect it to the Base URL
driver.get("https://demo.guru99.com/test/guru99home/" );
//Maximizes 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 do Código
No exemplo acima,
Considere o seguinte código:
driver.manage().timeouts().implicitlyWait(10,TimeUnit.SECONDS) ;
A espera implícita aceitará 2 parâmetros, o primeiro parâmetro aceitará o tempo como um valor inteiro e o segundo parâmetro aceitará a medição do tempo em termos de SEGUNDOS, MINUTOS, MILISEGUNDOS, MICROSSEGUNDOS, NANOSSEGUNDOS, DIAS, HORAS, etc.
Espera explícita Selenium
A Espera explícita Selenium é usado para informar ao Web Driver para aguardar certas condições (Condições Esperadas) ou tempo máximo excedido antes de lançar a exceção “ElementNotVisibleException”. É um tipo inteligente de espera, mas só pode ser aplicado a elementos específicos. Ele oferece opções melhores do que a espera implícita, pois aguarda elementos Ajax carregados dinamicamente.
Depois de declararmos espera explícita, temos que usar “Condições esperadas”ou podemos configurar a frequência com que queremos verificar a condição usando Espera Fluente. Hoje em dia, durante a implementação, estamos usando Thread.Sleep () geralmente não é recomendado usar
No exemplo abaixo, estamos criando uma espera de referência para “WebDriverEspere”classe e instanciando usando“webdriver”Referência, e estamos dando um prazo máximo de 20 segundos.
Sintaxe de espera explícita:
WebDriverWait wait = new WebDriverWait(WebDriverRefrence,TimeOut);
package guru.test99;
import java.util.concurrent.TimeUnit;
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
{
System.setProperty ("webdriver.chrome.driver",".\\chromedriver.exe" );
driver = new ChromeDriver();
WebDriverWait wait=new WebDriverWait(driver, 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/" );
//Maximizes 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 do Código
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 espera do WebDriver, aguarde o tempo definido na caixa “WebDriverEspere”classe ou o“Condições esperadas”para ocorrer o que ocorrer primeiro.
O referido Java o código afirma que estamos aguardando um elemento pelo período de 20 segundos conforme definido em “WebDriverEspere”classe na página da web até o“Condições esperadas”são atendidos e a condição é“visibilidadedeElementLocated".
A seguir estão as condições esperadas que podem ser usadas em Selenium Espera explícita
- alertIsPresent()
- elementSelectionStateToBe()
- elementToBeClickable()
- elementToBeSelected()
- frameToBeAvaliableAndSwitchToIt()
- invisibilidadeOfTheElementLocated()
- invisibilidadeOfElementWithText()
- presençaOfAllElementsLocatedBy()
- presençaOfElementLocated()
- textToBePresentInElement()
- textToBePresentInElementLocated()
- textToBePresentInElementValue()
- títuloIs()
- títuloContém()
- visibilidadeOf()
- visibilidadeOfAllElements()
- visibilidadeOfAllElementsLocatedBy()
- visibilidadeOfElementLocated()
Espera Fluente Selenium
A Espera Fluente Selenium é usado para definir o tempo máximo para o driver web esperar por uma condição, bem como a frequência com que queremos verificar a condição antes de lançar uma exceção “ElementNotVisibleException”. Ele verifica o elemento da web em intervalos regulares até que o objeto seja encontrado ou o tempo limite atinja.
Frequência: Configurar um ciclo de repetição com prazo para verificar/verificar a condição em intervalos regulares de tempo
Vamos considerar um cenário onde um elemento é carregado em diferentes intervalos de tempo. O elemento pode carregar em 10 segundos, 20 segundos ou até mais do que se declararmos uma espera explícita de 20 segundos. Ele esperará até o tempo especificado antes de lançar uma exceção. Nesses cenários, a espera fluente é a espera ideal para usar, pois tentará encontrar o elemento em frequência diferente até encontrá-lo ou o cronômetro final se esgotar.
Sintaxe de espera fluente:
Wait wait = new FluentWait(WebDriver reference) .withTimeout(timeout, SECONDS) .pollingEvery(timeout, SECONDS) .ignoring(Exception.class);
O código acima está obsoleto em Selenium v3.11 e superior. Você precisa usar
Wait wait = new FluentWait(WebDriver reference) .withTimeout(Duration.ofSeconds(SECONDS)) .pollingEvery(Duration.ofSeconds(SECONDS)) .ignoring(Exception.class);
package guru.test99;
import org.testng.annotations.Test;
import java.util.NoSuchElementException;
import java.util.concurrent.TimeUnit;
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.ExpectedConditions;
import org.openqa.selenium.support.ui.FluentWait;
import org.openqa.selenium.support.ui.Wait;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.testng.annotations.Test;
public class AppTest3 {
protected WebDriver driver;
@Test
public void guru99tutorials() throws InterruptedException
{
System.setProperty ("webdriver.chrome.driver",".\\chromedriver.exe" );
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/" );
//Maximizes 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<WebDriver>(driver)
.withTimeout(30, TimeUnit.SECONDS)
.pollingEvery(5, TimeUnit.SECONDS)
.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 do Código
Considere o seguinte código:
Wait<WebDriver> wait = new FluentWait<WebDriver>(driver) .withTimeout(30, TimeUnit.SECONDS) .pollingEvery(5, TimeUnit.SECONDS) .ignoring(NoSuchElementException.class);
No exemplo acima, estamos declarando uma espera fluente com tempo limite de 30 segundos e a frequência é definida para 5 segundos ignorando “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"));
Criamos uma nova função para identificar o Elemento Web na página. (Ex: Aqui o Elemento Web nada mais é do que o Selenium link na página da web).
A frequência é definida para 5 segundos e o tempo máximo é definido para 30 segundos. Assim, isso significa que ele irá verificar o elemento na página web a cada 5 segundos pelo tempo máximo de 30 segundos. Se o elemento estiver localizado dentro deste período de tempo, ele executará as operações, caso contrário, lançará um “ElementNotVisibleException"
Verifique também: - Selenium Tutorial IDE para iniciantes
Diferença entre espera implícita e espera explícita
A seguir está a principal diferença 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 pretendidos por nós |
| Na espera implícita, precisamos não especifique “ExpectedConditions” no elemento a ser localizado | Em Espera Explícita, precisamos especificar “ExpectedConditions” no elemento a ser localizado |
| Recomenda-se utilizar quando os elementos estiverem localizados no intervalo de tempo especificado em Selenium espera implícita | Recomenda-se usar quando os elementos estão demorando muito para carregar e também para verificar a propriedade do elemento como(visibilityOfElementLocated, elementToBeClickable,elementToBeSelected) |
Conclusão
Espera Implícita, Explícita e Fluente são as diferentes esperas usadas em Selenium. A utilização dessas esperas é totalmente baseada nos elementos que são carregados em diferentes intervalos de tempo. Nem sempre é recomendado usar Thread.Sleep() enquanto Ensaios nossa aplicação ou construindo nossa estrutura.
Verifique também: - Selenium Tutorial para iniciantes: Aprenda WebDriver em 7 dias
