Test self-healing: quando un test che si ripara da solo nasconde un bug reale

I test self-healing tengono verde la suite quando l'app cambia. Come una falsa riparazione nasconde un bug reale, e come fare di ogni modifica una scelta visibile.

Di Ait Nohaila, Business Development Representative 11 min di lettura

I test self-healing si riparano da soli quando l'app cambia: un test che non trova un elemento ne sceglie uno simile e va avanti. Questo risparmia manutenzione, ma una scelta sbagliata fa passare un flusso rotto, e nessuno viene avvisato.

Conoscete quella mattina. È arrivata una nuova build, quaranta test sono rossi, e nessuno di loro ha trovato un bug: ognuno ha perso un pulsante che prima trovava. Il self-healing promette di mettere fine a quelle mattine. La domanda è cosa fa il giorno in cui il pulsante non c'è davvero più.

Cosa sono i test self-healing?

Definizione

Un test self-healing è un test automatizzato che si modifica da solo quando non riesce più a trovare un elemento.

  • Lo strumento cerca la corrispondenza più vicina sullo schermo e la usa al suo posto.
  • L'esecuzione prosegue come se niente fosse.

L'automazione dei test self-healing esiste a causa di un tipo di manutenzione. In un test scritto in codice, ogni pulsante, campo e link viene trovato tramite un locator: una riga che descrive dove si trova l'elemento nella pagina o nella finestra. Quando uno sviluppatore rinomina o sposta l'elemento, il locator non corrisponde più, e il test fallisce anche se l'app funziona.

Perché i locator si rompono così spesso è il tema di «element not found»: quando selettori e locator falliscono.

Perché i team vogliono l'automazione dei test self-healing

Tre problemi rendono attraente il self-healing.

Build rosse che non hanno trovato nulla

Una piccola modifica dell'app fa diventare rossi decine di test, e nessuno di loro indica un bug.

Ore di riparazioni

I tester passano la settimana a riparare locator invece di testare il prodotto.

Una suite di cui nessuno si fida

Dopo abbastanza falsi allarmi, il team smette del tutto di guardare i test rossi.

Il desiderio che c'è dietro è legittimo. Un test dovrebbe sopravvivere a una modifica che nessun utente noterebbe: un id rinominato, un pulsante spostato di poco, un nuovo contenitore intorno a un modulo. Nessuna di queste è un bug, e nessuna dovrebbe costare una mattina.

I test che falliscono senza motivo hanno un costo tutto loro, raccontato in test instabili e falsi positivi.

Cos'è una falsa riparazione?

Definizione

Una falsa riparazione è una riparazione che sceglie l'elemento sbagliato.

  • Il test va avanti e fa clic o controlla qualcosa che somiglia soltanto a ciò per cui era stato creato.
  • Poi passa.

L'esecuzione è verde su un flusso che è rotto.

La settimana scorsa

Il vostro ordine

Paga ora

Il test fa clic su Paga ora.

Questa settimana

Il vostro ordine

Paga dopo

Paga ora non c'è più. Il test si ripara da solo e fa clic su Paga dopo.

Cosa dice la build

Test superato

Cosa riceve il cliente

Un ordine mai pagato

Una falsa riparazione: il test si è riparato su un altro pulsante, e l'esecuzione è rimasta verde su un checkout rotto.
EsempioUn checkout che ha perso il pulsante Paga

Per errore, una release sostituisce il pulsante Paga ora con Paga dopo. Il test non trova Paga ora. La sua riparazione trova un pulsante della stessa dimensione nello stesso punto, con un nome simile, e ci fa clic. L'ordine viene salvato come non pagato, l'ultimo passaggio vede ancora una pagina d'ordine, e l'esecuzione passa. La prima persona ad accorgersene è un cliente.

Un test fallito costa qualche minuto. Una falsa riparazione elimina l'unico segnale che il test doveva dare.

Un falso allarme fallisce per niente. Una falsa riparazione passa per niente, ed è peggio: nessuno apre un test verde per controllarlo.

Come un test trova un elemento, e cosa si aspetta: due modifiche diverse

Non tutte le riparazioni comportano lo stesso rischio. Un test conserva due cose di ogni elemento, e non andrebbero trattate allo stesso modo.

Come si trova l'elemento

Un nuovo idUn pulsante spostatoUna finestra più largaUn elenco scorso

L'utente vede lo stesso schermo.

Il test può adattarsi da solo, e dire dove ha trovato l'elemento.

Cosa si aspetta il controllo

Altre paroleUn altro coloreUn'icona mancanteUn altro elemento

L'utente vede un altro schermo.

Il test fallisce, e decide una persona.

Un test conserva due cose di ogni elemento. Solo la prima può cambiare senza che una persona guardi.
Cosa è cambiatoEsempioSe il test si adatta in silenzio
Come si trova l'elementoIl pulsante ha mantenuto il suo aspetto e la sua funzione, ma si è spostato o ha un altro id.Rischio basso: l'utente vede lo stesso schermo.
Cosa si aspetta il testLe parole, il colore o lo stato del pulsante sono cambiati, oppure un altro elemento ha preso il suo posto.Rischio alto: è una decisione sul vostro prodotto.

La regola conta ancora di più quando è l'IA a scrivere il codice sotto test, come spiega come testare il codice generato dall'IA.

Due domande da fare a qualsiasi test self-healing

Prima di affidarvi a un test che si ripara da solo, fate due domande.

Chi viene avvisato?

Quando un test si è modificato da solo, chi viene avvisato, e può vedere da cosa a cosa è cambiato?

Chi ha deciso?

Chi ha deciso che la nuova versione era giusta: una persona che ha guardato lo schermo, o lo strumento da solo?

Se le risposte oneste sono “nessuno” e “lo strumento”, ogni esecuzione verde va ricontrollata, e il tempo risparmiato si spende di nuovo.La stessa abitudine di chiedere prima di fidarsi è alla base di Strumenti di test con IA: 7 domande da fare prima di sceglierne uno.

Meno rotture da riparare: nessun locator da mantenere

GUI Test Studio, che automatizza i test end-to-end di qualsiasi applicazione senza codice, parte dall'altro capo. Nessuno scrive un locator, quindi non ce n'è nessuno da mantenere. Registrate il flusso una volta, o lo descrivete in un prompt, e ogni controllo riguarda ciò che l'utente vede.

Il GTS Engine + AI trova ogni elemento in due modi.

  • Prima interroga l'app, tramite le sue informazioni di accessibilità.
  • Quando l'app non dice nulla, trova l'elemento a vista, sullo schermo.
  • Un pulsante spostato, una finestra più larga o un elenco che è scorso vengono trovati dove si trovano adesso, e il report di affidabilità dice dove.

Su una pagina web, un test registrato conserva diversi modi per raggiungere ogni elemento.Quando il primo smette di funzionare, il successivo trova lo stesso elemento, e l'esecuzione lo annota.Come GUI Test Studio trova gli elementi spiega entrambi i modi.

È per questa seconda metà che un sosia non passa inosservato. Se Paga dopo si trova dove c'era Paga ora, il controllo lo confronta con il Paga ora che si aspetta, e fallisce.

Quando lo schermo è cambiato davvero: un fallimento che tutti vedono

Alcune modifiche sono reali: nuove parole su un pulsante, un nuovo colore, un campo sparito. GUI Test Studio non decide al posto vostro cosa significano. Il controllo fallisce, l'esecuzione è rossa, e il report di affidabilità si apre su ciò che è successo.

Un controllo non superato nel report di affidabilità: l'atteso accanto all'effettivo, cosa è cambiato e il pulsante Accetta a destra.

Il report vi dà ciò che serve per decidere.

  • L'immagine attesa sta accanto a quella effettiva, e la differenza è evidenziata.
  • Con l'analisi intelligente con IA attivata, una frase dice cosa è cambiato in parole semplici, per esempio un pulsante passato da attivo a disattivato.
  • Il video dell'esecuzione mostra i passaggi che hanno portato lì.
  • Il report viene salvato con l'esecuzione, così il fallimento resta agli atti.

La guida Il report di affidabilità spiega tutto ciò che un'esecuzione mostra, e come leggere un report di test segue un fallimento dalla prima riga alla decisione.

Accettare il nuovo aspetto o segnalare il bug: decide una persona

Controllo non superato: pulsante Paga

Atteso

Paga ora

Effettivo

Paga dopo

Le parole del pulsante sono passate da “Paga ora” a “Paga dopo”.

Nessuno lo voleva: segnalate il bug

Una segnalazione di bug con i passaggi e le due immagini, come file o come ticket Jira.

Era voluto: accettate il nuovo aspetto

Un clic, annullabile, poi salvato nel test.

La stessa modifica, resa visibile: l'esecuzione è rossa, i due aspetti sono sullo schermo, e sceglie una persona.
  1. Guardare

    L'atteso accanto all'effettivo

  2. Un bug?

    Segnalarlo dal report

  3. Di proposito?

    Accettare il nuovo aspetto

  4. Salvare

    Nel test

  1. 1

    Aprire il controllo non superato

    Nel report di affidabilità, selezionate il controllo non superato. La sua immagine attesa sta accanto a quella effettiva, e la differenza è evidenziata.

  2. 2

    Decidere: un bug, o una modifica voluta

    Chiedetevi se il team voleva che lo schermo avesse questo aspetto. Se nessuno lo voleva, è un bug.

  3. 3

    Un bug: segnalarlo dal report

    Create una segnalazione di bug come file PDF o Excel, oppure come ticket Jira. I passaggi, le immagini e il motivo vengono compilati dall'esecuzione.

  4. 4

    Una modifica voluta: accettare il nuovo aspetto

    Fate clic su Accetta l'effettivo come atteso.Il nuovo aspetto resta in sospeso finché non salvate, e Ctrl+Z lo annulla.

  5. 5

    Salvare

    Fate clic su Salva.Il file di test viene aggiornato, e l'esecuzione successiva si aspetta il nuovo aspetto.

Dopo un restyling, molti controlli falliscono per lo stesso motivo.Un unico foglio elenca ogni controllo non superato con le sue due immagini: togliete la spunta ai bug reali e accettate tutti gli altri insieme.Aggiornare un test dopo una modifica mostra ogni finestra.

Una riparazione silenziosa e una decisione visibile a confronto

DomandaUna riparazione silenziosaUna decisione visibile
Cosa succede quando un elemento è cambiato?Lo strumento sceglie un elemento simile, e l'esecuzione va avanti.Il controllo fallisce, e l'esecuzione lo dice.
Chi viene avvisato?Chi legge il log delle riparazioni, se qualcuno lo fa.Tutti quelli che vedono la build. Il report si apre sul fallimento.
Chi decide che la nuova versione è giusta?Lo strumento.Una persona che ha visto l'atteso accanto all'effettivo.
Che aspetto ha un bug reale?Un test verde.Un test rosso, con entrambe le immagini.
Cosa resta dopo?Un'esecuzione verde, e un test che non controlla più ciò per cui era stato creato.Il report salvato dell'esecuzione fallita, e l'aspetto accettato nel test.
Quanto costa?Niente oggi, e un bug sfuggito domani.Un clic per modifica, o una sola revisione per molte.

Un test che si modifica da solo tra due esecuzioni non è più lo stesso test.Perché lo stesso test dovrebbe dare due volte la stessa risposta è il tema dei test ripetibili con l'IA.

Cosa sapere prima di iniziare

LimiteCosa significa
Accettare costa un clic per modificaUna persona esamina ogni nuovo aspetto. Dopo un restyling, il foglio dei controlli non superati permette di accettarne molti insieme.
Un test controlla ciò che gli è stato detto di controllareUna modifica in una parte dello schermo che nessun controllo guarda non viene vista. Aggiungete un controllo dove conta.
L'IA può far passare una differenza minoreCon l'analisi intelligente con IA attivata, un controllo non superato che differisce solo in modi che un utente non noterebbe può essere superato. Il report lo dice, e il file di test non viene modificato.

Punti chiave

  • 1I test self-healing si riparano da soli scegliendo un elemento simile quando il loro non viene trovato.
  • 2Una falsa riparazione sceglie l'elemento sbagliato: un test verde su un flusso rotto, e nessuno viene avvisato.
  • 3Due modifiche, due regole: il modo in cui si trova un elemento può adattarsi, ciò che un controllo si aspetta cambia solo quando una persona è d'accordo.
  • 4In GUI Test Studio non c'è nessun locator da mantenere: ogni elemento viene trovato prima tramite le informazioni di accessibilità dell'app, e a vista quando l'app non dice nulla.
  • 5Una modifica reale fallisce sotto gli occhi di tutti, e una persona accetta il nuovo aspetto con un clic o segnala il bug.

Domande

Cosa sono i test self-healing?

I test self-healing sono test automatizzati che si modificano da soli quando non riescono più a trovare un elemento. Lo strumento cerca la corrispondenza più vicina sullo schermo, la usa al suo posto e prosegue l'esecuzione. Lo scopo è risparmiare al team la riparazione dei test dopo piccole modifiche dell'app.

Cos'è una falsa riparazione nell'automazione dei test?

Una falsa riparazione è una riparazione che sceglie l'elemento sbagliato. Il test fa clic o controlla qualcosa che somiglia soltanto all'elemento per cui era stato creato, e passa. Il risultato è un test verde su un flusso che è rotto.

L'automazione dei test self-healing è sicura?

È sicura quando cambia solo il modo in cui un test trova un elemento e ve lo dice ogni volta. È un rischio quando cambia ciò che il test si aspetta, o sceglie un altro elemento, senza che una persona guardi. Chiedete chi viene avvisato quando un test si è modificato da solo, e chi ha deciso che la modifica era giusta.

Perché i test automatizzati si rompono quando l'app cambia?

La maggior parte dei test scritti in codice trova ogni pulsante e campo tramite un locator, una riga che descrive dove si trova l'elemento nella pagina o nella finestra. Quando uno sviluppatore rinomina o sposta l'elemento, il locator non corrisponde più e il test fallisce, anche se l'app funziona.

GUI Test Studio ha test self-healing?

Ha bisogno di molte meno riparazioni, e lascia la decisione a una persona. Non c'è nessun locator da scrivere o riparare: ogni elemento viene trovato prima tramite le informazioni di accessibilità dell'app, e a vista quando l'app non dice nulla. Quando lo schermo è cambiato davvero, il controllo fallisce nel report di affidabilità, e accettate il nuovo aspetto con un clic o segnalate il bug.

Come aggiorno un test dopo una modifica voluta?

Aprite il controllo non superato nel report di affidabilità, guardate l'immagine attesa e quella effettiva, e fate clic su Accetta l'effettivo come atteso. Ctrl+Z lo annulla finché non fate clic su Salva. Dopo il salvataggio, il test si aspetta il nuovo aspetto.

Posso accettare molte modifiche insieme dopo un restyling?

Sì. Il report di affidabilità elenca ogni controllo non superato con le sue due immagini in un unico foglio. Togliete la spunta a quelli che sono bug reali e accettate tutti gli altri insieme.

Chi dovrebbe decidere quando un test cambia?

Una persona che ha visto cosa è cambiato. Un test dichiara ciò che il vostro team si aspetta dal prodotto, quindi una modifica a ciò che si aspetta è una decisione di prodotto. Uno strumento può preparare quella decisione mostrando l'atteso accanto all'effettivo, ma non dovrebbe prenderla da solo.

Windows e Jira sono marchi dei rispettivi proprietari.

Tutti gli articoli