Selenium Espera: esperas implícitas, explícitas y fluidas
Krishna rungta
In SeleniumLas "esperas" juegan un papel importante en la ejecución de las pruebas. En este tutorial, aprenderá varios aspectos y la diferencia entre espera implícita y explícita en Selenium.
¿Por qué necesitamos esperas? Selenium?
La mayoría de las aplicaciones web se desarrollan utilizando Ajax e Javascript. Cuando el navegador carga una página, los elementos con los que queremos interactuar pueden cargarse en diferentes intervalos de tiempo.
No sólo dificulta la identificación del elemento sino que además si no se localiza el elemento arrojará un “ElementoNotVisibleException" excepción. Usando Selenium Espera, podemos resolver este problema.
Consideremos un escenario en el que tenemos que utilizar esperas implícitas y explícitas en nuestra prueba. Supongamos 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 tenga alguna “Condiciones esperadas “(Espera explícita), si el elemento no se encuentra dentro del período de tiempo definido por la espera explícita (10 segundos), utilizará el período de tiempo definido por la espera implícita (20 segundos) antes de lanzar un “ElementoNotVisibleException".
Selenium El controlador web espera
- Espera implícita
- Espera explícita
En este tutorial, aprenderá sobre los diferentes tipos de esperas en Selenium:
Espera implícita Selenium
Los Espera implícita Selenium se utiliza para indicar al controlador web que espere una cierta cantidad de tiempo antes de generar una “Excepción por falta de elemento”. La configuración predeterminada es 0. Una vez que configuramos el tiempo, el controlador web esperará el elemento durante ese tiempo antes de generar una excepción.
Selenium Web Driver ha tomado prestada la idea de esperas implícitas de Watir.
En el siguiente ejemplo, hemos declarado una espera implícita con un período de tiempo de 10 segundos. Significa que si el elemento no se encuentra en la página web dentro de ese período de tiempo, se generará una excepción.
Para declarar espera implícita en Selenium controlador web:
Sintaxis 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("http://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();
}
}
Explicación del código
En el ejemplo anterior,
Considere el siguiente código:
driver.manage().timeouts().implicitlyWait(10,TimeUnit.SECONDS) ;
La espera implícita aceptará 2 parámetros, el primer parámetro aceptará el tiempo como un valor entero y el segundo parámetro aceptará la medida del tiempo en términos de SEGUNDOS, MINUTOS, MILISEGUNDOS, MICROSEGUNDOS, NANOSEGUNDOS, DÍAS, HORAS, etc.
Espera explícita Selenium
Los Espera explícita Selenium se utiliza para indicarle al controlador web que espere ciertas condiciones (condiciones esperadas) o que se exceda el tiempo máximo antes de generar la excepción “ElementNotVisibleException”. Es un tipo de espera inteligente, pero se puede aplicar solo a elementos específicos. Ofrece mejores opciones que la espera implícita, ya que espera elementos Ajax cargados dinámicamente.
Una vez que declaramos espera explícita tenemos que usar "Condiciones esperadas”o podemos configurar la frecuencia con la que queremos verificar la condición usando Espera fluida. En estos días, mientras implementamos, estamos usando Thread.Sleep () generalmente no se recomienda su uso
En el siguiente ejemplo, estamos creando una espera de referencia para "WebDriverEsperar"clase y creación de instancias usando"Controlador web”Referencia, y estamos dando un marco de tiempo máximo de 20 segundos.
Sintaxis 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("http://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();
}
}
Explicación del código
Considere el siguiente 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();
En este ejemplo de espera de WebDriver, espere la cantidad de tiempo definida en el cuadro "WebDriverEsperar” clase o el “Condiciones esperadas” ocurrirá lo que ocurra primero.
Lo anterior Java El código indica que estamos esperando un elemento durante el período de tiempo de 20 segundos como se define en "WebDriverEsperar”clase en la página web hasta el “Condiciones esperadas” se cumplen y la condición es “visibilidad del elemento ubicado".
Las siguientes son las condiciones esperadas que se pueden utilizar en Selenium Espera explícita
- alertaEstáPresente()
- elementoSelectionStateToBe()
- elementoToBeClickable()
- elementoToBeSelected()
- marcoToBeAvaliableAndSwitchToIt()
- invisibilidaddelelementoubicado()
- invisibilidadDeElementoConTexto()
- presencia de todos los elementos ubicados por ()
- presenciaDeElementoUbicado()
- textoToBePresentInElement()
- textoToBePresentInElementLocated()
- textoToBePresentInElementValue()
- títuloEs()
- títuloContiene()
- visibilidad de()
- visibilidad de todos los elementos()
- visibilidad de todos los elementos ubicados por ()
- visibilidad del elemento ubicado()
Esperar con fluidez Selenium
Los Esperar con fluidez Selenium se utiliza para definir el tiempo máximo que el controlador web debe esperar a que se cumpla una condición, así como la frecuencia con la que queremos comprobar la condición antes de lanzar una excepción “ElementNotVisibleException”. Comprueba el elemento web a intervalos regulares hasta que se encuentra el objeto o se agota el tiempo de espera.
Frecuencia: Configurar un ciclo de repetición con el marco de tiempo para verificar/comprobar la condición en el intervalo de tiempo regular
Consideremos un escenario en el que un elemento se carga en diferentes intervalos de tiempo. El elemento podría cargarse en 10 segundos, 20 segundos o incluso más si declaramos una espera explícita de 20 segundos. 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 intentará encontrar el elemento en diferentes frecuencias hasta que lo encuentre o se agote el temporizador final.
Sintaxis de espera fluida:
Wait wait = new FluentWait(WebDriver reference) .withTimeout(timeout, SECONDS) .pollingEvery(timeout, SECONDS) .ignoring(Exception.class);
El código anterior está obsoleto en Selenium v3.11 y superiores. Necesitas 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("http://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() ;
}
}
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, declaramos una espera fluida con un tiempo de espera de 30 segundos y la frecuencia se establece en 5 segundos ignorando "Ninguna excepción de elemento tal"
Considere el siguiente 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"));
Hemos creado una nueva función para identificar el Elemento Web en la página. (Ejemplo: aquí el elemento web no es más que el Selenium enlace en la página web).
La frecuencia se establece en 5 segundos y el tiempo máximo en 30 segundos. Esto significa que 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 período de tiempo, realizará las operaciones; de lo contrario, arrojará un mensaje de error.ElementoNotVisibleException"
También verifique: Selenium Tutorial IDE para principiantes
Diferencia entre espera implícita y espera explícita
A continuación se muestra la principal diferencia entre la espera implícita y la espera explícita en Selenium:
| Espera implícita | Espera explícita |
|---|---|
| El tiempo de espera implícito se aplica a todos los elementos del script. | El tiempo de espera explícito se aplica solo a aquellos elementos previstos por nosotros. |
| En espera implícita, necesitamos no especifique "Condiciones esperadas" en el elemento que se ubicará | En espera explícita, debemos especificar "Condiciones esperadas" en el elemento que se ubicará |
| Se recomienda su uso cuando los elementos se encuentren ubicados con el plazo especificado en Selenium espera implícita | Se recomienda usarlo cuando los elementos tardan mucho en cargarse y también para verificar la propiedad del elemento como (visibilityOfElementLocated, elementToBeClickable,elementToBeSelected) |
Conclusión
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 Pruebas nuestra aplicación o construyendo nuestro framework.
También verifique: Selenium Tutorial para principiantes: aprenda WebDriver en 7 días
