Selenium Vänta – implicit och explicit med syntax
Krishna Rungta
In Selenium, "Väntar" spelar en viktig roll för att utföra tester. I den här handledningen kommer du att lära dig olika aspekter och skillnaden mellan implicit och explicit vänta in Selenium.
Varför behöver vi väntan Selenium?
De flesta webbapplikationer är utvecklade med hjälp av Ajax och Javascript. När en sida laddas av webbläsaren kan elementen som vi vill interagera med laddas med olika tidsintervall.
Det gör det inte bara svårt att identifiera elementet utan även om elementet inte finns kommer det att kasta ett "ElementNotVisibleException" undantag. Använder sig av Selenium Vänta, vi kan lösa det här problemet.
Låt oss överväga ett scenario där vi måste använda både implicita och explicita väntetider i vårt test. Antag att den implicita väntetiden är inställd på 20 sekunder och den explicita väntetiden är inställd på 10 sekunder.
Anta att vi försöker hitta ett element som har några "Förväntade villkor "(Explicit Wait), om elementet inte är lokaliserat inom tidsramen som definieras av Explicit wait (10 sekunder), kommer det att använda tidsramen som definieras av implicit wait (20 sekunder) innan det kastar en "ElementNotVisibleException".
Selenium Webbdrivrutin väntar
- Implicit vänta
- Explicit vänta
I den här handledningen kommer du att lära dig om olika typer av väntetider Selenium:
Implicit Vänta in Selenium
Ocuco-landskapet Implicit Vänta in Selenium används för att säga åt webbdrivrutinen att vänta en viss tid innan den skickar ett "Inget sådant elementundantag". Standardinställningen är 0. När vi väl har ställt in tiden, väntar webbdrivrutinen på elementet för den tiden innan ett undantag görs.
Selenium Web Driver har lånat idén om implicita väntetider från Watir.
I exemplet nedan har vi deklarerat en implicit väntan med tidsramen på 10 sekunder. Det betyder att om elementet inte finns på webbsidan inom den tidsramen kommer det att skapa ett undantag.
För att förklara implicit vänta in Selenium WebDriver:
Implicit vänta-syntax:
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();
}
}
Förklaring av koden
I exemplet ovan,
Överväg följande kod:
driver.manage().timeouts().implicitlyWait(10,TimeUnit.SECONDS) ;
Implicit wait kommer att acceptera 2 parametrar, den första parametern accepterar tiden som ett heltalsvärde och den andra parametern kommer att acceptera tidsmätningen i termer av SEKUNDER, MINUTTER, MILISEKUND, MIKROSECONDS, NANOSECONDS, DAYS, HOURS, etc.
Explicit Vänta in Selenium
Ocuco-landskapet Explicit Vänta in Selenium används för att tala om för webbdrivrutinen att vänta på vissa villkor (förväntade villkor) eller maximal tid överskriden innan undantaget "ElementNotVisibleException" skapas. Det är en intelligent typ av väntan, men den kan endast användas för specificerade element. Det ger bättre alternativ än implicit väntan när det väntar på dynamiskt laddade Ajax-element.
När vi deklarerar explicit väntan måste vi använda "Förväntade villkor” eller så kan vi konfigurera hur ofta vi vill kontrollera tillståndet med hjälp av Flytande vänta. Dessa dagar under implementeringen använder vi Thread.Sleep() i allmänhet rekommenderas det inte att använda
I exemplet nedan skapar vi referensvänta för "WebDriverWait" klass och instansiera med "webbdrivrutin” referens, och vi ger en maximal tidsram på 20 sekunder.
Explicit vänta-syntax:
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();
}
}
Förklaring av koden
Överväg följande kod:
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 det här WebDriver-väntexemplet väntar du på den tid som definieras i "WebDriverWait" klassen eller "Förväntade villkor” att inträffa vilket som inträffar först.
Ovanstående Java koden anger att vi väntar på ett element under tidsramen på 20 sekunder som definieras i "WebDriverWait" på webbsidan tills "Förväntade villkor" är uppfyllda och villkoret är "synlighet avElementLocated".
Följande är de förväntade villkoren som kan användas i Selenium Explicit vänta
- alertIsPresent()
- elementSelectionStateToBe()
- elementToBeClickable()
- elementToBeSelected()
- frameToBeAvaliableAndSwitchToIt()
- invisibilityOfTheElementLocated()
- invisibilityOfElementWithText()
- presenceOfAllElementsLocatedBy()
- närvaroOfElementLocated()
- textToBePresentInElement()
- textToBePresentInElementLocated()
- textToBePresentInElementValue()
- titleIs()
- titleContains()
- visibilityOf()
- visibilityOfAllElements()
- visibilityOfAllElementsLocatedBy()
- visibilityOfElementLocated()
Flytande Vänta in Selenium
Ocuco-landskapet Flytande Vänta in Selenium används för att definiera maximal tid för webbdrivrutinen att vänta på ett tillstånd, samt med vilken frekvens vi vill kontrollera tillståndet innan vi kastar ett "ElementNotVisibleException"-undantag. Den söker efter webbelementet med jämna mellanrum tills objektet hittas eller timeout inträffar.
Frekvens: Ställa in en upprepad cykel med tidsramen för att verifiera/kontrollera tillståndet med regelbundna tidsintervall
Låt oss överväga ett scenario där ett element laddas med olika tidsintervall. Elementet kan laddas inom 10 sekunder, 20 sekunder eller till och med mer än om vi deklarerar en explicit väntan på 20 sekunder. Det kommer att vänta till den angivna tiden innan ett undantag görs. I sådana scenarier är den flytande väntan den idealiska väntan att använda eftersom denna kommer att försöka hitta elementet med en annan frekvens tills det hittar det eller den slutliga timern går ut.
Fluent Wait-syntax:
Wait wait = new FluentWait(WebDriver reference) .withTimeout(timeout, SECONDS) .pollingEvery(timeout, SECONDS) .ignoring(Exception.class);
Ovanstående kod är utfasad i Selenium v3.11 och senare. Du måste använda
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() ;
}
}
Förklaring av koden
Överväg följande kod:
Wait<WebDriver> wait = new FluentWait<WebDriver>(driver) .withTimeout(30, TimeUnit.SECONDS) .pollingEvery(5, TimeUnit.SECONDS) .ignoring(NoSuchElementException.class);
I exemplet ovan förklarar vi en flytande väntetid med timeout på 30 sekunder och frekvensen är inställd på 5 sekunder genom att ignorera "NoSuchElementException"
Överväg följande kod:
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 skapat en ny funktion för att identifiera webbelementet på sidan. (Ex: Här är webbelementet inget annat än Selenium länk på webbsidan).
Frekvensen är inställd på 5 sekunder och maxtiden är inställd på 30 sekunder. Detta betyder alltså att den kommer att leta efter elementet på webbsidan var 5:e sekund under den maximala tiden på 30 sekunder. Om elementet är lokaliserat inom denna tidsram kommer det att utföra operationerna annars kommer det att skicka ett "ElementNotVisibleException"
Kontrollera också: - Selenium IDE-handledning för nybörjare
Skillnaden mellan implicit väntan och explicit väntan
Följande är huvudskillnaden mellan implicit väntan och explicit väntan Selenium:
| Implicit vänta | Explicit vänta |
|---|---|
| Implicit väntetid tillämpas på alla element i skriptet | Explicit väntetid tillämpas endast på de element som är avsedda av oss |
| I Implicit Wait behöver vi inte ange "ExpectedConditions" på elementet som ska lokaliseras | I Explicit Wait måste vi ange "ExpectedConditions" på elementet som ska lokaliseras |
| Det rekommenderas att använda när elementen är placerade med den tidsram som anges i Selenium implicit vänta | Det rekommenderas att använda när elementen tar lång tid att ladda och även för att verifiera egenskapen för elementet like(visibilityOfElementLocated, elementToBeClickable,elementToBeSelected) |
Slutsats
Implicit, Explicit och Fluent Wait är de olika väntan som används i Selenium. Användningen av dessa väntar är helt baserad på de element som laddas med olika tidsintervall. Det rekommenderas alltid inte att använda Thread.Sleep() while Testning vår applikation eller bygga vårt ramverk.
Kontrollera också: - Selenium Handledning för nybörjare: Lär dig WebDriver på 7 dagar
