Testare le app desktop Windows senza scrivere codice
Test delle app desktop Windows senza codice: registrate il flusso una volta, scegliete cosa verificare ed eseguitelo a ogni build. Niente script né id di elementi.
Per testare un'app desktop Windows senza scrivere codice, registrate il flusso una volta, scegliete che cosa verifica il test ed eseguitelo a ogni build. In GUI Test Studio, la registrazione diventa il test.
Avete cercato come testare un'applicazione desktop e avete trovato librerie di codice. Ora scrivete script, ispezionate alberi di elementi e regolate attese, e la prossima versione dell'app ne romperà la metà. Questo articolo mostra la via d'uscita.
Perché testare un'app desktop Windows è di solito un lavoro di programmazione?
Definizione
Testare un'applicazione desktop con una libreria di codice significa descrivere l'app a uno script.
- Per ogni passaggio, lo script deve trovare una finestra, trovare un elemento al suo interno, attendere che sia pronto, agire su di esso e rileggere un risultato.
È un lavoro di programmazione, anche quando il test in sé sono tre clic.
Librerie come pywinauto, FlaUI e WinAppDriver sono fatte così, per persone che scrivono codice ogni giorno. Un tester che conosce l'app a memoria, ma non il linguaggio di programmazione, resta ad aspettare uno sviluppatore.
Un test scritto in codice
- 1Avviare l'app e trovare la sua finestra
- 2Trovare il pulsante Salva tramite il suo id
- 3Attendere che il pulsante sia pronto
- 4Farci clic
- 5Trovare il messaggio e leggerne il testo
- 6Confrontare il testo con quello atteso
Sei cose da scrivere, per un clic e un controllo.
Un test registrato
Fate clic su Salva e leggete il messaggio, una volta.
La registrazione conserva
Niente da scrivere: la registrazione diventa il test.
Cinque cose che rallentano un team con una libreria di codice
Serve un programmatore
Ogni test è un programma, quindi le persone che conoscono meglio i flussi non possono scriverlo né correggerlo.
Alberi di elementi da ispezionare
Prima che uno script possa fare clic su un pulsante, qualcuno apre uno strumento di ispezione e va a caccia dell'id o del nome del pulsante.
App che non dicono nulla
Molte app descrivono solo una parte della propria schermata, così un grafico, un canvas o una griglia personalizzata restano fuori dalla portata di uno script.
Codice per i tempi di attesa
Allo script va detto quanto attendere per ogni finestra e ogni risultato, e una stima troppo corta fallisce in una giornata lenta.
Manutenzione a ogni modifica
Quando una schermata viene ridisegnata, id e nomi cambiano, e gli script si riparano uno per uno.
I tempi di attesa da soli sono all'origine di molti test che falliscono senza motivo: vedete le pause fisse nei test e test instabili e falsi positivi.
Libreria di codice o nessun codice: che cosa scrivete e mantenete
L'obiettivo è lo stesso in entrambi i casi: un test che fa ciò che fa un utente e controlla ciò che lo schermo mostra. Ciò che cambia è quanto dovete scrivere e mantenere per arrivarci.
| Che cosa serve a un test | In una libreria di codice | In GUI Test Studio |
|---|---|---|
| Avviare l'app | Codice che avvia il programma e attende la sua finestra. | Una casella da spuntare: il test avvia l'app e la chiude alla fine. |
| Trovare ogni pulsante e ogni campo | Un locator per elemento, trovato ispezionando l'app, riparato quando la schermata cambia. | Niente da scrivere: la registrazione conserva ciò che l'app dice di ogni elemento, e la sua immagine. |
| Un componente che l'app non descrive | Fuori portata, oppure un espediente scritto a mano. | Trovato a vista, come qualsiasi altro elemento. |
| Attendere l'app | Un'attesa scritta per ogni passaggio, da regolare di nuovo quando l'app rallenta. | Ogni controllo attende da solo, e prosegue nel momento in cui l'elemento è presente. |
| Controllare il risultato | Asserzioni scritte in codice, una per valore. | Controlli creati dalla registrazione, modificati su una timeline. |
| Leggere un fallimento | Uno stack trace e un numero di riga. | Un report con l'atteso accanto all'effettivo, e il video dell'esecuzione. |
| Chi può farlo | Un programmatore che conosce la libreria. | Chiunque conosca il flusso. |
Creare un test dovrebbe richiedere la conoscenza del flusso, non quella di un linguaggio di programmazione.
Test di app desktop Windows senza codice: registrare, verificare, eseguire
GUI Test Studio automatizza i test end-to-end di qualsiasi applicazione senza codice. Sono due app. GUI Test Runner-Recorder registra un test e lo esegue. GUI Test Studio lo modifica su una timeline, come un video.
Registrare
Fare il flusso una volta
Verificare
Scegliere che cosa si controlla
Eseguire
A ogni build
Leggere
Che cosa è passato, che cosa è cambiato
Una registrazione vi dà un test completo.
- Ogni clic e ogni tasto, riprodotti nello stesso ordine a ogni esecuzione.
- Un controllo di ogni elemento su cui avete fatto clic, eseguito prima del clic.
- Controlli di ciò che è apparso sullo schermo, come una finestra di dialogo o un messaggio.
- Un file di proprietà del vostro team, con i suoi passaggi, le sue immagini e la sua registrazione.
Quali applicazioni desktop Windows si possono testare così?
Qualsiasi programma mostrato su uno schermo Windows, con qualunque tecnologia sia stato costruito. All'app non si aggiunge nulla: nessuna build di test, nessuna libreria e nessun id.
App WPF e WinForms
I componenti standard si descrivono da soli, un grafico o una griglia personalizzata no.
Qt e altri toolkit
Si usa ciò che l'app descrive, e il resto si trova sullo schermo.
App Windows più vecchie
Molte dicono poco delle proprie schermate, e si testano lo stesso.
App Electron
La pagina all'interno e la finestra intorno, in un solo test.
App che disegnano da sé i propri componenti
Un canvas, una timeline, una mappa, un'area di disegno.
Un'app in una finestra di desktop remoto
Al vostro schermo arriva solo un'immagine, e un'immagine basta.
Tre articoli vanno più a fondo: automazione dei test WPF e WinForms, app Windows senza albero di accessibilità e test di app Electron.La guida a cosa potete testare copre tutto il resto, dalle app web a un telefono Android.
Finestre di selezione file, più finestre, più monitor
Un flusso reale raramente resta in una sola finestra. Apre una finestra di selezione file, una finestra delle impostazioni o una finestra di messaggio, a volte su un altro monitor.
Finestra principale
Fare clic su Importa
Finestra di selezione file
Scegliere il file
Finestra di anteprima
Controllare le prime righe
Secondo monitor
Leggere il risultato
Una registrazione, un test
Su un computer con più monitor, il registratore chiede quale schermo usa il test: un solo monitor, oppure tutti per un'app che apre le sue finestre ovunque.
Come fa un test a trovare un pulsante senza uno script?
Il GTS Engine + AI, il motore all'interno di GUI Test Studio, ha due modi per trovare ogni elemento. Prima interroga l'app, tramite le sue informazioni di accessibilità, la stessa descrizione che usa uno screen reader. Quando l'app non dice nulla, trova l'elemento a vista, come fareste voi.
| La vostra app | Come viene trovato ogni elemento |
|---|---|
| Descrive i suoi componenti | Tramite ciò che dice l'app, con l'immagine dell'elemento come seconda via. |
| Ne descrive alcuni | Ogni elemento nel modo che funziona per lui, nello stesso test. |
| Non descrive nulla | A vista, sullo schermo. |
Due vie verso un elemento rendono un test robusto: un id rinominato non lo rompe, e nemmeno un componente che l'app non ha mai descritto.Non scegliete nulla e non ispezionate nulla, perché la registrazione conserva da sola ciò che le serve.Come GUI Test Studio trova gli elementi spiega entrambe le vie.
Come automatizzare un test di un'app desktop Windows senza codice
Un primo test richiede pochi minuti. Scegliete un flusso breve che conoscete bene: aprire un record, cambiare un valore, salvare, leggere la conferma.
- 1
Portare l'app sulla sua schermata iniziale
Aprite la vostra app sulla schermata in cui inizia il flusso, nello stato da cui ogni esecuzione deve partire.
- 2
Fare clic su Registra e scegliere Un'app
In GUI Test Runner-Recorder, fate clic su Registra, scegliete Un'app e selezionate il vostro programma.Spuntate la casella che avvia l'app con il test e la chiude alla fine.
Un'app limita i controlli automatici alle finestre, alle finestre di dialogo e ai menu del vostro programma. - 3
Fare il flusso una volta
Fate clic, digitate e scorrete come farebbe un utente, a un ritmo normale. Premete il tasto Termina quando il flusso è finito.
- 4
Scegliere che cosa verifica il test
Rispondete alla domanda Cosa deve verificare questo test? Per un primo test lasciate le tre schede come sono, poi salvate il test.
Tre schede decidono quali controlli il test riceve da solo. - 5
Eseguirlo e leggere il report
Riportate l'app sulla sua schermata iniziale e fate clic su Esegui test.Il report di affidabilità si apre con ciò che è passato e ciò che è cambiato.
- 6
Eseguirlo a ogni build
Aggiungete un comando gtr-cli alla vostra pipeline. Un test fallito fa allora fallire la build, con il video e le immagini dell'esecuzione come artefatti.
Il vostro primo test, passo dopo passo vi accompagna in ogni schermata, e Registrare un test spiega ogni scelta del registratore.
Modificare un test in seguito, senza un programmatore
Un test registrato non è una scatola nera. In GUI Test Studio si apre su una timeline: la registrazione in alto, sotto i clic e i tasti, e sotto ancora i controlli. Spostate, aggiungete o rimuovete un blocco come montereste un video.
| Volete | Che cosa fate |
|---|---|
| Controllare una cosa in più | Trascinate un controllo dalla tavolozza Asserzioni sulla timeline, e mostrategli sulla registrazione che cosa cercare. |
| Dare più tempo a una schermata lenta | Aumentate il tempo massimo del controllo nelle sue Proprietà. |
| Digitare un altro valore | Modificate il testo del passaggio Testo digitato. |
| Seguire una modifica voluta dell'app | Accettate il nuovo aspetto nel report di affidabilità, con un clic. |
Quale controllo risponde a quale esigenza è spiegato in Scegliere il controllo giusto.Che cosa vi dice un'esecuzione fallita è in come leggere un report di test.
Eseguire i test desktop a ogni build
Un test si ripaga quando viene eseguito senza che nessuno lo avvii. gtr-cli, il runner da riga di comando, esegue lo stesso test in qualsiasi strumento di CI/CD. Un test fallito fa fallire la build, e i risultati arrivano in formato JUnit, JSON o Markdown.
gtr-cli run tests --countdown 0 --junit results\junit.xml --artifacts results\artifactsEseguire i test nella pipeline elenca ogni opzione.
Preferite descrivere il test? Usate l'IA che scegliete voi
Registrare è uno dei tre modi di creare un test.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.L'assistente registra il test, aggiunge i controlli e lo esegue.
Quale IA usare, se usarne una, resta una scelta del vostro team.
- Un'IA nel cloud, con la vostra chiave.
- Un modello di IA locale, nostro o vostro.
- Nessuna IA: registrare ed eseguire un test non ne richiede.
In ogni caso i test, le registrazioni e i report sono file sui vostri computer.Sovranità dell'IA nel test del software spiega perché conta.
Cosa sapere prima di iniziare
| Limite | Cosa significa |
|---|---|
| Un'esecuzione usa lo schermo reale | Un test desktop riproduce clic e tasti reali, quindi il computer è occupato durante un'esecuzione, e un agente di build ha bisogno di una sessione desktop sbloccata. |
| Lo stesso punto di partenza | Un test si riproduce da dove è iniziata la registrazione. Riportate l'app su quella schermata prima di ogni esecuzione, oppure lasciate che sia il test ad avviare l'app. |
| Un test controlla ciò che gli è stato detto di controllare | Un bug che sfugge a ogni controllo passa inosservato. Scegliete i controlli con cura, e aggiungetene uno quando un bug vi sfugge. |
| Un altro tema o un'altra scala dello schermo | Lì una schermata corretta appare diversa.Date al test una versione per quel caso, non una copia: vedete un solo test per la modalità scura e ogni lingua. |
Punti chiave
- 1Una libreria di codice trasforma il test desktop in programmazione: script, id degli elementi, attese, e riparazioni a ogni cambiamento della schermata.
- 2GUI Test Studio non richiede codice: registrate il flusso una volta, scegliete che cosa verifica il test, eseguitelo a ogni build.
- 3Testa qualsiasi app desktop Windows, da WPF e WinForms a Qt, Electron, alle app più vecchie e ai componenti che un'app disegna da sé.
- 4Ogni elemento ha due modi per essere trovato: ciò che l'app dice di esso, e a vista quando l'app non dice nulla.
- 5Il test resta vostro da modificare: un file di proprietà del vostro team, modificato su una timeline da chiunque conosca il flusso.
Domande
Posso testare un'app desktop Windows senza scrivere codice?
Sì. Registrate il flusso una volta in GUI Test Runner-Recorder, scegliete che cosa verifica il test ed eseguitelo. La registrazione diventa un test con i suoi clic, i suoi tasti e i suoi controlli, e nessuno scrive uno script.
Qual è il modo più semplice per automatizzare un'applicazione Windows?
Fare il flusso una volta mentre un registratore osserva. In GUI Test Studio, ogni clic e ogni tasto viene conservato, ogni elemento su cui avete fatto clic riceve un controllo, e il test si riproduce da solo a ogni build.
Devo ispezionare l'albero degli elementi dell'app o conoscere gli id dei suoi componenti?
No. La registrazione conserva da sola ciò che l'app dice di ogni elemento, e una sua immagine. Non aprite mai uno strumento di ispezione e non digitate mai un id.
Funziona con WPF, WinForms, Qt e le app Windows più vecchie?
Sì. Qualsiasi programma mostrato su uno schermo Windows può essere testato, con qualunque tecnologia sia stato costruito. All'app non si aggiunge nulla: nessuna build di test, nessuna libreria e nessun id.
E se la mia app disegna da sé i propri componenti e non dice nulla a uno strumento di test?
Il test trova quei componenti a vista, sullo schermo, come fa una persona. Un grafico, un canvas o una griglia personalizzata si testano nella stessa registrazione dei pulsanti standard che li circondano.
Un test desktop creato senza codice può girare in CI/CD?
Sì. gtr-cli esegue lo stesso test da una riga di comando in qualsiasi strumento di CI/CD. Un test fallito fa fallire la build, e il video, le immagini e i risultati dell'esecuzione vengono conservati come artefatti.
Mi serve l'IA per creare o eseguire i test?
No. Registrare ed eseguire un test non richiede alcuna IA. L'IA è una scelta: un'IA nel cloud con la vostra chiave, un modello di IA locale, fornito da noi o vostro, oppure nessuna.
Quali sono i limiti del test di un'app desktop senza codice?
Un test desktop usa lo schermo reale mentre è in esecuzione. Inoltre un test controlla solo ciò che gli è stato detto di controllare, quindi vale la pena scegliere i controlli con cura.
pywinauto, FlaUI, WinAppDriver, WPF, Windows Forms, Qt, Electron e Windows sono nomi o marchi dei rispettivi proprietari.
Continua a leggere
Tutti gli articoli
App desktop
Automazione dei test WPF e test dell'interfaccia WinForms senza codice (e senza albero di accessibilità)
10 min di lettura

App desktop
Test end-to-end delle app Electron: oltre il supporto di Playwright per Electron
10 min di lettura

App desktop
WinAppDriver: alternative per le app senza albero di accessibilità
11 min di lettura