Selenium Czekaj – niejawne i jawne ze składnią
Krishna Szczebel
In Selenium„Oczekiwania” odgrywają ważną rolę w wykonywaniu testów. W tym samouczku poznasz różne aspekty i różnice między niejawnym a jawnym oczekiwaniem Selenium.
Dlaczego potrzebujemy poczekań Selenium?
Większość aplikacji internetowych jest tworzona przy użyciu ajax i Javascript. Kiedy strona ładuje się przez przeglądarkę, elementy, z którymi chcemy wejść w interakcję, mogą ładować się w różnych odstępach czasu.
Nie tylko utrudnia to identyfikację elementu, ale także, jeśli element nie zostanie zlokalizowany, wyświetli się komunikat „Wyjątek ElementNotVisible" wyjątek. Za pomocą Selenium Czekaj, możemy rozwiązać ten problem.
Rozważmy scenariusz, w którym w naszym teście musimy zastosować zarówno ukryte, jak i jawne oczekiwania. Załóżmy, że niejawny czas oczekiwania jest ustawiony na 20 sekund, a jawny czas oczekiwania jest ustawiony na 10 sekund.
Załóżmy, że próbujemy znaleźć element, który ma jakieś „Oczekiwane warunki „(Jawne oczekiwanie), Jeśli element nie znajduje się w przedziale czasowym określonym przez jawne oczekiwanie (10 sekund), zostanie użyty przedział czasowy określony przez niejawne oczekiwanie (20 sekund) przed zgłoszeniem „Wyjątek ElementNotVisible".
Selenium Sterownik sieciowy czeka
- Niejawne oczekiwanie
- Wyraźne oczekiwanie
W tym samouczku poznasz różne rodzaje oczekiwania Selenium:
Niejawne Czekanie Selenium
Menu główne Niejawne Czekanie Selenium jest używane do polecenia sterownikowi sieci web, aby poczekał określony czas, zanim zgłosi wyjątek „No Such Element Exception”. Domyślne ustawienie to 0. Po ustawieniu czasu sterownik sieci web będzie czekał na element przez ten czas, zanim zgłosi wyjątek.
Selenium Web Driver zapożyczył ideę ukrytego oczekiwania od Watir.
W poniższym przykładzie zadeklarowaliśmy ukryte oczekiwanie z przedziałem czasowym wynoszącym 10 sekund. Oznacza to, że jeśli element nie znajdzie się na stronie w tym czasie, zgłosi wyjątek.
Aby zadeklarować ukryte oczekiwanie Selenium Sterownik sieciowy:
Niejawna składnia oczekiwania:
driver.manage().timeouts().implicitlyWait(TimeOut, TimeUnit.SECONDS);
package guru.test99;
import java.util.concurrent.TimeUnit;
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
{
System.setProperty ("webdriver.chrome.driver",".\\chromedriver.exe" );
driver = new ChromeDriver();
driver.manage().timeouts().implicitlyWait(10,TimeUnit.SECONDS) ;
String eTitle = "Demo Guru99 Page";
String aTitle = "" ;
// launch Chrome and redirect it to the Base URL
driver.get("https://demo.guru99.com/test/guru99home/" );
//Maximizes 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();
}
}
Wyjaśnienie kodu
W powyższym przykładzie
Rozważ poniższy kod:
driver.manage().timeouts().implicitlyWait(10,TimeUnit.SECONDS) ;
Niejawne oczekiwanie akceptuje 2 parametry: pierwszy parametr akceptuje czas jako wartość całkowitą, a drugi parametr akceptuje pomiar czasu w SEKUNDACH, MINUTACH, MILISEKONDACH, MIKROSEKUNDACH, NANOSEKONDACH, DNIACH, GODZINACH itd.
Wyraźne czekanie Selenium
Menu główne Wyraźne czekanie Selenium jest używane do polecenia Web Driverowi, aby czekał na określone warunki (oczekiwane warunki) lub przekroczony został maksymalny czas przed zgłoszeniem wyjątku „ElementNotVisibleException”. Jest to inteligentny rodzaj oczekiwania, ale może być stosowany tylko dla określonych elementów. Daje lepsze opcje niż niejawne oczekiwanie, ponieważ czeka na dynamicznie ładowane elementy Ajax.
Kiedy zadeklarujemy jawne oczekiwanie, musimy użyć „Oczekiwane warunki” lub możemy skonfigurować częstotliwość sprawdzania warunku za pomocą Płynne czekanie. Obecnie podczas wdrażania używamy Wątek.Sen() generalnie nie zaleca się stosowania
W poniższym przykładzie tworzymy oczekiwanie referencyjne dla „WebDriverCzekaj” klasa i tworzenie instancji przy użyciu „Sterownik sieciowy” i podajemy maksymalny przedział czasowy wynoszący 20 sekund.
Jawna składnia oczekiwania:
WebDriverWait wait = new WebDriverWait(WebDriverRefrence,TimeOut);
package guru.test99;
import java.util.concurrent.TimeUnit;
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
{
System.setProperty ("webdriver.chrome.driver",".\\chromedriver.exe" );
driver = new ChromeDriver();
WebDriverWait wait=new WebDriverWait(driver, 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/" );
//Maximizes 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();
}
}
Wyjaśnienie kodu
Rozważ poniższy kod:
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();
W tym przykładzie oczekiwania WebDriver poczekaj przez czas określony w „WebDriverCzekaj„klasa” lub „Oczekiwane warunki” zaistnieje, w zależności od tego, co nastąpi wcześniej.
Powyżej Java kod stwierdza, że czekamy na element przez okres 20 sekund zdefiniowany w „WebDriverCzekaj” na stronie internetowej do momentu „Oczekiwane warunki” są spełnione, a warunek brzmi „widoczność zlokalizowanego elementu".
Poniżej przedstawiono oczekiwane warunki, które można zastosować w Selenium Wyraźne oczekiwanie
- alertIsPresent()
- elementSelectionStateToBe()
- elementToBeClickable()
- elementToBeSelected()
- ramkaToBeAvaliableAndSwitchToIt()
- niewidzialnośćOfTheElementLocated()
- niewidzialnośćElementuWithText()
- obecnośćOfAllElementsLocatedBy()
- obecnośćOfElementLocated()
- tekstToBePresentInElement()
- tekstToBePresentInElementLocated()
- tekstToBePresentInElementValue()
- tytułIs()
- tytułZawiera()
- widoczność()
- widocznośćOfAllElements()
- widocznośćOfAllElementsLocatedBy()
- widocznośćOfElementLocated()
Płynnie Zaczekaj Selenium
Menu główne Płynnie Zaczekaj Selenium służy do definiowania maksymalnego czasu oczekiwania sterownika internetowego na warunek, a także częstotliwości, z jaką chcemy sprawdzać warunek przed zgłoszeniem wyjątku „ElementNotVisibleException”. Sprawdza on element internetowy w regularnych odstępach czasu, aż obiekt zostanie znaleziony lub nastąpi przekroczenie limitu czasu.
Częstotliwość: Ustawianie cyklu powtarzania z ramą czasową sprawdzania/weryfikacji stanu w regularnych odstępach czasu
Rozważmy scenariusz, w którym element jest ładowany w różnych odstępach czasu. Element może załadować się w ciągu 10 sekund, 20 sekund lub nawet więcej, jeśli zadeklarujemy jawne oczekiwanie wynoszące 20 sekund. Będzie czekać do określonego czasu przed zgłoszeniem wyjątku. W takich scenariuszach oczekiwanie płynne jest idealnym oczekiwaniem, ponieważ będzie próbowało znaleźć element z różną częstotliwością, aż go znajdzie lub upłynie ostateczny czas.
Składnia płynnego oczekiwania:
Wait wait = new FluentWait(WebDriver reference) .withTimeout(timeout, SECONDS) .pollingEvery(timeout, SECONDS) .ignoring(Exception.class);
Powyższy kod jest przestarzały w Selenium v3.11 i nowsze. Musisz użyć
Wait wait = new FluentWait(WebDriver reference) .withTimeout(Duration.ofSeconds(SECONDS)) .pollingEvery(Duration.ofSeconds(SECONDS)) .ignoring(Exception.class);
package guru.test99;
import org.testng.annotations.Test;
import java.util.NoSuchElementException;
import java.util.concurrent.TimeUnit;
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.ExpectedConditions;
import org.openqa.selenium.support.ui.FluentWait;
import org.openqa.selenium.support.ui.Wait;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.testng.annotations.Test;
public class AppTest3 {
protected WebDriver driver;
@Test
public void guru99tutorials() throws InterruptedException
{
System.setProperty ("webdriver.chrome.driver",".\\chromedriver.exe" );
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/" );
//Maximizes 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<WebDriver>(driver)
.withTimeout(30, TimeUnit.SECONDS)
.pollingEvery(5, TimeUnit.SECONDS)
.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() ;
}
}
Wyjaśnienie kodu
Rozważ poniższy kod:
Wait<WebDriver> wait = new FluentWait<WebDriver>(driver) .withTimeout(30, TimeUnit.SECONDS) .pollingEvery(5, TimeUnit.SECONDS) .ignoring(NoSuchElementException.class);
W powyższym przykładzie deklarujemy płynne oczekiwanie z limitem czasu 30 sekund, a częstotliwość ustawiamy na 5 sekund ignorując „Wyjątek NoSuchElement"
Rozważ poniższy kod:
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"));
Stworzyliśmy nową funkcję identyfikującą Element WWW na stronie. (Przykład: Tutaj element sieciowy to nic innego jak plik Selenium link na stronie).
Częstotliwość jest ustawiona na 5 sekund, a maksymalny czas jest ustawiony na 30 sekund. Oznacza to, że będzie sprawdzać element na stronie internetowej co 5 sekund przez maksymalny czas 30 sekund. Jeśli element znajduje się w tym przedziale czasowym, wykona operacje, w przeciwnym razie wyrzuci „Wyjątek ElementNotVisible"
Sprawdź również: - Selenium Samouczek IDE dla początkujących
Różnica między niejawnym oczekiwaniem a jawnym oczekiwaniem
Poniżej przedstawiono główną różnicę między oczekiwaniem niejawnym a oczekiwaniem jawnym. Selenium:
| Niejawne oczekiwanie | Wyraźne oczekiwanie |
|---|---|
| Niejawny czas oczekiwania jest stosowany do wszystkich elementów skryptu | Jawny czas oczekiwania jest stosowany tylko do tych elementów, które są przez nas zamierzone |
| W Implicit Wait potrzebujemy nie określ „ExpectedConditions” na elemencie, który ma zostać zlokalizowany | W trybie Explicit Wait musimy określić „ExpectedConditions” dla elementu, który ma zostać zlokalizowany |
| Zaleca się stosować, gdy elementy znajdują się w przedziale czasowym określonym w Selenium ukryte oczekiwanie | Zaleca się go używać, gdy ładowanie elementów zajmuje dużo czasu, a także do sprawdzania właściwości elementu, np. (visibilityOfElementLocated, elementToBeClickable,elementToBeSelected) |
Podsumowanie
Niejawne, jawne i płynne oczekiwanie to różne rodzaje czekania używane w Selenium. Użycie tych oczekiwań opiera się całkowicie na elementach, które są ładowane w różnych odstępach czasu. Nie zawsze zaleca się używanie funkcji Thread.Sleep() podczas Testowanie naszej aplikacji lub budowania naszego frameworka.
Sprawdź również: - Selenium Samouczek dla początkujących: Naucz się WebDrivera w 7 dni
