Implizites und explizites Warten in Selenium mit Syntax

In Selenium„Wartebefehle“ spielen eine wichtige Rolle bei der Durchführung zuverlässiger Tests. In diesem Tutorial lernen Sie die wichtigsten Aspekte und Unterschiede zwischen impliziten und expliziten Wartebefehlen kennen. Selenium, zusammen mit praktischen Hinweisen zur Verwendung von Fluent Wait.

Warum brauchen wir Wartezeiten? Selenium?

Die meisten modernen Webanwendungen werden entwickelt mit Ajax und JavaSkriptWenn eine Seite vom Browser geladen wird, können die Elemente, mit denen wir interagieren möchten, in unterschiedlichen Zeitabständen geladen werden.

Dies erschwert nicht nur die Identifizierung des Elements, sondern führt auch dazu, dass, wenn das Element nicht rechtzeitig lokalisiert wird, Selenium wird ein werfen ElementNotVisibleException. Selenium Durch Wartezeiten wird dieses Synchronisierungsproblem gelöst, indem dem WebDriver ein definiertes Zeitfenster zur Verfügung gestellt wird, in dem er ein Element finden kann, bevor ein Fehler auftritt.

Betrachten wir ein Szenario, in dem implizite und explizite Wartezeiten im selben Test verwendet werden. Angenommen, die implizite Wartezeit ist auf 20 Sekunden und die explizite Wartezeit auf 10 Sekunden festgelegt.

Wenn wir nach einem Element suchen, das bestimmten Gesetzen unterliegt Erwartete Bedingungen (Explizites Warten) und sich das Element nicht innerhalb des expliziten Zeitfensters von 10 Sekunden befindet, greift der WebDriver auf das implizite Zeitfenster von 20 Sekunden zurück, bevor er eine Ausnahme auslöst. ElementNotVisibleException.

Selenium WebDriver wartet

1. Implizites Warten
2. Explizites Warten
3. Fließend warten

Implizites Warten Selenium

Das Implizites Warten Selenium Weist den WebDriver an, eine definierte Zeitspanne abzuwarten, bevor eine NoSuchElementException ausgelöst wird. Der Standardwert ist 0. Nach der Konfiguration prüft der WebDriver das DOM während dieser Zeitspanne, bevor er einen Fehler ausgibt. Selenium WebDriver hat das Konzept der impliziten Wartezeiten von Watir.

Im folgenden Beispiel deklarieren wir eine implizite Wartezeit von 10 Sekunden. Befindet sich das Element nicht innerhalb dieses Zeitfensters, wird eine Ausnahme ausgelöst.

Implizite Wartesyntax (Selenium 4):

driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));

package guru.test99;
import java.time.Duration;
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 {
        driver = new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
        String eTitle = "Demo Guru99 Page";
        String aTitle = "";
        // launch Chrome and redirect it to the Base URL
        driver.get("https://demo.guru99.com/test/guru99home/");
        // Maximize 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 von Code

Betrachten Sie im obigen Beispiel die folgende Aussage:

driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));

Selenium Version 4 ersetzte die ältere Signatur mit zwei Argumenten (Ganzzahl plus Zeiteinheit) durch ein einzelnes Duration-Argument. Die Duration-Klasse unterstützt Sekunden, Minuten, Millisekunden und andere Zeiteinheiten durch statische Hilfsmethoden wie Duration.ofSeconds, Duration.ofMillis und Duration.ofMinutes.

Explizites Warten Selenium

Das Explizites Warten Selenium Weist den WebDriver an, auf bestimmte Bedingungen (Erwartete Bedingungen) oder eine maximale Dauer zu warten, bevor eine ElementNotVisibleException ausgelöst wird. Diese Wartezeit ist effizienter, da sie sich nur auf das angegebene Element bezieht. Explizites Warten ist implizitem Warten vorzuziehen, wenn der Test dynamisch geladene Ajax-Inhalte verarbeiten muss.

Sobald eine explizite Wartezeit deklariert wurde, müssen Sie verwenden Erwartete BedingungenAlternativ können Sie die Abfragehäufigkeit konfigurieren mit Fließend warten. Vermeide das Benutzen Thread.sleep()Da dies die Ausführung bedingungslos unterbricht und allgemein als schlechte Praxis gilt.

Im folgenden Beispiel erstellen wir eine Referenz auf die WebDriverWarten Klasse, instanziieren Sie sie mit der WebTreiber Referenz und konfigurieren Sie ein maximales Fenster von 20 Sekunden.

Explizite Wartesyntax (Selenium 4):

WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(20));

package guru.test99;

import java.time.Duration;
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 {
        driver = new ChromeDriver();
        WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(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/");
        // Maximize 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 von Code

Betrachten 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();

In diesem WebDriverWait-Beispiel wartet das Skript bis zu 20 Sekunden, wie durch die WebDriverWarten Klasse, bis die Erwartete Bedingungen sind erfüllt – je nachdem, welches Ereignis zuerst eintritt.

Die obige Java Der Code wartet bis zu 20 Sekunden auf die Bedingung. Sichtbarkeit des gefundenen Elements um wahr zu sein.

Folgende erwartete Bedingungen können verwendet werden in Selenium Explizites Warten:

1. alarmIsPresent()
2. elementSelectionStateToBe()
3. elementToBeClickable()
4. elementToBeSelected()
5. frameToBeAvailableAndSwitchToIt()
6. invisibilityOfTheElementLocated()
7. invisibilityOfElementWithText()
8. presentOfAllElementsLocatedBy()
9. presentOfElementLocated()
10. textToBePresentInElement()
11. textToBePresentInElementLocated()
12. textToBePresentInElementValue()
13. titleIs()
14. titleContains()
15. SichtbarkeitOf()
16. VisibilityOfAllElements()
17. VisibilityOfAllElementsLocationBy()
18. sichtbarkeitOfElementLocated()

Fließend warten Selenium

Das Fließend warten Selenium Definiert die maximale Wartezeit des WebDrivers auf eine Bedingung sowie die Abfragehäufigkeit zur Überprüfung dieser Bedingung, bevor eine ElementNotVisibleException ausgelöst wird. Fluent Wait prüft in regelmäßigen Abständen, ob das Element gefunden wurde oder das Timeout abgelaufen ist.

Frequenz: Der Wiederholungszyklus zur Beurteilung des Zustands in regelmäßigen Abständen.

Stellen Sie sich ein Szenario vor, in dem ein Element in unvorhersehbaren Abständen geladen wird. Das Laden kann beispielsweise 10 Sekunden, 20 Sekunden oder länger dauern. Wenn wir eine explizite Wartezeit von 20 Sekunden festlegen, wartet das Skript die gesamte Dauer ab, bevor es einen Fehler ausgibt. In solchen Fällen ist Fluent Wait die ideale Wahl, da es in der angegebenen Frequenz abfragt, bis das Element gefunden wurde oder der Timer abgelaufen ist.

Fluent Wait Syntax (Selenium 4):

Wait<WebDriver> wait = new FluentWait<>(driver)
    .withTimeout(Duration.ofSeconds(30))
    .pollingEvery(Duration.ofSeconds(5))
    .ignoring(NoSuchElementException.class);

Die ältere Signatur, die ganzzahlige Werte plus TimeUnit akzeptierte, wurde in Selenium 3.11 und entfernt in Selenium 4. Die oben dargestellte, auf der Dauer basierende API ist der aktuell empfohlene Ansatz.

package guru.test99;

import java.time.Duration;
import java.util.NoSuchElementException;
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.FluentWait;
import org.openqa.selenium.support.ui.Wait;
import org.testng.annotations.Test;

public class AppTest3 {
    protected WebDriver driver;

    @Test
    public void guru99tutorials() throws InterruptedException {
        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/");
        // Maximize 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<>(driver)
            .withTimeout(Duration.ofSeconds(30))
            .pollingEvery(Duration.ofSeconds(5))
            .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 von Code

Betrachten Sie den folgenden Code:

Wait<WebDriver> wait = new FluentWait<>(driver)
    .withTimeout(Duration.ofSeconds(30))
    .pollingEvery(Duration.ofSeconds(5))
    .ignoring(NoSuchElementException.class);

Im obigen Beispiel deklarieren wir eine Fluent Wait-Anweisung mit einem Timeout von 30 Sekunden, einer Abfragefrequenz von 5 Sekunden und ignorieren NoSuchElementException.

Betrachten 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"));
}

Diese Funktion identifiziert das WebElement auf der Seite (hier das Selenium (Link auf der Startseite). Mit einem Abfrageintervall von 5 Sekunden und einem Timeout von 30 Sekunden prüft das Skript alle 5 Sekunden, ob das Element vorhanden ist, maximal jedoch 30 Sekunden lang. Befindet sich das Element innerhalb dieses Zeitraums, wird das Skript fortgesetzt. Andernfalls wird ein Fehler behoben. ElementNotVisibleException ist geworfen.

Überprüfen Sie auch: Selenium IDE-Tutorial für Anfänger

Unterschied zwischen implizitem und explizitem Warten

Die folgende Tabelle hebt die wichtigsten Unterschiede zwischen implizitem und explizitem Warten hervor. Selenium.

Implizites Warten	Explizites Warten
Die implizite Wartezeit wird auf alle Elemente im Skript angewendet.	Die explizite Wartezeit wird nur auf die explizit ausgewählten Elemente angewendet.
Bei implizitem Warten werden keine Erwarteten Bedingungen für das Element angegeben.	Bei explizitem Warten müssen ExpectedConditions für das Element definiert werden.
Empfohlen, wenn Elemente innerhalb des konfigurierten impliziten Wartefensters geladen werden.	Empfohlen, wenn Elemente länger zum Laden benötigen und wenn Elementzustände wie visibilityOfElementLocated, elementToBeClickable oder elementToBeSelected überprüft werden.
Einmal festgelegt und für den gesamten Lebenszyklus der WebDriver-Instanz angewendet.	Einstellen pro Element oder pro Prüfung für eine feinere Steuerung.

Wie man die richtige Wartezeitstrategie auswählt

Die Wahl des richtigen Wartebefehls hat direkten Einfluss auf die Stabilität und Ausführungszeit des Skripts. Nutzen Sie dieses Entscheidungsmodell, um für jedes Szenario die passende Option auszuwählen.

1. Lastmuster ermitteln: Prüfen Sie, ob das Element zu einem festen Zeitpunkt, nach einer Ajax-Antwort oder in unvorhersehbaren Abständen erscheint. Feste Lasten eignen sich für Implicit Wait, während unvorhersehbare Lasten Fluent Wait erfordern.
2. Vermeiden Sie die Vermischung von impliziten und expliziten Wartezeiten: Die Kombination beider Faktoren kann zu unerwarteten Verzögerungen führen, da die längere Wartezeit überwiegen kann. Selenium Die Dokumentation empfiehlt, pro WebDriver-Sitzung nur eine Strategie zu verwenden.
3. Standardmäßig auf „Explizit warten“ eingestellt: Wenn Seiten von Ajax, bedingtem Rendering oder Animationen abhängen, zielt Explicit Wait mit ExpectedConditions genau auf das relevante Element ab.
4. Verwenden Sie Fluent Wait für variable Zeitsteuerung: Wenn die Ladezeiten von Elementen zwischen den Durchläufen variieren, konfigurieren Sie Fluent Wait mit einem Abfrageintervall. Die Abfrage reduziert die gesamte Wartezeit im Vergleich zu einem einzelnen langen Timeout.
5. Ersetze Thread.sleep: Fest codierte Wartezeiten verlangsamen Testreihen und verschleiern tatsächliche Timing-Probleme. Ersetzen Sie diese durch bedingte Wartezeiten, um eine schnelle und deterministische Ausführung zu gewährleisten.
6. Timeout-Werte anpassen: Beginnen Sie mit kurzen Timeouts (5–10 Sekunden) und erhöhen Sie diese erst, wenn Fehler auf eine tatsächliche geringe Last hinweisen. Lange Standard-Timeouts verschleiern Leistungseinbußen.
7. Wartezeiten in Hilfsfunktionen beibehalten: Die Wartelogik sollte in einer Hilfsklasse zentralisiert werden, damit Änderungen der Timeout-Richtlinie für die gesamte Testsuite gelten.

Durch die Anwendung dieses Frameworks können Automatisierungsingenieure robuste Skripte erstellen, die sich an das tatsächliche Timing von Anwendungen anpassen, ohne langsam oder fehleranfällig zu werden.

Häufige Fehler, die Sie vermeiden sollten Selenium Wartet

Selbst erfahrene Tester tappen bei der Arbeit mit einigen wiederkehrenden Fehlern. Selenium Wartezeiten. Durch die Vermeidung dieser Probleme bleiben Skripte schnell, deterministisch und einfach zu warten – team- und umgebungsübergreifend.

Der erste häufige Fehler ist die übermäßige Verwendung von `Thread.sleep`. Eine fest codierte Pause zwingt das Skript, unabhängig von der tatsächlichen Verfügbarkeit der Elemente die volle Dauer abzuwarten, was die Gesamtlaufzeit unnötig verlängert. Ersetzen Sie solche Pausen durch `Explicit Wait` oder `Fluent Wait`, damit das Skript fortfährt, sobald die Bedingung erfüllt ist.

Der zweite Fehler besteht darin, implizite und explizite Wartezeiten im selben Test zu vermischen. Die beiden Mechanismen können sich gegenseitig verstärken und zu unvorhersehbaren Timeouts führen, die schwer zu debuggen sind. Wählen Sie pro WebDriver-Sitzung eine Strategie und wenden Sie diese konsequent an.

Ein dritter Fehler besteht darin, Timeouts „vorsichtshalber“ zu hoch anzusetzen. Lange Standard-Timeouts verschleiern tatsächliche Leistungsprobleme und verlangsamen das Feedback in Continuous-Integration-Pipelines. Beginnen Sie mit kurzen Timeouts und verlängern Sie diese erst, wenn Fehlerprotokolle ein tatsächliches Timing-Problem belegen.

Überprüfen Sie auch: Selenium Tutorial für Anfänger: Erlernen Sie WebDriver in 7 Tagen

Häufig gestellte Fragen