Selenium Warten – implizit und explizit mit Syntax
Krishna Runta
In Selenium, „Waits“ spielen eine wichtige Rolle bei der Durchführung von Tests. In diesem Tutorial lernen Sie verschiedene Aspekte und Unterschiede zwischen implizitem und explizitem Warten kennen Selenium.
Warum brauchen wir Wartezeiten? Selenium?
Die meisten Webanwendungen werden mit entwickelt Ajax und Javascript. Wenn eine Seite vom Browser geladen wird, werden die Elemente, mit denen wir interagieren möchten, möglicherweise in unterschiedlichen Zeitintervallen geladen.
Dies erschwert nicht nur die Identifizierung des Elements, sondern wirft auch eine Fehlermeldung aus, wenn das Element nicht gefunden wird:ElementNotVisibleException" Ausnahme. Benutzen Selenium Warten Sie, wir können dieses Problem lösen.
Betrachten wir ein Szenario, in dem wir in unserem Test sowohl implizite als auch explizite Wartezeiten verwenden müssen. Gehen Sie davon aus, dass die implizite Wartezeit auf 20 Sekunden und die explizite Wartezeit auf 10 Sekunden eingestellt ist.
Angenommen, wir versuchen, ein Element zu finden, das welche hat „Erwartete Bedingungen „(Explizites Warten), Wenn sich das Element nicht innerhalb des durch die explizite Wartezeit (10 Sekunden) definierten Zeitrahmens befindet, wird der durch die implizite Wartezeit (20 Sekunden) definierte Zeitrahmen verwendet, bevor ein „ElementNotVisibleException".
Selenium Web-Treiber wartet
- Implizites Warten
- Explizites Warten
In diesem Tutorial erfahren Sie mehr über verschiedene Arten von Wartezeiten Selenium:
Implizites Warten Selenium
Das Implizites Warten Selenium wird verwendet, um dem Webtreiber mitzuteilen, dass er eine bestimmte Zeit warten soll, bevor er eine Ausnahme „Kein solches Element“ ausgibt. Die Standardeinstellung ist 0. Sobald wir die Zeit eingestellt haben, wartet der Webtreiber diese Zeit auf das Element, bevor er eine Ausnahme ausgibt.
Selenium Web Driver hat die Idee des impliziten Wartens übernommen Watir.
Im folgenden Beispiel haben wir eine implizite Wartezeit mit einem Zeitrahmen von 10 Sekunden deklariert. Das bedeutet, dass eine Ausnahme ausgelöst wird, wenn das Element innerhalb dieses Zeitraums nicht auf der Webseite gefunden wird.
Implizites Warten deklarieren Selenium WebDriver:
Implizite Wait-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();
}
}
Erklärung des Codes
Im obigen Beispiel ist
Beachten Sie den folgenden Code:
driver.manage().timeouts().implicitlyWait(10,TimeUnit.SECONDS) ;
Implizites Warten akzeptiert zwei Parameter: Der erste Parameter akzeptiert die Zeit als Ganzzahlwert und der zweite Parameter akzeptiert die Zeitmessung in SEKUNDEN, MINUTEN, MILISEKUNDEN, MIKROSEKUNDEN, NANOSEKUNDEN, TAGEN, STUNDEN usw.
Explizites Warten Selenium
Das Explizites Warten Selenium wird verwendet, um dem Webtreiber mitzuteilen, dass er auf bestimmte Bedingungen (erwartete Bedingungen) oder eine Überschreitung der maximalen Zeit warten soll, bevor die Ausnahme „ElementNotVisibleException“ ausgelöst wird. Dies ist eine intelligente Art des Wartens, kann jedoch nur für bestimmte Elemente angewendet werden. Es bietet bessere Optionen als implizites Warten, da es auf dynamisch geladene Ajax-Elemente wartet.
Sobald wir explizites Warten deklarieren, müssen wir „Erwartete Bedingungen” oder wir können konfigurieren, wie oft wir den Zustand überprüfen möchten Fließend warten. Heutzutage verwenden wir bei der Implementierung Thread.Sleep() Im Allgemeinen wird die Verwendung nicht empfohlen
Im folgenden Beispiel erstellen wir eine Referenzwartezeit für „WebDriverWarten”-Klasse und Instanziierung mit „WebTreiber” Referenz, und wir geben einen maximalen Zeitrahmen von 20 Sekunden an.
Explizite Warte-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();
}
}
Erklärung des Codes
Beachten Sie den folgenden Code:
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();
Warten Sie in diesem WebDriver-Wartebeispiel die in „WebDriverWarten” Klasse oder die „Erwartete Bedingungen” tritt ein, je nachdem, was zuerst eintritt.
Die obige Java Der Code besagt, dass wir für den Zeitraum von 20 Sekunden auf ein Element warten, wie im „WebDriverWarten”-Klasse auf der Webseite, bis das „Erwartete Bedingungen” sind erfüllt und die Bedingung ist „SichtbarkeitvonElementLocation".
Im Folgenden sind die erwarteten Bedingungen aufgeführt, die verwendet werden können in Selenium Explizites Warten
- alarmIsPresent()
- elementSelectionStateToBe()
- elementToBeClickable()
- elementToBeSelected()
- frameToBeAvaliableAndSwitchToIt()
- invisibilityOfTheElementLocated()
- invisibilityOfElementWithText()
- presentOfAllElementsLocatedBy()
- presentOfElementLocated()
- textToBePresentInElement()
- textToBePresentInElementLocated()
- textToBePresentInElementValue()
- titleIs()
- titleContains()
- SichtbarkeitOf()
- VisibilityOfAllElements()
- VisibilityOfAllElementsLocationBy()
- sichtbarkeitOfElementLocated()
Fließend warten Selenium
Das Fließend warten Selenium wird verwendet, um die maximale Zeit zu definieren, die der Webtreiber auf eine Bedingung warten soll, sowie die Häufigkeit, mit der wir die Bedingung überprüfen möchten, bevor eine Ausnahme „ElementNotVisibleException“ ausgelöst wird. Es prüft in regelmäßigen Abständen, ob das Webelement gefunden wurde, bis das Objekt gefunden wird oder ein Timeout auftritt.
Frequenz: Einrichten eines Wiederholungszyklus mit dem Zeitrahmen, um den Zustand in regelmäßigen Zeitintervallen zu überprüfen/überprüfen
Betrachten wir ein Szenario, in dem ein Element in unterschiedlichen Zeitabständen geladen wird. Das Element kann innerhalb von 10 Sekunden, 20 Sekunden oder sogar noch länger geladen werden, wenn wir eine explizite Wartezeit von 20 Sekunden deklarieren. Es wird bis zur angegebenen Zeit gewartet, bevor eine Ausnahme ausgelöst wird. In solchen Szenarien ist die flüssige Wartezeit die ideale Wartezeit, da diese versucht, das Element in unterschiedlichen Intervallen zu finden, bis es gefunden wird oder der letzte Timer abgelaufen ist.
Fluent Wait-Syntax:
Wait wait = new FluentWait(WebDriver reference) .withTimeout(timeout, SECONDS) .pollingEvery(timeout, SECONDS) .ignoring(Exception.class);
Der obige Code ist veraltet Selenium v3.11 und höher. Sie müssen verwenden
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() ;
}
}
Erklärung des Codes
Beachten Sie den folgenden Code:
Wait<WebDriver> wait = new FluentWait<WebDriver>(driver) .withTimeout(30, TimeUnit.SECONDS) .pollingEvery(5, TimeUnit.SECONDS) .ignoring(NoSuchElementException.class);
Im obigen Beispiel deklarieren wir ein fließendes Warten mit einer Zeitüberschreitung von 30 Sekunden und die Häufigkeit wird durch Ignorieren von „ auf 5 Sekunden festgelegt.NoSuchElementException"
Beachten Sie den folgenden Code:
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"));
Wir haben eine neue Funktion erstellt, um das Webelement auf der Seite zu identifizieren. (Beispiel: Hier ist Web Element nichts anderes als das Selenium Link auf der Webseite).
Die Frequenz ist auf 5 Sekunden und die maximale Zeit auf 30 Sekunden eingestellt. Das bedeutet, dass alle 5 Sekunden für die maximale Zeit von 30 Sekunden nach dem Element auf der Webseite gesucht wird. Wenn sich das Element innerhalb dieses Zeitrahmens befindet, werden die Operationen ausgeführt, andernfalls wird eine Meldung ausgegeben:ElementNotVisibleException"
Überprüfen Sie auch: - Selenium IDE-Tutorial für Anfänger
Unterschied zwischen implizitem und explizitem Warten
Der Hauptunterschied zwischen implizitem und explizitem Warten ist folgender: Selenium:
| Implizites Warten | Explizites Warten |
|---|---|
| Die implizite Wartezeit wird auf alle Elemente im Skript angewendet | Die explizite Wartezeit wird nur auf die von uns beabsichtigten Elemente angewendet |
| Im impliziten Warten brauchen wir nicht Geben Sie „ExpectedConditions“ für das zu suchende Element an | Beim expliziten Warten müssen wir „ExpectedConditions“ für das zu suchende Element angeben |
| Die Verwendung wird empfohlen, wenn die Elemente innerhalb des in angegebenen Zeitrahmens lokalisiert werden Selenium implizites warten | Die Verwendung wird empfohlen, wenn das Laden der Elemente lange dauert und auch zur Überprüfung der Eigenschaften des Elements wie (visibilityOfElementLocated, elementToBeClickable,elementToBeSelected) |
Fazit
Implizites, explizites und fließendes Warten sind die verschiedenen Wartezeiten, die in verwendet werden Selenium. Die Verwendung dieser Wartezeiten basiert vollständig auf den Elementen, die in unterschiedlichen Zeitintervallen geladen werden. Es wird immer davon abgeraten, Thread.Sleep() while zu verwenden Testen unsere Anwendung oder den Aufbau unseres Frameworks.
Überprüfen Sie auch: - Selenium Tutorial für Anfänger: Erlernen Sie WebDriver in 7 Tagen
