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.

Di Ait Nohaila, Business Development Representative 10 min di lettura

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

  1. 1Avviare l'app e trovare la sua finestra
  2. 2Trovare il pulsante Salva tramite il suo id
  3. 3Attendere che il pulsante sia pronto
  4. 4Farci clic
  5. 5Trovare il messaggio e leggerne il testo
  6. 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

Il clic su SalvaUn controllo del pulsante SalvaUn controllo del messaggio

Niente da scrivere: la registrazione diventa il test.

Una libreria di codice vi chiede di descrivere ogni elemento e ogni attesa. Una registrazione li conserva per voi.

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 testIn una libreria di codiceIn GUI Test Studio
Avviare l'appCodice 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 campoUn 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 descriveFuori portata, oppure un espediente scritto a mano.Trovato a vista, come qualsiasi altro elemento.
Attendere l'appUn'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 risultatoAsserzioni scritte in codice, una per valore.Controlli creati dalla registrazione, modificati su una timeline.
Leggere un fallimentoUno stack trace e un numero di riga.Un report con l'atteso accanto all'effettivo, e il video dell'esecuzione.
Chi può farloUn 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.

  1. Registrare

    Fare il flusso una volta

  2. Verificare

    Scegliere che cosa si controlla

  3. Eseguire

    A ogni build

  4. 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.

Lo dice l'appA vista

Qt e altri toolkit

Si usa ciò che l'app descrive, e il resto si trova sullo schermo.

Lo dice l'appA vista

App Windows più vecchie

Molte dicono poco delle proprie schermate, e si testano lo stesso.

A vista

App Electron

La pagina all'interno e la finestra intorno, in un solo test.

Lo dice l'appA vista

App che disegnano da sé i propri componenti

Un canvas, una timeline, una mappa, un'area di disegno.

A vista

Un'app in una finestra di desktop remoto

Al vostro schermo arriva solo un'immagine, e un'immagine basta.

A vista
Ogni elemento viene trovato tramite ciò che l'app dice di esso, oppure a vista sullo schermo. Un test usa entrambi i modi, elemento per elemento.

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.

1

Finestra principale

Fare clic su Importa

2

Finestra di selezione file

Scegliere il file

3

Finestra di anteprima

Controllare le prime righe

4

Secondo monitor

Leggere il risultato

Una registrazione, un test

La registrazione segue il flusso ovunque vada, perché registra lo schermo e non una sola finestra.

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 appCome viene trovato ogni elemento
Descrive i suoi componentiTramite ciò che dice l'app, con l'immagine dell'elemento come seconda via.
Ne descrive alcuniOgni elemento nel modo che funziona per lui, nello stesso test.
Non descrive nullaA 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. 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. 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. 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. 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. 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. 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.

Un test sulla sua timeline: ogni clic, ogni tasto e ogni controllo è un blocco che potete selezionare e modificare.
VoleteChe 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 lentaAumentate il tempo massimo del controllo nelle sue Proprietà.
Digitare un altro valoreModificate il testo del passaggio Testo digitato.
Seguire una modifica voluta dell'appAccettate 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.

Tutti i test di una cartella, a ogni build
gtr-cli run tests --countdown 0 --junit results\junit.xml --artifacts results\artifacts

Eseguire 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

LimiteCosa significa
Un'esecuzione usa lo schermo realeUn 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 partenzaUn 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 controllareUn 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 schermoLì 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.

Tutti gli articoli