Sleep fissi nei test: smettete di indovinare un tempo, aspettate lo schermo
Gli sleep fissi nei test (attese fisse) rendono la suite lenta e instabile. Sostituiteli con un controllo che attende lo schermo e passa appena compare l'elemento.
Uno sleep fisso in un test è una stima: troppo corto e il test fallisce in una giornata lenta, troppo lungo e ogni esecuzione spreca tempo. Attendete invece lo schermo, con un controllo che passa quando l'elemento appare.
Conoscete il copione. Un test fallisce sulla macchina di build, qualcuno aggiunge due secondi di sleep, e passa. Un mese dopo fallisce di nuovo, e lo sleep diventa di cinque secondi. La suite diventa più lenta, e non più stabile.
Che cos'è uno sleep fisso in un test?
Definizione
Uno sleep fisso, o attesa fissa, è un passaggio che mette in pausa un test per un tempo prestabilito prima dell'azione successiva.
- C'è perché l'app ha bisogno di un momento: una pagina si carica, una finestra di dialogo si apre, una ricerca restituisce i risultati.
La pausa non guarda l'app, quindi non può sapere se quel momento è passato.
Nel codice di test è una riga come uno sleep di 2 secondi. In un test registrato è una pausa che qualcuno ha aggiunto a mano dopo un fallimento. In entrambi i casi, una persona ha tirato a indovinare un numero.
Perché uno sleep fisso è sempre sbagliato: troppo corto o troppo lungo
Un'app non impiega mai due volte lo stesso tempo. La macchina di build è occupata, la rete è lenta, il database è più grande del mese scorso. Un solo numero fisso non può andare bene per ogni giornata.
Uno sleep fisso di 3 secondi
Una giornata veloce: la pagina è pronta dopo 1 secondo
Il test attende 3 secondi: 2 per niente.
Una giornata lenta: la pagina è pronta dopo 5 secondi
Il test fa clic dopo 3 secondi, troppo presto, e fallisce.
Un controllo che attende fino a 10 secondi
Una giornata veloce: la pagina è pronta dopo 1 secondo
Il controllo passa dopo 1 secondo, e il test prosegue.
Una giornata lenta: la pagina è pronta dopo 5 secondi
Il controllo passa dopo 5 secondi, e il test prosegue.
| La stima è | Che cosa succede | Che cosa vede il team |
|---|---|---|
| Troppo corta | Il test fa clic prima che la schermata sia pronta. | Un test che fallisce nelle giornate lente e passa se rieseguito: un test instabile (flaky). |
| Troppo lunga | Il test attende dopo che la schermata è pronta. | Una suite che dura di più a ogni esecuzione, anche nelle giornate veloci. |
| Giusta oggi | L'app cambia, e la stima è di nuovo sbagliata. | Qualcuno alza il numero, e la suite rallenta ancora un po'. |
I tempi di attesa sono una delle ragioni principali per cui un test fallisce mentre niente è rotto.Le altre sono in test instabili e falsi positivi.
Quanto costano le attese fisse a una suite di test: un piccolo calcolo
Uno sleep di 2 secondi sembra innocuo. Una suite ne contiene centinaia, e ogni esecuzione li paga tutti.
Prendete 200 test con tre sleep di 2 secondi ciascuno. Fanno 1200 secondi: 20 minuti di ogni esecuzione passati ad attendere. Con dieci esecuzioni al giorno, più di tre ore passano senza che succeda nulla. E il giorno in cui una pagina impiega 3 secondi, i test falliscono comunque.
Uno sleep fisso fa pagare a ogni esecuzione la giornata più lenta, e comunque non la copre.
Attese esplicite in un framework scritto in codice: la soluzione che scrivete voi
In un framework scritto in codice come Selenium, Playwright o Cypress, la risposta a uno sleep fisso è attendere una condizione nel codice, la cosiddetta attesa esplicita (explicit wait): indicare l'elemento, indicare la condizione, fissare un limite. È l'idea giusta. È anche codice da scrivere, da leggere e da mantenere.
| Che cosa vi serve | In un framework scritto in codice | In GUI Test Studio |
|---|---|---|
| Attendere che un elemento appaia | Una riga di codice che indica l'elemento e la condizione. | Niente da scrivere: il controllo che cerca l'elemento è l'attesa. |
| Attendere che un indicatore di caricamento scompaia | Un'altra riga, con la condizione opposta. | Un'asserzione visiva di assenza sull'indicatore di caricamento. |
| Impostare quanto attendere | Un numero nel codice o in un file di configurazione. | Un campo del controllo, modificabile per più controlli insieme. |
| Seguire un'app che è diventata più lenta | Trovare le attese nel codice e regolarle. | Aumentate un tempo massimo. Non costa nulla in una giornata veloce. |
In GUI Test Studio, ogni controllo è un'attesa
GUI Test Studio automatizza i test end-to-end di qualsiasi applicazione senza codice. Registrate un flusso, e il test riceve i suoi controlli dalla registrazione. Un controllo non guarda una volta per poi arrendersi. Continua a guardare finché ciò che si aspetta non è sullo schermo, e il test prosegue subito.
Tre cose valgono per ogni controllo.
- Ha un tempo massimo, il più a lungo che attenderà, impostato a 5 secondi per impostazione predefinita.
- Passa nel momento in cui l'elemento è presente, non alla fine del tempo massimo.
- Fallisce solo quando il tempo massimo scade senza l'elemento.
Una registrazione lo fa per voi.Ogni elemento su cui fate clic riceve un controllo posto prima del clic, così il test si assicura che il pulsante ci sia, poi ci fa clic.La domanda dopo una registrazione chiama il tempo massimo Attendere fino a, e GUI Test Studio lo chiama Tempo massimo.Tempi massimi, aree di ricerca e fallimenti contiene i dettagli.
Non c'è codice in nessun momento, né su un'app web né su un'app desktop: vedete testare un'app desktop Windows senza scrivere codice.
Che cosa state aspettando? Il controllo da usare
Dietro ogni sleep c'è qualcosa che l'autore stava aspettando. Dategli un nome, e avrete dato un nome al controllo.
Attendere che appaia
Asserzione visiva o asserzione testuale
Passa nel momento in cui l'elemento è sullo schermo.
Attendere che scompaia
Asserzione visiva di assenza o asserzione testuale di assenza
Passa nel momento in cui l'indicatore di caricamento è scomparso.
Attendere il giusto tipo di valore
Asserzione testuale dinamica
Passa nel momento in cui è presente un valore di quel formato, qualunque esso sia.
| Che cosa state aspettando | Il controllo da usare | Passa |
|---|---|---|
| Che appaia un pulsante, un'icona o un'immagine | Asserzione visiva | Nel momento in cui l'elemento è sullo schermo e ha l'aspetto giusto. |
| Che appaia un messaggio o un titolo | Asserzione testuale | Nel momento in cui le parole sono sullo schermo. |
| Che scompaia un indicatore di caricamento o una barra di avanzamento | Asserzione visiva di assenza | Nel momento in cui ha lasciato lo schermo. |
| Che scompaia una parola come Caricamento | Asserzione testuale di assenza | Nel momento in cui la parola non c'è più. |
| Che compaia un totale, una data o un numero d'ordine | Asserzione testuale dinamica | Nel momento in cui è presente un valore del formato giusto, qualunque esso sia. |
| Che un elenco contenga il numero giusto di righe | Asserzione visiva di conteggio o asserzione testuale di conteggio | Nel momento in cui il conteggio rispetta la sua regola. |
| Qualcosa che lo schermo non mostra mai | Un passaggio Attesa | Dopo il tempo fisso che gli avete dato. |
Scegliere il controllo giusto parte dalla stessa domanda per tutti e nove i controlli.
Come si attende che un indicatore di caricamento (spinner) scompaia?
Con un controllo che passa quando qualcosa è scomparso. Un indicatore di caricamento è l'app che dice di non essere pronta. Quindi l'attesa migliore è la fine dell'indicatore stesso.
Dopo un clic su Genera report, un indicatore di caricamento gira per un tempo che va da 2 a 20 secondi. Uno sleep fisso dovrebbe essere di 20 secondi, ogni volta. Un'asserzione visiva di assenza sull'indicatore, con un tempo massimo di 30 secondi, lascia proseguire il test nel momento in cui il report è pronto.
Un valore che cambia a ogni esecuzione si attende allo stesso modo.Un'asserzione testuale dinamica non si aspetta un totale o una data precisi: attende un valore del formato giusto, come un importo o un numero d'ordine.Asserzioni visive e Asserzioni testuali descrivono ciascuno di questi controlli.
Che cosa succede quando il tempo scade: interrompere o continuare
Un'attesa che termina senza il suo elemento è un fallimento, e ogni controllo dice che cosa fa quel fallimento.
| In caso di errore | Adatto a |
|---|---|
| Interrompi il test | Un controllo da cui dipendono i clic successivi, come il controllo di un pulsante prima del suo clic. Proseguire farebbe clic nel posto sbagliato. |
| Continua il test | Un controllo che conferma soltanto ciò che è sullo schermo. Una sola esecuzione segnala allora ogni problema che incontra. |
In entrambi i casi, dopo non resta nulla da indovinare.Il report dice quale controllo ha esaurito il tempo e mostra com'era lo schermo in quel momento: vedete come leggere un report di test.
Come sostituire uno sleep fisso con un controllo che attende
Un test registrato ha poche pause fisse, se ne ha. Questa procedura serve per l'Attesa che qualcuno ha aggiunto dopo una brutta giornata, o per un passaggio che fallisce ancora quando l'app è lenta.
- 1
Trovare la pausa fissa
Aprite il test in GUI Test Studio e trovate l'Attesa sul righello temporale, oppure il passaggio che fallisce nelle giornate lente.
- 2
Chiedersi che cosa stava aspettando la pausa
Guardate la registrazione in quel momento e date un nome a ciò che mostra che l'app è pronta: un pulsante, un messaggio, o un indicatore di caricamento scomparso.
- 3
Aggiungere il controllo che lo attende
Trascinate il controllo corrispondente dalla tavolozza Asserzioni sulla traccia Asserzioni in quel momento, e mostrategli sulla registrazione che cosa cercare.
- 4
Impostare quanto può attendere
Impostate il Tempo massimo del controllo sulla giornata più lenta che accettate.In una giornata veloce il controllo passa comunque subito.
- 5
Decidere che cosa fa un fallimento
Scegliete Interrompi il test quando i passaggi successivi dipendono dal controllo, oppure Continua il test quando conferma soltanto ciò che è sullo schermo.
- 6
Rimuovere l'Attesa ed eseguire il test
Spuntate Ignorato sull'Attesa, oppure eliminatela, poi eseguite il test.L'esecuzione ora prosegue nel momento in cui la schermata è pronta.
Potete anche chiedere la modifica in un prompt, al vostro assistente IA o a un modello di IA locale, fornito da noi o vostro: dare a un controllo un tempo massimo più lungo, aggiungere un'attesa, decidere che cosa succede se fallisce.Vedete Creare un test da un prompt.
Quando un vero passaggio Attesa è la scelta giusta
A volte l'app ha bisogno di tempo e intanto non mostra nulla. Nessun controllo può attendere ciò che non è sullo schermo. È a questo che serve il passaggio Attesa.
Un'Attesa fissa è giusta in pochi casi.
- Un file viene scritto in background prima che il passaggio successivo lo legga.
- Un job sul server gira senza alcun avanzamento sullo schermo.
- Uno strumento esterno all'app ha bisogno di un momento per avviarsi.
Un'Attesa si trova nella tavolozza Eventi, sotto Flusso del test.Rilasciatela sulla timeline e si posa sul righello temporale, in quel momento.Flusso del test: attese, app, telefoni e script la descrive.
Cosa sapere prima di iniziare
| Buono a sapersi | Cosa significa |
|---|---|
| Un controllo che fallisce usa tutto il suo tempo massimo | Un controllo che fallisce attende fino alla fine prima di dirlo. Impostate ogni tempo massimo sulla giornata più lenta che accettate, non molto oltre. |
| Un controllo ha bisogno di qualcosa da vedere | Quando niente sullo schermo dice che l'app è pronta, usate un passaggio Attesa. |
| Una schermata che sta ancora apparendo | Un elemento può essere trovato mentre un menu sta ancora comparendo in dissolvenza o una pagina si sta ancora caricando.Un'asserzione visiva viene confrontata nel suo momento migliore, nel breve tempo dopo che è stata trovata: vedete la passata di accuratezza avanzata. |
| Un test controlla ciò che gli è stato detto di controllare | Un'attesa dimostra che un elemento è arrivato. Che cos'altro c'è su quella schermata viene controllato solo se un controllo lo guarda. |
Punti chiave
- 1Uno sleep fisso è una stima, e una stima è troppo corta in una giornata lenta e troppo lunga in tutte le altre.
- 2Gli sleep rendono una suite lenta e instabile insieme: ogni esecuzione li paga, e la giornata più lenta fallisce comunque.
- 3Attendete invece lo schermo: che un elemento appaia, che scompaia, o che mostri il giusto tipo di valore.
- 4In GUI Test Studio ogni controllo è quell'attesa, fino a 5 secondi per impostazione predefinita, e passa nel momento in cui l'elemento è presente.
- 5Riservate il passaggio Attesa a ciò che nessun controllo può vedere, come un file scritto in background.
Domande
Perché gli sleep fissi fanno male ai test?
Perché uno sleep fisso è una stima. Quando l'app è più lenta della stima, il test agisce troppo presto e fallisce. Quando l'app è più veloce, il test attende per niente, a ogni esecuzione.
Che cosa usare al posto di uno sleep in un test?
Attendete ciò che lo schermo mostra quando l'app è pronta: un pulsante, un messaggio, o un indicatore di caricamento scomparso. In GUI Test Studio, un controllo lo fa da solo: continua a guardare fino al suo tempo massimo e passa nel momento in cui l'elemento è presente.
Qual è la differenza tra un'attesa fissa e un'attesa esplicita?
Un'attesa fissa mette in pausa per un tempo prestabilito, qualunque cosa faccia l'app. Un'attesa esplicita mette in pausa finché una condizione non è vera, fino a un limite, quindi termina appena l'app è pronta. In un framework scritto in codice la scrivete per ogni elemento, mentre in GUI Test Studio ogni controllo ne è una.
Quanto deve attendere un test per un elemento?
Quanto la giornata più lenta che accettate. In GUI Test Studio un controllo attende fino a 5 secondi per impostazione predefinita, e potete aumentare il valore per una schermata lenta. Il limite viene raggiunto solo quando l'elemento non appare mai.
Un tempo massimo (timeout) più lungo rallenta i miei test?
No, non quando i test passano. Un controllo prosegue nel momento in cui l'elemento è presente, quindi un tempo massimo di 30 secondi costa 1 secondo in una giornata in cui la schermata impiega 1 secondo. Solo un controllo che fallisce usa tutto il suo tempo massimo.
Come attendo che un indicatore di caricamento (spinner) scompaia?
Usate un controllo che passa quando qualcosa è scomparso. In GUI Test Studio, un'asserzione visiva di assenza sull'indicatore di caricamento passa nel momento in cui l'indicatore ha lasciato lo schermo, e un'asserzione testuale di assenza fa lo stesso per una parola come Caricamento.
Quando un'attesa fissa è ancora la scelta giusta?
Quando l'app ha bisogno di tempo e intanto non mostra nulla: un file scritto in background, un job su un server senza alcun avanzamento sullo schermo. GUI Test Studio ha un passaggio Attesa per questo caso.
Devo aggiungere io le attese in un test registrato?
No. Una registrazione dà a ogni elemento su cui fate clic un controllo posto prima del clic, e quel controllo attende l'elemento. Regolate un tempo massimo solo quando una schermata è più lenta del solito.
Selenium, Playwright e Cypress sono marchi dei rispettivi proprietari.
Continua a leggere
Tutti gli articoli
Affidabilità dei test
Test self-healing: quando un test che si ripara da solo nasconde un bug reale
11 min di lettura

Affidabilità dei test
Prove di test per gli audit: cosa chiede un auditor a un test automatizzato
11 min di lettura

Affidabilità dei test
Ancora «element not found»? Come testare quando selettori e locator falliscono
14 min di lettura