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.

Di Ait Nohaila, Business Development Representative 10 min di lettura

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.

Ogni barra è il tempo che il test ha passato ad attendere. Lo sleep è sbagliato in entrambe le giornate. Il controllo è giusto in entrambe, perché segue lo schermo.
La stima èChe cosa succedeChe cosa vede il team
Troppo cortaIl 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 lungaIl test attende dopo che la schermata è pronta.Una suite che dura di più a ogni esecuzione, anche nelle giornate veloci.
Giusta oggiL'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.

200 test3 sleep in ciascuno2 secondi per sleep20 minuti di ogni esecuzione
Un calcolo di esempio, non una statistica: metteteci i vostri numeri. Il tempo viene speso che l'app ne avesse bisogno o no.
EsempioTest lenti e instabili allo stesso tempo

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 serveIn un framework scritto in codiceIn GUI Test Studio
Attendere che un elemento appaiaUna 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 scompaiaUn'altra riga, con la condizione opposta.Un'asserzione visiva di assenza sull'indicatore di caricamento.
Impostare quanto attendereUn numero nel codice o in un file di configurazione.Un campo del controllo, modificabile per più controlli insieme.
Seguire un'app che è diventata più lentaTrovare 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.
Il tempo massimo è un campo del controllo. La scheda in alto lo dice a parole: attende fino a 5 s.

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

Esporta

Asserzione visiva o asserzione testuale

Passa nel momento in cui l'elemento è sullo schermo.

Attendere che scompaia

Caricamento

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

ORD-20418

Asserzione testuale dinamica

Passa nel momento in cui è presente un valore di quel formato, qualunque esso sia.

Qualunque cosa attendiate, il controllo chiude l'attesa nel momento in cui lo dice lo schermo. Nessun tempo viene stimato.
Che cosa state aspettandoIl controllo da usarePassa
Che appaia un pulsante, un'icona o un'immagineAsserzione visivaNel momento in cui l'elemento è sullo schermo e ha l'aspetto giusto.
Che appaia un messaggio o un titoloAsserzione testualeNel momento in cui le parole sono sullo schermo.
Che scompaia un indicatore di caricamento o una barra di avanzamentoAsserzione visiva di assenzaNel momento in cui ha lasciato lo schermo.
Che scompaia una parola come CaricamentoAsserzione testuale di assenzaNel momento in cui la parola non c'è più.
Che compaia un totale, una data o un numero d'ordineAsserzione testuale dinamicaNel momento in cui è presente un valore del formato giusto, qualunque esso sia.
Che un elenco contenga il numero giusto di righeAsserzione visiva di conteggio o asserzione testuale di conteggioNel momento in cui il conteggio rispetta la sua regola.
Qualcosa che lo schermo non mostra maiUn passaggio AttesaDopo 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.

EsempioUn report che richiede da 2 a 20 secondi

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 erroreAdatto a
Interrompi il testUn 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 testUn 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. 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. 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. 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. 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. 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. 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.

Un'Attesa ha una sola impostazione che conta: la durata.

Cosa sapere prima di iniziare

Buono a sapersiCosa significa
Un controllo che fallisce usa tutto il suo tempo massimoUn 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 vedereQuando niente sullo schermo dice che l'app è pronta, usate un passaggio Attesa.
Una schermata che sta ancora apparendoUn 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 controllareUn'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.

Tutti gli articoli