Selenium Vent – implicit, eksplicit og flydende ventetid
Krishna Rungta
In Selenium, "Venter" spiller en vigtig rolle ved udførelse af tests. I denne tutorial lærer du forskellige aspekter og forskellen mellem implicit og eksplicit wait in Selenium.
Hvorfor har vi brug for ventetider Selenium?
De fleste af webapplikationerne er udviklet vha Ajax og Javascript. Når en side indlæses af browseren, kan de elementer, vi ønsker at interagere med, indlæses med forskellige tidsintervaller.
Det gør det ikke kun vanskeligt at identificere elementet, men også, hvis elementet ikke er placeret, vil det kaste et "ElementNotVisibleException" undtagelse. Ved brug af Selenium Vent, vi kan løse dette problem.
Lad os overveje et scenario, hvor vi skal bruge både implicitte og eksplicitte ventetider i vores test. Antag, at implicit ventetid er indstillet til 20 sekunder, og eksplicit ventetid er indstillet til 10 sekunder.
Antag, at vi forsøger at finde et element, som har nogle "Forventede forhold "(Eksplicit ventetid), hvis elementet ikke er placeret inden for tidsrammen defineret af eksplicit ventetid (10 sekunder), vil det bruge tidsrammen defineret af implicit ventetid (20 sekunder), før det kaster en "ElementNotVisibleException".
Selenium Web-driver venter
- Implicit Vent
- Eksplicit Vent
I denne vejledning lærer du om forskellige typer ventetider Selenium:
Implicit Vent ind Selenium
Implicit Vent ind Selenium bruges til at fortælle webdriveren om at vente i et vist tidsrum, før den afgiver en "No Such Element Exception". Standardindstillingen er 0. Når vi har indstillet klokkeslættet, vil webdriveren vente på elementet for den tid, før den afgiver en undtagelse.
Selenium Web Driver har lånt ideen om implicit ventetid fra Watir.
I eksemplet nedenfor har vi erklæret en implicit ventetid med tidsrammen på 10 sekunder. Det betyder, at hvis elementet ikke er placeret på websiden inden for den tidsramme, vil det give en undtagelse.
At erklære implicit ventetid Selenium WebDriver:
Implicit ventesyntaks:
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();
}
}
Forklaring af kode
I ovenstående eksempel
Overvej følgende kode:
driver.manage().timeouts().implicitlyWait(10,TimeUnit.SECONDS) ;
Implicit ventetid vil acceptere 2 parametre, den første parameter vil acceptere tiden som en heltalværdi og den anden parameter vil acceptere tidsmålingen i form af SEKUNDER, MINUTTER, MILISEKUNDER, MIKROSEKUNDER, NANOSEKUNDER, DAGE, TIMER osv.
Eksplicit Vent ind Selenium
Eksplicit Vent ind Selenium bruges til at bede webdriveren om at vente på visse betingelser (forventede betingelser) eller maksimal tid overskredet, før du kaster "ElementNotVisibleException" undtagelse. Det er en intelligent form for ventetid, men den kan kun anvendes til bestemte elementer. Det giver bedre muligheder end implicit ventetid, mens det venter på dynamisk indlæste Ajax-elementer.
Når vi erklærer eksplicit ventetid, skal vi bruge "Forventede betingelser” eller vi kan konfigurere, hvor ofte vi vil kontrollere tilstanden vha Flydende Vent. Disse dage, mens vi implementerer, bruger vi Thread.Sleep() generelt anbefales det ikke at bruge
I eksemplet nedenfor opretter vi referencevent på "WebDriverWait" klasse og instansiering ved hjælp af "webdriver” reference, og vi giver en maksimal tidsramme på 20 sekunder.
Eksplicit Vent-syntaks:
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();
}
}
Forklaring af kode
Overvej følgende kode:
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();
I dette WebDriver-venteksempel skal du vente på den tid, der er defineret i "WebDriverWait" klasse eller "Forventede betingelser” at indtræffe, alt efter hvad der indtræffer først.
Ovenstående Java kode angiver, at vi venter på et element i tidsrammen på 20 sekunder som defineret i "WebDriverWait" klasse på websiden indtil "Forventede betingelser" er opfyldt, og betingelsen er "synlighed af Element Lokaliseret".
Følgende er de forventede betingelser, der kan bruges i Selenium Eksplicit Vent
- alertIsPresent()
- elementSelectionStateToBe()
- elementToBeClickable()
- elementToBeSelected()
- frameToBeAvaliableAndSwitchToIt()
- invisibilityOfTheElementLocated()
- invisibilityOfElementWithText()
- presenceOfAllElementsLocatedBy()
- presenceOfElementLocated()
- textToBePresentInElement()
- textToBePresentInElementLocated()
- textToBePresentInElementValue()
- titleIs()
- titelIndeholder()
- visibilityOf()
- visibilityOfAllElements()
- visibilityOfAllElementsLocatedBy()
- visibilityOfElementLocated()
Flydende Vent ind Selenium
Flydende Vent ind Selenium bruges til at definere den maksimale tid for webdriveren til at vente på en betingelse, samt den frekvens, hvormed vi ønsker at kontrollere tilstanden, før vi kaster en "ElementNotVisibleException"-undtagelse. Den tjekker for webelementet med jævne mellemrum, indtil objektet er fundet eller timeout sker.
Frekvens: Opsætning af en gentagelsescyklus med tidsrammen for at verificere/kontrollere tilstanden med det regelmæssige tidsinterval
Lad os overveje et scenarie, hvor et element indlæses med forskellige tidsintervaller. Elementet kan indlæses inden for 10 sekunder, 20 sekunder eller endnu mere end, hvis vi erklærer en eksplicit ventetid på 20 sekunder. Det vil vente til det angivne tidspunkt, før du kaster en undtagelse. I sådanne scenarier er den flydende ventetid den ideelle ventetid, da denne vil forsøge at finde elementet med en anden frekvens, indtil det finder det, eller den endelige timer løber ud.
Flydende ventesyntaks:
Wait wait = new FluentWait(WebDriver reference) .withTimeout(timeout, SECONDS) .pollingEvery(timeout, SECONDS) .ignoring(Exception.class);
Ovenstående kode er forældet i Selenium v3.11 og nyere. Du skal bruge
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() ;
}
}
Forklaring af kode
Overvej følgende kode:
Wait<WebDriver> wait = new FluentWait<WebDriver>(driver) .withTimeout(30, TimeUnit.SECONDS) .pollingEvery(5, TimeUnit.SECONDS) .ignoring(NoSuchElementException.class);
I ovenstående eksempel erklærer vi en flydende ventetid med timeout på 30 sekunder, og frekvensen er sat til 5 sekunder ved at ignorere "NoSuchElementException"
Overvej følgende kode:
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"));
Vi har oprettet en ny funktion til at identificere webelementet på siden. (Eks.: Her er webelementet intet andet end Selenium link på hjemmesiden).
Frekvensen er indstillet til 5 sekunder, og den maksimale tid er indstillet til 30 sekunder. Det betyder således, at den vil tjekke for elementet på websiden hvert 5. sekund i den maksimale tid på 30 sekunder. Hvis elementet er placeret inden for denne tidsramme, vil det udføre handlingerne, ellers vil det kaste et "ElementNotVisibleException"
Tjek også:- Selenium IDE Tutorial for begyndere
Forskellen mellem implicit ventetid og eksplicit ventetid
Følgende er hovedforskellen mellem implicit ventetid og eksplicit ventetid Selenium:
| Implicit Vent | Eksplicit Vent |
|---|---|
| Implicit ventetid anvendes på alle elementer i scriptet | Eksplicit ventetid anvendes kun på de elementer, som er tiltænkt af os |
| I Implicit Vent, vi har brug for ikke angiv "ExpectedConditions" på det element, der skal lokaliseres | I Explicit Wait skal vi angive "ExpectedConditions" på det element, der skal lokaliseres |
| Det anbefales at bruge, når elementerne er placeret med den tidsramme, der er angivet i Selenium implicit ventetid | Det anbefales at bruge, når elementerne tager lang tid at indlæse, og også til at verificere egenskaben for elementet som(visibilityOfElementLocated, elementToBeClickable,elementToBeSelected) |
Konklusion
Implicit, Explicit og Fluent Wait er de forskellige ventetider, der bruges i Selenium. Brugen af disse ventetider er fuldstændig baseret på de elementer, der indlæses med forskellige tidsintervaller. Det anbefales altid ikke at bruge Thread.Sleep() mens Test vores applikation eller opbygning af vores rammer.
Tjek også:- Selenium Tutorial for begyndere: Lær WebDriver på 7 dage
