Implicit og eksplicit ventetid Selenium med syntaks

In Selenium"Ventetider" spiller en vigtig rolle i udførelsen af ​​pålidelige tests. I denne vejledning lærer du de vigtigste aspekter og forskelle mellem implicitte og eksplicitte ventekommandoer i Selenium, sammen med praktisk brug af Fluent Wait.

Hvorfor har vi brug for ventetider Selenium?

De fleste moderne webapplikationer er udviklet vha. Ajax og JavaScriptNår en side indlæses af browseren, kan de elementer, vi ønsker at interagere med, indlæses med forskellige tidsintervaller.

Dette gør ikke blot identifikation af grundstoffer vanskelig, men hvis grundstoffet ikke lokaliseres i tide, Selenium vil kaste en ElementNotVisibleException. Selenium Ventetider løser dette synkroniseringsproblem ved at give WebDriver et defineret vindue, hvor et element kan findes, før det fejler.

Overvej et scenarie, hvor både implicitte og eksplicitte ventetider bruges i den samme test. Antag, at den implicitte ventetid er indstillet til 20 sekunder, og den eksplicitte ventetid er indstillet til 10 sekunder.

Hvis vi leder efter et element, der er styret af bestemte Forventede betingelser (Eksplicit ventetid), og elementet ikke er placeret inden for det eksplicitte vindue på 10 sekunder, falder WebDriveren tilbage til det implicitte vindue på 20 sekunder, før den udløser en ElementNotVisibleException.

Selenium WebDriver venter

1. Implicit Vent
2. Eksplicit Vent
3. Flydende Vent

Implicit Vent ind Selenium

Implicit Vent ind Selenium instruerer WebDriver til at vente i en defineret varighed, før der udløses en NoSuchElementException. Standardværdien er 0. Når den er konfigureret, forespørger WebDriver DOM'en i løbet af denne varighed, før den fejler. Selenium WebDriver arvede konceptet med implicitte ventetider fra Watir.

I eksemplet nedenfor erklærer vi en implicit ventetid med en varighed på 10 sekunder. Hvis elementet ikke er placeret inden for dette vindue, genereres en undtagelse.

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

Forklaring af Code

I ovenstående eksempel skal du overveje følgende sætning:

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

Selenium Version 4 erstattede den ældre signatur med to argumenter (heltal plus TimeUnit) med et enkelt Duration-argument. Duration-klassen understøtter sekunder, minutter, millisekunder og andre tidsenheder via statiske hjælpere som Duration.ofSeconds, Duration.ofMillis og Duration.ofMinutes.

Eksplicit Vent ind Selenium

Eksplicit Vent ind Selenium instruerer WebDriver til at vente på specifikke betingelser (forventede betingelser) eller en maksimal varighed, før en ElementNotVisibleException udløses. Det er en smartere ventefunktion, fordi den kun gælder for det angivne element. Explicit Wait foretrækkes frem for Implicit Wait, når testen skal håndtere dynamisk indlæst Ajax-indhold.

Når en eksplicit ventetid er angivet, skal du bruge Forventede betingelser, eller du kan konfigurere pollingfrekvens ved hjælp af Flydende Vent. Undgå at bruge Thread.sleep(), da det sætter udførelsen på pause ubetinget og generelt betragtes som dårlig praksis.

I eksemplet nedenfor opretter vi en reference til WebDriverWait klasse, instantiér den med webdriver reference, og konfigurer et maksimalt vindue på 20 sekunder.

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

Forklaring af Code

Overvej følgende kode:

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 dette WebDriverWait-eksempel venter scriptet op til 20 sekunder, som defineret af WebDriverWait klasse, indtil Forventede betingelser er opfyldt – alt efter hvad der indtræffer først.

Ovenstående Java Koden venter op til 20 sekunder på betingelsen synlighedAfElementPlaceret for at være sand.

Følgende forventede betingelser kan anvendes i Selenium Eksplicit ventetid:

1. alertIsPresent()
2. elementSelectionStateToBe()
3. elementToBeClickable()
4. elementToBeSelected()
5. frameToBeAvailableAndSwitchToIt()
6. invisibilityOfTheElementLocated()
7. invisibilityOfElementWithText()
8. presenceOfAllElementsLocatedBy()
9. presenceOfElementLocated()
10. textToBePresentInElement()
11. textToBePresentInElementLocated()
12. textToBePresentInElementValue()
13. titleIs()
14. titelIndeholder()
15. visibilityOf()
16. visibilityOfAllElements()
17. visibilityOfAllElementsLocatedBy()
18. visibilityOfElementLocated()

Flydende Vent ind Selenium

Flydende Vent ind Selenium definerer den maksimale varighed, som WebDriver skal vente på en betingelse, sammen med pollingfrekvensen for at verificere betingelsen, før en ElementNotVisibleException udløses. Fluent Wait kontrollerer for elementet med jævne mellemrum, indtil objektet findes, eller timeout udløber.

Frekvens: Gentagelsescyklussen til evaluering af tilstanden med jævne mellemrum.

Forestil dig et scenarie, hvor et element indlæses med uforudsigelige intervaller. Elementet kan indlæses på 10 sekunder, 20 sekunder eller længere. Hvis vi erklærer en eksplicit ventetid på 20 sekunder, vil scriptet vente i hele varigheden, før det fejler. I sådanne tilfælde er Fluent Wait det ideelle valg, fordi det poller med den angivne frekvens, indtil elementet er fundet, eller den endelige timer udløber.

Flydende ventesyntaks (Selenium 4):

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

Den ældre signatur, der accepterede heltalsværdier plus TimeUnit, blev udfaset i Selenium 3.11 og fjernet i Selenium 4. Den ovenfor viste varighedsbaserede API er den nuværende anbefalede fremgangsmåde.

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

Forklaring af Code

Overvej følgende kode:

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

I ovenstående eksempel erklærer vi en Fluent Wait med en timeout på 30 sekunder, en pollingfrekvens på 5 sekunder og ignorerer NoSuchElementException.

Overvej følgende kode:

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

Denne funktion identificerer WebElementet på siden (her, Selenium link på hjemmesiden). Med et pollinginterval på 5 sekunder og en timeout på 30 sekunder tjekker ventefunktionen for elementet hvert 5. sekund i maksimalt 30 sekunder. Hvis elementet er placeret inden for dette vindue, fortsætter scriptet. Ellers vil en ElementNotVisibleException bliver kastet.

Kontroller også: Selenium IDE Tutorial for begyndere

Forskellen mellem implicit ventetid og eksplicit ventetid

Tabellen nedenfor fremhæver de vigtigste forskelle mellem implicit ventetid og eksplicit ventetid. Selenium.

Implicit Vent	Eksplicit Vent
Implicit ventetid anvendes på alle elementer i scriptet.	Eksplicit ventetid anvendes kun på de elementer, der er specifikt målrettet.
I Implicit Wait er ExpectedConditions ikke angivet for elementet.	I Explicit Wait skal ExpectedConditions defineres for elementet.
Anbefales, når elementer indlæses inden for det konfigurerede implicitte ventevindue.	Anbefales, når elementer tager længere tid at indlæse, og ved validering af elementtilstande som f.eks. visibilityOfElementLocated, elementToBeClickable eller elementToBeSelected.
Angivet én gang og anvendt i WebDriver-instansens livscyklus.	Indstil pr. element eller pr. kontrol, hvilket giver finere kontrol.

Sådan vælger du den rigtige ventestrategi

Valg af den korrekte wait-kommando påvirker direkte scriptstabilitet og udførelsestid. Brug denne beslutningsramme til at vælge den passende mulighed for hvert scenarie.

1. Identificér belastningsmønsteret: Tjek om elementet vises på et fast tidspunkt, efter Ajax-svaret eller med uforudsigelige intervaller. Faste indlæsninger passer til Implicit Wait, hvorimod uforudsigelige indlæsninger kræver Fluent Wait.
2. Undgå at blande implicitte og eksplicitte ventetider: Kombinationen af ​​de to kan forårsage uventede forsinkelser, fordi den længere ventetid kan være dominerende. Selenium Dokumentationen anbefaler kun at bruge én strategi pr. WebDriver-session.
3. Standardindstilling er eksplicit. Vent på dynamisk indhold: Når sider er afhængige af Ajax, betinget gengivelse eller animationer, målretter Explicit Wait med ExpectedConditions præcis det element, der er vigtigt.
4. Brug Fluent Wait til variabel timing: Når elementindlæsningstimingen varierer mellem kørsler, skal Fluent Wait konfigureres med et pollinginterval. Polling reducerer den samlede ventetid sammenlignet med en enkelt lang timeout.
5. Erstat Thread.sleep: Hardkodede dvaler forsinker testpakker og skjuler reelle timingproblemer. Erstat dem med betingede ventetider for at holde udførelsen hurtig og deterministisk.
6. Timeout-værdier for finjustering: Start med korte timeouts (5-10 sekunder), og øg dem kun, når fejl viser reel langsom belastning. Lange standard timeouts maskerer ydeevneregressioner.
7. Behold ventetider i hjælpeværktøjer: Centraliser ventelogik i en hjælperklasse, så ændringer i timeout-politikken gælder på tværs af hele testsuiten.

Ved at følge denne ramme kan automatiseringsingeniører bygge robuste scripts, der tilpasser sig den faktiske applikationstiming uden at blive langsomme eller skrøbelige.

Almindelige fejl at undgå med Selenium Venter

Selv erfarne testere falder i en række tilbagevendende fælder, når de arbejder med Selenium venter. Ved at undgå disse problemer forbliver scripts hurtige, deterministiske og nemme at vedligeholde på tværs af teams og miljøer.

Den første almindelige fejl er overforbrug af Thread.sleep. En hardcoded pause tvinger scriptet til at vente i hele varigheden uanset den faktiske elementtilgængelighed, hvilket oppuster den samlede kørselstid. Erstat sådanne pauser med Explicit eller Fluent Wait, så scriptet fortsætter i det øjeblik, betingelsen er opfyldt.

Den anden fejl er at blande implicitte og eksplicitte ventetider i den samme test. De to mekanismer kan blandes sammen og skabe uforudsigelige timeouts, der er svære at fejlfinde. Vælg én strategi pr. WebDriver-session, og anvend den konsekvent.

En tredje fejl er at sætte timeouts for højt "bare i tilfælde af". Lange standardvinduer skjuler reelle ydeevneproblemer og forsinker feedback i kontinuerlige integrationspipeliner. Start med korte timeouts, og forlæng dem kun, når fejllogge beviser, at der er et reelt timingproblem.

Kontroller også: Selenium Tutorial for begyndere: Lær WebDriver på 7 dage

Ofte Stillede Spørgsmål