Kaudne ja selgesõnaline ootamine Selenium süntaksiga

In Selenium, „Ooterežiimidel” (ingl k „waits”) on usaldusväärsete testide läbiviimisel oluline roll. Selles õpetuses saate teada implitsiitsete ja eksplitsiitsete ooterežiimide (ingl k „implicit waith”) põhiaspekte ja erinevusi. Seleniumkoos praktilise Fluent Wait'i kasutamisega.

Miks me vajame ooteaegu? Selenium?

Enamik tänapäevaseid veebirakendusi on loodud kasutades Ajax ja JavaScriptKui brauser lehe laadib, võivad elemendid, millega me suhelda tahame, laadida erinevate ajavahemike järel.

See mitte ainult ei raskenda elemendi tuvastamist, vaid kui elementi õigeaegselt ei leita, Selenium viskab ühe ElementNotVisibleException. Selenium Ooteajad lahendavad selle sünkroniseerimisprobleemi, andes WebDriverile määratletud akna, mille jooksul enne nurjumist element leida.

Vaatleme stsenaariumi, kus samas testis kasutatakse nii otseseid kui ka implitsiitseid ooteaegu. Eeldame, et implitsiitseks ooteajaks on seatud 20 sekundit ja otseseks ooteajaks 10 sekundit.

Kui otsime elementi, mida juhib teatud Eeldatavad tingimused (Otsene ooteaeg) ja element ei asu 10-sekundilise selgesõnalise akna piires, langeb WebDriver enne veateate viskamist tagasi 20-sekundilisele kaudsele aknale. ElementNotVisibleException.

Selenium WebDriveri ootamised

1. Kaudne ootamine
2. Selgesõnaline ootamine
3. Sujuv ootamine

Kaudne ootamine Selenium

. Kaudne ootamine Selenium annab WebDriverile korralduse oodata enne NoSuchElementExceptioni viskamist määratud aja. Vaikimisi väärtus on 0. Pärast konfigureerimist küsitleb WebDriver enne nurjumist DOM-i selle aja jooksul. Selenium WebDriver päris implitsiitsete ootamiste kontseptsiooni Watir.

Allolevas näites deklareerime vaikimisi ooteaja, mille kestus on 10 sekundit. Kui element selles aknas ei asu, tekib erand.

Kaudne ootamise süntaks (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();
    }
}

Selgitus Code

Ülaltoodud näites vaatleme järgmist väidet:

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

Selenium Versioonis 4 asendati vanem kaheargumendiline signatuur (täisarv pluss ajaühik) ühe Duration argumendiga. Duration klass toetab sekundeid, minuteid, millisekundeid ja teisi ajaühikuid staatiliste abimeeste, näiteks Duration.ofSeconds, Duration.ofMillis ja Duration.ofMinutes, kaudu.

Selgesõnaline Oodake sisse Selenium

. Selgesõnaline Oodake sisse Selenium annab WebDriverile korralduse oodata enne ElementNotVisibleExceptioni viskamist teatud tingimusi (eeldatavaid tingimusi) või maksimaalset kestust. See on targem ootamine, kuna see kehtib ainult määratud elemendi kohta. Selgesõnalist ootamist eelistatakse kaudsele ootamisele alati, kui test peab käsitlema dünaamiliselt laaditud Ajax-sisu.

Kui selgesõnaline ooteaeg on deklareeritud, peate kasutama Eeldatavad tingimusedvõi saate küsitlussageduse konfigureerida, kasutades Sujuv ootamine. Vältige kasutamist Thread.sleep(), kuna see peatab täitmise tingimusteta ja seda peetakse üldiselt halvaks tavaks.

Allolevas näites loome viite WebDriverOota klassi, looge see Veebidraiver viide ja konfigureerige maksimaalseks aknaks 20 sekundit.

Selgesõnaline ootamissüntaks (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();
    }
}

Selgitus Code

Mõelge järgmisele koodile:

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

Selles WebDriverWaiti näites ootab skript kuni 20 sekundit, nagu on määratletud WebDriverOota klassi, kuni Eeldatavad tingimused on täidetud – olenevalt sellest, kumb toimub varem.

Ülaltoodud Java kood ootab tingimuse täitmiseks kuni 20 sekundit Asukoha nähtavus tõsi olla.

Järgmisi eeldatavaid tingimusi saab kasutada Selenium Selgesõnaline ootamine:

1. alertIsPresent()
2. elementSelectionStateToBe()
3. elementToBeClickable()
4. elementToBeSelected()
5. raamSaadavalJaLülitaSelle()
6. InvisibilityOfThe ElementLocated()
7. elemendi nähtamatus koos tekstiga()
8. Kõikide elementide olemasolu Asukoht()
9. esinemineOfElementLocated()
10. textToBe PresentInElement()
11. textToBePresentInElementLocated()
12. textToBePresentInElementValue()
13. pealkiri on()
14. titleContains()
15. visibilityOf()
16. VisibilityOfAll Elements()
17. VisibilityOfAll ElementsLocatedBy()
18. visibilityOfElementLocated()

Ladus Oota sisse Selenium

. Ladus Oota sisse Selenium Määrab WebDriveri maksimaalse ootamisaja tingimuse saabumisel ning küsitlussageduse selle tingimuse kontrollimiseks enne ElementNotVisibleExceptioni väljastamist. Fluent Wait kontrollib elementi regulaarsete intervallidega, kuni objekt leitakse või ajalõpp aegub.

Sagedus: Kordustsükkel seisundi hindamiseks regulaarsete intervallidega.

Kujutage ette stsenaariumi, kus element laadib ettearvamatute intervallidega. Element võib laadida 10 sekundi, 20 sekundi või kauem. Kui deklareerime selgesõnalise 20-sekundilise ooteaja, ootab skript enne nurjumist kogu ooteaja. Sellistel juhtudel on Fluent Wait ideaalne valik, kuna see küsitleb määratud sagedusega, kuni element leitakse või viimane taimer aegub.

Sujuva ootamise süntaks (Selenium 4):

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

Vanem signatuur, mis aktsepteeris täisarve ja ajaühikut, aegus aastal Selenium 3.11 ja eemaldatud Selenium 4. Ülaltoodud kestuspõhine API on praegu soovitatav lähenemisviis.

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

Selgitus Code

Mõelge järgmisele koodile:

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

Ülaltoodud näites deklareerime Fluent Wait'i, mille ajalõpp on 30 sekundit, küsitlussagedus on 5 sekundit ja ignoreerime NoSuchElementException.

Mõelge järgmisele koodile:

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

See funktsioon tuvastab lehel veebielemendi (antud juhul Selenium link avalehel). 5-sekundilise küsitlusintervalli ja 30-sekundilise ajalõpuga kontrollib ooterežiim elementi iga 5 sekundi järel maksimaalselt 30 sekundi jooksul. Kui element asub selles aknas, jätkab skript tööd. Vastasel juhul ElementNotVisibleException visatakse.

Samuti kontrollige: Selenium IDE õpetus algajatele

Erinevus kaudse ootamise ja otsese ootamise vahel

Allolev tabel toob esile peamised erinevused kaudse ja otsese ootamise vahel. Selenium.

Kaudne ootamine	Selgesõnaline ootamine
Kaudne ooteaeg rakendatakse skripti kõigile elementidele.	Selgesõnalist ooteaega rakendatakse ainult konkreetselt sihtrühmale määratud elementidele.
Kaudse ootamise korral ei ole elemendi jaoks oodatavaid tingimusi määratud.	Selgesõnalise ootamise korral peavad elemendi jaoks olema määratletud oodatavad tingimused.
Soovitatav, kui elemendid laaditakse konfigureeritud vaikimisi ooteaja jooksul.	Soovitatav, kui elementide laadimine võtab kauem aega ja elementide olekute (nt visibilityOfElementLocated, elementToBeClickable või elementToBeSelected) valideerimisel.
Määratakse üks kord ja rakendatakse WebDriveri eksemplari elutsükli jaoks.	Määrake elemendi või kontrolli kohta, pakkudes täpsemat kontrolli.

Kuidas valida õige ootamisstrateegia

Õige ootamiskäsu valimine mõjutab otseselt skripti stabiilsust ja täitmisaega. Kasutage seda otsustusraamistikku iga stsenaariumi jaoks sobiva valiku valimiseks.

1. Tuvastage koormusmuster: Kontrollige, kas element ilmub fikseeritud ajal, pärast Ajaxi vastust või ettearvamatute intervallidega. Fikseeritud koormused sobivad kaudse ootamise jaoks, samas kui ettearvamatud koormused nõuavad sujuvat ootamist.
2. Vältige kaudsete ja otseste ootamisaegade segamist: Nende kahe kombineerimine võib põhjustada ootamatuid viivitusi, kuna pikem ooteaeg võib domineerida. Selenium dokumentatsioon soovitab WebDriveri seansi kohta kasutada ainult ühte strateegiat.
3. Vaikimisi valitud on selgesõnaline dünaamilise sisu ootamine: Kui lehed sõltuvad Ajaxist, tingimuslikust renderdamisest või animatsioonidest, siis Explicit Wait koos ExpectedConditionsiga on suunatud täpselt olulisele elemendile.
4. Kasutage muutuva ajastuse jaoks Fluent Wait'i: Kui elementide laadimise ajastus käivituste vahel varieerub, konfigureerige Fluent Wait küsitlusintervalliga. Küsitlus vähendab ooteaega võrreldes ühe pika ajalõpuga.
5. Asenda Thread.sleep: Kõvakodeeritud unerežiimid aeglustavad testimiskomplekte ja peidavad reaalajas ajastusega seotud probleeme. Asendage need tingimuslike ootamistega, et hoida täitmine kiire ja deterministlik.
6. Häälestamise ajalõpu väärtused: Alusta lühikeste ajalõpudega (5–10 sekundit) ja suurenda neid ainult siis, kui tõrked näitavad tõelist aeglast laadimist. Pikad vaikimisi ajalõpud varjavad jõudluse regressioone.
7. Hoidke ooteajad abiprogrammides: Tsentraliseeri ooteloogika abiklassi, et ajalõpupoliitika muudatused kehtiksid kogu testikomplektis.

Seda raamistikku järgides saavad automatiseerimisinsenerid luua vastupidavaid skripte, mis kohanduvad reaalse rakenduse ajastusega ilma aeglaseks või hapraks muutumata.

Levinud vead, mida tuleks vältida Selenium Ootab

Isegi kogenud testijad langevad töötades väikestesse korduvatesse lõksudesse Selenium ootab. Nende probleemide vältimine hoiab skriptid kiired, deterministlikud ja meeskondade ja keskkondade lõikes hõlpsasti hallatavad.

Esimene levinud viga on Thread.sleepi ülekasutamine. Kõvakodeeritud paus sunnib skripti ootama kogu kestuse vältel, olenemata elemendi tegelikust saadavusest, mis pikendab kogu käitusaega. Asendage sellised pausid otsese või sujuva ootamisega, et skript jätkaks tööd hetkel, mil tingimus on täidetud.

Teine viga on implitsiitsete ja eksplitsiitsete ooteaegade segamine samas testis. Need kaks mehhanismi võivad omavahel kokku sulada, tekitades ettearvamatuid ajalõpusid, mida on raske siluda. Valige iga WebDriveri seansi kohta üks strateegia ja rakendage seda järjepidevalt.

Kolmas viga on liiga pikkade ajalõpude seadmine „igaks juhuks“. Pikad vaikesätete aknad varjavad tegelikke jõudlusprobleeme ja aeglustavad tagasisidet pideva integratsiooni käigus. Alustage lühikeste ajalõpudega ja pikendage neid ainult siis, kui tõrkelogid tõestavad tegeliku ajastusprobleemi olemasolu.

Samuti kontrollige: Selenium Õpetus algajatele: õppige WebDriver 7 päevaga

KKK