Aspettare implicito ed esplicito in Selenium con la sintassi

In Selenium, Le “attensioni” svolgono un ruolo importante nell’esecuzione di test affidabili. In questo tutorial, imparerai gli aspetti chiave e le differenze tra i comandi di attesa impliciti ed espliciti in Selenium, insieme all'utilizzo pratico di Fluent Wait.

Perché abbiamo bisogno di attese Selenium?

La maggior parte delle applicazioni web moderne sono sviluppate utilizzando Ajax and JavaCopioneQuando una pagina viene caricata dal browser, gli elementi con cui vogliamo interagire possono essere caricati in intervalli di tempo diversi.

Ciò non solo rende difficile l'identificazione dell'elemento, ma se l'elemento non viene localizzato in tempo, Selenium lancerà un ElementNotVisibleException. Selenium Le attese risolvono questo problema di sincronizzazione fornendo al WebDriver un intervallo di tempo definito entro il quale trovare un elemento prima di fallire.

Consideriamo uno scenario in cui sia l'attesa implicita che quella esplicita vengono utilizzate nello stesso test. Supponiamo che l'attesa implicita sia impostata a 20 secondi e quella esplicita a 10 secondi.

Se stiamo cercando un elemento governato da certi Condizioni previste (Attesa esplicita) e l'elemento non si trova entro la finestra esplicita di 10 secondi, WebDriver torna alla finestra implicita di 20 secondi prima di generare un errore ElementNotVisibleException.

Selenium WebDriverWaits

1. Attesa implicita
2. Aspetta esplicita
3. Aspetta fluente

Attesa implicita Selenium

Migliori Attesa implicita Selenium Indica al WebDriver di attendere per una durata definita prima di generare un'eccezione NoSuchElementException. Il valore predefinito è 0. Una volta configurato, il WebDriver esegue il polling del DOM durante tale durata prima di generare un errore. Selenium WebDriver ha ereditato il concetto di attese implicite da Watir.

Nell'esempio seguente, dichiariamo un'attesa implicita con una durata di 10 secondi. Se l'elemento non si trova entro tale intervallo, viene generata un'eccezione.

Sintassi di attesa implicita (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();
    }
}

Spiegazione di Code

Nell'esempio precedente, si consideri la seguente affermazione:

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

Selenium La versione 4 ha sostituito la vecchia firma a due argomenti (intero più TimeUnit) con un singolo argomento Duration. La classe Duration supporta secondi, minuti, millisecondi e altre unità di tempo tramite helper statici come Duration.ofSeconds, Duration.ofMillis e Duration.ofMinutes.

Aspetta esplicita Selenium

Migliori Aspetta esplicita Selenium Indica a WebDriver di attendere determinate condizioni (Expected Conditions) o una durata massima prima di generare un'eccezione ElementNotVisibleException. Si tratta di un'attesa più intelligente perché si applica solo all'elemento specificato. L'attesa esplicita è preferibile all'attesa implicita ogni volta che il test deve gestire contenuti Ajax caricati dinamicamente.

Una volta dichiarata un'attesa esplicita, è necessario utilizzare Condizioni previste, oppure è possibile configurare la frequenza di polling utilizzando Aspetta fluente. Evitare di utilizzare Discussione.sleep(), poiché interrompe l'esecuzione incondizionatamente ed è generalmente considerata una cattiva pratica.

Nell'esempio seguente creiamo un riferimento del WebDriverAttendi classe, istanziala con la webdriver fare riferimento e configurare una finestra massima di 20 secondi.

Sintassi di attesa esplicita (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();
    }
}

Spiegazione di Code

Considera il codice seguente:

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 WebDriverWait, lo script attende fino a 20 secondi, come definito da WebDriverAttendi classe, fino alla Condizioni previste sono soddisfatti — a seconda di quale dei due eventi si verifichi per primo.

Quanto sopra Java il codice attende fino a 20 secondi per la condizione visibilitàDellelementoPosizionato per essere vero.

Le seguenti condizioni previste possono essere utilizzate in Selenium Attesa esplicita:

1. alertIsPresent()
2. elementoSelectionStateToBe()
3. elementoToBeClickable()
4. elementoToBeSelected()
5. frameToBeAvailableAndSwitchToIt()
6. invisibilitàOfTheElementLocated()
7. invisibilityOfElementWithText()
8. presenzaOfAllElementsLocatedBy()
9. presenzaOfElementLocated()
10. textToBePresentInElement()
11. textToBePresentInElementLocated()
12. textToBePresentInElementValue()
13. titoloIs()
14. titoloContiene()
15. visibilitàDi()
16. visibilitàOfAllElements()
17. visibilitàOfAllElementsLocatedBy()
18. visibilitàOfElementLocated()

Ottima attesa Selenium

Migliori Ottima attesa Selenium Definisce la durata massima di attesa per WebDriver per una determinata condizione, insieme alla frequenza di polling per la verifica di tale condizione prima di generare un'eccezione ElementNotVisibleException. Fluent Wait controlla la presenza dell'elemento a intervalli regolari finché l'oggetto non viene trovato o non scade il timeout.

Frequenza: Il ciclo di ripetizione per valutare la condizione a intervalli regolari.

Consideriamo uno scenario in cui un elemento si carica a intervalli imprevedibili. L'elemento potrebbe caricarsi in 10 secondi, 20 secondi o più. Se dichiariamo un'attesa esplicita di 20 secondi, lo script attenderà per l'intera durata prima di fallire. In questi casi, Fluent Wait è la scelta ideale perché esegue il polling alla frequenza specificata fino a quando l'elemento non viene trovato o il timer finale non scade.

Sintassi di attesa fluida (Selenium 4):

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

La vecchia firma che accettava valori interi più TimeUnit è stata deprecata in Selenium 3.11 e rimosso in Selenium 4. L'API basata sulla durata mostrata sopra è l'approccio attualmente consigliato.

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

Spiegazione di Code

Considera il codice seguente:

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

Nell'esempio precedente, dichiariamo un Fluent Wait con un timeout di 30 secondi, una frequenza di polling di 5 secondi e ignoriamo NoSuchElementException.

Considera il codice seguente:

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

Questa funzione identifica l'elemento WebElement sulla pagina (qui, il Selenium (link sulla homepage). Con un intervallo di polling di 5 secondi e un timeout di 30 secondi, l'attesa controlla l'elemento ogni 5 secondi per un massimo di 30 secondi. Se l'elemento si trova entro tale finestra, lo script procede. Altrimenti, un ElementNotVisibleException viene lanciato.

Controlla anche: Selenium Tutorial IDE per principianti

Differenza tra attesa implicita e attesa esplicita

La tabella seguente evidenzia le principali differenze tra attesa implicita e attesa esplicita in Selenium.

Attesa implicita	Aspetta esplicita
Il tempo di attesa implicito viene applicato a tutti gli elementi dello script.	Il tempo di attesa esplicito viene applicato solo agli elementi specificamente selezionati.
In Implicit Wait, le ExpectedConditions non sono specificate per l'elemento.	In Explicit Wait, ExpectedConditions deve essere definito per l'elemento.
Consigliato quando gli elementi vengono caricati entro la finestra di attesa implicita configurata.	Consigliato quando il caricamento degli elementi richiede più tempo e quando si convalidano gli stati degli elementi, come visibilityOfElementLocated, elementToBeClickable o elementToBeSelected.
Impostato una sola volta e applicato per l'intero ciclo di vita dell'istanza di WebDriver.	Impostabile per singolo elemento o per singolo controllo, per una maggiore precisione.

Come scegliere la giusta strategia di attesa

La scelta del comando di attesa corretto influisce direttamente sulla stabilità dello script e sui tempi di esecuzione. Utilizza questo schema decisionale per selezionare l'opzione appropriata per ogni scenario.

1. Identificare il modello di carico: Verifica se l'elemento appare a un orario fisso, dopo una risposta Ajax, o a intervalli imprevedibili. I caricamenti fissi sono adatti a Implicit Wait, mentre i caricamenti imprevedibili richiedono Fluent Wait.
2. Evitate di mescolare attese implicite ed esplicite: La combinazione dei due può causare ritardi imprevisti perché l'attesa più lunga potrebbe prevalere. Selenium La documentazione raccomanda di utilizzare una sola strategia per sessione WebDriver.
3. Imposta come predefinito la modalità esplicita. Attendi i contenuti dinamici: Quando le pagine dipendono da Ajax, rendering condizionale o animazioni, Explicit Wait with ExpectedConditions si applica esattamente all'elemento rilevante.
4. Utilizzare Fluent Wait per la gestione di tempi variabili: Quando i tempi di caricamento degli elementi variano tra le diverse esecuzioni, configura Fluent Wait con un intervallo di polling. Il polling riduce il tempo di attesa totale rispetto a un singolo timeout lungo.
5. Sostituisci Thread.sleep: Le pause codificate in modo rigido rallentano le suite di test e nascondono i reali problemi di temporizzazione. Sostituiscile con attese condizionali per mantenere l'esecuzione veloce e deterministica.
6. Valori di timeout per la sintonizzazione: Iniziate con timeout brevi (5-10 secondi) e aumentateli solo quando i guasti indicano un effettivo rallentamento del carico. Timeout predefiniti lunghi mascherano i cali di prestazioni.
7. Mantieni i tempi di attesa nelle utilità ausiliarie: Centralizza la logica di attesa in una classe di supporto in modo che le modifiche alla politica di timeout si applichino all'intera suite di test.

Seguendo questo schema, gli ingegneri dell'automazione possono creare script resilienti che si adattano ai tempi reali dell'applicazione senza diventare lenti o fragili.

Errori comuni da evitare con Selenium Aspetta

Anche i tester più esperti cadono in una piccola serie di trappole ricorrenti quando lavorano con Selenium attese. Evitare questi problemi mantiene gli script veloci, deterministici e facili da gestire in team e ambienti diversi.

Il primo errore comune è l'abuso di Thread.sleep. Una pausa codificata forza lo script ad attendere per l'intera durata, indipendentemente dall'effettiva disponibilità dell'elemento, il che aumenta il tempo di esecuzione totale. Sostituite queste pause con Explicit o Fluent Wait, in modo che lo script proceda non appena la condizione viene soddisfatta.

Il secondo errore consiste nel combinare attese implicite ed esplicite nello stesso test. I due meccanismi possono sommarsi, creando timeout imprevedibili e difficili da diagnosticare. Scegliete una sola strategia per ogni sessione di WebDriver e applicatela in modo coerente.

Un terzo errore consiste nell'impostare timeout troppo lunghi "per sicurezza". Finestre temporali predefinite troppo lunghe nascondono problemi di prestazioni reali e rallentano il feedback nelle pipeline di integrazione continua. Iniziate con timeout brevi e aumentateli solo quando i log degli errori dimostrano l'esistenza di un problema di temporizzazione reale.

Controlla anche: Selenium Tutorial per principianti: impara WebDriver in 7 giorni

DOMANDE FREQUENTI