Implicit és explicit várakozás Selenium szintaxissal

In SeleniumA „várakozások” fontos szerepet játszanak a megbízható tesztek végrehajtásában. Ebben az oktatóanyagban megismerkedhetsz az implicit és explicit várakozási parancsok főbb aspektusaival és különbségeivel a Selenium, valamint a Fluent Wait gyakorlati használatát.

Miért van szükségünk várakozásra? Selenium?

A legtöbb modern webes alkalmazás fejlesztése a következő eszközökkel történik: Ajax és a JavaForgatókönyvAmikor a böngésző betölt egy oldalt, az általunk használni kívánt elemek eltérő időközönként töltődhetnek be.

Ez nemcsak az elem azonosítását nehezíti meg, de ha az elem nem található meg időben, Selenium dobni fog egy ElementNotVisibleException. Selenium A várakozások úgy oldják meg ezt a szinkronizációs problémát, hogy egy meghatározott ablakot adnak a WebDrivernek, amelyben megkeresheti az elemet a hiba előtt.

Tekintsünk egy olyan forgatókönyvet, amelyben implicit és explicit várakozást is használunk ugyanabban a tesztben. Tegyük fel, hogy az implicit várakozás 20 másodpercre, az explicit várakozás pedig 10 másodpercre van beállítva.

Ha egy bizonyos elemek által szabályozott elemet keresünk Várható feltételek (Explicit várakozás) és az elem nem található a 10 másodperces explicit ablakon belül, a WebDriver visszatér a 20 másodperces implicit ablakhoz, mielőtt hibaüzenetet dobna. ElementNotVisibleException.

Selenium WebDriver várakozások

1. Implicit várakozás
2. Kifejezett várakozás
3. Folyékony várakozás

Implicit bevárás Selenium

Az Implicit bevárás Selenium Arra utasítja a WebDrivert, hogy egy meghatározott ideig várjon, mielőtt NoSuchElementException kivételt dobna. Az alapértelmezett érték 0. A konfigurálás után a WebDriver lekérdezi a DOM-ot ez idő alatt, mielőtt meghibásodna. Selenium A WebDriver az implicit várakozások koncepcióját a következőtől örökölte: Watir.

Az alábbi példában egy implicit várakozást deklarálunk 10 másodperces időtartammal. Ha az elem nem található meg az adott ablakban, kivétel keletkezik.

Implicit várakozási szintaxis (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();
    }
}

Magyarázat Code

A fenti példában vegyük figyelembe a következő állítást:

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

Selenium A 4-es verzió a régebbi, két argumentumos aláírást (egész szám plusz TimeUnit) egyetlen Duration argumentummal váltotta fel. A Duration osztály másodperceket, perceket, milliszekundumokat és más időegységeket támogat statikus segédfüggvényeken, például Duration.ofSeconds, Duration.ofMillis és Duration.ofMinutes függvényeken keresztül.

Explicit Várj be Selenium

Az Explicit Várj be Selenium Arra utasítja a WebDriver-t, hogy várjon bizonyos feltételekre (Várható feltételek) vagy egy maximális időtartamra, mielőtt ElementNotVisibleException kivételt dobna. Ez egy okosabb várakozási mód, mivel csak a megadott elemre vonatkozik. Az Explicit Wait (explit várakozás) előnyben részesül az Implicit Waittel szemben, amikor a tesztnek dinamikusan betöltött Ajax tartalmat kell kezelnie.

Miután egy explicit várakozást deklaráltál, a következőt kell használnod: Várható feltételek, vagy beállíthatja a lekérdezési gyakoriságot a következővel: Folyékony várakozás. Kerülje a használatát Thread.sleep(), mivel feltétel nélkül szünetelteti a végrehajtást, és általában rossz gyakorlatnak számít.

Az alábbi példában létrehozunk egy hivatkozást a WebDriverVárjon osztály, példányosítsd a webdriver referenciát, és állítson be egy maximum 20 másodperces ablakot.

Explicit várakozási szintaxis (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();
    }
}

Magyarázat Code

Vegye figyelembe a következő kódot:

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

Ebben a WebDriverWait példában a szkript legfeljebb 20 másodpercig vár, a WebDriverVárjon osztály, egészen addig, amíg Várható feltételek teljesülnek – attól függően, hogy melyik következik be előbb.

A fenti Java a kód akár 20 másodpercig is vár a feltételre ElemLáthatósága hogy igaz legyen.

A következő várható feltételek használhatók a következőkben: Selenium Kifejezett várakozás:

1. alertIsPresent()
2. elementSelectionStateToBe()
3. elementToBeClickable()
4. elemToBeSelected()
5. frameToLehetőÉs VáltsonToIt()
6. invisibilityOfThe ElementLocated()
7. invisibilityOf ElementWithText()
8. jelenlétOfAll ElementsLocatedBy()
9. jelenlétOfElementLocated()
10. textToBePresentInElement()
11. textToBePresentInElementLocated()
12. textToBePresentInElementValue()
13. titleIs()
14. titleContains()
15. láthatósága()
16. VisibilityOfAll Elements()
17. VisibilityOfAll ElementsLocatedBy()
18. VisibilityOfElementLocated()

Folyékony Várjon Selenium

Az Folyékony Várjon Selenium A Fluent Wait függvény meghatározza a WebDriver által egy feltételre várakozó maximális időtartamot, valamint a feltétel ElementNotVisibleException kivétel dobása előtti lekérdezési gyakoriságot. A Fluent Wait függvény rendszeres időközönként ellenőrzi az elem meglétét, amíg az objektum meg nem található, vagy az időkorlát le nem jár.

Frekvencia: Az állapot rendszeres időközönkénti értékelésének ismétlési ciklusa.

Vegyünk egy olyan forgatókönyvet, ahol egy elem kiszámíthatatlan időközönként töltődik be. Az elem betöltődhet 10 másodperc, 20 másodperc vagy hosszabb idő alatt. Ha explicit módon 20 másodperces várakozást deklarálunk, a szkript a teljes időtartamig vár, mielőtt meghibásodna. Ilyen esetekben a Fluent Wait az ideális választás, mivel a megadott gyakorisággal lekérdezi az elemet, amíg meg nem találja, vagy az utolsó időzítő le nem jár.

Fluent Wait szintaxis (Selenium 4):

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

A régebbi aláírás, amely egész számokat és a TimeUnit-ot fogadta el, elavulttá vált a következőben: Selenium 3.11-ben és eltávolítva Selenium 4. A fent bemutatott időtartam-alapú API a jelenleg ajánlott megközelítés.

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

Magyarázat Code

Vegye figyelembe a következő kódot:

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

A fenti példában egy Fluent Wait-ot deklarálunk 30 másodperces időtúllépéssel, 5 másodperces lekérdezési gyakorisággal, és figyelmen kívül hagyjuk a következőt: NoSuchElementException.

Vegye figyelembe a következő kódot:

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

Ez a függvény azonosítja az oldalon található WebElement elemet (itt a Selenium link a kezdőlapon). 5 másodperces lekérdezési intervallummal és 30 másodperces időtúllépéssel a várakozás 5 másodpercenként ellenőrzi az elemet, legfeljebb 30 másodpercig. Ha az elem az adott ablakon belül található, a szkript folytatódik. Ellenkező esetben egy ElementNotVisibleException el van dobva.

Szintén ellenőrizze: Selenium IDE oktatóanyag kezdőknek

Különbség az implicit várakozás és az explicit várakozás között

Az alábbi táblázat kiemeli az implicit és az explicit várakozás közötti főbb különbségeket. Selenium.

Implicit várakozás	Kifejezett várakozás
Az implicit várakozási idő a szkript összes elemére vonatkozik.	Az explicit várakozási idő csak a konkrétan célzott elemekre vonatkozik.
Az Implicit Wait esetén az elemhez nincsenek megadva a VárhatóFeltételek.	Explicit Wait esetén az elemhez definiálni kell a ExpectedConditions értékeket.
Ajánlott, ha az elemek a konfigurált implicit várakozási ablakon belül töltődnek be.	Ajánlott, ha az elemek betöltése lassabb időt vesz igénybe, és olyan elemállapotok érvényesítésekor, mint a visibilityOfElementLocated, az elementToBeClickable vagy az elementToBeSelected.
Egyszer beállítva és alkalmazva a WebDriver példány életciklusára.	Elemenként vagy ellenőrzésenként beállítható, ami finomabb szabályozást biztosít.

Hogyan válasszuk ki a megfelelő várakozási stratégiát

A helyes várakozási parancs kiválasztása közvetlenül befolyásolja a szkript stabilitását és végrehajtási idejét. Használja ezt a döntési keretrendszert a megfelelő opció kiválasztásához minden egyes forgatókönyvhöz.

1. A terhelési minta azonosítása: Ellenőrizd, hogy az elem egy fix időpontban, az Ajax válasz után vagy kiszámíthatatlan időközönként jelenik-e meg. A fix terhelések implicit várakozást igényelnek, míg a kiszámíthatatlan terhelések folyékony várakozást igényelnek.
2. Kerüld az implicit és explicit várakozások keverését: A kettő kombinációja váratlan késéseket okozhat, mivel a hosszabb várakozás dominálhat. Selenium A dokumentáció WebDriver munkamenetenként csak egy stratégia használatát javasolja.
3. Alapértelmezett beállítás Explicit várakozás dinamikus tartalom esetén: Amikor az oldalak Ajaxtól, feltételes rendereléssel vagy animációkkal függenek, az Explicit Wait with ExpectedConditions pontosan a fontos elemet célozza meg.
4. Használja a Fluent Wait funkciót változó időzítéshez: Ha az elemek betöltési időzítése a futtatások között változik, konfigurálja a Fluent Wait szolgáltatást lekérdezési intervallummal. A lekérdezés csökkenti a teljes várakozási időt egyetlen hosszú időtúllépéshez képest.
5. Cserélje le a Thread.sleep fájlt: A fixen kódolt alvó üzemmódok lelassítják a tesztcsomagokat és elrejtik a valós időzítési problémákat. Cseréld le őket feltételes várakozásokkal, hogy a végrehajtás gyors és determinisztikus maradjon.
6. Hangolási időtúllépési értékek: Kezdj rövid időtúllépésekkel (5–10 másodperc), és csak akkor növeld őket, ha a hibák valódi lassú betöltést mutatnak. A hosszú alapértelmezett időtúllépések elfedik a teljesítménybeli visszaeséseket.
7. Várakozások megtartása a segédprogramokban: Központosítsa a várakozási logikát egy segítő osztályban, hogy az időtúllépési szabályzat módosításai a teljes tesztkészletre érvényesek legyenek.

Ezt a keretrendszert követve az automatizálási mérnökök rugalmas szkripteket hozhatnak létre, amelyek alkalmazkodnak a valós alkalmazásidőzítéshez anélkül, hogy lassúvá vagy törékennyé válnának.

Gyakori hibák, amelyeket el kell kerülni a Selenium Vár

Még a tapasztalt tesztelők is beleesnek egy sor visszatérő csapdába, amikor a következővel dolgoznak: Selenium várakozások. Ezen problémák elkerülése gyors, determinisztikus és könnyen karbantartható szkripteket eredményez a különböző csapatok és környezetek között.

Az első gyakori hiba a Thread.sleep túlzott használata. A fixen kódolt szünetek arra kényszerítik a szkriptet, hogy a teljes időtartamig várjon, függetlenül az elem tényleges elérhetőségétől, ami megnöveli a teljes futási időt. Az ilyen szüneteket cserélje le Explicit vagy Fluent Wait szünetekre, hogy a szkript a feltétel teljesülésekor folytassa a folyamatot.

A második hiba az implicit és explicit várakozások keverése ugyanabban a tesztben. A két mechanizmus összeadódhat, kiszámíthatatlan időtúllépéseket eredményezve, amelyeket nehéz hibakeresni. Válasszon egy stratégiát WebDriver munkamenetenként, és alkalmazza azt következetesen.

Egy harmadik hiba az időkorlátok túl magasra állítása „csak a biztonság kedvéért”. A hosszú alapértelmezett ablakok elrejtik a valódi teljesítményproblémákat, és lelassítják a visszajelzést a folyamatos integrációs folyamatokban. Kezdjünk rövid időkorlátokkal, és csak akkor hosszabbítsuk meg őket, ha a hibanaplók valódi időzítési problémát bizonyítanak.

Szintén ellenőrizze: Selenium Oktatóanyag kezdőknek: Tanulja meg a WebDrivert 7 nap alatt

GYIK