Selenium Várjon – implicit és explicit szintaxissal
Krishna Rungta
In Selenium, A „várások” fontos szerepet játszanak a tesztek végrehajtásában. Ebben az oktatóanyagban megismerheti az implicit és az explicit várakozás különböző szempontjait és különbségeit Selenium.
Miért van szükségünk várakozásra? Selenium?
A webalkalmazások többsége felhasználásával készül Ajax és a Javascript. Amikor egy oldalt betölt a böngésző, azok az elemek, amelyekkel kapcsolatba akarunk lépni, különböző időközönként töltődnek be.
Nem csak ez nehezíti meg az elem azonosítását, hanem ha az elem nem található, akkor egy "ElementNotVisibleException” kivétel. Használata Selenium Várj, meg tudjuk oldani ezt a problémát.
Tekintsünk egy olyan forgatókönyvet, amelyben implicit és explicit várakozásokat is kell használnunk a tesztünkben. Tegyük fel, hogy az implicit várakozási idő 20 másodperc, az explicit várakozási idő pedig 10 másodperc.
Tegyük fel, hogy megpróbálunk találni egy olyan elemet, amelynek van néhány „Várható feltételek "(Explicit Wait), Ha az elem nem az Explicit várakozás (10 másodperc) által meghatározott időkereten belül található, akkor az implicit várakozás (20 másodperc) által meghatározott időkeretet fogja használni, mielőtt egy "ElementNotVisibleException".
Selenium Web Driver vár
- Implicit várakozás
- Kifejezett várakozás
Ebből az oktatóanyagból megismerheti a várakozások különböző típusait Selenium:
Implicit bevárás Selenium
A Implicit bevárás Selenium arra szolgál, hogy a web-illesztőprogramot arra utasítsa, hogy várjon egy bizonyos ideig, mielőtt a „Nincs ilyen elem kivétel” üzenetet ad. Az alapértelmezett beállítás 0. Miután beállítottuk az időt, a web-illesztőprogram megvárja az elemet addig, mielőtt kivételt dobna.
Selenium A Web Driver az implicit várakozás gondolatát tőle kölcsönözte Watir.
Az alábbi példában implicit várakozást deklaráltunk 10 másodperces időkerettel. Ez azt jelenti, hogy ha az elem ezen időkereten belül nem található meg a weboldalon, akkor kivételt dob.
Az implicit várakozás kinyilvánítása Selenium WebDriver:
Implicit várakozás szintaxis:
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();
}
}
A kód magyarázata
A fenti példában
Fontolja meg a következő kódot:
driver.manage().timeouts().implicitlyWait(10,TimeUnit.SECONDS) ;
Az implicit várakozás 2 paramétert fogad el, az első paraméter egész értékként fogadja el az időt, a második paraméter pedig az időmérést MÁSODPERC, PERC, MILISECOND, MIKROSZEKUNDUM, NANOSECOND, NAP, ÓRA stb.
Explicit Várj be Selenium
A Explicit Várj be Selenium arra szolgál, hogy utasítsa a web-illesztőprogramot, hogy várja meg bizonyos feltételeket (elvárt feltételek) vagy a maximális időtartam túllépését, mielőtt „ElementNotVisibleException” kivételt dobna. Ez egy intelligens fajta várakozás, de csak meghatározott elemekre alkalmazható. Jobb lehetőségeket ad, mint az implicit várakozás, mivel dinamikusan betöltött Ajax elemekre vár.
Miután kifejeztük a várakozást, használnunk kell a „Várható feltételek” vagy beállíthatjuk, hogy milyen gyakran akarjuk ellenőrizni az állapotot Folyékony várakozás. Ezekben a napokban a megvalósítás során használjuk Thread.Sleep() általában nem ajánlott használni
Az alábbi példában referenciavárakozást hozunk létre a „WebDriverVárjon" osztály és példányosítás a " használatávalwebdriver” hivatkozást, és maximum 20 másodperces időkeretet adunk meg.
Explicit várakozás szintaxis:
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();
}
}
A kód magyarázata
Fontolja meg a következő kódot:
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();
Ebben a WebDriver várakozási példában várja meg a „WebDriverVárjon" osztály vagy a "Várható feltételek”, amelyik előbb bekövetkezik.
A fenti Java kód kimondja, hogy egy elemre 20 másodperces időkeretre várunk aWebDriverVárjon" osztály a weboldalon egészen a "Várható feltételek" teljesülnek, és a feltétel "láthatóságaElementLocated".
Az alábbiakban felsoroljuk azokat a várható feltételeket, amelyekben használható Selenium Kifejezett várakozás
- alertIsPresent()
- elementSelectionStateToBe()
- elementToBeClickable()
- elemToBeSelected()
- frameToLehetőÉs VáltsonToIt()
- invisibilityOfThe ElementLocated()
- invisibilityOf ElementWithText()
- jelenlétOfAll ElementsLocatedBy()
- jelenlétOfElementLocated()
- textToBePresentInElement()
- textToBePresentInElementLocated()
- textToBePresentInElementValue()
- titleIs()
- titleContains()
- láthatósága()
- VisibilityOfAll Elements()
- VisibilityOfAll ElementsLocatedBy()
- VisibilityOfElementLocated()
Folyékony Várjon Selenium
A Folyékony Várjon Selenium A web-illesztőprogram maximális időtartamának meghatározására szolgál egy feltételre, valamint azt a gyakoriságot, amellyel ellenőrizni akarjuk a feltételt, mielőtt „ElementNotVisibleException” kivételt dobnánk. Rendszeres időközönként ellenőrzi a webelemet, amíg meg nem találja az objektumot, vagy amíg az időtúllépés meg nem történik.
Frekvencia: Ismétlési ciklus beállítása az időkerettel az állapot rendszeres időközönkénti ellenőrzésére/ellenőrzésére
Tekintsünk egy forgatókönyvet, ahol egy elemet különböző időközönként töltenek be. Az elem betöltődhet 10 másodpercen belül, 20 másodpercen belül vagy még ennél is többet, ha 20 másodperces explicit várakozást deklarálunk. Vár a megadott ideig, mielőtt kivételt dobna. Ilyen forgatókönyvekben a folyékony várakozás az ideális várakozás, mivel ez különböző gyakorisággal próbálja megtalálni az elemet, amíg meg nem találja, vagy a végső időzítő le nem jár.
Fluent Wait szintaxis:
Wait wait = new FluentWait(WebDriver reference) .withTimeout(timeout, SECONDS) .pollingEvery(timeout, SECONDS) .ignoring(Exception.class);
A fenti kód elavult Selenium v3.11 és újabb. Használnod kell
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() ;
}
}
A kód magyarázata
Fontolja meg a következő kódot:
Wait<WebDriver> wait = new FluentWait<WebDriver>(driver) .withTimeout(30, TimeUnit.SECONDS) .pollingEvery(5, TimeUnit.SECONDS) .ignoring(NoSuchElementException.class);
A fenti példában folyékony várakozást deklarálunk 30 másodperces időtúllépéssel, és a gyakoriságot 5 másodpercre állítjuk be a „NoSuchElementException"
Fontolja meg a következő kódot:
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"));
Létrehoztunk egy új funkciót a webelem azonosítására az oldalon. (Pl.: Itt a Web Element nem más, mint a Selenium link a weboldalon).
A frekvencia 5 másodpercre, a maximális idő pedig 30 másodpercre van állítva. Ez azt jelenti, hogy 5 másodpercenként ellenőrzi az elemet a weboldalon, legfeljebb 30 másodpercig. Ha az elem ezen az időkereten belül található, akkor végrehajtja a műveleteket, különben egy "ElementNotVisibleException"
Ellenőrizze még:- Selenium IDE oktatóanyag kezdőknek
Különbség az implicit várakozás és az explicit várakozás között
Az alábbiakban bemutatjuk a fő különbséget az implicit várakozás és az explicit várakozás között Selenium:
| Implicit várakozás | Kifejezett várakozás |
|---|---|
| Az implicit várakozási idő a szkript összes elemére vonatkozik | Az explicit várakozási idő csak az általunk tervezett elemekre vonatkozik |
| Az implicit várakozásban szükségünk van nem adja meg az „ExpectedConditions”-t a keresendő elemen | Az Explicit Wait-ben meg kell adnunk az „ExpectedConditions”-t a keresendő elemen |
| Használata akkor javasolt, ha az elemek a pontban meghatározott időkerettel helyezkednek el Selenium implicit várakozás | Használata akkor javasolt, ha az elemek betöltése sokáig tart, valamint az elem tulajdonságainak ellenőrzésére is, mint például (visibilityOfElementLocated, elementToBeClickable,elementToBeSelected) |
Következtetés
Az Implicit, Explicit és Fluent Wait a különböző várakozások Selenium. Ezeknek a várakozásoknak a felhasználása teljes mértékben a különböző időközönként betöltött elemeken alapul. Mindig nem ajánlott a Thread.Sleep() használata while Tesztelés alkalmazásunk vagy keretünk felépítése.
Ellenőrizze még:- Selenium Oktatóanyag kezdőknek: Tanulja meg a WebDrivert 7 nap alatt
