Selenium Așteptați – așteptări implicite, explicite și fluente


In Selenium, „Așteptările” joacă un rol important în executarea testelor. În acest tutorial, veți învăța diferite aspecte și diferența dintre așteptarea implicită și explicită Selenium.

De ce avem nevoie de așteptări Selenium?

Majoritatea aplicațiilor web sunt dezvoltate folosind Ajax si Javascript. Atunci când o pagină este încărcată de browser, elementele cu care dorim să interacționăm se pot încărca la intervale de timp diferite.

Nu numai că îngreunează identificarea elementului, dar și dacă elementul nu este localizat, va arunca un „ElementNotVisibleException" excepție. Folosind Selenium Așteaptă, putem rezolva această problemă.

Să luăm în considerare un scenariu în care trebuie să folosim atât așteptări implicite, cât și explicite în testul nostru. Să presupunem că timpul de așteptare implicit este setat la 20 de secunde și timpul de așteptare explicit este setat la 10 secunde.

Să presupunem că încercăm să găsim un element care are unele „Condiții așteptate „(Așteptare explicită), Dacă elementul nu este localizat în intervalul de timp definit de așteptarea explicită (10 secunde), va folosi intervalul de timp definit de așteptarea implicită (20 secunde) înainte de a arunca un „ElementNotVisibleException".

Selenium Driverul web așteaptă

  1. Așteptați implicit
  2. Așteptați explicit

În acest tutorial, veți afla despre diferitele tipuri de așteptări Selenium:

Așteptați implicit Selenium

Așteptați implicit Selenium este folosit pentru a-i spune driverului web să aștepte o anumită perioadă de timp înainte de a genera o „Fără o astfel de excepție a elementului”. Setarea implicită este 0. Odată ce setăm ora, driverul web va aștepta elementul pentru acel timp înainte de a arunca o excepție.

Selenium Web Driver a împrumutat ideea așteptărilor implicite de la Watir.

În exemplul de mai jos am declarat o așteptare implicită cu intervalul de timp de 10 secunde. Înseamnă că, dacă elementul nu este localizat pe pagina web în acel interval de timp, va arunca o excepție.

Pentru a declara implicit wait in Selenium WebDriver:

Sintaxa de așteptare implicită:

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();
}
}

Explicația Codului

În exemplul de mai sus,

Luați în considerare următorul cod:

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

Așteptarea implicită va accepta 2 parametri, primul parametru va accepta timpul ca valoare întreagă, iar al doilea parametru va accepta măsurarea timpului în termeni de SECONDE, MINUTE, MILISECUNDE, MICROSECUNDE, NANOSECONDE, ZILE, ORE etc.

Așteptați explicit Selenium

Așteptați explicit Selenium este folosit pentru a spune driverului web să aștepte anumite condiții (condiții așteptate) sau timpul maxim depășit înainte de a arunca excepția „ElementNotVisibleException”. Este un fel inteligent de așteptare, dar poate fi aplicat doar pentru elementele specificate. Oferă opțiuni mai bune decât așteptarea implicită, deoarece așteaptă elementele Ajax încărcate dinamic.

Odată ce declarăm așteptarea explicită, trebuie să folosim „Condiții așteptate” sau putem configura cât de des vrem să verificăm starea folosind Așteptați fluent. În aceste zile, în timp ce implementăm, folosim Thread.Sleep() în general, nu se recomandă utilizarea

În exemplul de mai jos, creăm referință așteptare pentru „WebDriverWait” clasă și instanțierea folosind ”webdriver” și oferim un interval de timp maxim de 20 de secunde.

Sintaxă explicită Wait:

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();
	}
	
}

Explicația Codului

Luați în considerare următorul cod:

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();

În acest exemplu de așteptare WebDriver, așteptați perioada de timp definită în „WebDriverWait„clasa” sau „Condiții așteptate” să apară oricare dintre acestea se întâmplă mai întâi.

Cele de mai sus Java codul spune că așteptăm un element pentru intervalul de timp de 20 de secunde, așa cum este definit în „WebDriverWaitclasa ” pe pagina web până la ”Condiții așteptate" sunt îndeplinite și condiția este "visibilityofElementLocated".

Următoarele sunt condițiile așteptate care pot fi utilizate în Selenium Așteptați explicit

  1. alertIsPresent()
  2. elementSelectionStateToBe()
  3. elementToBeClickable()
  4. elementToBeSelected()
  5. frameToBeAvaliableAndSwitchToIt()
  6. invizibilityOfTheElementLocated()
  7. invizibilityOfElementWithText()
  8. prezentaOfToateElementeleLocatedBy()
  9. presentOfElementLocated()
  10. textToBePresentInElement()
  11. textToBePresentInElementLocated()
  12. textToBePresentInElementValue()
  13. titleIs()
  14. titleContains()
  15. vizibilityOf()
  16. visibilityOfAllElements()
  17. visibilityOfAllElementsLocatedBy()
  18. visibilityOfElementLocated()

Fluent Așteptați Selenium

Fluent Așteptați Selenium este folosit pentru a defini timpul maxim pentru care driverul web să aștepte o condiție, precum și frecvența cu care dorim să verificăm condiția înainte de a arunca o excepție „ElementNotVisibleException”. Verifică elementul web la intervale regulate până când obiectul este găsit sau expiră.

Frecventa: Configurarea unui ciclu de repetare cu intervalul de timp pentru a verifica/verifica starea la intervalul regulat de timp

Să luăm în considerare un scenariu în care un element este încărcat la diferite intervale de timp. Elementul se poate încărca în 10 secunde, 20 de secunde sau chiar mai mult decât dacă declarăm o așteptare explicită de 20 de secunde. Va aștepta până la ora specificată înainte de a arunca o excepție. În astfel de scenarii, așteptarea fluentă este așteptarea ideală de utilizat, deoarece aceasta va încerca să găsească elementul la o frecvență diferită până când îl găsește sau cronometrul final se epuizează.

Sintaxă Fluent Wait:

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

Codul de mai sus este depreciat în Selenium v3.11 și mai sus. Trebuie să utilizați

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() ;
	}
}

Explicația Codului

Luați în considerare următorul cod:

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

În exemplul de mai sus, declarăm o așteptare fluentă cu un timeout de 30 de secunde și frecvența este setată la 5 secunde ignorând „NoSuchElementException

Luați în considerare următorul cod:

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"));

Am creat o nouă funcție pentru a identifica Elementul Web de pe pagină. (Ex: Aici Web Element nu este altceva decât Selenium link pe pagina web).

Frecvența este setată la 5 secunde, iar timpul maxim este setat la 30 de secunde. Astfel, aceasta înseamnă că va verifica elementul de pe pagina web la fiecare 5 secunde pentru un timp maxim de 30 de secunde. Dacă elementul este localizat în acest interval de timp, va efectua operațiunile, altfel va arunca un „ElementNotVisibleException

Verificați și: - Selenium Tutorial IDE pentru începători

Diferența dintre așteptarea implicită și așteptarea explicită

Mai jos este diferența principală dintre așteptarea implicită și așteptarea explicită Selenium:

Așteptați implicit Așteptați explicit
Timpul de așteptare implicit este aplicat tuturor elementelor din script Timpul de așteptare explicit se aplică numai acelor elemente care sunt intenționate de noi
În așteptarea implicită, avem nevoie nu specificați „ExpectedConditions” pe elementul care urmează să fie localizat În Explicit Wait, trebuie să specificăm „ExpectedConditions” pe elementul care urmează să fie localizat
Se recomandă utilizarea atunci când elementele sunt localizate în intervalul de timp specificat în Selenium asteptare implicita Se recomandă utilizarea atunci când elementele durează mult să se încarce și, de asemenea, pentru verificarea proprietății elementului cum ar fi (visibilityOfElementLocated, elementToBeClickable,elementToBeSelected)

Concluzie

Așteptarea implicită, explicită și fluentă sunt diferitele așteptări utilizate în Selenium. Utilizarea acestor așteptări se bazează în totalitate pe elementele care sunt încărcate la diferite intervale de timp. Nu este întotdeauna recomandat să utilizați Thread.Sleep() în timp ce Testarea aplicația noastră sau construirea cadrului nostru.

Verificați și: - Selenium Tutorial pentru începători: Învață WebDriver în 7 zile

Citește mai mult Readmore