Impliciet en expliciet wachten in Selenium met Syntax

In SeleniumWachtopdrachten spelen een belangrijke rol bij het uitvoeren van betrouwbare tests. In deze handleiding leer je de belangrijkste aspecten en verschillen tussen impliciete en expliciete wachtopdrachten. Selenium, samen met praktisch gebruik van Fluent Wait.

Waarom hebben we wachttijden nodig Selenium?

De meeste moderne webapplicaties worden ontwikkeld met behulp van Ajax en JavaScriptWanneer een pagina door de browser wordt geladen, kunnen de elementen waarmee we willen interageren op verschillende tijdstippen worden geladen.

Dit maakt niet alleen de identificatie van elementen moeilijk, maar als het element niet in de tijd wordt gelokaliseerd, Selenium zal een gooien ElementNiet ZichtbaarUitzondering. Selenium Wachten lost dit synchronisatieprobleem op door de WebDriver een gedefinieerd tijdsvenster te geven waarin hij een element moet zoeken voordat hij faalt.

Stel je een scenario voor waarin zowel impliciete als expliciete wachttijden in dezelfde test worden gebruikt. Ga ervan uit dat de impliciete wachttijd is ingesteld op 20 seconden en de expliciete wachttijd op 10 seconden.

Als we op zoek zijn naar een element dat door bepaalde factoren wordt beheerst. Verwachte omstandigheden (Expliciete wachttijd) en als het element zich niet binnen het expliciete venster van 10 seconden bevindt, valt de WebDriver terug op het impliciete venster van 20 seconden voordat een uitzondering wordt gegenereerd. ElementNiet ZichtbaarUitzondering.

Selenium WebDriver wacht

1. Impliciete wachttijd
2. Expliciete wachttijd
3. Vloeiend wachten

Impliciet Wacht binnen Selenium

De Impliciet Wacht binnen Selenium Geeft de WebDriver de opdracht om een ​​bepaalde tijd te wachten voordat een NoSuchElementException wordt gegenereerd. De standaardwaarde is 0. Na configuratie controleert de WebDriver gedurende die tijd de DOM voordat er een fout optreedt. Selenium WebDriver heeft het concept van impliciete wachttijden overgenomen van Watir.

In het onderstaande voorbeeld declareren we een impliciete wachttijd van 10 seconden. Als het element zich niet binnen dat tijdsvenster bevindt, wordt er een uitzondering gegenereerd.

Impliciete wachtsyntaxis (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();
    }
}

Uitleg van Code

In het bovenstaande voorbeeld, beschouw de volgende bewering:

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

Selenium In versie 4 werd de oudere signatuur met twee argumenten (integer plus TimeUnit) vervangen door een enkel argument van het type Duration. De klasse Duration ondersteunt seconden, minuten, milliseconden en andere tijdseenheden via statische hulpmethoden zoals Duration.ofSeconds, Duration.ofMillis en Duration.ofMinutes.

Expliciet Wacht binnen Selenium

De Expliciet Wacht binnen Selenium Explicit Wait instrueert de WebDriver om te wachten op specifieke voorwaarden (Expected Conditions) of een maximale tijdsduur voordat een ElementNotVisibleException wordt gegenereerd. Het is een slimmere wachtmethode omdat deze alleen van toepassing is op het opgegeven element. Explicit Wait heeft de voorkeur boven Implicit Wait wanneer de test dynamisch geladen Ajax-content moet verwerken.

Zodra een expliciete wachtopdracht is aangegeven, moet u deze gebruiken. Verwachte omstandighedenOf u kunt de pollingfrequentie configureren met Vloeiend wachten. Vermijd te gebruiken Draad.slaap(), omdat het de uitvoering onvoorwaardelijk onderbreekt en over het algemeen als slechte praktijk wordt beschouwd.

In het onderstaande voorbeeld maken we een verwijzing naar de WebDriverWacht klasse, instantieer deze met de webdriver referentie en configureer een maximaal venster van 20 seconden.

Expliciete wachtsyntaxis (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();
    }
}

Uitleg van Code

Beschouw de volgende 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 dit WebDriverWait-voorbeeld wacht het script maximaal 20 seconden, zoals gedefinieerd door de WebDriverWacht les, tot de Verwachte omstandigheden zijn tevreden — welke van beide het eerst plaatsvindt.

Bovenstaande Java De code wacht maximaal 20 seconden op de voorwaarde. zichtbaarheidVanElementLocatie te zijn.

De volgende verwachte omstandigheden kunnen worden gebruikt in Selenium Expliciet wachten:

1. alertIsAanwezig()
2. elementSelectionStateToBe()
3. elementToBeClickable()
4. elementToBeSelected()
5. frameToBeAvailableAndSwitchToIt()
6. onzichtbaarheidOfTheElementLocated()
7. onzichtbaarheidOfElementWithText()
8. aanwezigheidOfAllElementsLocatedBy()
9. aanwezigheidOfElementLocated()
10. textToBePresentInElement()
11. textToBePresentInElementLocated()
12. textToBePresentInElementValue()
13. titelIs()
14. titelBevat()
15. zichtbaarheidVan()
16. zichtbaarheidOfAllElements()
17. zichtbaarheidOfAllElementsLocatedBy()
18. zichtbaarheidOfElementLocated()

Vloeiend Wacht binnen Selenium

De Vloeiend Wacht binnen Selenium Definieert de maximale duur dat de WebDriver op een bepaalde voorwaarde mag wachten, samen met de pollingfrequentie om die voorwaarde te verifiëren voordat een ElementNotVisibleException wordt gegenereerd. Fluent Wait controleert het element met regelmatige tussenpozen totdat het object is gevonden of de time-out verloopt.

Frequentie: De herhalingscyclus voor het regelmatig evalueren van de toestand.

Stel je een scenario voor waarin een element op onvoorspelbare intervallen laadt. Het element kan bijvoorbeeld 10 seconden, 20 seconden of langer nodig hebben om te laden. Als we expliciet een wachttijd van 20 seconden opgeven, wacht het script de volledige tijd af voordat het een foutmelding geeft. In zulke gevallen is Fluent Wait de ideale keuze, omdat het met de opgegeven frequentie controleert totdat het element is gevonden of de timer afloopt.

Vloeiende wachtsyntaxis (Selenium 4):

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

De oudere handtekening die integerwaarden plus TimeUnit accepteerde, is afgeschaft in Selenium 3.11 en verwijderd in Selenium 4. De hierboven getoonde API op basis van duur is de momenteel aanbevolen aanpak.

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

Uitleg van Code

Beschouw de volgende code:

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

In het bovenstaande voorbeeld declareren we een Fluent Wait met een time-out van 30 seconden, een pollingfrequentie van 5 seconden en negeren we Geen DergelijkElementUitzondering.

Beschouw de volgende 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"));
}

Deze functie identificeert het WebElement op de pagina (hier, de Selenium link op de homepage). Met een pollinginterval van 5 seconden en een time-out van 30 seconden controleert de wachtfunctie elke 5 seconden of het element aanwezig is, gedurende maximaal 30 seconden. Als het element zich binnen dat venster bevindt, gaat het script verder. Anders wordt een foutmelding gegenereerd. ElementNiet ZichtbaarUitzondering wordt gegooid.

Controleer ook: Selenium IDE-zelfstudie voor beginners

Verschil tussen impliciet wachten versus expliciet wachten

De onderstaande tabel geeft de belangrijkste verschillen weer tussen Implicit Wait en Explicit Wait. Selenium.

Impliciete wachttijd	Expliciete wachttijd
De impliciete wachttijd wordt toegepast op alle elementen in het script.	De expliciete wachttijd wordt alleen toegepast op de specifiek geselecteerde elementen.
Bij een impliciete wachttoestand worden de ExpectedConditions niet gespecificeerd voor het element.	Bij expliciet wachten moeten ExpectedConditions voor het element gedefinieerd zijn.
Aanbevolen wanneer elementen binnen het geconfigureerde impliciete wachtvenster worden geladen.	Aanbevolen wanneer het laden van elementen langer duurt en bij het valideren van de status van elementen, zoals visibilityOfElementLocation, elementToBeClickable of elementToBeSelected.
Eenmalig ingesteld en van toepassing gedurende de gehele levenscyclus van het WebDriver-exemplaar.	Instellen per element of per controle, voor meer controle.

Hoe kies je de juiste wachtstrategie?

Het kiezen van het juiste wachtcommando heeft directe invloed op de stabiliteit en uitvoeringstijd van het script. Gebruik dit beslissingskader om de juiste optie voor elk scenario te selecteren.

1. Identificeer het belastingpatroon: Controleer of het element op een vast tijdstip verschijnt, na een Ajax-reactie, of met onvoorspelbare tussenpozen. Vaste laadtijden zijn geschikt voor Implicit Wait, terwijl onvoorspelbare laadtijden Fluent Wait vereisen.
2. Vermijd het combineren van impliciete en expliciete wachtinstructies: Het combineren van beide kan onverwachte vertragingen veroorzaken, omdat de langere wachttijd de overhand kan krijgen. Selenium De documentatie adviseert om slechts één strategie per WebDriver-sessie te gebruiken.
3. Standaard instellen op Expliciet wachten op dynamische inhoud: Wanneer pagina's afhankelijk zijn van Ajax, voorwaardelijke weergave of animaties, richt Explicit Wait met ExpectedConditions zich precies op het element dat ertoe doet.
4. Gebruik Fluent Wait voor variabele timing: Als de laadtijd van elementen varieert tussen verschillende uitvoeringen, configureer dan Fluent Wait met een polling-interval. Polling verkort de totale wachttijd in vergelijking met één lange time-out.
5. Vervang Thread.sleep: Hardgecodeerde slaapinstructies vertragen testsuites en maskeren echte timingproblemen. Vervang ze door voorwaardelijke wachtinstructies om de uitvoering snel en deterministisch te houden.
6. De time-outwaarden aanpassen: Begin met korte time-outs (5-10 seconden) en verleng deze alleen als er daadwerkelijk sprake is van een trage laadtijd. Lange standaard time-outs maskeren prestatieverminderingen.
7. Houd wachttijden in hulpprogramma's: Centraliseer de wachtlogica in een hulpklasse, zodat wijzigingen in het time-outbeleid van toepassing zijn op de gehele testsuite.

Door dit raamwerk te volgen, kunnen automatiseringsengineers robuuste scripts bouwen die zich aanpassen aan de daadwerkelijke timing van de applicatie, zonder traag of kwetsbaar te worden.

Veelgemaakte fouten die je moet vermijden bij Selenium Wacht

Zelfs ervaren testers trappen in een aantal terugkerende valkuilen wanneer ze met Selenium wachttijden. Door deze problemen te vermijden, blijven scripts snel, voorspelbaar en gemakkelijk te onderhouden, ongeacht het team of de omgeving.

De eerste veelgemaakte fout is het overmatig gebruik van Thread.sleep. Een hardgecodeerde pauze zorgt ervoor dat het script de volledige duur wacht, ongeacht of een element daadwerkelijk beschikbaar is, wat de totale uitvoertijd verlengt. Vervang dergelijke pauzes door Explicit of Fluent Wait, zodat het script verdergaat zodra aan de voorwaarde is voldaan.

De tweede fout is het combineren van impliciete en expliciete wachttijden in dezelfde test. De twee mechanismen kunnen elkaar versterken en onvoorspelbare time-outs veroorzaken die moeilijk te debuggen zijn. Kies één strategie per WebDriver-sessie en pas deze consequent toe.

Een derde veelgemaakte fout is het instellen van te lange time-outs "voor het geval dat". Lange standaard time-outs maskeren echte prestatieproblemen en vertragen de feedback in continue integratieprocessen. Begin met korte time-outs en verleng ze alleen als uit de foutenlogboeken blijkt dat er daadwerkelijk een timingprobleem bestaat.

Controleer ook: Selenium Tutorial voor beginners: leer WebDriver in 7 dagen

Veelgestelde vragen