Attente implicite et explicite dans Selenium avec syntaxe

In SeleniumLes « attentes » jouent un rôle important dans l'exécution de tests fiables. Dans ce tutoriel, vous découvrirez les aspects clés et les différences entre les commandes d'attente implicites et explicites. Selenium, ainsi que l'utilisation pratique de Fluent Wait.

Pourquoi avons-nous besoin d'attendre Selenium?

La plupart des applications web modernes sont développées à l'aide de Ajax et JavascénarioLorsqu'une page est chargée par le navigateur, les éléments avec lesquels nous souhaitons interagir peuvent se charger à des intervalles de temps différents.

Non seulement cela rend l'identification de l'élément difficile, mais si l'élément n'est pas localisé à temps, Selenium lancera un ElementNotVisibleException. Selenium Les fonctions d'attente résolvent ce problème de synchronisation en donnant au WebDriver une fenêtre définie dans laquelle il peut rechercher un élément avant d'échouer.

Prenons l'exemple d'un test utilisant à la fois des délais d'attente implicites et explicites. Supposons que le délai d'attente implicite soit de 20 secondes et le délai d'attente explicite de 10 secondes.

Si nous recherchons un élément régi par certaines Conditions attendues (Attente explicite) et si l'élément n'est pas trouvé dans la fenêtre explicite de 10 secondes, WebDriver utilise la fenêtre implicite de 20 secondes avant de lever une exception. ElementNotVisibleException.

Selenium WebDriver attend

1. Attente implicite
2. Attente explicite
3. Attente fluide

Attendre implicitement Selenium

Le Attendre implicitement Selenium Cette configuration indique au WebDriver d'attendre une durée définie avant de lever une exception NoSuchElementException. La valeur par défaut est 0. Une fois configuré, le WebDriver interroge le DOM pendant cette durée avant de générer une erreur. Selenium WebDriver a hérité du concept d'attentes implicites de Watir.

Dans l'exemple ci-dessous, nous déclarons une attente implicite d'une durée de 10 secondes. Si l'élément n'est pas trouvé dans cet intervalle, une exception est levée.

Syntaxe d'attente implicite (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();
    }
}

Explication de Code

Dans l'exemple ci-dessus, considérez l'énoncé suivant :

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

Selenium La version 4 remplace l'ancienne signature à deux arguments (entier et unité de temps) par un unique argument de type durée. La classe Duration prend en charge les secondes, les minutes, les millisecondes et d'autres unités de temps grâce à des fonctions d'assistance statiques telles que Duration.ofSeconds, Duration.ofMillis et Duration.ofMinutes.

Attendre explicitement Selenium

Le Attendre explicitement Selenium Cette instruction demande au WebDriver d'attendre des conditions spécifiques (conditions attendues) ou une durée maximale avant de lever une exception ElementNotVisibleException. Il s'agit d'une attente plus intelligente, car elle ne s'applique qu'à l'élément spécifié. L'attente explicite est préférable à l'attente implicite lorsque le test doit gérer du contenu Ajax chargé dynamiquement.

Une fois qu'une attente explicite est déclarée, vous devez utiliser Conditions attendues, ou vous pouvez configurer la fréquence d'interrogation à l'aide de Attente fluide. Évitez d'utiliser Thread.sommeil(), car elle interrompt l'exécution sans condition et est généralement considérée comme une mauvaise pratique.

Dans l'exemple ci-dessous, nous créons une référence de WebDriverAttendez classe, instanciez-la avec la pilote web Référencez et configurez une fenêtre maximale de 20 secondes.

Syntaxe d'attente explicite (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();
    }
}

Explication de Code

Considérez le code suivant :

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 WebDriverWait, le script attend jusqu'à 20 secondes, comme défini par WebDriverAttendez classe, jusqu'à la Conditions attendues sont satisfaits — selon la première éventualité.

Le dessus Java Le code attend jusqu'à 20 secondes que la condition soit remplie. visibilitéDeL'ÉlémentLocalisé pour être vrai.

Les conditions attendues suivantes peuvent être utilisées dans Selenium Attente explicite :

1. alertIsPresent()
2. elementSelectionStateToBe()
3. elementToBeClickable()
4. elementToBeSelected()
5. frameToBeAvailableAndSwitchToIt()
6. invisibilitéOfTheElementLocated()
7. invisibilitéOfElementWithText()
8. présenceOfAllElementsLocatedBy()
9. présenceOfElementLocated()
10. textToBePresentInElement()
11. textToBePresentInElementLocated()
12. textToBePresentInElementValue()
13. titreEst()
14. titreContient()
15. visibilitéDe()
16. visibilitéOfAllElements()
17. visibilitéOfAllElementsLocatedBy()
18. visibilitéOfElementLocated()

Courant Attendre Selenium

Le Courant Attendre Selenium Définit la durée maximale d'attente du WebDriver pour une condition, ainsi que la fréquence d'interrogation pour vérifier cette condition avant de lever une exception ElementNotVisibleException. Fluent Wait vérifie la présence de l'élément à intervalles réguliers jusqu'à ce que l'objet soit trouvé ou que le délai d'attente expire.

Fréquence : Le cycle de répétition pour évaluer l'état à intervalles réguliers.

Imaginons un scénario où un élément se charge à intervalles imprévisibles : 10 secondes, 20 secondes, voire plus. Si l’on spécifie un délai d’attente de 20 secondes, le script attendra la durée totale avant de s’arrêter. Dans ce cas, Fluent Wait est la solution idéale, car il interroge l’élément à la fréquence indiquée jusqu’à ce qu’il soit trouvé ou que le délai soit écoulé.

Syntaxe d'attente fluide (Selenium 4):

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

L'ancienne signature qui acceptait des valeurs entières plus TimeUnit a été dépréciée dans Selenium 3.11 et supprimé dans Selenium 4. L'API basée sur la durée présentée ci-dessus est l'approche actuellement recommandée.

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

Explication de Code

Considérez le code suivant :

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

Dans l'exemple ci-dessus, nous déclarons une attente Fluent avec un délai d'expiration de 30 secondes, une fréquence d'interrogation de 5 secondes et ignorons NoSuchElementException.

Considérez le code suivant :

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

Cette fonction identifie l'élément Web sur la page (ici, le Selenium (lien sur la page d'accueil). Avec un intervalle d'interrogation de 5 secondes et un délai d'expiration de 30 secondes, l'attente vérifie la présence de l'élément toutes les 5 secondes pendant un maximum de 30 secondes. Si l'élément est présent dans cet intervalle, le script s'exécute. Sinon, une erreur se produit. ElementNotVisibleException Est lancé.

Vérifiez également: Selenium Tutoriel IDE pour les débutants

Différence entre l'attente implicite et l'attente explicite

Le tableau ci-dessous met en évidence les principales différences entre l'attente implicite et l'attente explicite. Selenium.

Attente implicite	Attente explicite
Un temps d'attente implicite est appliqué à tous les éléments du script.	Le temps d'attente explicite s'applique uniquement aux éléments spécifiquement ciblés.
Dans l'attente implicite, les conditions attendues ne sont pas spécifiées pour l'élément.	Dans Explicit Wait, ExpectedConditions doit être défini pour l'élément.
Recommandé lorsque les éléments se chargent dans la fenêtre d'attente implicite configurée.	Recommandé lorsque les éléments mettent plus de temps à se charger et lors de la validation des états des éléments tels que visibilityOfElementLocated, elementToBeClickable ou elementToBeSelected.
Défini une seule fois et appliqué pour le cycle de vie de l'instance WebDriver.	Paramétrable par élément ou par contrôle, pour un contrôle plus précis.

Comment choisir la bonne stratégie d'attente

Le choix de la commande d'attente appropriée influe directement sur la stabilité du script et son temps d'exécution. Utilisez ce cadre de décision pour sélectionner l'option adéquate à chaque situation.

1. Identifier le modèle de charge : Vérifiez si l'élément apparaît à un moment fixe, après une réponse Ajax, ou à intervalles imprévisibles. Les chargements fixes conviennent à l'attente implicite, tandis que les chargements imprévisibles nécessitent une attente fluide.
2. Évitez de mélanger les attentes implicites et explicites : La combinaison des deux peut entraîner des retards imprévus car l'attente la plus longue risque de prévaloir. Selenium La documentation recommande d'utiliser une seule stratégie par session WebDriver.
3. Par défaut, attendre explicitement le contenu dynamique : Lorsque les pages dépendent d'Ajax, du rendu conditionnel ou d'animations, l'option Explicit Wait avec ExpectedConditions cible précisément l'élément concerné.
4. Utilisez Fluent Wait pour une temporisation variable : Lorsque le temps de chargement des éléments varie d'une exécution à l'autre, configurez Fluent Wait avec un intervalle d'interrogation. L'interrogation réduit le temps d'attente total par rapport à un délai d'attente unique et long.
5. Remplacer Thread.sleep : Les pauses codées en dur ralentissent les suites de tests et masquent les problèmes de synchronisation réels. Remplacez-les par des attentes conditionnelles pour garantir une exécution rapide et déterministe.
6. Ajuster les valeurs de délai d'attente : Commencez par des délais d'attente courts (5 à 10 secondes) et augmentez-les uniquement lorsque les échecs révèlent une réelle baisse de charge. Des délais d'attente par défaut trop longs masquent les baisses de performances.
7. Conserver les temps d'attente dans les utilitaires auxiliaires : Centralisez la logique d'attente dans une classe d'assistance afin que les modifications de la politique de délai d'attente s'appliquent à l'ensemble de la suite de tests.

En suivant ce cadre, les ingénieurs en automatisation peuvent créer des scripts robustes qui s'adaptent au rythme réel des applications sans devenir lents ou fragiles.

Erreurs courantes à éviter Selenium Attend

Même les testeurs expérimentés tombent dans un petit nombre de pièges récurrents lorsqu'ils travaillent avec Selenium Les temps d'attente sont un facteur important. En évitant ces problèmes, les scripts restent rapides, déterministes et faciles à maintenir pour toutes les équipes et tous les environnements.

La première erreur fréquente consiste à abuser de `Thread.sleep`. Une pause codée en dur force le script à attendre toute la durée, quelle que soit la disponibilité réelle de l'élément, ce qui augmente considérablement le temps d'exécution total. Remplacez ces pauses par `Explicit` ou `Fluent Wait` afin que le script reprenne son exécution dès que la condition est remplie.

La seconde erreur consiste à mélanger les attentes implicites et explicites dans un même test. Ces deux mécanismes peuvent s'accumuler et engendrer des délais d'attente imprévisibles et difficiles à déboguer. Choisissez une stratégie par session WebDriver et appliquez-la systématiquement.

Une troisième erreur consiste à définir des délais d'attente trop longs « au cas où ». Des délais par défaut trop longs masquent de véritables problèmes de performance et ralentissent le retour d'information dans les pipelines d'intégration continue. Commencez par des délais d'attente courts et n'augmentez-les que lorsque les journaux d'erreurs prouvent l'existence d'un réel problème de synchronisation.

Vérifiez également: Selenium Tutoriel pour débutants : Apprenez WebDriver en 7 jours

FAQ