Dans Selenium, les "Waits" jouent un rôle important dans l'exécution des tests. Dans ce didacticiel, vous apprendrez divers aspects des attentes «implicites» et «explicites» dans Selenium.
Dans ce tutoriel, vous apprendrez:
- Pourquoi avons-nous besoin d'attentes dans le sélénium?
- Attente implicite
- Attente explicite
- Attente fluide
Pourquoi avons-nous besoin d'attentes dans le sélénium?
La plupart des applications Web sont développées en utilisant Ajax et Javascript. Lorsqu'une page est chargée par le navigateur, les éléments avec lesquels nous voulons interagir peuvent se charger à des intervalles de temps différents.
Non seulement cela rend difficile l'identification de l'élément, mais aussi si l'élément n'est pas localisé, il lèvera une exception " ElementNotVisibleException ". En utilisant Selenium Waits, nous pouvons résoudre ce problème.
Considérons un scénario dans lequel nous devons utiliser à la fois des attentes implicites et explicites dans notre test. Supposons que le temps d'attente implicite est défini sur 20 secondes et que le temps d'attente explicite est défini sur 10 secondes.
Supposons que nous essayions de trouver un élément qui a des "ExpectedConditions " (Explicit Wait), si l'élément n'est pas situé dans le délai défini par l'attente explicite (10 secondes), il utilisera le délai défini par l'attente implicite ( 20 secondes) avant de lancer une " ElementNotVisibleException ".
Le pilote Web Selenium attend
- Attente implicite
- Attente explicite
Attente implicite dans Selenium
L' attente implicite dans Selenium est utilisée pour indiquer au pilote Web d'attendre pendant un certain temps avant de lancer une "exception d'élément". Le paramètre par défaut est 0. Une fois l'heure définie, le pilote Web attendra l'élément pendant cette durée avant de lancer une exception.
Selenium Web Driver a emprunté l'idée d'attentes implicites à Watir.
Dans l'exemple ci-dessous, nous avons déclaré une attente implicite avec un laps de temps de 10 secondes. Cela signifie que si l'élément n'est pas situé sur la page Web dans ce laps de temps, il lèvera une exception.
Pour déclarer une attente implicite:
Syntaxe :
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 {pilote WebDriver protégé;@Testpublic void guru99tutorials () lance InterruptedException{System.setProperty ("webdriver.chrome.driver", ". \\ chromedriver.exe");pilote = nouveau ChromeDriver ();driver.manage (). timeouts (). implicitlyWait (10, TimeUnit.SECONDS);String eTitle = "Page de démonstration Guru99";String aTitle = "";// lance Chrome et redirige-le vers l'URL de basedriver.get ("http://demo.guru99.com/test/guru99home/");// Agrandit la fenêtre du navigateurdriver.manage (). window (). maximiser ();// récupère la valeur réelle du titreaTitle = driver.getTitle ();// comparer le titre réel avec le titre attenduif (aTitle.equals (eTitle)){System.out.println ("Test réussi");}autre {System.out.println ("Le test a échoué");}// ferme le navigateurdriver.close ();}}
Explication du code
Dans l'exemple ci-dessus,
Pensez à suivre le code:
driver.manage (). timeouts (). implicitlyWait (10, TimeUnit.SECONDS);
L'attente implicite acceptera 2 paramètres, le premier paramètre acceptera le temps comme une valeur entière et le deuxième paramètre acceptera la mesure du temps en termes de SECONDES, MINUTES, MILISECOND, MICROSECONDES, NANOSECONDES, JOURS, HEURES, etc.
Attente explicite dans Selenium
L' attente explicite dans Selenium est utilisée pour indiquer au pilote Web d'attendre certaines conditions (conditions attendues) ou le temps maximal dépassé avant de lancer l'exception "ElementNotVisibleException". C'est une sorte d'attente intelligente, mais elle ne peut être appliquée que pour des éléments spécifiés. Il donne de meilleures options que l'attente implicite en attendant les éléments Ajax chargés dynamiquement.
Une fois que nous déclarons une attente explicite, nous devons utiliser " ExpectedConditions " ou nous pouvons configurer la fréquence à laquelle nous voulons vérifier la condition en utilisant Fluent Wait . Ces jours-ci, lors de l'implémentation, nous utilisons Thread.Sleep () en général, il n'est pas recommandé d'utiliser
Dans l'exemple ci-dessous, nous créons une attente de référence pour la classe " WebDriverWait " et l'instanciation à l'aide de la référence " WebDriver ", et nous donnons un délai maximum de 20 secondes.
Syntaxe:
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 {pilote WebDriver protégé;@Testpublic void guru99tutorials () lance InterruptedException{System.setProperty ("webdriver.chrome.driver", ". \\ chromedriver.exe");pilote = nouveau ChromeDriver ();WebDriverWait wait = nouveau WebDriverWait (pilote, 20);String eTitle = "Page de démonstration Guru99";String aTitle = "";// lance Chrome et redirige-le vers l'URL de basedriver.get ("http://demo.guru99.com/test/guru99home/");// Agrandit la fenêtre du navigateurdriver.manage (). window (). maximiser ();// récupère la valeur réelle du titreaTitle = driver.getTitle ();// comparer le titre réel avec le titre attenduif (aTitle.contentEquals (eTitle)){System.out.println ("Test réussi");}autre {System.out.println ("Le test a échoué");}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 ();}}
Explication du code
Pensez à suivre le code:
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 ();
Dans cet exemple d'attente WebDriver, attendez que la durée définie dans la classe « WebDriverWait » ou « ExpectedConditions » se produise selon la première éventualité.
Le code Java ci-dessus indique que nous attendons un élément pour l'intervalle de temps de 20 secondes tel que défini dans la classe " WebDriverWait " sur la page Web jusqu'à ce que les " ExpectedConditions " soient remplies et que la condition soit " visibilitéofElementLocated ".
Voici les conditions attendues qui peuvent être utilisées dans Selenium Explicit Wait
- alertIsPresent ()
- elementSelectionStateToBe ()
- elementToBeClickable ()
- elementToBeSelected ()
- frameToBeAvaliableAndSwitchToIt ()
- invisibilityOfTheElementLocated ()
- invisibilityOfElementWithText ()
- presenceOfAllElementsLocatedBy ()
- presenceOfElementLocated ()
- textToBePresentInElement ()
- textToBePresentInElementLocated ()
- textToBePresentInElementValue ()
- titleIs ()
- titleContains ()
- visibilitéOf ()
- visibilitéOfAllElements ()
- visibilitéOfAllElementsLocatedBy ()
- visibilitéOfElementLocated ()
Attendre couramment dans le sélénium
Le Fluent Wait in Selenium est utilisé pour définir le temps maximum pendant lequel le pilote Web attend une condition, ainsi que la fréquence à laquelle nous voulons vérifier la condition avant de lancer une exception "ElementNotVisibleException". Il recherche l'élément Web à intervalles réguliers jusqu'à ce que l'objet soit trouvé ou que le délai d'expiration se produise.
Fréquence: mise en place d'un cycle de répétition avec le laps de temps pour vérifier / vérifier la condition à l'intervalle de temps régulier
Considérons un scénario où un élément est chargé à différents intervalles de temps. L'élément peut se charger en 10 secondes, 20 secondes ou même plus que si nous déclarons une attente explicite de 20 secondes. Il attendra jusqu'à l'heure spécifiée avant de lancer une exception. Dans de tels scénarios, l'attente fluide est l'attente idéale à utiliser, car elle tentera de trouver l'élément à une fréquence différente jusqu'à ce qu'il le trouve ou que la minuterie finale s'épuise.
Syntaxe:
Wait wait = new FluentWait (référence WebDriver).withTimeout (délai d'expiration, SECONDES).pollingEvery (délai d'expiration, SECONDES).ignoring (classe.exception);
Le code ci-dessus est obsolète dans Selenium v3.11 et supérieur. Vous devez utiliser
Wait wait = new FluentWait (référence WebDriver).withTimeout (Durée. de secondes (SECONDES)).pollingEvery (Durée. de secondes (SECONDES)).ignoring (classe.exception);
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 {pilote WebDriver protégé;@Testpublic void guru99tutorials () lance InterruptedException{System.setProperty ("webdriver.chrome.driver", ". \\ chromedriver.exe");String eTitle = "Page de démonstration Guru99";String aTitle = "";pilote = nouveau ChromeDriver ();// lance Chrome et redirige-le vers l'URL de basedriver.get ("http://demo.guru99.com/test/guru99home/");// Agrandit la fenêtre du navigateurdriver.manage (). window (). maximiser ();// récupère la valeur réelle du titreaTitle = driver.getTitle ();// comparer le titre réel avec le titre attenduif (aTitle.contentEquals (eTitle)){System.out.println ("Test réussi");}autre {System.out.println ("Le test a échoué");}Wait wait = new FluentWait (pilote).withTimeout (30, TimeUnit.SECONDS).pollingEvery (5, TimeUnit.SECONDS).ignoring (NoSuchElementException.class);WebElement clickseleniumlink = wait.until (nouvelle fonction () {public WebElement s'applique (pilote WebDriver) {renvoie driver.findElement (Par.xpath ("/ html / corps / 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 "));}});// cliquez sur le lien séléniumclickseleniumlink.click ();// ferme ~ navigateurdriver.close ();}}
Explication du code
Pensez à suivre le code:
Waitwait = new FluentWait (pilote).withTimeout (30, TimeUnit.SECONDS).pollingEvery (5, TimeUnit.SECONDS).ignoring (NoSuchElementException.class);
Dans l'exemple ci-dessus, nous déclarons une attente fluide avec un délai de 30 secondes et la fréquence est définie sur 5 secondes en ignorant " NoSuchElementException "
Pensez à suivre le code:
public WebElement s'applique (pilote WebDriver) {renvoie driver.findElement (Par.xpath ("/ html / corps / 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 "));
Nous avons créé une nouvelle fonction pour identifier l'élément Web sur la page. (Ex: Ici, Web Element n'est rien d'autre que le lien Selenium sur la page Web).
La fréquence est réglée sur 5 secondes et la durée maximale est réglée sur 30 secondes. Cela signifie donc qu'il vérifiera l'élément sur la page Web toutes les 5 secondes pendant une durée maximale de 30 secondes. Si l'élément est situé dans ce laps de temps, il effectuera les opérations sinon il lèvera une " ElementNotVisibleException "
Différence entre l'attente implicite et l'attente explicite
| Attente implicite | Attente explicite |
|---|---|
|
|
|
|
|
|
Conclusion:
Les attentes implicites, explicites et fluentes sont les différentes attentes utilisées dans Selenium. L'utilisation de ces attentes est totalement basée sur les éléments qui sont chargés à des intervalles de temps différents. Il n'est toujours pas recommandé d'utiliser Thread.Sleep () lors du test de notre application ou de la construction de notre framework.
Cet article est contribué par Chaitanya Pujari