Tutorial esperas (Waits) en Selenium WebDriver

Tutorial Explicit Wait y Implicit Wait en Selenium WebDriver

En ésta entrada explicaremos como usar los «Waits» o tiempos de espera que nos facilita la API de Selenium WebDriver. Trataremos los tipos de espera Explicit Wait e Implicit Wait también profundizaremos en el manejo de condiciones para explicit wait.
Las esperas en selenium webdriver son muy útiles para solucionar o evitar los frecuentes errores presentados por Selenium (no such element exception, Element not visible Exception, Element is not clickable at point) entre otras frecuentes excepciones.

¿Por qué necesitamos esperas (Waits) en Selenium?

La mayoría de las aplicaciones web se desarrollan utilizando Ajax y JavaScript. Cuando una página es cargada por el navegador, los elementos con los que queremos interactuar pueden cargarse a intervalos de tiempo diferentes.

No sólo hace que esto sea difícil de identificar el elemento, sino también si el elemento no está situado, se producirá una excepción «ElementNotVisibleException». Usando las esperas, podemos resolver este problema.

Pensemos en un escenario en el que tengamos que usar tanto las esperas implícitas como las explícitas en nuestra prueba. Suponga que el tiempo de espera implícito se establece en 20 segundos y el tiempo de espera explícito se establece en 10 segundos.

Supongamos que estamos tratando de encontrar un elemento que tiene algún «ExpectedConditions» (espera explícita), si el elemento no está situado dentro del marco de tiempo definido por la espera explícita (10 segundos), se utilizará el marco de tiempo definido por la espera implícita (20 segundos) antes de lanzar un «ElementNotVisibleException».

Esperas/Waits

Hay dos tipos de esperas.

  • Implicit Wait – se utiliza para establecer el tiempo de espera predeterminado en todo el programa.
  • Explicit Wait – se utiliza para establecer el tiempo de espera para solo una instancia en particular.

En resumidas cuentas… Implicit Wait ejecutará un tiempo de espera sin que se cumpla alguna condición. Sí o sí ejecuta el tiempo de espera. Explicit Wait ejecutara un tiempo de espera dependiendo de la condición que se establezca.

Implicit Wait – Espera Implícita

  • Es más sencillo de codificar que las esperas explícitas(Explicit Wait).
  • Normalmente se declara en la parte de instanciación del código.
  • Sólo necesitará un paquete adicional para importar.

Implicit Wait le dirá al WebDriver que espere cierta cantidad de tiempo antes de que lance una excepción de «No Such Element Exception». La configuración predeterminada es 0. Una vez que configuremos el tiempo, el WebDriver esperará ese tiempo antes de lanzar una excepción.

En el ejemplo siguiente hemos declarado una Implicit Wait con el marco de tiempo de 10 segundos. Esto significa que si el elemento no está situado en la página web dentro de ese marco de tiempo, se producirá una excepción.

Para declarar la espera implícita:

Sintaxis:

driver.manage().timeouts().implicitlyWait(TimeOut, TimeUnit.SECONDS);
package tupaquete;
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 tutorialselenium() throws InterruptedException 
  {
  System.setProperty ("webdriver.chrome.driver",".\\chromedriver.exe" );
  driver = new ChromeDriver(); 
  driver.manage().timeouts().implicitlyWait(10,TimeUnit.SECONDS) ;
  String Titulo = "Google";
  String aTitulo = "" ;
  // Lanzar Chrome y redirecciona a la base URL
  driver.get("http://www.google.com" );
  //Maximizar la ventana del navegador
  driver.manage().window().maximize() ;
  //Obtiene el valor actual del titulo
  aTitulo = driver.getTitle();
  //Compara el titulo actual con el titulo esperado
  if (aTitulo.equals(Titulo))
  {
  System.out.println( "La prueba ha pasado") ;
  }
  else {
  System.out.println( "La prueba ha fallado" );
  }
  //Cerrar el navegador
  driver.close();
}
}
 Explicación del código
Considere el siguiente código:
driver.manage().timeouts().implicitlyWait(10,TimeUnit.SECONDS);
Implicit Wait aceptará 2 parámetros, el primer parámetro aceptará el tiempo como un valor entero y el segundo parámetro aceptará la medida de tiempo en términos de segundos, minutos, milisegundos, microsegundos, nanosegundos, días, horas, etc.

Explicit Wait – Espera explicita

Explicit Wait se utiliza para decirle al WebDriver que espere ciertas condiciones (Expected Conditions) o el tiempo máximo excedido antes de lanzar una excepción «ElementNotVisibleException».
Explicit Wait es un tipo inteligente de espera, pero sólo se puede aplicar para los elementos especificados. La espera explícita ofrece mejores opciones que la de una espera implícita, ya que esperará los elementos Ajax cargados dinámicamente.
Una vez declarada la espera explícita tenemos que utilizar «ExpectedCondtions» o podemos configurar con qué frecuencia queremos comprobar la condición con Fluent Wait.
En el ejemplo siguiente, estamos creando la espera de referencia para la clase «WebDriverWait» y la creación de instancias usando la referencia «WebDriver», y estamos dando un plazo máximo de 20 segundos.
Sintaxis: 

WebDriverWait wait = new WebDriverWait(WebDriverRefrence,TimeOut);
package tupaquete;
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 tutorialselenium() throws InterruptedException 
  {
  System.setProperty ("webdriver.chrome.driver",".\\chromedriver.exe" );
  driver = new ChromeDriver(); 
  driver.manage().timeouts().implicitlyWait(10,TimeUnit.SECONDS) ;
  String Titulo = "Google";
  String aTitulo = "" ;
  // Lanzar Chrome y redirecciona a la base URL
  driver.get("http://www.google.com" );
  //Maximizar la ventana del navegador
  driver.manage().window().maximize() ;
  //Obtiene el valor actual del titulo
  aTitulo = driver.getTitle();
  //Compara el titulo actual con el titulo esperado
  if (aTitulo.equals(Titulo))
  {
  System.out.println( "La prueba ha pasado") ;
  }
  else {
  System.out.println( "La prueba ha fallado" );
  }

        WebElement txtGoogle;
  txtGoogle= wait.until(ExpectedConditions.visibilityOfElementLocated(By.id( "lst-ib")));
  txtGoogle.sendKeys("tutorial selenium");

}
}

Explicación del código.

Considere el siguiente código:

WebElement txtGoogle;
txtGoogle= wait.until(ExpectedConditions.visibilityOfElementLocated(By.id( "lst-ib")));
txtGoogle.sendKeys("tutorial selenium");

En el ejemplo anterior, Selenium espera la cantidad de tiempo definida en la clase «WebDriverWait» o «ExpectedConditions». Lo que ocurra primero.

El código Java anterior indica que estamos esperando un elemento en un rango de tiempo de 20 segundos tal como se define en la clase «WebDriverWait» o hasta que se cumplan los «ExpectedConditions» en esta ocasión la condición es «visibilityofElementLocated» (Hasta que el elemento referenciado sea visible).

Las siguientes son las condiciones esperadas que se pueden utilizar en la espera explícita.

  1. alertIsPresent()
  2. elementSelectionStateToBe()
  3. elementToBeClickable()
  4. elementToBeSelected()
  5. frameToBeAvaliableAndSwitchToIt()
  6. invisibilityOfTheElementLocated()
  7. invisibilityOfElementWithText()
  8. presenceOfAllElementsLocatedBy()
  9. presenceOfElementLocated()
  10. textToBePresentInElement()
  11. textToBePresentInElementLocated()
  12. textToBePresentInElementValue()
  13. titleIs()
  14. titleContains()
  15. visibilityOf()
  16. visibilityOfAllElements()
  17. visibilityOfAllElementsLocatedBy()
  18. visibilityOfElementLocated()

Fluent Wait – Espera fluida

La espera fluida/Fluent Wait se utiliza para decirle al WebDriver que espere una condición, así como la frecuencia con la que queremos comprobar la condición antes de lanzar una excepción «ElementNotVisibleException».
Frecuencia: configuración de un ciclo de repetición con el marco de tiempo para verificar/comprobar la condición en el intervalo regular de tiempo.

Consideremos un escenario donde un elemento se carga en diferentes intervalos de tiempo. El elemento podría cargarse en 10 segundos, 20 segundos o incluso más que si declaramos una espera explícita de 20 segundos. Se esperará hasta el tiempo especificado antes de lanzar una excepción. En tales escenarios, la espera fluida es la espera ideal para usar ya que esto tratará de encontrar el elemento a diferentes frecuencias hasta que lo encuentre o el temporizador final se agote.

Sintaxis

Wait wait = new FluentWait(WebDriver reference)
.withTimeout(timeout, SECONDS)
.pollingEvery(timeout, SECONDS)
.ignoring(Exception.class);

 

package tupaquete;
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 AppTest {
  
  protected WebDriver driver;
  @Test
  public void tutorialselenium() throws InterruptedException 
  {
  System.setProperty ("webdriver.chrome.driver",".\\chromedriver.exe" );
  driver = new ChromeDriver(); 
  driver.manage().timeouts().implicitlyWait(10,TimeUnit.SECONDS) ;
  String Titulo = "Google";
  String aTitulo = "" ;
  // Lanzar Chrome y redirecciona a la base URL
  driver.get("http://www.google.com" );
  //Maximizar la ventana del navegador
  driver.manage().window().maximize() ;
  //Obtiene el valor actual del titulo
  aTitulo = driver.getTitle();
  //Compara el titulo actual con el titulo esperado
  if (aTitulo.equals(Titulo))
  {
  System.out.println( "La prueba ha pasado") ;
  }
  else {
  System.out.println( "La prueba ha fallado" );
  }
        Wait<WebDriver> wait = new FluentWait<WebDriver>(driver)							
      .withTimeout(30, TimeUnit.SECONDS) 			
      .pollingEvery(5, TimeUnit.SECONDS) 			
      .ignoring(NoSuchElementException.class);
  WebElement txtGoogle= wait.until(new Function<Webdriver, WebElement>(){
  
    public WebElement apply(WebDriver driver ) {
      return driver.findElement(By.id("lst-ib"));
    }
  });
  //Escribir en la caja de texto de google
  txtGoogle.sendKeys("Tutorial Selenium");
  //Cerrar navegador
  driver.close() ;
  }
}

Explicación del código

Considere el siguiente código

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

En el ejemplo anterior, estamos declarando una espera fluida con el tiempo de espera de 30 segundos y la frecuencia se establece en 5 segundos ignorando «NoSuchElementException».

Considere el siguiente código

public WebElement apply(WebDriver driver ) {
      return driver.findElement(By.id("lst-ib"));
    }

Hemos creado una nueva función para identificar el elemento Web en la página. (ej: aquí el elemento Web no es más que la caja de texto buscar de google).

La frecuencia se ajusta a 5 segundos y el tiempo máximo se ajusta a 30 segundos. Así, esto significa que se comprobará el elemento en la página web cada 5 segundos durante el tiempo máximo de 30 segundos. Si el elemento se encuentra dentro de este marco de tiempo que realizará las operaciones de otro modo se lanzará un «ElementNotVisibleException».

Diferencias entre Implicit Wait y Explicit Wait

Implicit Wait
Explicit Wait
  • El tiempo de espera implícito se aplica a todos los elementos en el script.
  • El tiempo de espera explícito sólo se aplica a aquellos elementos que están destinados por nosotros.
  • En espera implícita, no necesitamos especificar «ExpectedConditions» en el elemento que se ubicará.
  • En la espera explícita, necesitamos especificar «ExpectedConditions» en el elemento que se ubicará.
  • Se recomienda utilizar cuando los elementos están ubicados con el marco de tiempo especificado en espera implícita.
  • Se recomienda utilizar cuando los elementos están tardando mucho tiempo en cargarse y también para verificar la propiedad del elemento como (visibilityOfElementLocated, elementToBeClickable, elementToBeSelected)

Conclusión.

la espera implícita, explícita y fluida son las diferentes esperas utilizadas en Selenium. El uso de estas esperas se basa totalmente en los elementos que se cargan en diferentes intervalos de tiempo. No siempre se recomienda utilizar Thread.Sleep() mientras se prueba nuestra aplicación o se construye nuestro Framework.

Continúa aprendiendo con nuestro Tutorial Selenium WebDriver 

Puedes visitar Documentación oficial Selenium

Compartir artículo

Leave Comment

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.