- Sto parlando di test unitari nel senso TDD. ("Integrazione" non automatizzata, o quello che ti piace chiamarlo test.)
- Codice legacy come in: codice (C ++) senza test. (vedi: Michael Feathers ' Funzionante in modo efficace con il codice legacy )
- Ma anche codice legacy come in: Codice con cui il nostro team ha lavorato per gli ultimi 10-5 anni, quindi molto spesso abbiamo una buona idea di dove mettere le cose per cambiare qualcosa.
- Facciamo test di unità in atto (tramite Boost.Test) per alcuni moduli che sono venuti dopo o sono stati adattati "naturali" ai test di unità (contenitori specifici per app comuni, string-stuff, helper di rete, ecc.)
- Non abbiamo ancora test di accettazione automatici adeguati.
Ora, di recente ho avuto il "piacere" di implementare 3 nuove funzionalità per gli utenti.
Ognuno di quelli mi ha impiegato circa 1-2 ore per arrivare al massimo con le parti del codice che dovevo cambiare, 1-2 ore per implementare il (piccolo) codice che dovevo cambiare e altre 1-2 ore per fare certo che l'app ha funzionato correttamente in seguito e ha fatto è stato dovrebbe farlo.
Ora, ho davvero aggiunto un piccolo codice. (Penso che un metodo e alcune linee di chiamata per ogni funzione.)
Factoring out this code (tramite uno qualsiasi dei metodi suggeriti in WEwLC ), in modo che un test unitario avesse senso (e non fosse una completa tautologia) avrebbe facilmente preso altre 2-4 ore, se non di più. Questo avrebbe aggiunto il 50% -100% del tempo a ciascuna funzione, senza alcun beneficio immediato, come
- Non avevo bisogno del test dell'unità per capire qualcosa sul codice
- Il test manuale ha la stessa quantità di lavoro, poiché ho ancora bisogno di testare se il codice è correttamente integrato nel resto dell'app.
Certo, se , più tardi, "qualcuno" è arrivato e ha toccato quel codice, lui teoricamente potrebbe trarre qualche beneficio da quel test unitario. (Solo in teoria, poiché quell'isola di codice collaudata vivrebbe in un oceano di codice non testato.)
Quindi, "questa volta" ho scelto di non fare il duro lavoro di aggiungere un test unitario: Il codice cambia per ottenere quella roba da testare sarebbe stato molto più complesso delle modifiche al codice per ottenere correttamente la funzione (e pulito) implementato.
Questo è tipico del codice legacy strongmente accoppiato? Sono pigro / impostiamo le priorità sbagliate come una squadra? O sono prudente, sto solo testando cose in cui il sovraccarico non è troppo alto?