Selenium Oota – kaudne ja selgesõnaline koos süntaksiga
Krishna Rungta
In Selenium, "Ootused" mängivad testide läbiviimisel olulist rolli. Selles õpetuses saate teada erinevaid aspekte ja erinevusi kaudse ja selgesõnalise ootamise vahel Selenium.
Miks me vajame ooteaegu? Selenium?
Enamik veebirakendusi on välja töötatud kasutades Ajax ja Javascript. Kui brauser lehe laadib, võivad elemendid, millega soovime suhelda, laadida erinevate ajavahemike järel.
See mitte ainult ei muuda elemendi tuvastamist keeruliseks, vaid ka siis, kui elementi ei asuta, ilmub see "ElementNotVisibleException” erand. Kasutades Selenium Oota, me saame selle probleemi lahendada.
Vaatleme stsenaariumi, kus peame oma testis kasutama nii kaudseid kui ka otseseid ootamisi. Oletame, et kaudseks ooteajaks on seatud 20 sekundit ja otseseks ooteajaks on seatud 10 sekundit.
Oletame, et püüame leida elementi, millel on mõned "Oodatavad tingimused "(Explicit Wait), kui element ei asu sõnaselge ootamise (10 sekundit) määratud ajaraami sees, kasutab see aega, mis on määratud kaudse ootamisega (20 sekundit), enne kui viskab "ElementNotVisibleException".
Selenium Veebidraiver ootab
- Kaudne ootamine
- Selgesõnaline ootamine
Sellest õpetusest saate teada erinevate ootetüüpide kohta Selenium:
Kaudne ootamine Selenium
. Kaudne ootamine Selenium kasutatakse selleks, et öelda veebidraiverile, et ta ootaks teatud aja, enne kui ta teeb teate „Sellise elemendi erandit pole”. Vaikesäte on 0. Kui oleme kellaaja määranud, ootab veebidraiver selle aja elementi enne erandi tegemist.
Selenium Web Driver on kaudse ootamise idee laenanud Watir.
Allolevas näites oleme deklareerinud kaudse ootamise ajaraamiga 10 sekundit. See tähendab, et kui element ei asu selle aja jooksul veebilehel, teeb see erandi.
Kaudse ootamise kuulutamiseks Selenium Veebidraiver:
Kaudne oote süntaks:
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("https://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();
}
}
Koodi selgitus
Ülaltoodud näites
Kaaluge järgmist koodi:
driver.manage().timeouts().implicitlyWait(10,TimeUnit.SECONDS) ;
Kaudne ootamine aktsepteerib 2 parameetrit, esimene parameeter aktsepteerib aega täisarvuna ja teine parameeter aktsepteerib aja mõõtmist SEKUNDITES, MINUTITES, MILISEUNDITES, MIKROSEUNDITES, NANOSEKONDITES, PÄEVAS, TUNDIDES jne.
Selgesõnaline Oodake sisse Selenium
. Selgesõnaline Oodake sisse Selenium kasutatakse selleks, et käskida veebidraiveril oodata teatud tingimuste (oodatavad tingimused) või maksimaalse aja ületamist, enne kui teeb erandi „ElementNotVisibleException”. See on intelligentne ootamise tüüp, kuid seda saab rakendada ainult määratud elementide jaoks. See annab paremaid valikuid kui kaudne ootamine, kui see ootab dünaamiliselt laaditud Ajaxi elemente.
Kui oleme selgesõnalise ootamise deklareerinud, peame kasutama "Eeldatavad tingimused” või saame konfigureerida, kui sageli soovime seisukorda kontrollida Sujuv ootamine. Nendel päevadel juurutamise ajal kasutame Thread.Sleep() üldiselt ei soovitata seda kasutada
Allolevas näites loome viite ootamise "WebDriverOota" klassis ja eksemplari kasutades "Veebidraiver” viide ja anname maksimaalseks ajaraamiks 20 sekundit.
Selgesõnaline oote süntaks:
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("https://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();
}
}
Koodi selgitus
Kaaluge järgmist koodi:
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();
Selles WebDriveri ootenäites oodake jaotises "WebDriverOota" klass või "Eeldatavad tingimused” toimuma olenevalt sellest, kumb juhtub varem.
Ülaltoodud Java kood ütleb, et ootame elementi 20-sekundilise aja jooksul, nagu on määratletud jaotises "WebDriverOota” klassi veebilehel kuni „Eeldatavad tingimused" on täidetud ja tingimus on "ElementLocated nähtavus".
Järgmised on eeldatavad tingimused, milles saab kasutada Selenium Selgesõnaline ootamine
- alertIsPresent()
- elementSelectionStateToBe()
- elementToBeClickable()
- elementToBeSelected()
- raamSaadavaleJaSelleleLülita()
- InvisibilityOfThe ElementLocated()
- elemendi nähtamatus koos tekstiga()
- Kõikide elementide olemasolu Asukoht()
- esinemineOfElementLocated()
- textToBe PresentInElement()
- textToBePresentInElementLocated()
- textToBePresentInElementValue()
- pealkiri on()
- titleContains()
- visibilityOf()
- VisibilityOfAll Elements()
- VisibilityOfAll ElementsLocatedBy()
- visibilityOfElementLocated()
Ladus Oota sisse Selenium
. Ladus Oota sisse Selenium kasutatakse selleks, et määratleda maksimaalne aeg, mille jooksul veebidraiver peab tingimust ootama, samuti sagedus, millega soovime tingimust enne erandi „ElementNotVisibleException” loomist kontrollida. See kontrollib veebielementi korrapäraste ajavahemike järel, kuni objekt leitakse või aegumiseni.
Sagedus: Ajaraamiga kordustsükli seadistamine, et kontrollida/kontrollida seisukorda korrapäraste ajavahemike järel
Vaatleme stsenaariumi, kus elementi laaditakse erinevate ajavahemike järel. Element võib laadida 10 sekundi, 20 sekundi või isegi rohkem kui siis, kui deklareerime selgesõnalise 20-sekundilise ootamise. Enne erandi tegemist ootab see määratud ajani. Selliste stsenaariumide korral on sujuv ootamine ideaalne ootamine, kuna see püüab elementi leida erineva sagedusega, kuni see leiab või viimane taimer saab otsa.
Fluent Wait süntaks:
Wait wait = new FluentWait(WebDriver reference) .withTimeout(timeout, SECONDS) .pollingEvery(timeout, SECONDS) .ignoring(Exception.class);
Ülaltoodud kood on aegunud Selenium v3.11 ja uuemad. Sa pead kasutama
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("https://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() ;
}
}
Koodi selgitus
Kaaluge järgmist koodi:
Wait<WebDriver> wait = new FluentWait<WebDriver>(driver) .withTimeout(30, TimeUnit.SECONDS) .pollingEvery(5, TimeUnit.SECONDS) .ignoring(NoSuchElementException.class);
Ülaltoodud näites deklareerime sujuva ootamise ajalõpuga 30 sekundit ja sageduseks määratakse 5 sekundit, ignoreerides "NoSuchElementException"
Kaaluge järgmist koodi:
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"));
Oleme loonud uue funktsiooni lehel oleva veebielemendi tuvastamiseks. (Näiteks: siin pole veebielement midagi muud kui Selenium link veebilehel).
Sagedus on seatud 5 sekundile ja maksimaalne aeg on seatud 30 sekundile. Seega see tähendab, et ta kontrollib elementi veebilehel iga 5 sekundi järel maksimaalselt 30 sekundi jooksul. Kui element asub selle aja jooksul, sooritab see toimingud, vastasel juhul kuvab see "ElementNotVisibleException"
Kontrollige ka: - Selenium IDE õpetus algajatele
Erinevus kaudse ootamise ja otsese ootamise vahel
Järgmine on peamine erinevus kaudse ootamise ja otsese ootamise vahel Selenium:
| Kaudne ootamine | Selgesõnaline ootamine |
|---|---|
| Kõigile skripti elementidele rakendatakse kaudset ooteaega | Selgesõnalist ooteaega rakendatakse ainult nendele elementidele, mis on meie poolt ette nähtud |
| Implicit Wait'is vajame mitte määrake leiduval elemendil "ExpectedConditions". | Explicit Wait'is peame leidval elemendil määrama "ExpectedConditions". |
| Soovitatav on kasutada, kui elemendid asuvad punktis määratud ajaraamiga Selenium kaudne ootamine | Soovitatav on kasutada siis, kui elementide laadimine võtab kaua aega ja ka elemendi omaduse kontrollimiseks nagu(visibilityOfElementLocated, elementToBeClickable,elementToBeSelected) |
Järeldus
Kaudne, selgesõnaline ja sujuv ootamine on erinevad ootamised, mida kasutatakse Selenium. Nende ootamiste kasutamine põhineb täielikult erinevate ajavahemike järel laaditavatel elementidel. Alati ei ole soovitatav kasutada Thread.Sleep() while Testimine meie rakendus või raamistiku ehitamine.
Kontrollige ka: - Selenium Õpetus algajatele: õppige WebDriver 7 päevaga
