Implicitní a explicitní čekání Selenium se syntaxí

In Selenium„Čekání“ hraje důležitou roli při provádění spolehlivých testů. V tomto tutoriálu se dozvíte klíčové aspekty a rozdíly mezi implicitními a explicitními příkazy čekání. Selenium, spolu s praktickým využitím Fluent Wait.

Proč potřebujeme čekat dovnitř Selenium?

Většina moderních webových aplikací je vyvíjena pomocí Ajax a JavaScénářKdyž prohlížeč načte stránku, prvky, se kterými chceme interagovat, se mohou načítat v různých časových intervalech.

To nejen ztěžuje identifikaci prvku, ale pokud prvek není lokalizován v čase, Selenium hodí ElementNotVisibleException. Selenium Funkce Waits řeší tento problém se synchronizací tím, že WebDriveru poskytne definované okno, ve kterém má najít prvek před selháním.

Uvažujme scénář, ve kterém se ve stejném testu používají implicitní i explicitní čekání. Předpokládejme, že implicitní čekání je nastaveno na 20 sekund a explicitní čekání je nastaveno na 10 sekund.

Pokud hledáme prvek řízený určitými Očekávané podmínky (Explicitní čekání) a element se nenachází v explicitním okně 10 sekund, WebDriver se vrátí k implicitnímu okně 20 sekund před vyvoláním chyby. ElementNotVisibleException.

Selenium Čekání WebDriveru

1. Implicitní čekání
2. Explicitně čekejte
3. Plynule počkejte

Implicitní čekání Selenium

Jedno Implicitní čekání Selenium instruuje WebDriver, aby čekal po definovanou dobu, než vyvolá výjimku NoSuchElementException. Výchozí hodnota je 0. Po nakonfigurování WebDriver dotazuje DOM během této doby, než dojde k selhání. Selenium WebDriver zdědil koncept implicitního čekání od Watir.

V níže uvedeném příkladu deklarujeme implicitní čekání s dobou trvání 10 sekund. Pokud se prvek nenachází v daném okně, je vyvolána výjimka.

Implicitní syntaxe čekání (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();
    }
}

Vysvětlení Code

Ve výše uvedeném příkladu zvažte následující tvrzení:

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

Selenium Verze 4 nahradila starší dvouargumentovou signaturu (celé číslo plus TimeUnit) jedním argumentem Duration. Třída Duration podporuje sekundy, minuty, milisekundy a další časové jednotky prostřednictvím statických pomocných metod, jako jsou Duration.ofSeconds, Duration.ofMillis a Duration.ofMinutes.

Explicitně počkejte Selenium

Jedno Explicitně počkejte Selenium instruuje WebDriver, aby čekal na specifické podmínky (očekávané podmínky) nebo maximální dobu trvání, než vyvolá výjimku ElementNotVisibleException. Je to chytřejší čekání, protože se vztahuje pouze na zadaný element. Explicitní čekání je upřednostňováno před implicitním čekáním, kdykoli test potřebuje zpracovat dynamicky načítaný obsah Ajaxu.

Jakmile je deklarováno explicitní čekání, musíte použít Očekávané podmínkynebo můžete nakonfigurovat frekvenci dotazování pomocí Plynule počkejte. Nepoužívejte Thread.sleep(), protože bezpodmínečně pozastaví provádění a je to obecně považováno za špatný postup.

V níže uvedeném příkladu vytvoříme referenci na WebDriverPočkejte třídu, vytvořte její instanci pomocí webový ovladač referenci a nakonfigurujte maximální okno 20 sekund.

Explicitní syntaxe čekání (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();
    }
}

Vysvětlení Code

Zvažte následující kód:

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

V tomto příkladu WebDriverWait skript čeká až 20 sekund, jak je definováno v WebDriverPočkejte třída, až do té doby, Očekávané podmínky jsou splněny – podle toho, co nastane dříve.

Výše Java kód čeká na podmínku až 20 sekund viditelnostUmístěnéhoPrvku být pravdivý.

Následující očekávané podmínky lze použít v Selenium Explicitní čekání:

1. alertIsPresent()
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. viditelnost()
16. viditelnostOfAllElements()
17. viditelnostOfAllElementsLocatedBy()
18. viditelnostOfElementLocated()

Plynule Počkejte dovnitř Selenium

Jedno Plynule Počkejte dovnitř Selenium Definuje maximální dobu, po kterou WebDriver čeká na podmínku, spolu s frekvencí dotazování pro ověření této podmínky před vyvoláním výjimky ElementNotVisibleException. Fluent Wait kontroluje element v pravidelných intervalech, dokud není objekt nalezen nebo nevyprší časový limit.

Frekvence: Opakovací cyklus pro vyhodnocování stavu v pravidelných intervalech.

Uvažujme scénář, kdy se prvek načítá v nepředvídatelných intervalech. Prvek se může načíst za 10 sekund, 20 sekund nebo i déle. Pokud explicitně deklarujeme čekání na 20 sekund, skript bude čekat po celou dobu, než selže. V takových případech je Fluent Wait ideální volbou, protože se dotazuje s určenou frekvencí, dokud není prvek nalezen nebo dokud nevyprší poslední časovač.

Syntaxe plynulého čekání (Selenium 4):

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

Starší podpis, který akceptoval celočíselné hodnoty plus TimeUnit, byl v roce 2004 zastaralý. Selenium 3.11 a odstraněno v Selenium 4. Výše ​​uvedené API založené na trvání je aktuálně doporučeným přístupem.

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

Vysvětlení Code

Zvažte následující kód:

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

Ve výše uvedeném příkladu deklarujeme Fluent Wait s časovým limitem 30 sekund, frekvencí dotazování 5 sekund a ignorujeme NoSuchElementException.

Zvažte následující kód:

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

Tato funkce identifikuje WebElement na stránce (zde Selenium odkaz na domovské stránce). S intervalem dotazování 5 sekund a časovým limitem 30 sekund čekání kontroluje prvek každých 5 sekund po dobu maximálně 30 sekund. Pokud se prvek nachází v daném okně, skript pokračuje. V opačném případě ElementNotVisibleException je hozen.

Také zkontrolujte: Selenium Výukový program IDE pro začátečníky

Rozdíl mezi implicitním čekáním a explicitním čekáním

Níže uvedená tabulka zdůrazňuje klíčové rozdíly mezi implicitním a explicitním čekáním. Selenium.

Implicitní čekání	Explicitně čekejte
Implicitní doba čekání se aplikuje na všechny prvky ve skriptu.	Explicitní doba čekání se aplikuje pouze na konkrétně cílené prvky.
V implicitním čekání nejsou pro element zadány očekávané podmínky (ExpectedConditions).	V Explicit Wait musí být pro element definovány ExpectedConditions.
Doporučuje se, když se prvky načtou v rámci nakonfigurovaného implicitního okna čekání.	Doporučuje se, když načítání elementů trvá déle a při ověřování stavů elementů, jako je visibilityOfElementLocated, elementToBeClickable nebo elementToBeSelected.
Jednou nastaveno a použito pro životní cyklus instance WebDriveru.	Nastaveno pro každý prvek nebo pro každou kontrolu, což poskytuje jemnější kontrolu.

Jak zvolit správnou strategii čekání

Výběr správného příkazu wait přímo ovlivňuje stabilitu skriptu a dobu provádění. Pomocí tohoto rozhodovacího rámce vyberte vhodnou možnost pro každý scénář.

1. Určete vzorec zatížení: Zkontrolujte, zda se prvek objeví v pevně stanoveném čase, po odpovědi Ajaxu nebo v nepředvídatelných intervalech. Pevné zátěže vyhovují implicitnímu čekání, zatímco nepředvídatelné zátěže vyžadují plynulé čekání.
2. Vyhněte se kombinování implicitních a explicitních čekání: Kombinace obou může způsobit neočekávaná zpoždění, protože delší čekání může dominovat. Selenium Dokumentace doporučuje používat pouze jednu strategii na relaci WebDriveru.
3. Výchozí nastavení Explicitní čekání na dynamický obsah: Pokud stránky závisí na Ajaxu, podmíněném vykreslování nebo animacích, Explicit Wait s ExpectedConditions cílí přesně na ten důležitý element.
4. Pro variabilní načasování použijte Fluent Wait: Pokud se časování načítání prvků mezi jednotlivými spuštěními liší, nakonfigurujte Fluent Wait s intervalem dotazování. Dotazování zkracuje celkovou dobu čekání ve srovnání s jedním dlouhým časovým limitem.
5. Nahradit Thread.sleep: Pevně ​​zakódované režimy spánku zpomalují testovací sady a skrývají skutečné problémy s načasováním. Nahraďte je podmíněným čekáním, aby bylo provádění rychlé a deterministické.
6. Hodnoty časového limitu ladění: Začněte s krátkými časovými limity (5–10 sekund) a prodlužujte je pouze v případě, že selhání vykazují skutečně pomalé načítání. Dlouhé výchozí časové limity maskují zhoršení výkonu.
7. Udržovat čekání v pomocných utilitách: Centralizujte logiku čekání v pomocné třídě, aby se změny zásad časového limitu vztahovaly na celou testovací sadu.

Dodržováním tohoto rámce mohou automatizační inženýři vytvářet odolné skripty, které se přizpůsobí reálnému načasování aplikace, aniž by se staly pomalými nebo křehkými.

Časté chyby, kterým se vyhnout Selenium Čeká

I zkušení testeři padají při práci s několika opakujícími se pastmi. Selenium čeká. Vyhýbání se těmto problémům udržuje skripty rychlé, deterministické a snadno udržovatelné napříč týmy a prostředími.

První častou chybou je nadužívání Thread.sleep. Pevně ​​zakódovaná pauza nutí skript čekat po celou dobu bez ohledu na skutečnou dostupnost elementu, což zvyšuje celkovou dobu běhu. Nahraďte takové pauzy explicitním nebo plynulým čekáním, aby skript pokračoval v okamžiku splnění podmínky.

Druhou chybou je kombinování implicitního a explicitního čekání ve stejném testu. Tyto dva mechanismy se mohou kombinovat a vytvářet nepředvídatelné časové limity, které je obtížné ladit. Vyberte jednu strategii pro každou relaci WebDriveru a používejte ji konzistentně.

Třetí chybou je nastavení příliš vysokých časových limitů „pro jistotu“. Dlouhá výchozí okna skrývají skutečné problémy s výkonem a zpomalují zpětnou vazbu v procesech kontinuální integrace. Začněte s krátkými časovými limity a prodlužujte je pouze tehdy, když protokoly selhání prokáží skutečný problém s časováním.

Také zkontrolujte: Selenium Výukový program pro začátečníky: Naučte se WebDriver za 7 dní

Nejčastější dotazy