ho familiarità con i principi fondamentali del TDD, essendo:Qual è l'approccio migliore per il test delle unità quando si hanno interfacce con implementazioni sia fittizie che reali?
- test di scrittura, queste verranno a mancare a causa di alcuna implementazione
- Scrivi implementazione di base per effettuare test passano
- codice Refactor
Tuttavia, sono un po 'confuso su dove si integrano interfacce e implementazione. Sto creando un'applicazione web Spring nel mio tempo libero, e piuttosto che andare in armi da fuoco, mi piacerebbe capire come posso testare le interfacce/implementazioni un po 'meglio, prendere questo semplice codice di esempio che ho creato qui:
public class RunMe
{
public static void main(String[] args)
{
// Using a dummy service now, but would have a real implementation later (fetch from DB etc.)
UserService userService = new DummyUserService();
System.out.println(userService.getUserById(1));
}
}
interface UserService
{
public String getUserById(Integer id);
}
class DummyUserService implements UserService
{
@Override
public String getUserById(Integer id)
{
return "James";
}
}
ho creato l'interfaccia UserService, in ultima analisi, ci sarà una vera e propria attuazione del presente che interrogare un database, ma al fine di ottenere l'applicazione decollare ho sostituito un'implementazione DummyUserService che sarà solo ritorno alcuni dati statici per ora.
Domanda: Come posso implementare una strategia di test per quanto sopra?
ho potuto creare una classe di test chiamato DummyUserServiceTest e la prova che quando chiamo getUserById() che tornerà James, sembra abbastanza semplice, se non una perdita di tempo (?).
Successivamente, è stato anche possibile creare una classe di prova RealUserService per verificare che getUserById() restituisca un nome utente dal database. Questa è la parte che mi confonde leggermente, nel fare ciò, questo non supera in modo sostanziale il limite di un test unitario e diventa più un test di intergrazione (con il colpo sul DB)?
Domanda (migliorata, un po '): quando si utilizzano interfacce con fittizio/stubato e implementazioni reali, quali parti devono essere testate dall'unità e quali parti possono essere tranquillamente lasciate non testate?
ho trascorso un paio d'ore Googling su questo argomento la scorsa notte, e per lo più trovato sia esercitazioni su ciò che TDD è, o esempi di come utilizzare JUnit, ma niente nei regni di consulenza ciò che dovrebbe in realtà essere testato. È del tutto possibile però, che non ho cercato abbastanza o non stavo cercando la cosa giusta ...