În Seleniu, „Așteptați” joacă un rol important în executarea testelor. În acest tutorial, veți învăța diferite aspecte atât ale așteptărilor „implicite”, cât și „explicite” în seleniu.
În acest tutorial, veți învăța:
- De ce avem nevoie de așteptări în seleniu?
- Așteptați implicit
- Așteptați explicit
- Așteptați fluent
De ce avem nevoie de așteptări în seleniu?
Majoritatea aplicațiilor web sunt dezvoltate folosind Ajax și Javascript. 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ă face acest lucru dificil de identificat elementul, dar și dacă elementul nu este localizat, va arunca o excepție „ ElementNotVisibleException ”. Folosind Selenium Waits, 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 de secunde) înainte de a arunca o „ ElementNotVisibleException ”.
Selenium Web Driver așteaptă
- Așteptați implicit
- Așteptați explicit
Așteptați implicit în seleniu
Așteptare Implicit în Seleniul este folosit pentru a spune șoferului web să aștepte pentru o anumită perioadă de timp înainte de a arunca o „Nici o astfel de excepție Element“. Setarea implicită este 0. Odată ce am setat ora, driverul web va aștepta elementul pentru acel moment înainte de a arunca o excepție.
Selenium Web Driver a împrumutat de la Watir ideea așteptărilor implicite.
Î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 genera o excepție.
Pentru a declara așteptare implicită:
Sintaxă :
driver.manage (). timeouts (). implicit Așteptați (TimeOut, TimeUnit.SECONDS);
pachet 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;clasă publică AppTest {driver WebDriver protejat;@Testpublic void guru99tutorials () aruncă InterruptedException{System.setProperty ("webdriver.chrome.driver", ". \\ chromedriver.exe");driver = nou ChromeDriver ();driver.manage (). timeouts (). implicit Așteptați (10, TimeUnit.SECONDS);String eTitle = "Pagina Demo Guru99";String aTitle = "";// lansați Chrome și redirecționați-l către adresa URL de bazădriver.get ("http://demo.guru99.com/test/guru99home/");// Maximizează fereastra browseruluidriver.manage (). window (). maximize ();// obțineți valoarea reală a titluluiaTitle = driver.getTitle ();// comparați titlul real cu titlul așteptatif (aTitle.equals (eTitle)){System.out.println ("Testul a trecut");}altceva {System.out.println ("Testul nu a reușit");}// închide browseruldriver.close ();}}
Explicația Codului
În exemplul de mai sus,
Luați în considerare următorul cod:
driver.manage (). timeouts (). implicit Așteptați (10, TimeUnit.SECONDS);
Așteptarea implicită va accepta 2 parametri, primul parametru va accepta ora ca valoare întreagă și al doilea parametru va accepta măsurarea timpului în termeni de SECUNDE, MINUTE, MILISECOND, MICROSECONDE, NANOSECONDE, ZILE, ORE etc.
Așteptați explicit în seleniu
Stai Explicit in seleniu este folosit pentru a spune Driver Web să aștepte pentru anumite condiții (condițiile preconizate) sau timpul maxim depășit înainte de a arunca „ElementNotVisibleException“ excepție. Este un tip inteligent de așteptare, dar poate fi aplicat numai pentru elementele specificate. Oferă opțiuni mai bune decât așteptarea implicită, deoarece așteaptă elemente 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 dorim să verificăm starea folosind Fluent Wait . În aceste zile, în timpul implementării, folosim Thread.Sleep (), în general, nu este recomandat să se utilizeze
In exemplul de mai jos, vom crea așteptați referință pentru „ WebDriverWait clasă“ și instantiind folosind „ WebDriver “ de referință, iar noi oferim un interval de timp de maxim 20 secunde.
Sintaxă:
WebDriverWait wait = new WebDriverWait (WebDriverRefrence, TimeOut);
pachet 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;clasă publică AppTest2 {driver WebDriver protejat;@Testpublic void guru99tutorials () aruncă InterruptedException{System.setProperty ("webdriver.chrome.driver", ". \\ chromedriver.exe");driver = nou ChromeDriver ();WebDriverWait wait = new WebDriverWait (driver, 20);String eTitle = "Pagina Demo Guru99";String aTitle = "";// lansați Chrome și redirecționați-l către adresa URL de bazădriver.get ("http://demo.guru99.com/test/guru99home/");// Maximizează fereastra browseruluidriver.manage (). window (). maximize ();// obțineți valoarea reală a titluluiaTitle = driver.getTitle ();// comparați titlul real cu titlul așteptatif (aTitle.contentEquals (eTitle)){System.out.println ("Testul a trecut");}altceva {System.out.println ("Testul nu a reușit");}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 ca perioada de timp definită în clasa „ WebDriverWait ” sau „ ExpectedConditions ” să apară oricare dintre acestea apare mai întâi.
Codul Java de mai sus afirmă că așteptăm un element pentru intervalul de timp de 20 de secunde, așa cum este definit în clasa „ WebDriverWait ” de pe pagina web, până când „ ExpectedConditions ” sunt îndeplinite și condiția este „ vizibilitateaElementuluiLocat ”.
Următoarele sunt condițiile așteptate care pot fi utilizate în Selenium Explicit Wait
- alertIsPresent ()
- elementSelectionStateToBe ()
- elementToBeClickable ()
- elementToBeSelected ()
- frameToBeAvaliableAndSwitchToIt ()
- invisibilityOfTheElementLocated ()
- invisibilityOfElementWithText ()
- presenceOfAllElementsLocatedBy ()
- presenzaOfElementLocated ()
- textToBePresentInElement ()
- textToBePresentInElementLocated ()
- textToBePresentInElementValue ()
- titleIs ()
- titleContains ()
- vizibilitateDe ()
- visibleOfAllElements ()
- visibilityOfAllElementsLocatedBy ()
- visibleOfElementLocated ()
Așteptați fluent în seleniu
Stai Fluent in seleniu este utilizat pentru a defini timpul maxim pentru driver - ul web să aștepte o condiție, precum și frecvența cu care dorim să verifice starea înainte de a arunca o „ElementNotVisibleException“ excepție. Se verifică elementul web la intervale regulate până când obiectul este găsit sau se întâmplă timeout.
Frecvență: Configurarea unui ciclu de repetare cu intervalul de timp pentru a verifica / verifica starea la intervalul de timp regulat
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 decurs de 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 se termină temporizatorul final.
Sintaxă:
Așteptați așteptați = nou FluentWait (referință WebDriver).withTimeout (timeout, SECONDS).pollingEvery (timeout, SECONDS).ignoring (Exception.class);
Codul de mai sus este depreciat în Selenium v3.11 și mai sus. Trebuie să folosiți
Așteptați așteptați = nou FluentWait (referință WebDriver).withTimeout (Duration.ofSeconds (SECONDS)).pollingEvery (Duration.ofSeconds (SECONDS)).ignoring (Exception.class);
pachet 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 {driver WebDriver protejat;@Testpublic void guru99tutorials () aruncă InterruptedException{System.setProperty ("webdriver.chrome.driver", ". \\ chromedriver.exe");String eTitle = "Pagina Demo Guru99";String aTitle = "";driver = nou ChromeDriver ();// lansați Chrome și redirecționați-l către adresa URL de bazădriver.get ("http://demo.guru99.com/test/guru99home/");// Maximizează fereastra browseruluidriver.manage (). window (). maximize ();// obțineți valoarea reală a titluluiaTitle = driver.getTitle ();// comparați titlul real cu titlul așteptatif (aTitle.contentEquals (eTitle)){System.out.println ("Testul a trecut");}altceva {System.out.println ("Testul nu a reușit");}Așteptați așteptați = nou FluentWait (driver).withTimeout (30, TimeUnit.SECONDS).pollingEvery (5, TimeUnit.SECONDS).ignoring (NoSuchElementException.class);WebElement clickseleniumlink = wait.until (funcție nouă () {se aplică WebElement public (driver 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 "));}});// faceți clic pe linkul seleniuclickseleniumlink.click ();// închide ~ browseruldriver.close ();}}
Explicația Codului
Luați în considerare următorul cod:
Așteptațiașteptați = nou FluentWait (driver).withTimeout (30, TimeUnit.SECONDS).pollingEvery (5, TimeUnit.SECONDS).ignoring (NoSuchElementException.class);
În exemplul de mai sus, declarăm o așteptare fluentă cu expirarea de 30 de secunde și frecvența este setată la 5 secunde ignorând „ NoSuchElementException ”
Luați în considerare următorul cod:
se aplică WebElement public (driver 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 "));
Am creat o nouă funcție pentru a identifica elementul web de pe pagină. (De exemplu: aici Elementul Web nu este altceva decât linkul Selenium de 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 timpul maxim de 30 de secunde. Dacă elementul este situat în acest interval de timp, acesta va efectua operațiunile altfel va arunca o „ ElementNotVisibleException ”
Diferența dintre Așteptare implicită Vs Așteptare explicită
| Așteptați implicit | Așteptați explicit |
|---|---|
|
|
|
|
|
|
Concluzie:
Implicit, Explicit și Fluent Wait sunt diferitele așteptări utilizate în seleniu. 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 timpul testării aplicației noastre sau construirii cadrului nostru.
Acest articol este contribuit de Chaitanya Pujari