Cos'è il test end-to-end? Una guida semplice con un esempio reale

Cos'è il test end-to-end? Una definizione semplice e un esempio reale, un ordine in un'app di vendita, seguito dal primo clic a un test eseguito a ogni build.

Di Ait Nohaila, Business Development Representative 10 min di lettura

Il test end-to-end controlla un intero flusso di un'applicazione attraverso il suo schermo reale, dal primo clic dell'utente al risultato finale, con tutte le parti che stanno dietro al lavoro insieme. Dimostra che l'utente ottiene ciò per cui è venuto.

Tutti i team concordano che questi sono i test che contano di più, eppure la maggior parte ne ha pochissimi. Scritto in codice, un test end-to-end è lento da scrivere e si rompe a ogni restyling, così i flussi di cui l'azienda vive vengono ancora controllati a mano prima di ogni rilascio, oppure non vengono controllati affatto.

Che cos'è il test end-to-end?

Definizione

Il test end-to-end, spesso scritto test E2E, consiste nel testare un'applicazione come la usano i suoi utenti: un intero flusso, attraverso lo schermo reale, dall'inizio alla fine.

  • Il test fa clic, digita e legge ciò che viene mostrato, come farebbe una persona.
  • Tutto ciò che sta dietro lo schermo partecipa: i server, il database e i servizi esterni che il flusso chiama.

Il test passa solo quando il risultato finale dell'utente è giusto.

I due estremi del nome sono la prima azione dell'utente e il suo risultato finale.Ciò che sta in mezzo è l'intera applicazione.La pagina Test end-to-end mostra i tipi di app coperti, dalle app web alle app desktop Windows e ai telefoni.

Un esempio di test end-to-end: un ordine nell'app di un negozio

Questo articolo segue un solo esempio fino in fondo: un cliente di un negozio online ordina una lampada da scrivania. È lungo quattro schermate, ed è il flusso che il negozio non può permettersi di perdere.

1

Accedi

Digita l'email e la password.

Appare il nome dell'account.

2

Aggiungi al carrello

Apre la lampada da scrivania e la aggiunge.

Il carrello mostra un articolo e il suo prezzo.

3

Paga

Digita la carta e fa clic su Paga.

Non appare alcun messaggio di errore.

4

Conferma

Legge la pagina di conferma.

Sono mostrati il totale e un numero d'ordine.

Dietro lo schermo, tutto questo deve funzionare

Servizio di accessoCatalogo dei prodottiFornitore dei pagamentiDatabase degli ordiniEmail di conferma
Un solo test end-to-end: quattro schermate, un controllo su ciascuna, e ogni parte che sta dietro messa alla prova lungo il percorso.

Chi lo testa a mano fa esattamente questo: accede, aggiunge la lampada, paga con una carta di test e legge la conferma. Un test end-to-end fa lo stesso, nello stesso ordine, e controlla le stesse cose lungo il percorso.

Che cosa copre un test end-to-end che i test più piccoli non possono coprire

I test più piccoli guardano una parte alla volta: una funzione, un servizio, una schermata. Sono veloci e precisi, e hanno ragione sulla propria parte. Quello che non possono vedere è il passaggio di consegne da una parte all'altra, così come lo vive il cliente.

Ogni parte, testata da sola

Accesso
Carrello
Pagamento
Ordini

L'intero ordine, attraverso lo schermo

La pagina di conferma non mostra alcun numero d'ordine.

Ogni parte ha superato i propri test. Solo il test che ha seguito l'ordine fino all'ultima schermata ha visto ciò che avrebbe visto il cliente.

Un test end-to-end dell'ordine copre ciò che nessun test più piccolo copre.

  • Dimostra che l'accesso porta davvero al negozio, con l'account giusto.
  • Dimostra che l'articolo aggiunto in una schermata è l'articolo addebitato in quella successiva.
  • Dimostra che il pagamento andato a buon fine produce una conferma che il cliente può leggere.
  • Dimostra tutto questo sullo schermo, dove un valore giusto disegnato nel posto sbagliato resta un bug.

Come appare lo stesso bug visto da un test delle parti e da un test dello schermo è l'argomento di test end-to-end e test di integrazione a confronto.Un test di una sola funzione, come un campo per il codice sconto, è spiegato in che cos'è il test funzionale.

Che cosa controllare a ogni passaggio del flusso

Un test end-to-end che attraversa quattro schermate a colpi di clic e non controlla nulla dimostra soltanto che l'app non si è bloccata. Ogni passaggio termina su qualcosa che l'utente guarderebbe.

PassaggioChe cosa controlla il testCon quale controllo
AccediIl nome dell'account appare in cima alla pagina.Un'asserzione testuale, che legge le parole.
Aggiungi al carrelloIl carrello mostra un articolo, l'immagine della lampada e il suo prezzo.Un'asserzione testuale per il prezzo, un'asserzione visiva per l'immagine.
PagaL'indicatore di caricamento scompare e non appare alcun messaggio di errore.Un'asserzione visiva di assenza e un'asserzione testuale di assenza.
ConfermaIl messaggio di ringraziamento, il totale pagato e il numero d'ordine.Asserzioni testuali, e un'asserzione testuale dinamica per il numero.

Il numero d'ordine merita uno sguardo più attento, perché è il punto in cui molti test end-to-end sbagliano. È diverso a ogni esecuzione, quindi un controllo che si aspetta il numero visto durante la registrazione fallisce già il giorno dopo.

Un controllo che si aspetta il numero registrato

Esecuzione 1ORD-20418
Esecuzione 2ORD-20419
Esecuzione 3ORD-20420
Una build difettosaORD-

Fa fallire ogni ordine dopo il primo, anche se non c'è niente di rotto.

Un'asserzione testuale dinamica che si aspetta il formato

Esecuzione 1ORD-20418
Esecuzione 2ORD-20419
Esecuzione 3ORD-20420
Una build difettosaORD-

Passa con ogni vero numero d'ordine, e fallisce comunque con uno sbagliato.

Un valore che cambia a ogni esecuzione si controlla tramite il suo formato: qui, le lettere ORD, un trattino e cinque cifre.

Quando scrivere un test end-to-end, e quanti

Scrivete un test end-to-end quando un flusso è di quelli che l'azienda non può permettersi di perdere.

  • Riguarda denaro, dati personali o l'accesso.
  • Attraversa più parti dell'applicazione o un servizio esterno.
  • Un bug al suo interno impedirebbe a clienti o colleghi di fare il proprio lavoro.

Alla domanda su quanti ne servano la risposta è breve: pochi. Iniziate da uno, il flusso il cui guasto farebbe più male, e aggiungete gli altri che l'azienda non può perdere. La maggior parte delle applicazioni è ben protetta da cinque-quindici test di questo tipo, eseguiti a ogni build.

Da fare

  • Un intero flusso per test, dal primo clic al risultato
  • Un controllo di ciò che l'utente guarderebbe su ogni schermata
  • Un ambiente di test, un account di test e una carta di pagamento di test

Da evitare

  • Un test end-to-end per ogni opzione di ogni schermata
  • Un test che percorre il flusso a colpi di clic e non verifica nulla
  • Un test che dipende dai dati lasciati dall'esecuzione di ieri

Le opzioni di una schermata spettano a test più brevi, ciascuno dedicato a una sola funzione.E quando avrete diversi test end-to-end, smoke test, sanity test e test di regressione a confronto mostra quali eseguire a ogni build e quali di notte.

Perché i test E2E scritti in codice sono difficili da tenere in vita

In un framework scritto in codice come Playwright, Selenium o Cypress, il test dell'ordine è un programma. Scriverlo una volta è la parte piccola. Tenerlo in vita è il vero costo.

Che cosa serve al test dell'ordineIn un framework scritto in codiceIn GUI Test Studio
Trovare ogni campo e ogni pulsanteUn selettore per ciascuno, scritto e riparato a mano.Trovati prima tramite le informazioni di accessibilità dell'app, e a vista quando l'app non dice nulla.
Attendere ogni schermataCodice di attesa per ogni pagina e ogni indicatore di caricamento, oppure pause fisse.Ogni controllo attende da solo e passa nel momento in cui l'elemento è presente.
Il numero d'ordineUn pattern scritto in codice.Un'asserzione testuale dinamica: selezionate il numero, e il suo formato viene riconosciuto.
Un restyling del checkoutScript riparati da un programmatore, un selettore alla volta.Il nuovo aspetto accettato nel report con un clic, dopo averlo esaminato.
Chi può crearloQualcuno che programma.Chiunque sappia fare il flusso a mano.
Un test end-to-end conviene solo se mantenerlo costa poco. Togliete il codice, e il costo se ne va con lui.

Due di quelle righe causano la maggior parte dei fallimenti su un'app che funziona: trovare un elemento e attenderlo.Le pause fisse nei test mostra perché una pausa di durata fissa non è mai quella giusta, e test instabili e falsi positivi quanto costa quel rumore a un team.

Come creare questo test end-to-end senza codice, passo dopo passo

GUI Test Studio automatizza i test end-to-end di qualsiasi applicazione senza codice. Ecco il test dell'ordine di questo articolo, da zero a un test che gira da solo. La maggior parte del lavoro consiste nel fare l'ordine una volta.

  1. 1

    Preparare il punto di partenza

    Usate un ambiente di test, con un account di test e una carta di pagamento di test. Per un'app web, è il test ad aprire la pagina in una finestra del browser pulita a ogni esecuzione, quindi ogni esecuzione parte senza accesso effettuato, come un nuovo visitatore.

  2. 2

    Registrare l'ordine una volta

    Fate clic su Registra in GUI Test Runner-Recorder, scegliete un'app web e digitate l'indirizzo del negozio. Accedete, aggiungete la lampada da scrivania al carrello, pagate, attendete la pagina di conferma, poi premete Esc per terminare.

    Fatelo a un ritmo normale, e aspettate che ogni pagina finisca di caricarsi prima di agire.Potete anche descrivere il flusso in un prompt a Claude, a ChatGPT con Codex, o a un modello di IA locale, fornito da noi o vostro: vedete Creare un test da un prompt.

  3. 3

    Scegliere che cosa verifica il test

    La domanda Cosa deve verificare questo test decide quali controlli il test riceve da solo. Lasciate attivi Verificare gli elementi visivi e Verificare ciò che appare, attivate Verificare il testo perché le parole siano controllate come parole, poi fate clic su Salva il test.

    Posta a registrazione terminata: i controlli che farebbe un tester attento, scelti in un'unica finestra.
  4. 4

    Dare al numero d'ordine un'asserzione testuale dinamica

    Aprite il test in GUI Test Studio. Trascinate un'asserzione testuale dinamica dalla tavolozza Asserzioni al momento in cui appare la conferma, e selezionate il numero d'ordine sul fotogramma. L'editor sceglie il formato del valore, e un formato vostro si descrive una sola volta con un pattern.

    Un'asserzione testuale dinamica nel suo editor, qui su un importo: il valore è selezionato, il suo formato è scelto, e l'editor dice subito se un'esecuzione lo troverebbe.
  5. 5

    Eseguirlo e leggere il report di affidabilità

    Fate clic su Esegui test e non toccate mouse e tastiera. Al termine dell'esecuzione, il report dà l'esito, poi ogni passaggio e ogni controllo, con ciò che era atteso accanto a ciò che è stato trovato.

    Il report di affidabilità di un'esecuzione superata: l'esito in alto, sotto ogni passaggio e ogni controllo, in basso il video dell'esecuzione.
  6. 6

    Eseguirlo a ogni build

    Sulla macchina di build, gtr-cli esegue il test dopo ogni build. Un ordine fallito fa fallire la build, e il report, il video e le immagini dell'esecuzione vengono conservati.

Eseguire il test end-to-end a ogni build

Un test end-to-end protegge l'ordine solo se viene eseguito dopo ogni modifica. Su una macchina di build, gtr-cli lo esegue da qualsiasi strumento di CI/CD e risponde come una pipeline si aspetta.

Il test dell'ordine, dopo ogni build
gtr-cli run tests\Order.GTS --countdown 0 --junit results\order.xml --artifacts results\artifacts
  • Un ordine fallito fa fallire la build tramite il codice di uscita.
  • Il file dei risultati riempie la scheda dei test del vostro strumento di CI.
  • La cartella degli artefatti conserva il video dell'esecuzione, il suo report di affidabilità e le immagini di ciò che è fallito.

Quando una mattina l'ordine fallisce, il report mostra il passaggio fallito, ciò che era atteso accanto a ciò che è stato trovato, e l'ultima esecuzione superata.Come leggere un report di test mostra che cosa guardare per primo, e Eseguire i test nella pipeline offre un esempio pronto per ogni strumento di CI.

Lo stesso test su altri browser, dispositivi e app

L'ordine è stato registrato una volta, in un solo browser.Per un'app web, GUI Test Runner-Recorder può generare lo stesso test per Chrome, Edge e Firefox e per telefoni e tablet emulati: vedete test cross-browser da una sola registrazione.

Niente in questo articolo è specifico di un negozio o del web.Le stesse quattro mosse, registrare, scegliere che cosa verificare, eseguire, leggere il report, danno un test end-to-end di un'app desktop Windows, di un telefono Android collegato al computer o di un gioco.Testare un'app desktop Windows senza scrivere codice segue un esempio desktop.

Cosa sapere prima di iniziare

LimiteCosa significa
Il test paga davveroFa clic su Paga come farebbe un cliente. Eseguitelo su un ambiente di test, con una carta di test.
Lo stesso punto di partenzaUn test si riproduce a partire dallo stato in cui è stato registrato. Per un'app desktop, riportate l'app in quello stato prima di ogni esecuzione.
Un'esecuzione usa lo schermo realeNon toccate mouse e tastiera durante un'esecuzione, oppure date al test una macchina di build. Un test web può anche essere eseguito senza finestra del browser.
Un test controlla ciò che gli è stato detto di controllareUna schermata senza alcun controllo può cambiare senza che nessuno se ne accorga. Ogni passaggio termina con un controllo.

Punti chiave

  • 1Il test end-to-end segue un intero flusso attraverso lo schermo reale, dal primo clic dell'utente al risultato finale.
  • 2Copre i passaggi di consegne tra le parti, che i test di una parte alla volta non possono vedere.
  • 3Ogni passaggio termina con un controllo, e un valore che cambia, come un numero d'ordine, si controlla tramite il suo formato.
  • 4Tenetene pochi: i flussi che l'azienda non può perdere, eseguiti a ogni build.
  • 5Senza codice, il costo di mantenerli sparisce. GUI Test Studio registra il flusso una volta e lo riproduce da solo.

Domande

Che cos'è il test end-to-end in parole semplici?

Il test end-to-end controlla un intero flusso di un'applicazione attraverso il suo schermo reale, così come lo percorre un utente. Il test inizia dal primo clic e termina sul risultato per cui l'utente è venuto, come la conferma di un ordine.

Qual è un esempio di test end-to-end?

Un ordine nell'app di un negozio è l'esempio classico. Il test accede, aggiunge un articolo al carrello, paga e controlla che la pagina di conferma mostri il totale giusto e un numero d'ordine. Passa solo se tutte le parti dietro quelle schermate hanno funzionato insieme.

Qual è la differenza tra test end-to-end e test funzionale?

Un test funzionale controlla una funzione rispetto a ciò che dovrebbe fare, come un campo per il codice sconto. Un test end-to-end segue un intero flusso che attraversa molte funzioni. Un test end-to-end è un test funzionale nel suo perimetro più ampio.

Qual è la differenza tra test end-to-end e test di integrazione?

Il test di integrazione controlla che due o più parti di un'applicazione funzionino insieme, di solito tramite codice. Il test end-to-end controlla l'intera applicazione attraverso il suo schermo. Un test di integrazione può passare mentre lo schermo mostra il risultato sbagliato.

Quanti test end-to-end dovrebbe avere un team?

Pochi, e scelti bene. Iniziate dal flusso il cui guasto farebbe più male all'azienda, poi aggiungete gli altri che non può perdere. La maggior parte delle applicazioni è ben protetta da cinque-quindici test di questo tipo, eseguiti a ogni build.

Il test end-to-end è la stessa cosa del test dell'interfaccia utente (UI)?

Non proprio. Il test dell'interfaccia controlla lo schermo in sé: che i suoi elementi ci siano e abbiano l'aspetto giusto. Il test end-to-end usa lo schermo per seguire un intero flusso e controllarne il risultato. Di solito un test end-to-end fa controlli dell'interfaccia lungo il percorso.

Chi scrive i test end-to-end?

Tradizionalmente gli sviluppatori o gli ingegneri dell'automazione, perché i test erano codice. Quando un test viene registrato invece che scritto in codice, i tester e i product owner che conoscono il flusso possono crearlo e mantenerlo da soli.

I test end-to-end si possono automatizzare senza scrivere codice?

Sì. Con GUI Test Studio, fate il flusso una volta nella vostra applicazione mentre viene registrato, e scegliete che cosa verifica il test. Il test poi si riproduce da solo a ogni build, e non c'è codice di test da scrivere né da mantenere.

Playwright, Selenium, Cypress, Claude, ChatGPT, Chrome, Edge, Firefox, Android e Windows sono marchi dei rispettivi proprietari.

Tutti gli articoli