Saltar al contenido

Sea comprensible, explícito y fluido en Selenium WebDriver

En el selenio, las “esperas” juegan un papel importante en la realización de pruebas. En este tutorial, aprenderá varios aspectos y la diferencia entre permanencia implícita y explícita en selenio.

En este tutorial, aprenderá sobre los diferentes tipos de espera en Selenium:

¿Por qué nos quedamos en selenio?

La mayoría de las aplicaciones web se desarrollan utilizando Ajax y Javascript. Una vez que una página ha cargado el navegador, puede cargar los elementos con los que queremos interactuar en diferentes intervalos de tiempo.

Esto no solo dificulta la identificación del elemento, sino que si el elemento no está ubicado, debe “ElementNotVisibleException“A la espera de Selenium Waill, podemos resolver este problema.

Consideremos una situación en la que tenemos que utilizar la espera implícita y explícita en nuestras pruebas. Suponga que el tiempo de espera implícito se establece en 20 segundos y que el tiempo de espera implícito se establece en 10 segundos.

Supongamos que estamos tratando de encontrar una característica que tenga alguna característica “Condiciones esperadas “(Stay Stated), si el elemento no se encuentra dentro del marco de tiempo definido por Stated Stay (10 segundos), utilizará el marco de tiempo definido por la espera implícita (20 segundos) antes de ser usado”ElementNotVisibleException“.

El controlador web de Selenium permanece encendido

  1. Manténganse al tanto
  2. Mantenerse claro

Mantente implícito en el selenio

El es Mantente implícito en el selenio Se usa para decirle al controlador web que espere un cierto tiempo antes de ejecutar “Such No Element”. La configuración predeterminada es 0 .. Una vez que establezcamos la hora, el controlador web esperará el elemento durante ese tiempo antes de hacer una excepción.

Selenium Web Driver tuvo la idea de una suspensión implícita de Watir.

En el siguiente ejemplo, hemos confirmado una permanencia implícita con el marco 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 debe agregar una excepción.

Confirme una estadía implícita en Selenium WebDriver:

Sintaxis del ventilador 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 seguir el código:


driver.manage().timeouts().implicitlyWait(10,TimeUnit.SECONDS) ;

La espera implícita tomará 2 parámetros, el primer parámetro tomará el tiempo como un valor entero y el segundo parámetro tomará la medición del tiempo en términos de SEGUNDOS, MINUTOS, MILISEGUNDOS, MICROSECONDOS, NANOSECONDOS, DÍAS, HORAS, etc.

Quédate explícitamente en selenio

El es Quédate explícitamente en selenio se usa para decirle al controlador web que espere ciertas condiciones (condiciones esperadas) o el tiempo máximo violado antes de que se pase la excepción “ElementNotVisibleException”. Es una especie de estancia inteligente, pero solo se puede aplicar a elementos específicos. Ofrece mejores opciones que la espera implícita mientras se esperan elementos Ajax cargados dinámicamente.

Una vez que declaramos una estancia explícita, debemos utilizar “Condiciones esperadas“o podemos configurar la frecuencia con la que queremos verificar la condición usando Mantente fluido. Estos días, cuando aplicamos, estamos acostumbrados. Thread.Sleep () no se suele recomendar su uso

En el siguiente ejemplo, estamos creando una estancia de referencia para “WebDriverWait“usando clase e instantáneo”WebDriver“referencia, y estamos dando un marco de tiempo máximo de 20 segundos.

Sintaxis de estancia 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 seguir el 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 “WebDriverWait“clase o la”Condiciones esperadas“lo que sucede lo que suceda primero.

Sobre Java el código indica que estamos esperando un elemento para el período de tiempo de 20 segundos como se define en el “WebDriverWait“clase en la página web para”Condiciones esperadas“la condición se cumple y la condición”Visibilidad de ElementLocated“.

Las siguientes son las condiciones esperadas que pueden usarse en estadía especificada con selenio

  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. visibilidadDe ()
  16. visibilidadDeTodosElementos ()
  17. visibilidadOfAllElementosLocalizadosBy ()
  18. visibilidadOfElementoLocalizado ()

Manténgase fluido en el selenio

El es Manténgase fluido en el selenio se utiliza para definir el tiempo máximo para que el controlador web espere una condición, así como la frecuencia con la que necesitamos verificar la condición antes de la excepción “ElementNotVisibleException”. Comprueba el elemento web periódicamente hasta que se encuentra el objeto o se alcanza el límite de tiempo.

Frecuencia: Configure un ciclo con el marco de tiempo para verificar / verificar la condición en el intervalo de tiempo regular

Consideremos una situación en la que un elemento se carga en diferentes intervalos de tiempo. El elemento cargado puede estar dentro de los 10 segundos, luego 20 segundos o más, si declaramos una espera explícita de 20 segundos. Esperará hasta el tiempo especificado antes de que se sirva una excepción. En tales casos, la espera fluida es la espera ideal para usar, ya que intentará encontrar el elemento en una frecuencia diferente hasta que lo encuentre o se agote el temporizador final.

Mantén la fluidez en la sintaxis:


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

El código anterior no se informa en Selenium v3.11 y superior. Debes 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 seguir el 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 mantener la fluidez con el límite de tiempo de 30 segundos y la frecuencia se establece en 5 segundos ignorando “NoSuchElementException

Considere seguir el 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 la función web de la página. (Por ejemplo, aquí el elemento web contiene solo el enlace Selenium en la página web).

La frecuencia se establece en 5 segundos y el tiempo máximo se establece en 30 segundos. Esto significa que verificará el elemento en la página web cada 5 segundos durante un máximo de 30 segundos. Si el elemento se encuentra dentro de este período de tiempo, realizará las otras operaciones que debe “ ElementNotVisibleException

Diferencia entre ventilador implícito y ventilador explícito

La principal diferencia entre estancias implícitas y explícitas en Selenium es la siguiente:

Manténganse al tanto
Mantenerse claro
  • El tiempo de fan implícito se aplica a todos los elementos del guión.
  • El tiempo de espera especificado solo se aplica a aquellos elementos que proponemos
  • En Stay entendible, tenemos no especificar “ExpectedConditions” en el elemento que se ubicará
  • En Estadía Especificada, debemos especificar “Condiciones Esperadas” en el elemento a ubicar
  • Se recomienda que se utilicen cuando los elementos estén posicionados con el marco de tiempo especificado en la permanencia implícita de Selenium.
  • Se recomienda utilizarlos cuando los elementos tardan mucho en cargarse y también para verificar las propiedades del elemento como (visibilidadOfElementoLocalizado, elementoToBeClickable, elementoToBeSeleccionado)

Conclusión:

Mantente inteligible, expresivo y fluido son las diversas esperas que se utilizan en el selenio. El uso de estas estancias se basa íntegramente en los elementos cargados en diferentes intervalos de tiempo. No siempre se recomienda utilizar Thread.Sleep () mientras Prueba implementar o construir nuestro marco.

Chaitanya Pujari contribuye a este artículo

Entradas relacionadas

Deja una respuesta

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