Implisiittinen ja eksplisiittinen odotus Selenium syntaksin kanssa

In Selenium"Odotuksilla" on tärkeä rooli luotettavien testien suorittamisessa. Tässä opetusohjelmassa opit implisiittisten ja eksplisiittisten odotuskomentojen keskeiset näkökohdat ja erot. Seleniumsekä käytännön Fluent Wait -käyttöä.

Miksi tarvitsemme odotuksia Selenium?

Useimmat nykyaikaiset verkkosovellukset on kehitetty käyttämällä Ajax ja JavaKäsikirjoitusKun selain lataa sivun, elementit, joiden kanssa haluamme olla vuorovaikutuksessa, voivat latautua eri aikavälein.

Tämä ei ainoastaan ​​vaikeuta elementin tunnistamista, vaan jos elementtiä ei paikanneta ajoissa, Selenium heittää ElementNotVisibleException. Selenium Odotusajat ratkaisevat tämän synkronointiongelman antamalla WebDriverille määritellyn ikkunan, jossa elementti voidaan etsiä ennen epäonnistumista.

Tarkastellaan tilannetta, jossa samassa testissä käytetään sekä implisiittisiä että eksplisiittisiä odotusaikoja. Oletetaan, että implisiittinen odotus on asetettu 20 sekuntiin ja eksplisiittinen odotus on asetettu 10 sekuntiin.

Jos etsimme elementtiä, jota hallitsee tietty Odotetut olosuhteet (Eksplisiittinen odotus) ja elementti ei sijaitse eksplisiittisen 10 sekunnin ikkunan sisällä, WebDriver palaa implisiittiseen 20 sekunnin ikkunaan ennen virheen heittämistä. ElementNotVisibleException.

Selenium WebDriver-odotukset

1. Epäsuora odota
2. Selkeä odota
3. Sujuva odotus

Implisiittinen Odota sisään Selenium

Implisiittinen Odota sisään Selenium Ohjaa WebDriveria odottamaan määritetyn ajan ennen NoSuchElementException-poikkeuksen heittämistä. Oletusarvo on 0. Kun määritys on tehty, WebDriver kyselee DOM:ia kyseisen ajan ennen epäonnistumista. Selenium WebDriver peri implisiittisten odotusaikojen käsitteen Watir.

Alla olevassa esimerkissä määrittelemme implisiittisen odotuksen, jonka kesto on 10 sekuntia. Jos elementti ei sijaitse kyseisessä ikkunassa, syntyy poikkeus.

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

Selitys Code

Tarkastellaan yllä olevassa esimerkissä seuraavaa lausetta:

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

Selenium Versiossa 4 vanha kaksiargumenttinen allekirjoitus (kokonaisluku plus aikayksikkö) korvattiin yhdellä Duration-argumentilla. Duration-luokka tukee sekunteja, minuutteja, millisekunteja ja muita aikayksiköitä staattisten apufunktioiden, kuten Duration.ofSeconds, Duration.ofMillis ja Duration.ofMinutes, avulla.

Selkeä Odota sisään Selenium

Selkeä Odota sisään Selenium Ohjaa WebDriveria odottamaan tiettyjä ehtoja (odotetut ehdot) tai enimmäiskeston ennen ElementNotVisibleException-poikkeuksen heittämistä. Se on älykkäämpi odotustapa, koska se koskee vain määritettyä elementtiä. Eksplisiittinen odotus on parempi kuin implisiittinen odotus aina, kun testin on käsiteltävä dynaamisesti ladattua Ajax-sisältöä.

Kun eksplisiittinen odotus on ilmoitettu, sinun on käytettävä Odotetut olosuhteettai voit määrittää kyselytiheyden käyttämällä Sujuva odotus. Vältä käyttöä Thread.sleep(), koska se keskeyttää suorituksen ehdoitta ja sitä pidetään yleisesti huonona käytäntönä.

Alla olevassa esimerkissä luomme viittauksen kohteeseen WebDriverOdota luokka, luo siitä instanssi web-ajuri viittaus ja määritä enimmäisikkunaksi 20 sekuntia.

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

Selitys Code

Harkitse seuraavaa koodia:

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

Tässä WebDriverWait-esimerkissä komentosarja odottaa jopa 20 sekuntia, kuten on määritelty WebDriverOdota luokka, kunnes Odotetut olosuhteet täyttyvät – sen mukaan, kumpi tapahtuu ensin.

Ylempi Java koodi odottaa ehtoa jopa 20 sekuntia näkyvyysElementtiSijaittu olla totta.

Seuraavia odotettuja ehtoja voidaan käyttää Selenium Eksplisiittinen odotus:

1. alertIsPresent()
2. elementSelectionStateToBe()
3. elementToBeClickable()
4. elementToBeSelected()
5. frameToBeavailableJa SwitchToIt()
6. InvisibilityOfThe ElementLocated()
7. invisibilityOf ElementWithText()
8. läsnäoloAllElementsLocatedBy()
9. läsnäoloOfElementLocated()
10. textToBePresentInElement()
11. textToBePresentInElementLocated()
12. textToBePresentInElementValue()
13. titleIs()
14. titleContains()
15. näkyvyys()
16. VisibilityOfAll Elements()
17. VisibilityOfAll ElementsLocatedBy()
18. visibilityOfElementLocated()

Sujuva Odota Selenium

Sujuva Odota Selenium Määrittää WebDriverin enimmäisajan, jonka se odottaa ehtoa, sekä kyselytiheyden ehdon varmentamiseksi ennen ElementNotVisibleException-poikkeuksen heittämistä. Fluent Wait tarkistaa elementin säännöllisin väliajoin, kunnes objekti löytyy tai aikakatkaisuaika umpeutuu.

Taajuus: Toistosykli tilan arvioimiseksi säännöllisin väliajoin.

Tarkastellaan tilannetta, jossa elementti latautuu ennalta arvaamattomin väliajoin. Elementti voi latautua 10 sekunnissa, 20 sekunnissa tai pidempään. Jos määritämme eksplisiittisen 20 sekunnin odotusajan, skripti odottaa koko latauksen keston ennen epäonnistumista. Tällaisissa tapauksissa Fluent Wait on ihanteellinen valinta, koska se suorittaa kyselyn määritetyllä taajuudella, kunnes elementti löytyy tai viimeinen ajastin umpeutuu.

Sujuvan odotuksen syntaksi (Selenium 4):

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

Vanhempi allekirjoitus, joka hyväksyi kokonaislukuarvot ja aikayksikön, vanhentui vuonna Selenium 3.11 ja poistettu kohdassa Selenium 4. Yllä esitetty kestoon perustuva API on tällä hetkellä suositeltu lähestymistapa.

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

Selitys Code

Harkitse seuraavaa koodia:

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

Yllä olevassa esimerkissä määrittelemme Fluent Waitin, jonka aikakatkaisu on 30 sekuntia, kyselytaajuus on 5 sekuntia ja jätämme huomiotta NoSuchElementException.

Harkitse seuraavaa koodia:

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

Tämä funktio tunnistaa sivun WebElementin (tässä tapauksessa Selenium linkki kotisivulla). Viiden sekunnin kyselyvälillä ja 30 sekunnin aikakatkaisulla odotustoiminto tarkistaa elementin 5 sekunnin välein enintään 30 sekunnin ajan. Jos elementti sijaitsee kyseisessä ikkunassa, komentosarja jatkaa. Muussa tapauksessa ElementNotVisibleException heitetään.

Tarkista myös: Selenium IDE-opastus aloittelijoille

Ero implisiittisen odotuksen ja eksplisiittisen odotuksen välillä

Alla oleva taulukko korostaa implisiittisen odotuksen ja eksplisiittisen odotuksen keskeisiä eroja Selenium.

Epäsuora odota	Selkeä odota
Implisiittinen odotusaika sovelletaan kaikkiin skriptin elementteihin.	Eksplisiittistä odotusaikaa käytetään vain erityisesti kohdennettuihin elementteihin.
Implisiittisessä odotustilassa elementille ei ole määritetty odotettuja ehtoja.	Eksplisiittisessä odotustilassa elementille on määriteltävä ExpectedConditions.
Suositellaan, kun elementit latautuvat määritetyn implisiittisen odotusikkunan sisällä.	Suositellaan, kun elementtien lataaminen kestää kauemmin ja kun elementtien tiloja, kuten visibilityOfElementLocated, elementToBeClickable tai elementToBeSelected, validoidaan.
Asetettu kerran ja otettu käyttöön WebDriver-instanssin elinkaaren ajan.	Aseta elementtikohtaisesti tai tarkistuskohtaisesti, mikä tarjoaa tarkemman hallinnan.

Kuinka valita oikea odotusstrategia

Oikean odotuskomennon valitseminen vaikuttaa suoraan skriptin vakauteen ja suoritusaikaan. Käytä tätä päätöksentekokehystä valitaksesi sopivan vaihtoehdon kullekin skenaariolle.

1. Tunnista kuormituskuvio: Tarkista, ilmestyykö elementti kiinteään aikaan, Ajax-vastauksen jälkeen vai ennalta-arvaamattomin väliajoin. Kiinteät kuormat sopivat implisiittiseen odotukseen, kun taas ennalta-arvaamattomat kuormat vaativat sujuvaa odotusta.
2. Vältä implisiittisten ja eksplisiittisten odotusaikojen sekoittamista: Näiden kahden yhdistäminen voi aiheuttaa odottamattomia viivästyksiä, koska pidempi odotusaika voi olla hallitseva. Selenium dokumentaatio suosittelee vain yhden strategian käyttöä WebDriver-istuntoa kohden.
3. Oletusarvoisesti odota dynaamista sisältöä eksplisiittisen sisällön kohdalla: Kun sivut ovat riippuvaisia ​​Ajaxista, ehdollisesta renderöinnistä tai animaatioista, Explicit Wait with ExpectedConditions kohdistuu juuri siihen elementtiin, jolla on merkitystä.
4. Käytä Fluent Waitia muuttuvalle ajoitukselle: Kun elementtien latausaika vaihtelee ajojen välillä, määritä Fluent Wait -toimintoon kyselyväli. Kysely lyhentää kokonaisodotusaikaa verrattuna yhteen pitkään aikakatkaisuun.
5. Korvaa Thread.sleep: Kovakoodatut nukkumistoiminnot hidastavat testisarjoja ja piilottavat reaaliaikaisia ​​ajoitusongelmia. Korvaa ne ehdollisilla odotustoiminnoilla pitääksesi suorituksen nopeana ja deterministisenä.
6. Virityksen aikakatkaisuarvot: Aloita lyhyillä aikakatkaisuilla (5–10 sekuntia) ja lisää niitä vain, jos virheet osoittavat aitoa hidasta latausta. Pitkät oletusaikakatkaisut peittävät suorituskyvyn regressiot.
7. Pidä odotusajat apuohjelmissa: Keskitä odotuslogiikka apuluokkaan, jotta aikakatkaisukäytäntöjen muutokset koskevat koko testipakettia.

Tätä viitekehystä noudattamalla automaatioinsinöörit voivat rakentaa kestäviä skriptejä, jotka mukautuvat todelliseen sovellusajoitukseen hidastumatta tai haurastumatta.

Yleisiä virheitä, joita kannattaa välttää Selenium Odottaa

Jopa kokeneet testaajat lankeavat muutamaan toistuvaan ansoihin työskennellessään Selenium odotusajat. Näiden ongelmien välttäminen pitää skriptit nopeina, deterministisinä ja helposti ylläpidettävinä eri tiimeissä ja ympäristöissä.

Ensimmäinen yleinen virhe on Thread.sleep-funktion liikakäyttö. Kovakoodattu tauko pakottaa komentosarjan odottamaan koko keston riippumatta elementin todellisesta saatavuudesta, mikä pidentää kokonaissuoritusaikaa. Korvaa tällaiset tauot Explicit- tai Fluent Wait -taukoilla, jotta komentosarja jatkaa suoritusta heti, kun ehto täyttyy.

Toinen virhe on implisiittisten ja eksplisiittisten odotusaikojen yhdistäminen samaan testiin. Nämä kaksi mekanismia voivat kasaantua ja luoda arvaamattomia aikakatkaisuja, joita on vaikea korjata. Valitse yksi strategia WebDriver-istuntoa kohden ja käytä sitä johdonmukaisesti.

Kolmas virhe on asettaa liian pitkät aikakatkaisut "varmuuden vuoksi". Pitkät oletusikkunat peittävät aitoja suorituskykyongelmia ja hidastavat palautetta jatkuvissa integraatioputkissa. Aloita lyhyillä aikakatkaisuilla ja pidennä niitä vain, jos virhelokit osoittavat todellisen ajoitusongelman olemassaolon.

Tarkista myös: Selenium Opetusohjelma aloittelijoille: Opi WebDriver 7 päivässä

UKK