Implicitno i eksplicitno čekanje Selenium sa sintaksom

In Selenium„Čekanja“ igraju važnu ulogu u izvršavanju pouzdanih testova. U ovom vodiču naučit ćete ključne aspekte i razlike između implicitnih i eksplicitnih naredbi čekanja u Selenium, zajedno s praktičnom upotrebom Fluent Wait-a.

Zašto trebamo čekati Selenium?

Većina modernih web aplikacija razvijena je pomoću Ajax i JavaScriptKada preglednik učita stranicu, elementi s kojima želimo komunicirati mogu se učitavati u različitim vremenskim intervalima.

To ne samo da otežava identifikaciju elementa, već ako element nije lociran u vremenu, Selenium bacit će ElementNotVisibleException. Selenium Čekanja rješavaju ovaj problem sinkronizacije dajući WebDriveru definirani prozor u kojem treba pronaći element prije nego što dođe do greške.

Razmotrimo scenarij u kojem se u istom testu koriste i implicitna i eksplicitna čekanja. Pretpostavimo da je implicitno čekanje postavljeno na 20 sekundi, a eksplicitno čekanje na 10 sekundi.

Ako tražimo element kojim upravljaju određeni ExpectedConditions (Eksplicitno čekanje) i element se ne nalazi unutar eksplicitnog prozora od 10 sekundi, WebDriver se vraća na implicitni prozor od 20 sekundi prije izbacivanja greške. ElementNotVisibleException.

Selenium Čekanja web upravljačkog programa

1. Implicitno čekanje
2. Eksplicitno čekanje
3. Tečno pričekajte

Implicitno čekanje Selenium

The Implicitno čekanje Selenium Upućuje WebDriver da čeka definirano trajanje prije nego što izbaci NoSuchElementException. Zadana vrijednost je 0. Nakon konfiguracije, WebDriver ispituje DOM tijekom tog trajanja prije nego što doživi neuspjeh. Selenium WebDriver je naslijedio koncept implicitnih čekanja od Watir.

U donjem primjeru deklariramo implicitno čekanje s trajanjem od 10 sekundi. Ako se element ne nalazi unutar tog prozora, generirat će se iznimka.

Implicitna sintaksa čekanja (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();
    }
}

Objašnjenje Code

U gornjem primjeru, razmotrite sljedeću izjavu:

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

Selenium Verzija 4 zamijenila je stariji potpis s dva argumenta (cijeli broj plus TimeUnit) s jednim argumentom Duration. Klasa Duration podržava sekunde, minute, milisekunde i druge vremenske jedinice putem statičkih pomoćnih metoda kao što su Duration.ofSeconds, Duration.ofMillis i Duration.ofMinutes.

Eksplicitno čekanje Selenium

The Eksplicitno čekanje Selenium Upućuje WebDriver da čeka određene uvjete (Očekivani uvjeti) ili maksimalno trajanje prije nego što izbaci ElementNotVisibleException. To je pametnije čekanje jer se primjenjuje samo na određeni element. Eksplicitno čekanje je poželjnije od implicitnog čekanja kad god test treba obraditi dinamički učitan Ajax sadržaj.

Nakon što je deklarirano eksplicitno čekanje, morate koristiti ExpectedConditionsili možete konfigurirati učestalost ispitivanja pomoću Tečno pričekajte. Izbjegavajte upotrebu Thread.sleep(), jer bezuvjetno pauzira izvršavanje i općenito se smatra lošom praksom.

U donjem primjeru stvaramo referencu na WebDriverWait klasu, instancirajte je s webdriver referencu i konfigurirajte maksimalni prozor od 20 sekundi.

Eksplicitna sintaksa čekanja (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();
    }
}

Objašnjenje Code

Razmotrite sljedeći 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();

U ovom primjeru WebDriverWait, skripta čeka do 20 sekundi, kako je definirano u WebDriverWait razred, sve do ExpectedConditions zadovoljene - što god se prije dogodi.

Gore Java kod čeka do 20 sekundi za uvjet vidljivostElementLocated da bude istina.

Sljedeći očekivani uvjeti mogu se koristiti u Selenium Eksplicitno čekanje:

1. alertIsPresent()
2. elementSelectionStateToBe()
3. elementToBeClickable()
4. elementToBeSelected()
5. frameToBeAvailableAndSwitchToIt()
6. nevidljivostLociranogElementa()
7. nevidljivostElementa s tekstom()
8. prisutnostSvihElemenataLocatedBy()
9. prisutnostOfElementLocated()
10. textToBePresentInElement()
11. textToBePresentInElementLocated()
12. textToBePresentInElementValue()
13. naslovJe()
14. naslovSadrži()
15. vidljivost()
16. vidljivostSvihElemenata()
17. visibilityOfAllElementsLocatedBy()
18. visibilityOfElementLocated()

Tečno Pričekaj Selenium

The Tečno Pričekaj Selenium definira maksimalno trajanje čekanja uvjeta od strane WebDrivera, zajedno s učestalošću ispitivanja za provjeru tog uvjeta prije izbacivanja iznimke ElementNotVisibleException. Fluent Wait provjerava element u redovitim intervalima dok se objekt ne pronađe ili dok ne istekne vremensko ograničenje.

Frekvencija: Ciklus ponavljanja za procjenu stanja u redovitim intervalima.

Razmotrimo scenarij u kojem se element učitava u nepredvidivim intervalima. Element se može učitati za 10 sekundi, 20 sekundi ili dulje. Ako eksplicitno deklariramo čekanje od 20 sekundi, skripta će čekati puni period prije nego što zakaže. U takvim slučajevima, Fluent Wait je idealan izbor jer ispituje na navedenoj frekvenciji dok se element ne locira ili dok ne istekne posljednji timer.

Sintaksa fluentnog čekanja (Selenium 4):

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

Stariji potpis koji je prihvaćao cjelobrojne vrijednosti plus TimeUnit je zastario u Selenium 3.11 i uklonjeno u Selenium 4. API temeljen na trajanju prikazan gore trenutno je preporučeni pristup.

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

Objašnjenje Code

Razmotrite sljedeći kôd:

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

U gornjem primjeru deklariramo Fluent Wait s vremenskim ograničenjem od 30 sekundi, učestalošću ispitivanja od 5 sekundi i ignoriramo NoSuchElementException.

Razmotrite sljedeći 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"));
}

Ova funkcija identificira WebElement na stranici (ovdje, Selenium poveznica na početnoj stranici). S intervalom ispitivanja od 5 sekundi i vremenskim ograničenjem od 30 sekundi, čekanje provjerava element svakih 5 sekundi tijekom maksimalno 30 sekundi. Ako se element nalazi unutar tog prozora, skripta nastavlja. U suprotnom, ElementNotVisibleException je bačeno.

Također provjerite: Selenium IDE vodič za početnike

Razlika između implicitnog čekanja i eksplicitnog čekanja

Donja tablica ističe ključne razlike između implicitnog čekanja i eksplicitnog čekanja u Selenium.

Implicitno čekanje	Eksplicitno čekanje
Implicitno vrijeme čekanja primjenjuje se na sve elemente u skripti.	Eksplicitno vrijeme čekanja primjenjuje se samo na elemente koji su specifično ciljani.
U implicitnom čekanju, očekivani uvjeti nisu navedeni za element.	U eksplicitnom čekanju, očekivani uvjeti moraju biti definirani za element.
Preporučuje se kada se elementi učitavaju unutar konfiguriranog implicitnog prozora čekanja.	Preporučuje se kada je potrebno dulje vrijeme za učitavanje elemenata i prilikom provjere stanja elemenata kao što su visibilityOfElementLocated, elementToBeClickable ili elementToBeSelected.
Postavljeno jednom i primijenjeno za životni ciklus instance WebDrivera.	Postavlja se po elementu ili po provjeri, što omogućuje finiju kontrolu.

Kako odabrati pravu strategiju čekanja

Odabir ispravne naredbe čekanja izravno utječe na stabilnost skripte i vrijeme izvršavanja. Koristite ovaj okvir za odlučivanje kako biste odabrali odgovarajuću opciju za svaki scenarij.

1. Odredite uzorak opterećenja: Provjerite pojavljuje li se element u fiksno vrijeme, nakon Ajax odgovora ili u nepredvidivim intervalima. Fiksna učitavanja odgovaraju implicitnom čekanju, dok nepredvidiva učitavanja zahtijevaju fluentno čekanje.
2. Izbjegavajte miješanje implicitnih i eksplicitnih čekanja: Kombiniranje ta dva može uzrokovati neočekivana kašnjenja jer dulje čekanje može dominirati. Selenium Dokumentacija preporučuje korištenje samo jedne strategije po WebDriver sesiji.
3. Zadano na eksplicitno čekanje dinamičkog sadržaja: Kada stranice ovise o Ajaxu, uvjetnom renderiranju ili animacijama, Eksplicitno čekanje s očekivanim uvjetima cilja točno na element koji je važan.
4. Koristite Fluent Wait za varijabilno vrijeme: Kada se vrijeme učitavanja elemenata razlikuje između izvršavanja, konfigurirajte Fluent Wait s intervalom ispitivanja. Ispitivanje smanjuje ukupno vrijeme čekanja u usporedbi s jednim dugim vremenskim ograničenjem.
5. Zamijeni Thread.sleep: Tvrdo kodirana spavanja usporavaju testne pakete i skrivaju stvarne probleme s vremenom. Zamijenite ih uvjetnim čekanjima kako bi izvršavanje bilo brzo i determinističko.
6. Vrijednosti vremenskog ograničenja podešavanja: Započnite s kratkim vremenskim ograničenjima (5–10 sekundi) i povećavajte ih samo kada kvarovi pokazuju stvarno sporo učitavanje. Duga zadana vremenska ograničenja maskiraju regresije performansi.
7. Zadrži čekanja u pomoćnim programima: Centralizirajte logiku čekanja u pomoćnoj klasi tako da se promjene pravila vremenskog ograničenja primjenjuju na cijeli testni paket.

Slijedeći ovaj okvir, inženjeri automatizacije mogu izraditi otporne skripte koje se prilagođavaju stvarnom vremenu aplikacije bez da postanu spore ili krhke.

Uobičajene pogreške koje treba izbjegavati Selenium čeka

Čak i iskusni testeri upadaju u mali skup ponavljajućih zamki kada rade s Selenium čekanja. Izbjegavanje ovih problema održava skripte brzim, determinističkim i jednostavnim za održavanje u različitim timovima i okruženjima.

Prva uobičajena pogreška je prekomjerno korištenje Thread.sleep. Fiksno kodirana pauza prisiljava skriptu da čeka puno trajanje bez obzira na stvarnu dostupnost elementa, što povećava ukupno vrijeme izvođenja. Zamijenite takve pauze s Explicitnim ili Fluent Čekanjem kako bi skripta nastavila s izvršavanjem u trenutku kada je uvjet ispunjen.

Druga pogreška je miješanje implicitnih i eksplicitnih čekanja u istom testu. Dva mehanizma se mogu kombinirati, stvarajući nepredvidive vremenske granice koje je teško otkloniti. Odaberite jednu strategiju po sesiji WebDrivera i dosljedno je primjenjivajte.

Treća pogreška je postavljanje previsokih vremenskih ograničenja „za svaki slučaj“. Dugi zadani prozori skrivaju stvarne probleme s performansama i usporavaju povratne informacije u cjevovodima kontinuirane integracije. Započnite s kratkim vremenskim ograničenjima i produžite ih samo kada zapisnici o greškama dokažu da postoji stvarni problem s vremenom.

Također provjerite: Selenium Vodič za početnike: Naučite WebDriver u 7 dana

Pitanja i odgovori