2009-03-23 13 views
5

Basta googling 'TDD' e 'GWT' facilmente portare a this article dove l'autore ha spiegato come può testare un'applicazione GWT senza un contenitore. Tuttavia, penso che il suo esempio non sia guidato dal test, visto che ha prima tutto il progetto e poi scriverà il test in seguito, non "test-first".Come si esegue il test dello sviluppo GWT?

Questo mi porta a pensare: è possibile avere uno sviluppo "test-first" su un'interfaccia utente come GWT? Alcune persone hanno detto che il codice UI non è adatto per TDD. Ma penso che adottando il pattern MVC, forse potremo almeno testare la parte MC? (quindi V è la parte dell'interfaccia utente che non può essere sviluppata tramite test).

Quale sarà il primo test negativo che avremmo scritto nell'esempio di articolo?

risposta

14

Testare l'interfaccia utente è problematico perché spesso non si sa quello che si desidera sullo schermo finché non lo si vede sullo schermo. Per questo motivo, lo sviluppo della GUI tende ad essere massicciamente iterativo e quindi molto difficile da guidare con i test.

Ciò non significa che abbandoniamo semplicemente TDD per le GUI. Piuttosto, spingiamo più codice possibile dalla GUI, lasciandoci dietro solo un semplice codice di cablaggio. Questo cablaggio ci consente di apportare i cambiamenti massicciamente iterativi di cui abbiamo bisogno, senza compromettere l'essenza del problema.

Questa tecnica è stata probabilmente descritta meglio da Michael Feathers alcuni anni fa in un articolo intitolato "The Humble Dialog Box". È anche l'idea fondamentale alla base dello schema Model-View-Presenter che ha suscitato tanto scalpore quattro anni fa; e ora è stato suddiviso in schemi di visualizzazione passiva e controller di supervisione. Il collegamento dell'articolo in questa domanda sfrutta queste idee, ma in un test-dopo piuttosto che in un modo guidato dai test.

L'idea è di testare tutto tranne la vista. In effetti, non abbiamo nemmeno bisogno di scrivere la vista per un bel po 'di tempo. In effetti, la View è così assurdamente semplice che probabilmente non ha bisogno di alcun tipo di test unitario. O se lo fa, in realtà possono essere scritti per ultimi.

Per testare il controller di supervisione è sufficiente assicurarsi di aver compreso come i dati verranno presentati sullo schermo. Non è necessario sapere dove sono i dati, o qual è il carattere, o di che colore è, o uno qualsiasi degli altri problemi estetici che causano l'enorme iterazione di interfacce grafiche. Piuttosto, sai che un dato sarà una sorta di campo di testo. Un altro sarà un menu, un altro ancora sarà un pulsante o una casella di controllo. E poi ti assicuri che la Vista possa porre tutte le domande di cui ha bisogno per ottenere il corretto rendering di questi oggetti.

Ad esempio, la casella di testo potrebbe avere un valore predefinito. La vista dovrebbe essere in grado di chiederlo. Il menu potrebbe contenere alcuni elementi in grigio. La vista dovrebbe essere in grado di chiedere queste informazioni. Le domande che la vista richiede riguardano la presentazione e sono prive di regole aziendali.

Allo stesso modo, la vista dirà al supervisore di supervisione quando qualcosa cambia. Il controllore modificherà i dati in modo appropriato, includendo qualsiasi tipo di convalida e ripristino degli errori, e quindi la vista può chiedere come devono essere presentati tali dati.

Tutto questo può essere guidato da test perché è tutto disaccoppiato dal display. Si tratta di come i dati vengono manipolati e presentati, e non su ciò che sembra. Quindi non ha bisogno di essere massicciamente iterato.

3

Ho guidato con successo lo sviluppo di applicazioni Swing e GWT attraverso la GUI.

Il test "dietro la GUI" ignora l'integrazione tra il codice del modello e i componenti della GUI. L'applicazione deve collegare i gestori di eventi per visualizzare i dati nella GUI quando il modello cambia e riceve input dalla GUI e aggiorna il modello. Testare che tutti i gestori di eventi siano stati collegati correttamente è molto noioso se fatto manualmente.

Il grande problema da superare durante il test attraverso la GUI è come far fronte alle modifiche alla GUI durante lo sviluppo.

GWT dispone di agganci per aiutare con questo. È necessario impostare gli ID di debug nei widget GWT e importare il modulo DebugID nell'applicazione. I test possono quindi interagire con l'applicazione controllando un browser Web, individuando gli elementi con il loro id e facendo clic su di essi o inserendo del testo in essi. Web Driver è un'ottima API per farlo.

Questo è solo l'inizio, tuttavia. È inoltre necessario disaccoppiare i test dalla struttura della GUI: in che modo l'utente naviga attraverso l'interfaccia utente per svolgere il lavoro. Questo è il caso se testate attraverso la GUI o dietro la GUI contro il controller. Se si esegue il test contro il controller, il controller determina il modo in cui l'utente naviga attraverso le diverse visualizzazioni dell'applicazione e quindi il test è accoppiato a quella struttura di navigazione perché è accoppiato al controller.

Per risolvere questo problema, i nostri test controllano l'applicazione attraverso una gerarchia di "driver". I test interagiscono con i conducenti che consentono di svolgere attività incentrate sull'utente, come l'accesso, l'immissione di un ordine e l'esecuzione di un pagamento. Il driver acquisisce la conoscenza di come tali attività vengono eseguite navigando e immettendo i dati nella GUI. Lo fa utilizzando driver di livello inferiore che catturano il modo in cui la navigazione e l'immissione dei dati vengono eseguite da "gesti", come il clic su un pulsante o l'immissione di testo in un campo di input. Si finisce con una gerarchia come:

  • obiettivi dell'utente: i test verificano che l'utente può raggiungere i loro obiettivi con il sistema e dimostra come questi obiettivi sono raggiunti da una sequenza di ...
  • utente Attività: cose che l'utente fa attraverso la GUI, rappresentate come driver che eseguono ...
  • Gesti: mouse e tastiera di basso livello per controllare la GUI.

Questa gerarchia viene spesso utilizzata nella letteratura di progettazione centrata sull'utente (sebbene con terminologia diversa).

Problemi correlati