Așteptare implicită și explicită în Selenium cu sintaxă

In Selenium„Așteptările” joacă un rol important în executarea testelor fiabile. În acest tutorial, veți învăța aspectele cheie și diferențele dintre comenzile Implicit și Explicit Wait din Selenium, împreună cu utilizarea practică a funcției Fluent Wait.

De ce avem nevoie de așteptări Selenium?

Majoritatea aplicațiilor web moderne sunt dezvoltate folosind Ajax și JavaScenariuCând o pagină este încărcată de browser, elementele cu care dorim să interacționăm se pot încărca la intervale de timp diferite.

Nu numai că acest lucru îngreunează identificarea elementului, dar dacă elementul nu este localizat în timp, Selenium va arunca o ElementNotVisibleException. Selenium Funcțiile Wait rezolvă această problemă de sincronizare oferind WebDriver-ului o fereastră definită în care să găsească un element înainte de a eșua.

Să luăm în considerare un scenariu în care se utilizează atât așteptări implicite, cât și explicite în același test. Presupunem că așteptarea implicită este setată la 20 de secunde, iar așteptarea explicită este setată la 10 secunde.

Dacă căutăm un element guvernat de anumite Condiții așteptate (Așteptare explicită) și elementul nu este localizat în fereastra explicită de 10 secunde, WebDriver revine la fereastra implicită de 20 de secunde înainte de a genera o eroare ElementNotVisibleException.

Selenium Așteptări WebDriver

1. Așteptați implicit
2. Așteptați explicit
3. Așteptați fluent

Așteptați implicit Selenium

Așteptați implicit Selenium instruiește WebDriver-ul să aștepte o durată definită înainte de a genera o excepție NoSuchElementException. Valoarea implicită este 0. Odată configurat, WebDriver-ul interoghează DOM-ul în această durată înainte de a eșua. Selenium WebDriver a moștenit conceptul de așteptări implicite de la Watir.

În exemplul de mai jos, declarăm o așteptare implicită cu o durată de 10 secunde. Dacă elementul nu se află în acea fereastră, se generează o excepție.

Sintaxa de așteptare implicită (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();
    }
}

Explicația de Code

În exemplul de mai sus, luați în considerare următoarea afirmație:

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

Selenium Versiunea 4 a înlocuit vechea semnătură cu două argumente (întreg plus TimeUnit) cu un singur argument Duration. Clasa Duration acceptă secunde, minute, milisecunde și alte unități de timp prin intermediul unor instrumente statice precum Duration.ofSeconds, Duration.ofMillis și Duration.ofMinutes.

Așteptați explicit Selenium

Așteptați explicit Selenium instruiește WebDriver-ul să aștepte anumite condiții (Condiții așteptate) sau o durată maximă înainte de a genera o excepție ElementNotVisibleException. Este o așteptare mai inteligentă deoarece se aplică numai elementului specificat. Explicit Wait este preferată față de Implicit Wait ori de câte ori testul trebuie să gestioneze conținut Ajax încărcat dinamic.

Odată ce este declarată o așteptare explicită, trebuie să utilizați Condiții așteptate, sau puteți configura frecvența de interogare folosind Așteptați fluent. Evita sa folosesti Thread.sleep(), deoarece întrerupe necondiționat execuția și este în general considerată o practică proastă.

În exemplul de mai jos, creăm o referință a WebDriverWait clasă, instanțiează-o cu webdriver referință și configurați o fereastră maximă de 20 de secunde.

Sintaxa de așteptare explicită (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();
    }
}

Explicația de Code

Luați în considerare următorul cod:

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

În acest exemplu WebDriverWait, scriptul așteaptă până la 20 de secunde, așa cum este definit de WebDriverWait clasă, până la Condiții așteptate sunt satisfăcute — oricare dintre acestea survine prima.

Cele de mai sus Java Codul așteaptă până la 20 de secunde pentru condiție vizibilitateElementLocalizat a fi adevarat.

Următoarele condiții așteptate pot fi utilizate în Selenium Așteptați explicit:

1. alertIsPresent()
2. elementSelectionStateToBe()
3. elementToBeClickable()
4. elementToBeSelected()
5. frameToBeAvailableAndSwitchToIt()
6. invizibilityOfTheElementLocated()
7. invizibilityOfElementWithText()
8. prezentaOfToateElementeleLocatedBy()
9. presentOfElementLocated()
10. textToBePresentInElement()
11. textToBePresentInElementLocated()
12. textToBePresentInElementValue()
13. titleIs()
14. titleContains()
15. vizibilityOf()
16. visibilityOfAllElements()
17. visibilityOfAllElementsLocatedBy()
18. visibilityOfElementLocated()

Fluent Așteptați Selenium

Fluent Așteptați Selenium definește durata maximă de așteptare a unei condiții de către WebDriver, împreună cu frecvența de interogare pentru verificarea acelei condiții înainte de a genera o excepție ElementNotVisibleException. Fluent Wait verifică elementul la intervale regulate până când obiectul este găsit sau expiră timeout-ul.

Frecventa: Ciclul repetitiv pentru evaluarea stării la intervale regulate.

Să luăm în considerare un scenariu în care un element se încarcă la intervale imprevizibile. Elementul se poate încărca în 10 secunde, 20 de secunde sau mai mult. Dacă declarăm o așteptare explicită de 20 de secunde, scriptul va aștepta întreaga durată înainte de a eșua. În astfel de cazuri, Fluent Wait este alegerea ideală, deoarece efectuează sondaje la frecvența specificată până când elementul este localizat sau expiră cronometrul final.

Sintaxă Fluent Wait (Selenium 4):

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

Semnătura mai veche care accepta valori întregi plus TimeUnit a fost depreciată în Selenium 3.11 și eliminată în Selenium 4. API-ul bazat pe durată prezentat mai sus este abordarea recomandată în prezent.

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

Explicația de Code

Luați în considerare următorul cod:

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

În exemplul de mai sus, declarăm o stare Fluent Wait cu un timeout de 30 de secunde, o frecvență de interogare de 5 secunde și ignorăm NoSuchElementException.

Luați în considerare următorul cod:

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

Această funcție identifică WebElement-ul de pe pagină (aici, Selenium (link pe pagina principală). Cu un interval de interogare de 5 secunde și un timeout de 30 de secunde, așteptarea verifică elementul la fiecare 5 secunde timp de maximum 30 de secunde. Dacă elementul se află în acea fereastră, scriptul continuă. În caz contrar, un ElementNotVisibleException este aruncat.

De asemenea, verificați: Selenium Tutorial IDE pentru începători

Diferența dintre așteptarea implicită și așteptarea explicită

Tabelul de mai jos evidențiază principalele diferențe dintre Implicit Wait și Explicit Wait. Selenium.

Așteptați implicit	Așteptați explicit
Timpul de așteptare implicit se aplică tuturor elementelor din script.	Timpul de așteptare explicit se aplică numai elementelor vizate în mod specific.
În Implicit Wait, ExpectedConditions nu sunt specificate pentru element.	În Explicit Wait, trebuie definite ExpectConditions pentru element.
Recomandat când elementele se încarcă în fereastra de așteptare implicită configurată.	Recomandat atunci când elementele au nevoie de mai mult timp pentru încărcare și când se validează stările elementelor, cum ar fi visibilityOfElementLocated, elementToBeClickable sau elementToBeSelected.
Setată o singură dată și aplicată pentru ciclul de viață al instanței WebDriver.	Setați per element sau per verificare, oferind un control mai fin.

Cum să alegi strategia potrivită de așteptare

Alegerea comenzii wait corecte afectează direct stabilitatea scriptului și timpul de execuție. Folosește acest cadru decizional pentru a selecta opțiunea potrivită pentru fiecare scenariu.

1. Identificați modelul de încărcare: Verificați dacă elementul apare la un moment fix, după răspunsul Ajax sau la intervale imprevizibile. Încărcările fixe se potrivesc cu Implicit Wait, în timp ce încărcările imprevizibile necesită Fluent Wait.
2. Evitați să amestecați așteptările implicite și explicite: Combinarea celor două poate cauza întârzieri neașteptate, deoarece așteptarea mai lungă poate fi dominantă. Selenium Documentația recomandă utilizarea unei singure strategii per sesiune WebDriver.
3. Implicit la Așteptare explicită pentru conținut dinamic: Când paginile depind de Ajax, randare condiționată sau animații, Explicit Wait cu ExpectedConditions vizează exact elementul care contează.
4. Folosește Fluent Wait pentru temporizare variabilă: Când timpul de încărcare a elementului variază între rulări, configurați Fluent Wait cu un interval de interogare. Interogarea reduce timpul total de așteptare în comparație cu o singură expirare lungă.
5. Înlocuiți Thread.sleep: Momentele de repaus codificate hardcode încetinesc suitele de teste și ascund problemele de sincronizare reală. Înlocuiți-le cu așteptări condiționate pentru a menține execuția rapidă și deterministă.
6. Valori de expirare a reglajului: Începeți cu timeout-uri scurte (5–10 secunde) și creșteți-le doar atunci când erorile indică o încărcare cu adevărat lentă. Timeout-urile lungi implicite maschează regresiile de performanță.
7. Păstrați așteptările în utilitarele auxiliare: Centralizați logica de așteptare într-o clasă helper, astfel încât modificările politicii de timeout să se aplice în întreaga suită de teste.

Urmând acest cadru, inginerii de automatizare pot construi scripturi rezistente care se adaptează la sincronizarea reală a aplicațiilor fără a deveni lente sau fragile.

Greșeli frecvente de evitat cu Selenium Așteaptă

Chiar și testerii experimentați cad într-un set mic de capcane recurente atunci când lucrează cu Selenium așteaptă. Evitarea acestor probleme menține scripturile rapide, deterministe și ușor de întreținut în diferite echipe și medii.

Prima greșeală frecventă este utilizarea excesivă a Thread.sleep. O pauză hardcoded obligă scriptul să aștepte întreaga durată, indiferent de disponibilitatea reală a elementului, ceea ce crește timpul total de execuție. Înlocuiți astfel de pauze cu Explicit Wait sau Fluent Wait, astfel încât scriptul să continue în momentul în care condiția este îndeplinită.

A doua greșeală este combinarea Implicit Waits cu Explicit Waits în același test. Cele două mecanisme se pot combina, creând timeout-uri imprevizibile care sunt greu de depanat. Alegeți o strategie pentru fiecare sesiune WebDriver și aplicați-o în mod consecvent.

O a treia greșeală este setarea unor timeout-uri prea mari „pentru orice eventualitate”. Ferestrele implicite lungi ascund problemele reale de performanță și încetinesc feedback-ul în conductele de integrare continuă. Începeți cu timeout-uri scurte și extindeți-le doar atunci când jurnalele de erori dovedesc că există o problemă reală de sincronizare.

De asemenea, verificați: Selenium Tutorial pentru începători: Învață WebDriver în 7 zile

Întrebări frecvente