Scrivere giunchi in Test Driven Development prima di scrivere il codice reale?

Question

La gente è sempre detto in TDD che

dovremmo scrivere junits anche prima di scrivere il codice vero e proprio.

In qualche modo non sono in grado di capirlo nello spirito giusto. Spero che ciò significhi solo scrivere metodi vuoti con le firme giuste e il tuo caso di test dovrebbe inizialmente fallire

Dire nell'approccio TDD ho bisogno di ottenere l'elenco dei clienti.

Come per la mia comprensione scriverò il metodo vuoto come qui di seguito

public List<CustomerData> getCustomers(int custId){ 

return null; 
} 

Ora scriverò caso di test JUnit in cui controllerò la dimensione come 10 (che sto eactually aspettavo). È giusto?

Fondamentalmente la mia domanda è in TDD, Come possiamo scrivere il caso di test di junit prima di scrivere il codice vero?

Answer 1

spero che cosa significa è che basta scrivere metodi vuote wih firme giusti

Sì. E con i più moderni IDE, se scrivi un nome di metodo che non esiste nel tuo test, creerà uno stub per te.

Dire nell'approccio TDD ho bisogno di ottenere l'elenco dei clienti. qual è il modo giusto di procedere?

Il tuo esempio non è proprio lì. Volete testare una matrice di lunghezza 0, ma la restituite già: dovreste prima restituire null, il test ovviamente fallirà.

Quindi modificare il metodo in modo che il test abbia esito positivo.

Quindi creare un metodo di prova per l'aggiunta del cliente. Il test fallisce. Aggiustalo. Risciacquare. Ripetere.

Quindi, in pratica: con TDD, si avvia e scrive il test che si KNOW fallirà, quindi si corregge il codice in modo che funzioni.

Recommended read.

Answer 2

In parte è giusto.

Utilizzando un IDE (Eclipse, IntelliJ) è possibile creare un test. In quel test, invoca un metodo (che non esiste) e utilizza uno strumento di refactoring per creare un metodo con la firma appropriata.

Questo è un trucco che rende più semplice e divertente il lavoro con TDD.

Secondo Now i will write junit test case where i will check the size as 0. Is this Right? è necessario scrivere un test che fails e fornire un'implementazione corretta.

Answer 3

Spesso scriverai il test accanto allo scheletro del codice. Inizialmente è possibile scrivere un'implementazione non funzionale (ad esempio, lanciare un UnsupportedOperationException) e ciò provocherà un errore di test. Quindi dovrai implementare l'implementazione fino alla fine del test.

È necessario essere pragmatici al riguardo. Ovviamente non è possibile compilare il test almeno fino a quando la tua unità non è in fase di compilazione di test, e quindi devi eseguire una quantità minima di lavoro di implementazione insieme al test.

Partenza this recent Dr Dobbs editoral, che discute esattamente questo punto e il ruolo del pragmatismo intorno a questo, soprattutto dai maghi di questa pratica (Kent Beck et al)

Un principio fondamentale del TDD è che si non scrivere alcun codice senza prima scrivere un test dell'unità in errore. Ma in effetti, se parli con i principali sostenitori di TDD (come Kent Beck, che ha reso popolare la tecnica, e Bob Martin, che ha insegnato a migliaia di sviluppatori), tu, , trovi che entrambi scrivono del codice prima senza scrivere test. Non lo fanno - dovrei enfatizzare questo - vedere questi momenti come decade di fede, ma piuttosto come il pragmatismo necessario dello sviluppatore intelligente .