En Selenium, "Waits" juega un papel importante en la ejecución de pruebas. En este tutorial, aprenderá varios aspectos de las esperas "implícitas" y "explícitas" en Selenium.
En este tutorial, aprenderá:
- ¿Por qué necesitamos esperas en selenio?
- Espera implícita
- Espera explícita
- Espera fluida
¿Por qué necesitamos esperas en selenio?
La mayoría de las aplicaciones web se desarrollan utilizando Ajax y Javascript. Cuando el navegador carga una página, los elementos con los que queremos interactuar pueden cargarse en diferentes intervalos de tiempo.
No solo dificulta la identificación del elemento, sino que también, si el elemento no está ubicado, generará una excepción " ElementNotVisibleException ". Usando Selenium Waits, podemos resolver este problema.
Consideremos un escenario en el que tenemos que usar esperas implícitas y 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 algunas "condiciones esperadas " (espera explícita). Si el elemento no se encuentra dentro del marco de tiempo definido por la espera explícita (10 segundos), utilizará el marco de tiempo definido por la espera implícita ( 20 segundos) antes de lanzar una " ElementNotVisibleException ".
El controlador web Selenium espera
- Espera implícita
- Espera explícita
Espera implícita en selenio
La espera implícita en Selenium se utiliza para decirle al controlador web que espere una cierta cantidad de tiempo antes de lanzar una "Excepción de no tal elemento". La configuración predeterminada es 0. Una vez que establezcamos la hora, el controlador web esperará el elemento durante ese tiempo antes de lanzar 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 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, lanzará una excepción.
Para declarar espera implícita:
Sintaxis :
driver.manage (). timeouts (). implicitlyWait (TimeOut, TimeUnit.SECONDS);
paquete guru.test99;import java.util.concurrent.TimeUnit;import org.openqa.selenium.By;importar org.openqa.selenium.WebDriver;importar org.openqa.selenium.chrome.ChromeDriver;import org.testng.annotations.Test;AppTest de clase pública {controlador WebDriver protegido;@Pruebapublic void guru99tutorials () lanza InterruptedException{System.setProperty ("webdriver.chrome.driver", ". \\ chromedriver.exe");controlador = nuevo ChromeDriver ();driver.manage (). timeouts (). implicitlyWait (10, TimeUnit.SECONDS);String eTitle = "Página de demostración de Guru99";String aTitle = "";// lanzar Chrome y redirigirlo a la URL basedriver.get ("http://demo.guru99.com/test/guru99home/");// Maximiza la ventana del navegadordriver.manage (). window (). maximizar ();// obtiene el valor real del títuloaTitle = driver.getTitle ();// compara el título real con el título esperadoif (aTitle.equals (eTitle)){System.out.println ("Prueba aprobada");}demás {System.out.println ("Prueba fallida");}// cerrar navegadordriver.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 medición del tiempo en términos de SEGUNDOS, MINUTOS, MILISEGUNDOS, MICROSECONDOS, NANOSECONDOS, DÍAS, HORAS, etc.
Espera explícita en selenio
La espera explícita en Selenium se usa para indicarle al controlador web que espere ciertas condiciones (condiciones esperadas) o el tiempo máximo excedido antes de lanzar la excepción "ElementNotVisibleException". Es un tipo de espera inteligente, pero solo se puede aplicar a elementos específicos. Ofrece mejores opciones que la espera implícita mientras espera elementos Ajax cargados dinámicamente.
Una vez que declaramos la espera explícita, tenemos que usar " ExpectedConditions " o podemos configurar la frecuencia con la que queremos verificar la condición usando Fluent Wait . En estos días, mientras implementamos, estamos usando Thread.Sleep () generalmente no se recomienda usar
En el siguiente ejemplo, estamos creando una espera de referencia para la clase " WebDriverWait " y creando una instancia usando la referencia " WebDriver ", y estamos dando un marco de tiempo máximo de 20 segundos.
Sintaxis:
WebDriverWait wait = nuevo WebDriverWait (WebDriverRefrence, TimeOut);
paquete guru.test99;import java.util.concurrent.TimeUnit;import org.openqa.selenium.By;importar org.openqa.selenium.WebDriver;import org.openqa.selenium.WebElement;importar org.openqa.selenium.chrome.ChromeDriver;import org.openqa.selenium.support.ui.ExpectedConditions;importar org.openqa.selenium.support.ui.WebDriverWait;import org.testng.annotations.Test;AppTest2 de clase pública {controlador WebDriver protegido;@Pruebapublic void guru99tutorials () lanza InterruptedException{System.setProperty ("webdriver.chrome.driver", ". \\ chromedriver.exe");controlador = nuevo ChromeDriver ();WebDriverWait wait = new WebDriverWait (controlador, 20);String eTitle = "Página de demostración de Guru99";String aTitle = "";// lanzar Chrome y redirigirlo a la URL basedriver.get ("http://demo.guru99.com/test/guru99home/");// Maximiza la ventana del navegadordriver.manage (). window (). maximizar ();// obtiene el valor real del títuloaTitle = driver.getTitle ();// compara el título real con el título esperadoif (aTitle.contentEquals (eTitle)){System.out.println ("Prueba aprobada");}demás {System.out.println ("Prueba fallida");}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 a que ocurra 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 durante el período de tiempo de 20 segundos como se define en la clase " WebDriverWait " en la página web hasta que se cumplan las "condiciones esperadas " y la condición sea " visibilidad de elementos ubicados ".
Las siguientes son las condiciones esperadas que se pueden usar en la espera explícita de selenio
- alertIsPresent ()
- elementSelectionStateToBe ()
- elementToBeClickable ()
- elementToBeSelected ()
- frameToBeAvaliableAndSwitchToIt ()
- invisibilityOfTheElementLocated ()
- invisibilityOfElementWithText ()
- PresenceOfAllElementsLocatedBy ()
- PresenceOfElementLocated ()
- textToBePresentInElement ()
- textToBePresentInElementLocated ()
- textToBePresentInElementValue ()
- titleIs ()
- titleContains ()
- visibilidadDe ()
- visibilidadDeTodosElementos ()
- visibilidadOfAllElementosLocalizadosBy ()
- visibilidadOfElementoLocalizado ()
Espera fluida en selenio
La espera fluida en Selenium se usa para definir el tiempo máximo para que el controlador web espere una condición, así como la frecuencia con la que queremos verificar 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: configuración de un ciclo de repetición con el marco de tiempo para verificar / verificar 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 puede cargarse en 10 segundos, 20 segundos o incluso más de eso si declaramos una espera explícita de 20 segundos. Esperará hasta el momento 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 una frecuencia diferente hasta que lo encuentre o se agote el temporizador final.
Sintaxis:
Espere, espere = nuevo FluentWait (referencia de WebDriver).withTimeout (tiempo de espera, SEGUNDOS).pollingEvery (tiempo de espera, SEGUNDOS). ignorando (Exception.class);
El código anterior está obsoleto en Selenium v3.11 y superior. Necesitas usar
Espere, espere = nuevo FluentWait (referencia de WebDriver).withTimeout (Duración. de segundos (SEGUNDOS)).pollingEvery (Duración. de segundos (SEGUNDOS)). ignorando (Exception.class);
paquete 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;importar org.openqa.selenium.WebDriver;import org.openqa.selenium.WebElement;importar org.openqa.selenium.chrome.ChromeDriver;import org.openqa.selenium.support.ui.ExpectedConditions;importar org.openqa.selenium.support.ui.FluentWait;importar org.openqa.selenium.support.ui.Wait;importar org.openqa.selenium.support.ui.WebDriverWait;import org.testng.annotations.Test;AppTest3 de clase pública {controlador WebDriver protegido;@Pruebapublic void guru99tutorials () lanza InterruptedException{System.setProperty ("webdriver.chrome.driver", ". \\ chromedriver.exe");String eTitle = "Página de demostración de Guru99";String aTitle = "";controlador = nuevo ChromeDriver ();// lanzar Chrome y redirigirlo a la URL basedriver.get ("http://demo.guru99.com/test/guru99home/");// Maximiza la ventana del navegadordriver.manage (). window (). maximizar ();// obtiene el valor real del títuloaTitle = driver.getTitle ();// compara el título real con el título esperadoif (aTitle.contentEquals (eTitle)){System.out.println ("Prueba aprobada");}demás {System.out.println ("Prueba fallida");}Espera espera = nuevo FluentWait (controlador).withTimeout (30, TimeUnit.SECONDS).pollingEvery (5, TimeUnit.SECONDS).ignoring (NoSuchElementException.class);WebElement clickseleniumlink = wait.until (nueva función () {Se aplica WebElement público (controlador WebDriver) {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 "));}});// haga clic en el enlace de selenioclickseleniumlink.click ();// cerrar ~ navegadordriver.close ();}}
Explicación del código
Considere el siguiente código:
Esperaespera = nuevo FluentWait (controlador).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 " NoSuchElementException "
Considere el siguiente código:
Se aplica WebElement público (controlador WebDriver) {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. (Por ejemplo, aquí Web Element no es más que el enlace de Selenium en la página web).
La frecuencia se establece en 5 segundos y el tiempo máximo se establece en 30 segundos. Por lo tanto, esto significa que buscará 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, realizará las operaciones; de lo contrario, arrojará una " ElementNotVisibleException "
Diferencia entre espera implícita y espera explícita
| Espera implícita | Espera explícita |
|---|---|
|
|
|
|
|
|
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 usar Thread.Sleep () mientras prueba nuestra aplicación o construye nuestro marco.
Este artículo es una contribución de Chaitanya Pujari.