Nel selenio, le "attese" svolgono un ruolo importante nell'esecuzione dei test. In questo tutorial imparerai vari aspetti delle attese "implicite" ed "esplicite" in selenio.
In questo tutorial imparerai:
- Perché abbiamo bisogno di attese nel selenio?
- Attesa implicita
- Attesa esplicita
- Aspetta fluente
Perché abbiamo bisogno di attese nel selenio?
La maggior parte delle applicazioni web sono sviluppate utilizzando Ajax e Javascript. Quando una pagina viene caricata dal browser, gli elementi con cui vogliamo interagire possono caricarsi a intervalli di tempo diversi.
Non solo rende difficile identificare l'elemento, ma anche se l'elemento non si trova, genererà un'eccezione " ElementNotVisibleException ". Usando Selenium Waits, possiamo risolvere questo problema.
Consideriamo uno scenario in cui dobbiamo utilizzare attese sia implicite che esplicite nel nostro test. Si supponga che il tempo di attesa implicito sia impostato su 20 secondi e il tempo di attesa esplicito sia impostato su 10 secondi.
Supponiamo di provare a trovare un elemento che ha delle "ExpectedConditions " (Explicit Wait), Se l'elemento non si trova entro il periodo di tempo definito dall'Explicit wait (10 Seconds), utilizzerà il time frame definito da implicit wait ( 20 secondi) prima di lanciare una " ElementNotVisibleException ".
Selenium Web Driver attende
- Attesa implicita
- Attesa esplicita
Attesa implicita nel selenio
L' attesa implicita in selenio viene utilizzata per dire al driver web di attendere un certo periodo di tempo prima di lanciare una "eccezione di tale elemento". L'impostazione predefinita è 0. Una volta impostata l'ora, il driver web attenderà l'elemento per quel tempo prima di lanciare un'eccezione.
Selenium Web Driver ha preso in prestito l'idea delle attese implicite da Watir.
Nell'esempio seguente abbiamo dichiarato un'attesa implicita con un intervallo di tempo di 10 secondi. Significa che se l'elemento non si trova sulla pagina web entro quel lasso di tempo, genererà un'eccezione.
Per dichiarare l'attesa implicita:
Sintassi :
driver.manage (). timeouts (). implicitlyWait (TimeOut, TimeUnit.SECONDS);
pacchetto 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 {driver WebDriver protetto;@Testpublic void guru99tutorials () genera InterructedException{System.setProperty ("webdriver.chrome.driver", ". \\ chromedriver.exe");driver = nuovo ChromeDriver ();driver.manage (). timeouts (). implicitlyWait (10, TimeUnit.SECONDS);String eTitle = "Demo Guru99 Page";String aTitle = "";// avvia Chrome e reindirizzalo all'URL di basedriver.get ("http://demo.guru99.com/test/guru99home/");// Ingrandisce la finestra del browserdriver.manage (). window (). maxim ();// ottiene il valore effettivo del titoloaTitle = driver.getTitle ();// confronta il titolo effettivo con il titolo previstoif (aTitle.equals (eTitle)){System.out.println ("Test superato");}altro {System.out.println ("Test non riuscito");}// chiudi il browserdriver.close ();}}
Spiegazione del codice
Nell'esempio sopra,
Considera il seguente codice:
driver.manage (). timeouts (). implicitlyWait (10, TimeUnit.SECONDS);
L'attesa implicita accetterà 2 parametri, il primo parametro accetterà l'ora come valore intero e il secondo parametro accetterà la misurazione del tempo in termini di SECONDI, MINUTI, MILISECONDI, MICROSECONDI, NANOSECONDI, GIORNI, ORE, ecc.
Attesa esplicita in selenio
L' attesa esplicita in Selenium viene utilizzata per indicare al driver Web di attendere determinate condizioni (condizioni previste) o il tempo massimo superato prima di lanciare l'eccezione "ElementNotVisibleException". È un tipo di attesa intelligente, ma può essere applicato solo per elementi specificati. Offre opzioni migliori rispetto all'attesa implicita mentre attende gli elementi Ajax caricati dinamicamente.
Una volta dichiarata l'attesa esplicita, dobbiamo usare " ExpectedConditions " oppure possiamo configurare la frequenza con cui vogliamo controllare la condizione utilizzando Fluent Wait . In questi giorni durante l'implementazione stiamo usando Thread.Sleep () generalmente non è consigliabile usare
Nell'esempio seguente, creiamo l'attesa di riferimento per la classe " WebDriverWait " e creiamo un'istanza utilizzando il riferimento " WebDriver " e forniamo un intervallo di tempo massimo di 20 secondi.
Sintassi:
WebDriverWait wait = nuovo WebDriverWait (WebDriverRefrence, TimeOut);
pacchetto 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 {driver WebDriver protetto;@Testpublic void guru99tutorials () genera InterructedException{System.setProperty ("webdriver.chrome.driver", ". \\ chromedriver.exe");driver = nuovo ChromeDriver ();WebDriverWait wait = nuovo WebDriverWait (driver, 20);String eTitle = "Demo Guru99 Page";String aTitle = "";// avvia Chrome e reindirizzalo all'URL di basedriver.get ("http://demo.guru99.com/test/guru99home/");// Ingrandisce la finestra del browserdriver.manage (). window (). maxim ();// ottiene il valore effettivo del titoloaTitle = driver.getTitle ();// confronta il titolo effettivo con il titolo previstoif (aTitle.contentEquals (eTitle)){System.out.println ("Test superato");}altro {System.out.println ("Test non riuscito");}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 ();}}
Spiegazione del codice
Considera il seguente codice:
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 ();
In questo esempio di attesa WebDriver, attendere che si verifichi il periodo di tempo definito nella classe " WebDriverWait " o in " ExpectedConditions ", a seconda di quale condizione si verifica per prima.
Il codice Java di cui sopra afferma che stiamo aspettando un elemento per il periodo di tempo di 20 secondi come definito nella classe " WebDriverWait " sulla pagina web fino a quando le " ExpectedConditions " non vengono soddisfatte e la condizione è " visibleofElementLocated ".
Le seguenti sono le condizioni previste che possono essere utilizzate in Selenium Explicit Wait
- alertIsPresent ()
- elementSelectionStateToBe ()
- elementToBeClickable ()
- elementToBeSelected ()
- frameToBeAvaliableAndSwitchToIt ()
- invisibilityOfTheElementLocated ()
- invisibilityOfElementWithText ()
- PresenceOfAllElementsLocatedBy ()
- PresenceOfElementLocated ()
- textToBePresentInElement ()
- textToBePresentInElementLocated ()
- textToBePresentInElementValue ()
- titleIs ()
- titleContains ()
- visibilità di ()
- visibilitàOfAllElementi ()
- visibilitàOfAllElementsLocatedBy ()
- visibilitàOfElementLocated ()
Aspetta fluente in selenio
Il Fluent Wait in Selenium viene utilizzato per definire il tempo massimo di attesa del driver web per una condizione, così come la frequenza con cui vogliamo controllare la condizione prima di lanciare un'eccezione "ElementNotVisibleException". Controlla l'elemento web a intervalli regolari finché l'oggetto non viene trovato o si verifica il timeout.
Frequenza: impostare un ciclo di ripetizione con l'intervallo di tempo per verificare / controllare la condizione a intervalli di tempo regolari
Consideriamo uno scenario in cui un elemento viene caricato a diversi intervalli di tempo. L'elemento potrebbe caricarsi entro 10 secondi, 20 secondi o anche di più se dichiariamo un'attesa esplicita di 20 secondi. Aspetterà fino al tempo specificato prima di lanciare un'eccezione. In tali scenari, l'attesa fluida è l'attesa ideale da utilizzare poiché cercherà di trovare l'elemento con una frequenza diversa fino a quando non lo trova o fino allo scadere del tempo finale.
Sintassi:
Wait wait = new FluentWait (riferimento WebDriver).withTimeout (timeout, SECONDS).pollingEvery (timeout, SECONDS).ignoring (Exception.class);
Il codice precedente è deprecato in Selenium v3.11 e versioni successive. Devi usare
Wait wait = new FluentWait (riferimento WebDriver).withTimeout (Duration.ofSeconds (SECONDS)).pollingEvery (Duration.ofSeconds (SECONDS)).ignoring (Exception.class);
pacchetto 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 {driver WebDriver protetto;@Testpublic void guru99tutorials () genera InterructedException{System.setProperty ("webdriver.chrome.driver", ". \\ chromedriver.exe");String eTitle = "Demo Guru99 Page";String aTitle = "";driver = nuovo ChromeDriver ();// avvia Chrome e reindirizzalo all'URL di basedriver.get ("http://demo.guru99.com/test/guru99home/");// Ingrandisce la finestra del browserdriver.manage (). window (). maxim ();// ottiene il valore effettivo del titoloaTitle = driver.getTitle ();// confronta il titolo effettivo con il titolo previstoif (aTitle.contentEquals (eTitle)){System.out.println ("Test superato");}altro {System.out.println ("Test non riuscito");}Attendi wait = new FluentWait (driver).withTimeout (30, TimeUnit.SECONDS).pollingEvery (5, TimeUnit.SECONDS).ignoring (NoSuchElementException.class);WebElement clickseleniumlink = wait.until (new Function () {applicazione WebElement pubblica (driver WebDriver) {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 "));}});// fare clic sul collegamento selenioclickseleniumlink.click ();// chiudi il ~ browserdriver.close ();}}
Spiegazione del codice
Considera il seguente codice:
Attendiwait = new FluentWait (driver).withTimeout (30, TimeUnit.SECONDS).pollingEvery (5, TimeUnit.SECONDS).ignoring (NoSuchElementException.class);
Nell'esempio sopra, stiamo dichiarando un'attesa fluida con il timeout di 30 secondi e la frequenza è impostata su 5 secondi ignorando " NoSuchElementException "
Considera il seguente codice:
applicazione WebElement pubblica (driver WebDriver) {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 "));
Abbiamo creato una nuova funzione per identificare l'elemento Web nella pagina. (Es: Here Web Element non è altro che il collegamento Selenium sulla pagina web).
La frequenza è impostata su 5 secondi e il tempo massimo è impostato su 30 secondi. Quindi questo significa che controllerà l'elemento sulla pagina web ogni 5 secondi per il tempo massimo di 30 secondi. Se l'elemento si trova in questo intervallo di tempo eseguirà le operazioni altrimenti genererà una " ElementNotVisibleException "
Differenza tra attesa implicita e attesa esplicita
| Attesa implicita | Attesa esplicita |
|---|---|
|
|
|
|
|
|
Conclusione:
Implicit, Explicit e Fluent Wait sono le diverse attese utilizzate in Selenium. L'utilizzo di queste attese è totalmente basato sugli elementi che vengono caricati a diversi intervalli di tempo. Non è sempre consigliabile utilizzare Thread.Sleep () durante il test della nostra applicazione o la creazione del nostro framework.
Questo articolo è fornito da Chaitanya Pujari