Menu

Attente implicite et explicite dans Selenium WebDriver (types d'attentes Selenium)

implicit explicit wait selenium webdriver

Essayez Notre Instrument Pour Éliminer Les Problèmes

Apprenez l'attente implicite et explicite dans Selenium WebDriver:

Dans le tutoriel précédent, nous avons essayé de vous familiariser avec les différents Bouclage et opérations conditionnelles de WebDriver . Ces méthodes conditionnelles traitent souvent presque tous les types d'options de visibilité pour les éléments Web.

Aller de l'avant dans ce série de formation gratuite sur Selenium , nous discuterons différents types d'attente fournis par le Selenium WebDriver . Nous discuterons également de v divers types d'options de navigation disponible dans WebDriver.

Les attentes aident l'utilisateur à résoudre les problèmes tout en redirigeant vers différentes pages Web en actualisant la page Web entière et en rechargeant la nouvelle éléments Web. Parfois, il peut également y avoir des appels Ajax. Ainsi, un décalage dans le temps peut être observé lors du rechargement des pages Web et de la réflexion des éléments Web.

Attente implicite et explicite dans Selenium WebDriver

Les utilisateurs naviguent souvent dans diverses pages Web. Ainsi, les commandes / méthodes de navigation () fournies par WebDriver aident l'utilisateur à simuler les scénarios en temps réel en naviguant entre les pages Web en référence à l'historique du navigateur Web.

WebDriver équipe l'utilisateur de deux génèses d'attente afin de gérer le chargement récurrent des pages s, les chargements d'éléments Web, l'apparence des fenêtres, des fenêtres contextuelles et des messages d'erreur et la réflexion des éléments Web sur la page Web.

  • Attente implicite
  • Attente explicite

Laissez-nous discuter de chacun d'eux en détail compte tenu de l'approche pratique.

Ce que vous apprendrez:

Attente implicite WebDriver

Les attentes implicites sont utilisées pour fournir un temps d'attente par défaut (par exemple 30 secondes) entre chaque étape / commande de test consécutive sur l'ensemble du script de test. Ainsi, l'étape de test suivante ne s'exécuterait que lorsque les 30 secondes se seraient écoulées après l'exécution de l'étape / commande de test précédente.

Notes clés

  • L'attente implicite est une seule ligne de code et peut être déclarée dans la méthode de configuration du script de test.
  • Par rapport à l'attente explicite, l'attente implicite est transparente et simple. La syntaxe et l'approche sont plus simples que l'attente explicite.

Étant facile et simple à appliquer, l'attente implicite présente également quelques inconvénients. Cela donne lieu au temps d'exécution du script de test car chacune des commandes cesserait d'attendre pendant un laps de temps stipulé avant de reprendre l'exécution.

Ainsi, afin de résoudre ce problème, WebDriver introduit des attentes explicites où nous pouvons explicitement appliquer des attentes chaque fois que la situation se présente au lieu d'attendre de force lors de l'exécution de chacune des étapes de test.

Importer des déclarations

importer java.util.concurrent.TimeUnit - Pour pouvoir accéder et appliquer l'attente implicite dans nos scripts de test, nous sommes obligés d'importer ce package dans notre script de test.

Syntaxe
drv .manage (). timeouts (). implicitlyWait (10, TimeUnit. SECONDES );

Incluez la ligne de code ci-dessus dans votre script de test peu de temps après l'instanciation de la variable d'instance WebDriver. C'est donc tout ce qui est nécessaire pour définir une attente implicite dans votre script de test.

Procédure pas à pas du code

L'attente implicite oblige à passer deux valeurs comme paramètres. Le premier argument indique le temps dans les chiffres numériques que le système doit attendre. Le deuxième argument indique l'échelle de mesure du temps. Ainsi, dans le code ci-dessus, nous avons mentionné les «30» secondes comme temps d'attente par défaut et l'unité de temps a été réglée sur «secondes».

Attente explicite WebDriver

Les attentes explicites sont utilisées pour arrêter l'exécution jusqu'à ce qu'une condition particulière soit remplie ou que le temps maximum se soit écoulé. Contrairement aux attentes implicites, les attentes explicites ne sont appliquées qu'à une instance particulière.

WebDriver introduit des classes telles que WebDriverWait et ExpectedConditions pour appliquer des attentes explicites dans les scripts de test. Dans le cadre de cette discussion, nous utiliserons «gmail.com» comme spécimen.

Scénario à automatiser

  1. Lancez le navigateur Web et ouvrez le 'gmail.com'
  2. Entrez un nom d'utilisateur valide
  3. Entrez un mot de passe valide
  4. Cliquez sur le bouton de connexion
  5. Attendez que le bouton Composer soit visible après le chargement de la page

Code WebDriver utilisant l'attente explicite

Veuillez noter que pour la création de scripts, nous utiliserions le projet «Learning_Selenium» créé dans les anciens tutoriels.

Étape 1 : Créez une nouvelle classe Java nommée «Wait_Demonstration» sous le projet «Learning_Selenium».

Étape 2 : Copiez et collez le code ci-dessous dans la classe «Wait_Demonstration.java».

Vous trouverez ci-dessous le script de test qui équivaut au scénario mentionné ci-dessus.

import static org.junit.Assert.*; import java.util.concurrent.TimeUnit; import org.junit.After; import org.junit.Before; import org.junit.Test; import org.openqa.selenium.By; import org.openqa.selenium.WebDriver; import org.openqa.selenium.WebElement; import org.openqa.selenium.firefox.FirefoxDriver; import org.openqa.selenium.support.ui.ExpectedConditions; import org.openqa.selenium.support.ui.WebDriverWait; public class Wait_Demonstration { // created reference variable for WebDriver WebDriver drv; @Before public void setup() throws InterruptedException { // initializing drv variable using FirefoxDriver drv=new FirefoxDriver(); // launching gmail.com on the browser drv.get('https://gmail.com'); // maximized the browser window drv.manage().window().maximize(); drv.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS); } @Test public void test() throws InterruptedException { // saving the GUI element reference into a 'username' variable of WebElement type WebElement username = drv.findElement(By.id('Email')); // entering username username.sendKeys('shruti.shrivastava.in'); // entering password drv.findElement(By.id('Passwd')).sendKeys('password'); // clicking signin button drv.findElement(By.id('signIn')).click(); // explicit wait - to wait for the compose button to be click-able WebDriverWait wait = new WebDriverWait(drv,30); wait.until(ExpectedConditions.visibilityOfElementLocated(By.xpath('//div(contains(text(),'COMPOSE'))'))); // click on the compose button as soon as the 'compose' button is visible drv.findElement(By.xpath('//div(contains(text(),'COMPOSE'))')).click(); } @After public void teardown() { // closes all the browser windows opened by web driver drv.quit(); } }

Importer des déclarations

  • importer org. openqa.selenium.support.ui.ExpectedConditions
  • importer org. openqa.selenium.support.ui.WebDriverWait
  • Importez les packages ci-dessus avant la création du script. Les packages font référence à la classe Select qui est requise pour gérer la liste déroulante.

Instanciation d'objet pour la classe WebDriverWait

WebDriverWait wait = Nouveau WebDriverWait ( drv , 30);

Nous créons une variable de référence «wait» pour la classe WebDriverWait et l'instancions à l'aide de l'instance WebDriver et du temps d'attente maximal pour l'exécution de la mise à pied. Le temps d'attente maximal indiqué est mesuré en «secondes».

L'instanciation WebDriver a été abordée dans les didacticiels initiaux de WebDriver.

Condition attendue

wait.until(ExpectedConditions.visibilityOfElementLocated(By.xpath('//div(contains(text(),'COMPOSE'))'))); drv.findElement(By.xpath('//div(contains(text(),'COMPOSE'))')).click();

La commande ci-dessus attend pendant un laps de temps spécifié ou une condition prévue se produise, selon la première éventualité ou la première échéance.

Ainsi, pour pouvoir faire cela, nous utilisons la variable de référence «wait» de la classe WebDriverWait créée à l'étape précédente avec la classe ExpectedConditions et une condition réelle qui devrait se produire. Par conséquent, dès que la condition attendue se produit, la commande de programme passe à l'étape d'exécution suivante au lieu d'attendre de force pendant les 30 secondes entières.

Dans notre exemple, nous attendons que le bouton «composer» soit présent et chargé dans le cadre du chargement de la page d'accueil et ainsi, nous avançons en appelant la commande clic sur le bouton «composer».

Types de conditions attendues

La classe ExpectedConditions fournit une grande aide pour gérer les scénarios dans lesquels nous devons nous assurer qu'une condition se produit avant d'exécuter l'étape de test réelle.

La classe ExpectedConditions est fournie avec un large éventail de conditions attendues accessibles à l'aide de la variable de référence WebDriverWait et de la méthode until ().

Parlons-en longuement de quelques-uns:

# 1) elementToBeClickable () - La condition attendue attend qu'un élément soit cliquable, c'est-à-dire qu'il doit être présent / affiché / visible à l'écran ainsi qu'activé.

Exemple de code
wait.until (ExpectedConditions.elementToBeClickable (By.xpath ( '// div (contient (text (), 'COMPOSE'))» )));

# 2) textToBePresentInElement () - La condition attendue attend un élément ayant un certain modèle de chaîne.

Exemple de code
wait.until (ExpectedConditions.textToBePresentInElement (By.xpath ( '// div (@ id =' ForgotPass ''), 'texte à trouver' ));

java passe le tableau à la méthode par référence

# 3) alertIsPresent () - La condition attendue attend qu'une boîte d'alerte apparaisse.

Exemple de code
wait.until (ExpectedConditions.alertIsPresent ())! = null);

# 4) titleIs () - La condition attendue attend une page avec un titre spécifique.

Exemple de code
wait.until (ExpectedConditions.titleIs ( 'Gmail' ));

# 5) frameToBeAvailableAndSwitchToIt () - La condition attendue attend qu'une trame soit disponible puis dès que la trame est disponible, la commande y bascule automatiquement.

Exemple de code
wait.until (ExpectedConditions.frameToBeAvailableAndSwitchToIt (By.id (' nouveau cadre ')));

Navigation à l'aide de WebDriver

Il existe une action utilisateur très courante où l'utilisateur clique sur les boutons Précédent et Suivant du navigateur Web en arrière et en avant pour naviguer vers les différentes pages Web visitées dans la session en cours dans l'historique du navigateur. Ainsi, pour simuler de telles actions effectuées par les utilisateurs, WebDriver introduit les commandes Navigate.

Examinons ces commandes en détail:

# 1) naviguer (). Retour ()
Cette commande permet à l'utilisateur d'accéder à la page Web précédente.

Exemple de code:
driver.navigate (). back ();
La commande ci-dessus ne nécessite aucun paramètre et ramène l'utilisateur à la page Web précédente dans l'historique du navigateur Web.

# 2) naviguer (). Avancer ()
Cette commande permet à l'utilisateur de naviguer vers la page Web suivante en référence à l'historique du navigateur.

Exemple de code:
driver.navigate (). forward ();
La commande ci-dessus ne nécessite aucun paramètre et dirige l'utilisateur vers la page Web suivante dans l'historique du navigateur Web.

# 3) naviguer (). Refresh ()
Cette commande permet à l'utilisateur d'actualiser la page Web actuelle, rechargeant ainsi tous les éléments Web.

Exemple de code:
driver.navigate (). refresh ();
La commande ci-dessus ne nécessite aucun paramètre et recharge la page Web.

# 4) naviguer (). À ()
Cette commande permet à l'utilisateur de lancer une nouvelle fenêtre de navigateur Web et d'accéder à l'URL spécifiée.

Exemple de code:
driver.navigate (). to («http://google.com»);
La commande ci-dessus nécessite une URL Web en tant que paramètre, puis ouvre l'URL spécifiée dans un navigateur Web fraîchement lancé.

Conclusion

Dans ce Attente implicite et explicite dans le didacticiel Selenium WebDriver , nous avons essayé de vous familiariser avec les attentes du WebDriver. Nous avons discuté et exercé à la fois les attentes explicites et implicites. Dans le même temps, nous avons également discuté des différentes commandes de navigation.

Voici les points essentiels de cet article:

  • WebDriver permet à l'utilisateur de choisir parmi les temps d'attente disponibles pour gérer les situations dans lesquelles le flux d'exécution peut nécessiter une mise en veille de quelques secondes afin de charger les éléments Web ou de répondre à une condition spécifique. Il existe deux types d'attente disponibles dans WebDriver.
    • Attente implicite
    • Attente explicite
  • Attentes implicites sont utilisés pour fournir un temps d'attente par défaut entre chaque étape / commande de test consécutive sur l'ensemble du script de test. Ainsi, l'étape de test suivante ne s'exécuterait que lorsque la durée spécifiée s'est écoulée après l'exécution de l'étape / commande de test précédente.
  • Attentes explicites sont utilisés pour arrêter l'exécution jusqu'à ce qu'une condition particulière soit remplie ou que le temps maximum se soit écoulé. Contrairement aux attentes implicites, les attentes explicites ne sont appliquées qu'à une instance particulière.
  • WebDriver introduit des classes telles que WebDriverWait et ExpectedConditions pour appliquer les attentes explicites
  • Conditions attendues La classe fournit une grande aide pour gérer les scénarios dans lesquels nous devons nous assurer qu'une condition se produit avant d'exécuter l'étape de test réelle.
  • La classe ExpectedConditions est fournie avec un large éventail de conditions attendues accessibles à l'aide de la variable de référence WebDriverWait et de la méthode until ().
  • Navigate () méthodes Les commandes / sont utilisées pour simuler le comportement de l'utilisateur lors de la navigation entre différentes pages Web dans les deux sens.

Tutoriel suivant # 16 : En venant au didacticiel suivant de la liste, nous familiariserons les utilisateurs avec les différents types d'alertes qui peuvent apparaître lors de l'accès aux sites Web et leurs approches de gestion dans WebDriver. Les types d'alertes sur lesquelles nous nous concentrerions sont principalement: les fenêtres contextuelles d'alerte basées sur Windows et les fenêtres contextuelles d'alerte Web. Comme nous savons que la gestion des fenêtres contextuelles basées sur des fenêtres dépasse les capacités de WebDriver, nous utiliserions également certains utilitaires tiers pour gérer les fenêtres contextuelles.

Note aux lecteurs : Jusque-là, les lecteurs peuvent automatiser les scénarios avec divers chargements de page et éléments dynamiques apparaissant à l'écran en utilisant les différentes conditions attendues et les commandes de navigation.

lecture recommandée

^