implicit explicit wait selenium webdriver
Aprenda a esperar implícita e explícita no Selenium WebDriver:
No tutorial anterior, tentamos familiarizá-lo com os vários Loop do WebDriver e operações condicionais . Esses métodos condicionais geralmente lidam com quase todos os tipos de opções de visibilidade para elementos da web.
Seguindo em frente neste série de treinamento Selenium grátis , vamos discutir diferentes tipos de espera fornecidos pelo Selenium WebDriver . Também discutiremos sobre v vários tipos de opções de navegação disponível no WebDriver.
O Waits ajuda o usuário a solucionar problemas enquanto redireciona para diferentes páginas da web, atualizando toda a página e recarregando o novo elementos da web. Às vezes, pode haver chamadas de Ajax também. Assim, pode-se observar um lapso de tempo ao recarregar as páginas da web e refletir os elementos da web.
Os usuários são frequentemente encontrados navegando em várias páginas da web para frente e para trás. Assim, os comandos / métodos navegue () fornecidos pelo WebDriver ajudam o usuário a simular os cenários em tempo real, navegando entre as páginas da web com referência ao histórico do navegador da web.
O WebDriver equipa o usuário com duas gêneses de esperas para lidar com o carregamento recorrente da página s, carregamentos de elementos da web, aparência de janelas, pop-ups e mensagens de erro e reflexo de elementos da web na página da web.
- Espera Implícita
- Espera explícita
Vamos discutir cada um deles em detalhes, considerando a abordagem prática.
O que você aprenderá:
- Espera implícita WebDriver
- Espera explícita do WebDriver
- Condição esperada
- Navegação usando WebDriver
- Conclusão
- Leitura recomendada
Espera implícita WebDriver
As esperas implícitas são usadas para fornecer um tempo de espera padrão (digamos 30 segundos) entre cada etapa / comando de teste consecutivo em todo o script de teste. Assim, a etapa de teste subsequente só seria executada quando os 30 segundos tivessem decorrido após a execução da etapa de teste / comando anterior.
Notas Principais
- A espera implícita é uma única linha de um código e pode ser declarada no método de configuração do script de teste.
- Quando comparada à espera explícita, a espera implícita é transparente e descomplicada. A sintaxe e a abordagem são mais simples do que a espera explícita.
Por ser fácil e simples de aplicar, a espera implícita também apresenta algumas desvantagens. Isso dá origem ao tempo de execução do script de teste, pois cada um dos comandos deixaria de esperar por um período de tempo estipulado antes de retomar a execução.
Portanto, para solucionar esse problema, o WebDriver apresenta esperas explícitas, onde podemos aplicar explicitamente as esperas sempre que a situação surgir, em vez de esperar forçosamente enquanto executamos cada uma das etapas do teste.
Declarações de importação
importar java.util.concurrent.TimeUnit - Para poder acessar e aplicar a espera implícita em nossos scripts de teste, devemos importar este pacote em nosso script de teste.
Sintaxe
drv .manage (). timeouts (). implicitlyWait (10, TimeUnit. SEGUNDOS );
Inclua a linha de código acima em seu script de teste logo após a instanciação da variável de instância WebDriver. Portanto, isso é tudo o que é necessário para definir uma espera implícita em seu script de teste.
Passo a passo do código
A espera implícita ordena a passagem de dois valores como parâmetros. O primeiro argumento indica o tempo em dígitos numéricos que o sistema precisa esperar. O segundo argumento indica a escala de medição do tempo. Assim, no código acima, mencionamos os “30” segundos como tempo de espera padrão e a unidade de tempo foi configurada para “segundos”.
Espera explícita do WebDriver
Esperas explícitas são usadas para interromper a execução até que uma determinada condição seja atendida ou o tempo máximo tenha decorrido. Ao contrário das esperas implícitas, as esperas explícitas são aplicadas apenas a uma instância específica.
WebDriver apresenta classes como WebDriverWait e ExpectedConditions para impor esperas explícitas aos scripts de teste. No âmbito desta discussão, usaremos “gmail.com” como espécime.
Cenário a ser automatizado
- Inicie o navegador da web e abra o “gmail.com”
- Digite um nome de usuário válido
- Digite uma senha válida
- Clique no botão de login
- Aguarde até que o botão Escrever fique visível após o carregamento da página
Código WebDriver usando espera explícita
Observe que, para a criação do script, usaríamos o projeto “Learning_Selenium” criado nos tutoriais anteriores.
Passo 1 : Crie uma nova classe java chamada “Wait_Demonstration” no projeto “Learning_Selenium”.
Passo 2 : Copie e cole o código abaixo na classe “Wait_Demonstration.java”.
Abaixo está o script de teste que é equivalente ao cenário mencionado acima.
import static org.junit.Assert.*; import java.util.concurrent.TimeUnit; import org.junit.After; import org.junit.Before; import org.junit.Test; import org.openqa.selenium.By; import org.openqa.selenium.WebDriver; import org.openqa.selenium.WebElement; import org.openqa.selenium.firefox.FirefoxDriver; import org.openqa.selenium.support.ui.ExpectedConditions; import org.openqa.selenium.support.ui.WebDriverWait; public class Wait_Demonstration { // created reference variable for WebDriver WebDriver drv; @Before public void setup() throws InterruptedException { // initializing drv variable using FirefoxDriver drv=new FirefoxDriver(); // launching gmail.com on the browser drv.get('https://gmail.com'); // maximized the browser window drv.manage().window().maximize(); drv.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS); } @Test public void test() throws InterruptedException { // saving the GUI element reference into a 'username' variable of WebElement type WebElement username = drv.findElement(By.id('Email')); // entering username username.sendKeys('shruti.shrivastava.in'); // entering password drv.findElement(By.id('Passwd')).sendKeys('password'); // clicking signin button drv.findElement(By.id('signIn')).click(); // explicit wait - to wait for the compose button to be click-able WebDriverWait wait = new WebDriverWait(drv,30); wait.until(ExpectedConditions.visibilityOfElementLocated(By.xpath('//div[contains(text(),'COMPOSE')]'))); // click on the compose button as soon as the 'compose' button is visible drv.findElement(By.xpath('//div[contains(text(),'COMPOSE')]')).click(); } @After public void teardown() { // closes all the browser windows opened by web driver drv.quit(); } }
Declarações de importação
- importar org. openqa.selenium.support.ui.ExpectedConditions
- importar org. openqa.selenium.support.ui.WebDriverWait
- Importe os pacotes acima antes da criação do script. Os pacotes referem-se à classe Select que é necessária para lidar com o menu suspenso.
Instanciação de objetos para a classe WebDriverWait
WebDriverWait wait = novo WebDriverWait ( drv , 30);
Criamos uma variável de referência “espera” para a classe WebDriverWait e a instanciamos usando a instância WebDriver e o tempo máximo de espera para a execução até a dispensa. O tempo máximo de espera cotado é medido em “segundos”.
A instanciação do WebDriver foi discutida nos tutoriais iniciais do WebDriver.
Condição esperada
wait.until(ExpectedConditions.visibilityOfElementLocated(By.xpath('//div[contains(text(),'COMPOSE')]'))); drv.findElement(By.xpath('//div[contains(text(),'COMPOSE')]')).click();
O comando acima espera por um período de tempo estipulado ou uma condição esperada para ocorrer, o que ocorrer ou decorrer primeiro.
Assim, para poder fazer isso, usamos a variável de referência “espera” da classe WebDriverWait criada na etapa anterior com a classe ExpectedConditions e uma condição real que deve ocorrer. Portanto, assim que a condição esperada ocorrer, o controle do programa passará para a próxima etapa de execução em vez de esperar forçosamente por 30 segundos inteiros.
Em nossa amostra, esperamos que o botão “compor” esteja presente e carregado como parte do carregamento da página inicial e, assim, avançamos com a chamada do comando de clique no botão “compor”.
Tipos de condições esperadas
A classe ExpectedConditions fornece uma grande ajuda para lidar com cenários em que temos que verificar se uma condição ocorre antes de executar a etapa de teste real.
A classe ExpectedConditions vem com uma ampla gama de condições esperadas que podem ser acessadas com a ajuda da variável de referência WebDriverWait e do método until ().
Vamos discutir alguns deles em detalhes:
# 1) elementToBeClickable () - A condição esperada aguarda que um elemento seja clicável, ou seja, ele deve estar presente / exibido / visível na tela, bem como ativado.
Código de amostra
wait.until (ExpectedConditions.elementToBeClickable (By.xpath ( “// div [contains (text (),’ COMPOSE ’)]” )));
# 2) textToBePresentInElement () - A condição esperada espera por um elemento com um certo padrão de string.
Código de amostra
wait.until (ExpectedConditions.textToBePresentInElement (By.xpath ( “// div [@ id =‘ ForgotPass '”),“ texto a ser encontrado ” ));
como reverter um array em java
# 3) alertIsPresent () - A condição esperada aguarda o aparecimento de uma caixa de alerta.
Código de amostra
wait.until (ExpectedConditions.alertIsPresent ())! = null);
# 4) titleIs () - A condição esperada espera por uma página com um título específico.
Código de amostra
wait.until (ExpectedConditions.titleIs ( “Gmail” ));
# 5) frameToBeAvailableAndSwitchToIt () - A condição esperada espera que um quadro esteja disponível e, assim que o quadro estiver disponível, o controle muda para ele automaticamente.
Código de amostra
wait.until (ExpectedConditions.frameToBeAvailableAndSwitchToIt (By.id (“ newframe ')));
Há uma ação do usuário muito comum em que o usuário clica nos botões voltar e avançar do navegador da web para trás e para frente para navegar para as diferentes páginas da web visitadas na sessão atual no histórico do navegador. Assim, para simular as ações realizadas pelos usuários, o WebDriver introduz os comandos Navigate.
Vamos examinar esses comandos em detalhes:
# 1) navegar (). Voltar ()
Este comando permite que o usuário navegue para a página da web anterior.
Código de amostra:
driver.navigate (). back ();
O comando acima não requer parâmetros e leva o usuário de volta à página anterior no histórico do navegador.
# 2) navegar (). Avançar ()
Este comando permite que o usuário navegue para a próxima página da web com referência ao histórico do navegador.
Código de amostra:
driver.navigate (). forward ();
O comando acima não requer parâmetros e leva o usuário à próxima página no histórico do navegador.
# 3) navegar (). Atualizar ()
Este comando permite que o usuário atualize a página da web atual, recarregando todos os elementos da web.
Código de amostra:
driver.navigate (). refresh ();
O comando acima não requer parâmetros e recarrega a página da web.
# 4) navegue (). Para ()
Este comando permite que o usuário inicie uma nova janela do navegador da web e navegue até o URL especificado.
Código de amostra:
driver.navigate (). to (“http://google.com”);
O comando acima requer um URL da web como parâmetro e, em seguida, abre o URL especificado em um navegador da web recém-lançado.
Conclusão
Nisso Tutorial de espera implícita e explícita no Selenium WebDriver , tentamos informá-lo sobre as esperas do WebDriver. Discutimos e exercitamos as esperas explícitas e implícitas. Ao mesmo tempo, também discutimos os diferentes comandos de navegação.
Aqui estão os pontos essenciais deste artigo:
- O WebDriver permite que o usuário escolha entre as esperas disponíveis para lidar com situações em que o fluxo de execução pode exigir um descanso de alguns segundos para carregar os elementos da web ou atender a uma condição específica. Existem dois tipos de espera disponíveis no WebDriver.
- Espera Implícita
- Espera explícita
- Esperas implícitas são usados para fornecer um tempo de espera padrão entre cada etapa / comando de teste consecutivo em todo o script de teste. Portanto, a etapa de teste subsequente só seria executada quando o período de tempo especificado tiver decorrido após a execução da etapa / comando de teste anterior.
- Esperas explícitas são usados para interromper a execução até que uma determinada condição seja atendida ou que o tempo máximo tenha decorrido. Ao contrário das esperas implícitas, as esperas explícitas são aplicadas apenas a uma instância específica.
- WebDriver apresenta classes como WebDriverWait e ExpectedConditions para impor esperas explícitas
- Condições esperadas A classe fornece uma grande ajuda para lidar com cenários em que temos que verificar se uma condição ocorre antes de executar a etapa de teste real.
- A classe ExpectedConditions vem com uma ampla gama de condições esperadas que podem ser acessadas com a ajuda da variável de referência WebDriverWait e do método until ().
- Métodos Navigate () Os comandos / são usados para simular o comportamento do usuário enquanto navega entre várias páginas da web para frente e para trás.
Próximo Tutorial # 16 : Seguindo para o próximo tutorial na lista, faríamos os usuários familiarizados com vários tipos de alertas que podem aparecer ao acessar sites e suas abordagens de manuseio no WebDriver. Os tipos de alertas em que estaríamos nos concentrando são principalmente - pop-ups de alerta baseados em janelas e pop-ups de alerta baseados na web. Como sabemos que lidar com pop-ups baseados em janelas está além das capacidades do WebDriver, portanto, também usaríamos alguns utilitários de terceiros para lidar com pop-ups de janela.
Nota para os leitores : Até então, os leitores podem automatizar os cenários com vários carregamentos de página e elementos dinâmicos que aparecem na tela usando as várias condições esperadas e comandos de navegação.
Leitura recomendada
- Tutorial Cucumber Selenium: Cucumber Java Selenium WebDriver Integration
- Introdução ao Selenium WebDriver - Selenium Tutorial # 8
- Implementação do nosso primeiro script WebDriver - Selenium WebDriver Tutorial # 10
- Selenium FAQs
- Como lidar com alertas / pop-ups no Selenium WebDriver - Tutorial do Selenium nº 16
- Guia para gerar relatórios de extensão no Selenium WebDriver
- Como executar o Selenium WebDriver em diferentes navegadores populares
- Configuração e instalação completas do WebDriver com Eclipse - Selenium Tutorial # 9