No Selenium, "Waits" desempenha um papel importante na execução de testes. Neste tutorial, você aprenderá vários aspectos das esperas "Implícitas" e "Explícitas" no Selênio.
Neste tutorial, você aprenderá:
- Por que precisamos esperar no selênio?
- Espera implícita
- Espera explícita
- Espera Fluente
Por que precisamos esperar no selênio?
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 diferentes intervalos de tempo.
Isso não apenas torna difícil identificar o elemento, mas também, se o elemento não for localizado, ele lançará uma exceção " ElementNotVisibleException ". Usando o Selenium Waits, podemos resolver esse problema.
Vamos considerar um cenário em que precisamos 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 estejamos tentando encontrar um elemento que tenha algumas "condições esperadas " (espera explícita), se o elemento não estiver localizado dentro do período de tempo definido pela espera explícita (10 segundos), ele usará o período de tempo definido pela espera implícita ( 20 segundos) antes de lançar uma " ElementNotVisibleException ".
Selenium Web Driver espera
- Espera implícita
- Espera explícita
Espera implícita no selênio
A espera implícita no Selenium é usada para dizer ao driver da web para esperar por um determinado período de tempo antes de lançar uma "Nenhuma exceção de elemento". A configuração padrão é 0. Assim que definirmos o tempo, o driver da web aguardará o elemento por esse tempo antes de lançar uma exceção.
O Selenium Web Driver emprestou a idéia de esperas implícitas de Watir.
No exemplo a seguir, declaramos uma espera implícita com o 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:
Sintaxe :
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 {driver WebDriver protegido;@Testepublic void guru99tutorials () lança InterruptedException{System.setProperty ("webdriver.chrome.driver", ". \\ chromedriver.exe");driver = novo ChromeDriver ();driver.manage (). timeouts (). implicitlyWait (10, TimeUnit.SECONDS);String eTitle = "Página de demonstração Guru99";String aTitle = "";// inicie o Chrome e redirecione-o para o URL basedriver.get ("http://demo.guru99.com/test/guru99home/");// Maximiza a janela do navegadordriver.manage (). window (). maximize ();// obtém o valor real do títuloaTitle = driver.getTitle ();// compare o título real com o título esperadoif (aTitle.equals (eTitle)){System.out.println ("Teste aprovado");}outro {System.out.println ("Teste falhou");}// fecha o navegadordriver.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, MILISSEGUNDOS, MICROSECONDOS, NANOSSEGUNDOS, DIAS, HORAS, etc.
Espera explícita no selênio
A espera explícita no Selenium é usada para informar ao driver da Web para esperar por certas condições (condições esperadas) ou tempo máximo excedido antes de lançar a exceção "ElementNotVisibleException". É um tipo de espera inteligente, mas pode ser aplicado apenas para elementos específicos. Ele oferece opções melhores do que a espera implícita, pois espera por elementos Ajax carregados dinamicamente.
Depois de declarar a espera explícita, temos que usar " ExpectedConditions " 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 a classe " WebDriverWait " e instanciando usando a referência " WebDriver ", e estamos dando um período de tempo máximo de 20 segundos.
Sintaxe:
WebDriverWait wait = novo 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 {driver WebDriver protegido;@Testepublic void guru99tutorials () lança InterruptedException{System.setProperty ("webdriver.chrome.driver", ". \\ chromedriver.exe");driver = novo ChromeDriver ();WebDriverWait wait = novo WebDriverWait (driver, 20);String eTitle = "Página de demonstração Guru99";String aTitle = "";// inicie o Chrome e redirecione-o para o URL basedriver.get ("http://demo.guru99.com/test/guru99home/");// Maximiza a janela do navegadordriver.manage (). window (). maximize ();// obtém o valor real do títuloaTitle = driver.getTitle ();// compare o título real com o título esperadoif (aTitle.contentEquals (eTitle)){System.out.println ("Teste aprovado");}outro {System.out.println ("Teste falhou");}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 a quantidade de tempo definida na classe " WebDriverWait " ou " ExpectedConditions " para ocorrer o que ocorrer primeiro.
O código Java acima afirma que estamos aguardando um elemento pelo período de 20 segundos, conforme definido na classe " WebDriverWait " na página da Web, até que as " ExpectedConditions " sejam atendidas e a condição seja " visibilityofElementLocated ".
A seguir estão as condições esperadas que podem ser usadas na espera explícita do selênio
- alertIsPresent ()
- elementSelectionStateToBe ()
- elementToBeClickable ()
- elementToBeSelected ()
- frameToBeAvaliableAndSwitchToIt ()
- invisibilityOfTheElementLocated ()
- invisibilityOfElementWithText ()
- PresenceOfAllElementsLocatedBy ()
- PresenceOfElementLocated ()
- textToBePresentInElement ()
- textToBePresentInElementLocated ()
- textToBePresentInElementValue ()
- titleIs ()
- titleContains ()
- visibilidadeOf ()
- visibilidadeOfAllElements ()
- visibilidadeOfAllElementsLocatedBy ()
- visibilidadeOfElementLocated ()
Espera Fluente em Selênio
A Espera Fluente no Selenium é usada para definir o tempo máximo para o driver da web esperar por uma condição, bem como a frequência com a qual 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 ocorra.
Frequência: configurar um ciclo de repetição com o período de tempo para verificar / verificar a condição no intervalo regular de tempo
Vamos considerar um cenário em que 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 vai esperar até o tempo especificado antes de lançar uma exceção. Em tais cenários, a espera fluente é a espera ideal para usar, pois ela tentará encontrar o elemento em uma frequência diferente até que ele seja encontrado ou o tempo final se esgote.
Sintaxe:
Aguarde, aguarde = novo FluentWait (referência WebDriver).withTimeout (tempo limite, SECONDS).pollingEvery (tempo limite, SECONDS).ignoring (Exception.class);
O código acima está obsoleto no Selenium v3.11 e superior. Você precisa usar
Aguarde, aguarde = novo FluentWait (referência WebDriver).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 {driver WebDriver protegido;@Testepublic void guru99tutorials () lança InterruptedException{System.setProperty ("webdriver.chrome.driver", ". \\ chromedriver.exe");String eTitle = "Página de demonstração Guru99";String aTitle = "";driver = novo ChromeDriver ();// inicie o Chrome e redirecione-o para o URL basedriver.get ("http://demo.guru99.com/test/guru99home/");// Maximiza a janela do navegadordriver.manage (). window (). maximize ();// obtém o valor real do títuloaTitle = driver.getTitle ();// compare o título real com o título esperadoif (aTitle.contentEquals (eTitle)){System.out.println ("Teste aprovado");}outro {System.out.println ("Teste falhou");}Aguarde aguarde = novo FluentWait (driver).withTimeout (30, TimeUnit.SECONDS).pollingEvery (5, TimeUnit.SECONDS).ignoring (NoSuchElementException.class);WebElement clickseleniumlink = wait.until (new Function () {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 "));}});// clique no link selênioclickseleniumlink.click ();// feche ~ navegadordriver.close ();}}
Explicação do Código
Considere o seguinte código:
Aguardeaguarde = novo FluentWait (driver).withTimeout (30, TimeUnit.SECONDS).pollingEvery (5, TimeUnit.SECONDS).ignoring (NoSuchElementException.class);
No exemplo acima, estamos declarando uma espera fluente com o 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 Web Element na página. (Ex: aqui o Web Element nada mais é do que o link Selenium 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 verificará o elemento na página da web a cada 5 segundos pelo tempo máximo de 30 segundos. Se o elemento estiver localizado dentro desse período de tempo, ele executará as operações, caso contrário, lançará uma " ElementNotVisibleException "
Diferença entre espera implícita x espera explícita
| Espera implícita | Espera explícita |
|---|---|
|
|
|
|
|
|
Conclusão:
Espera implícita, explícita e fluente são as diferentes esperas usadas no selênio. O uso dessas esperas é totalmente baseado nos elementos que são carregados em diferentes intervalos de tempo. Nem sempre é recomendado usar Thread.Sleep () ao testar nosso aplicativo ou construir nosso framework.
Este artigo é uma contribuição de Chaitanya Pujari