In Selen spielen "Wartezeiten" eine wichtige Rolle bei der Durchführung von Tests. In diesem Tutorial lernen Sie verschiedene Aspekte von "impliziten" und "expliziten" Wartezeiten in Selen kennen.
In diesem Tutorial lernen Sie:
- Warum brauchen wir Wartezeiten in Selen?
- Implizites Warten
- Explizites Warten
- Fließend warten
Warum brauchen wir Wartezeiten in Selen?
Die meisten Webanwendungen werden mit Ajax und Javascript entwickelt. 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 löst auch eine Ausnahme " ElementNotVisibleException " aus, wenn das Element nicht gefunden wird . Mit Selenium Waits können wir dieses Problem lösen.
Betrachten wir ein Szenario, in dem wir in unserem Test sowohl implizite als auch explizite Wartezeiten verwenden müssen. Angenommen, die implizite Wartezeit ist auf 20 Sekunden und die explizite Wartezeit auf 10 Sekunden festgelegt.
Angenommen, wir versuchen, ein Element mit einigen "ExpectedConditions " (explizites Warten) zu finden. Wenn sich das Element nicht innerhalb des durch das explizite Warten (10 Sekunden) definierten Zeitrahmens befindet, wird der durch implizites Warten definierte Zeitrahmen verwendet ( 20 Sekunden) vor dem Auslösen einer " ElementNotVisibleException ".
Selenium Web Driver wartet
- Implizites Warten
- Explizites Warten
Implizites Warten in Selen
Das implizite Warten in Selen wird verwendet, um den Webtreiber anzuweisen, eine bestimmte Zeit zu warten, bevor eine "Keine solche Elementausnahme" ausgelöst wird. Die Standardeinstellung ist 0. Sobald wir die Zeit eingestellt haben, wartet der Webtreiber für diese Zeit auf das Element, bevor er eine Ausnahme auslöst.
Selenium Web Driver hat die Idee impliziter Wartezeiten von Watir übernommen.
Im folgenden Beispiel haben wir eine implizite Wartezeit mit einem Zeitrahmen von 10 Sekunden angegeben. Dies bedeutet, dass eine Ausnahme ausgelöst wird, wenn sich das Element innerhalb dieses Zeitraums nicht auf der Webseite befindet.
So erklären Sie implizites Warten:
Syntax :
driver.manage (). timeouts (). implicitlyWait (TimeOut, TimeUnit.SECONDS);
Paket 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;öffentliche Klasse AppTest {geschützter WebDriver-Treiber;@Prüfungpublic void guru99tutorials () löst InterruptedException aus{System.setProperty ("webdriver.chrome.driver", ". \\ chromedriver.exe");Treiber = neuer ChromeDriver ();driver.manage (). timeouts (). implicitlyWait (10, TimeUnit.SECONDS);String eTitle = "Demo Guru99 Page";String aTitle = "";// Chrome starten und zur Basis-URL umleitendriver.get ("http://demo.guru99.com/test/guru99home/");// Maximiert das Browserfensterdriver.manage (). window (). maxim ();// den tatsächlichen Wert des Titels abrufenaTitle = driver.getTitle ();// Vergleiche den tatsächlichen Titel mit dem erwarteten Titelif (aTitle.equals (eTitle)){System.out.println ("Test bestanden");}}sonst {System.out.println ("Test fehlgeschlagen");}}// Browser schließendriver.close ();}}}}
Erklärung des Codes
Im obigen Beispiel ist
Beachten Sie den folgenden Code:
driver.manage (). timeouts (). implicitlyWait (10, TimeUnit.SECONDS);
Das implizite Warten akzeptiert 2 Parameter, der erste Parameter akzeptiert die Zeit als ganzzahligen Wert und der zweite Parameter akzeptiert die Zeitmessung in Sekunden, Minuten, Meilen, Mikrosekunden, Nanosekunden, Tagen, Stunden usw.
Explizites Warten in Selen
Das explizite Warten in Selen wird verwendet, um den Webtreiber anzuweisen, auf bestimmte Bedingungen (erwartete Bedingungen) oder die maximale Zeit zu warten, die überschritten wurde, bevor die Ausnahme "ElementNotVisibleException" ausgelöst wird. Es 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 " ExpectedConditions " verwenden oder wir können konfigurieren, wie oft wir den Zustand mit Fluent Wait überprüfen möchten . Heutzutage verwenden wir während der Implementierung Thread.Sleep (). Es wird generell nicht empfohlen, Thread.Sleep () zu verwenden
Im folgende Beispiel, schaffen wir Referenzwartezeit für „ WebDriverWait “ -Klasse und Instantiieren „unter Verwendung von WebDriver “ Referenz, und wir einen maximalen Zeitrahmen von 20 Sekunden ergeben.
Syntax:
WebDriverWait wait = new WebDriverWait (WebDriverRefrence, TimeOut);
Paket 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;öffentliche Klasse AppTest2 {geschützter WebDriver-Treiber;@Prüfungpublic void guru99tutorials () löst InterruptedException aus{System.setProperty ("webdriver.chrome.driver", ". \\ chromedriver.exe");Treiber = neuer ChromeDriver ();WebDriverWait wait = new WebDriverWait (Treiber, 20);String eTitle = "Demo Guru99 Page";String aTitle = "";// Chrome starten und zur Basis-URL umleitendriver.get ("http://demo.guru99.com/test/guru99home/");// Maximiert das Browserfensterdriver.manage (). window (). maxim ();// den tatsächlichen Wert des Titels abrufenaTitle = driver.getTitle ();// Vergleiche den tatsächlichen Titel mit dem erwarteten Titelif (aTitle.contentEquals (eTitle)){System.out.println ("Test bestanden");}}sonst {System.out.println ("Test fehlgeschlagen");}}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, bis die in der Klasse " WebDriverWait " oder in den " ExpectedConditions " definierte Zeitspanne eintritt, je nachdem, was zuerst eintritt.
Der obige Java-Code besagt, dass wir auf ein Element für den Zeitraum von 20 Sekunden warten, wie in der Klasse " WebDriverWait " auf der Webseite definiert, bis die " ExpectedConditions " erfüllt sind und die Bedingung " Sichtbarkeit von ElementLocated " lautet .
Im Folgenden sind die erwarteten Bedingungen aufgeführt, die in Selenium Explicit Wait verwendet werden können
- alertIsPresent ()
- elementSelectionStateToBe ()
- elementToBeClickable ()
- elementToBeSelected ()
- frameToBeAvaliableAndSwitchToIt ()
- invisibilityOfTheElementLocated ()
- invisibilityOfElementWithText ()
- PresenceOfAllElementsLocatedBy ()
- PresenceOfElementLocated ()
- textToBePresentInElement ()
- textToBePresentInElementLocated ()
- textToBePresentInElementValue ()
- titleIs ()
- titleContains ()
- sichtbarkeit von ()
- sichtbarkeit von allElements ()
- sichtbarkeit von allElementsLocatedBy ()
- sichtbarkeitOfElementLocated ()
Fließendes Warten in Selen
Das fließende Warten in Selen wird verwendet, um die maximale Wartezeit des Webtreibers auf eine Bedingung sowie die Häufigkeit festzulegen, mit der die Bedingung überprüft werden soll, bevor eine "ElementNotVisibleException" -Ausnahme ausgelöst wird. In regelmäßigen Abständen wird nach dem Webelement gesucht, bis das Objekt gefunden wird oder eine Zeitüberschreitung auftritt.
Häufigkeit: Einrichten eines Wiederholungszyklus mit dem Zeitrahmen, um den Zustand im regulären Zeitintervall zu überprüfen / überprüfen
Betrachten wir ein Szenario, in dem ein Element in unterschiedlichen Zeitintervallen geladen wird. Das Element wird möglicherweise innerhalb von 10 Sekunden, 20 Sekunden oder sogar länger geladen, wenn eine explizite Wartezeit von 20 Sekunden angegeben wird. Es wird bis zur angegebenen Zeit gewartet, bevor eine Ausnahme ausgelöst wird. In solchen Szenarien ist das fließende Warten die ideale Wartezeit, da hierdurch versucht wird, das Element mit unterschiedlicher Häufigkeit zu finden, bis es gefunden wird oder der endgültige Timer abgelaufen ist.
Syntax:
Warten warten = neues FluentWait (WebDriver-Referenz).withTimeout (Timeout, SEKUNDEN).pollingEvery (Timeout, SEKUNDEN).ignoring (Exception.class);
Der obige Code ist in Selenium v3.11 und höher veraltet. Sie müssen verwenden
Warten warten = neues FluentWait (WebDriver-Referenz).withTimeout (Duration.ofSeconds (SEKUNDEN)).pollingEvery (Duration.ofSeconds (SEKUNDEN)).ignoring (Exception.class);
Paket 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;öffentliche Klasse AppTest3 {geschützter WebDriver-Treiber;@Prüfungpublic void guru99tutorials () löst InterruptedException aus{System.setProperty ("webdriver.chrome.driver", ". \\ chromedriver.exe");String eTitle = "Demo Guru99 Page";String aTitle = "";Treiber = neuer ChromeDriver ();// Chrome starten und zur Basis-URL umleitendriver.get ("http://demo.guru99.com/test/guru99home/");// Maximiert das Browserfensterdriver.manage (). window (). maxim ();// den tatsächlichen Wert des Titels abrufenaTitle = driver.getTitle ();// Vergleiche den tatsächlichen Titel mit dem erwarteten Titelif (aTitle.contentEquals (eTitle)){System.out.println ("Test bestanden");}}sonst {System.out.println ("Test fehlgeschlagen");}}Warten Sie wait = new FluentWait (Treiber).withTimeout (30, TimeUnit.SECONDS).pollingEvery (5, TimeUnit.SECONDS).ignoring (NoSuchElementException.class);WebElement clickseleniumlink = wait.until (neue Funktion () {public WebElement apply (WebDriver-Treiber) {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 "));}}});// Klicken Sie auf den Selen-Linkclickseleniumlink.click ();// ~ Browser schließendriver.close ();}}}}
Erklärung des Codes
Beachten Sie den folgenden Code:
Warten Siewait = new FluentWait (Treiber).withTimeout (30, TimeUnit.SECONDS).pollingEvery (5, TimeUnit.SECONDS).ignoring (NoSuchElementException.class);
Im obigen Beispiel erklären wir ein fließendes Warten mit einer Zeitüberschreitung von 30 Sekunden und die Frequenz wird auf 5 Sekunden eingestellt, indem " NoSuchElementException " ignoriert wird.
Beachten Sie den folgenden Code:
public WebElement apply (WebDriver-Treiber) {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 der Selenium-Link auf der Webseite).
Die Frequenz ist auf 5 Sekunden und die maximale Zeit auf 30 Sekunden eingestellt. Dies bedeutet, dass alle 5 Sekunden für die maximale Zeit von 30 Sekunden nach dem Element auf der Webseite gesucht wird. Befindet sich das Element innerhalb dieses Zeitrahmens, führt es die Operationen aus, andernfalls wird eine " ElementNotVisibleException " ausgelöst.
Unterschied zwischen implizitem Warten und explizitem Warten
| Implizites Warten | Explizites Warten |
|---|---|
|
|
|
|
|
|
Fazit:
Implizites, explizites und fließendes Warten sind die verschiedenen in Selen verwendeten Wartezeiten. Die Verwendung dieser Wartezeiten basiert vollständig auf den Elementen, die in unterschiedlichen Zeitintervallen geladen werden. Es wird immer nicht empfohlen, Thread.Sleep () zu verwenden, während Sie unsere Anwendung testen oder unser Framework erstellen.
Dieser Artikel wurde von Chaitanya Pujari verfasst