I passaggi da intraprendere per integrare lentamente i test unitari in un progetto

https://stackoverflow.com/questions/1017917

06-07-2019
|

Domanda

Attualmente sto lavorando a un progetto cooperativo su un progetto in fase di completamento con un altro studente cooperativo. Da quando questo progetto è stato tramandato da cooperativa a cooperativa, lungo il percorso sono state adottate cattive pratiche e i test sono stati lasciati fino alla fine. Ho deciso di scrivere unit-test per imparare qualcosa di nuovo durante i test.

Tuttavia, sto lavorando a un'app a 3 livelli, strettamente accoppiata, che sembra impossibile testare l'unità nella sua forma attuale. Non voglio respingere l'altro studente cooperativo senza alcuna conoscenza di nessuno di questi concetti rifattorizzando il codice oltre il riconoscimento durante la notte. Quindi quali passi devo prendere per tirare lentamente il codice verso l'unità-testabilità? Dovrei prima implementare un modello di fabbrica e lasciare che l'altro studente lo familiarizzi con quello prima di andare avanti?

Mi scuso se la mia conoscenza è difettosa e non dovrebbe esserci alcun problema. Sono nuovo a questo :)

Soluzione

Lavorare efficacemente con il codice legacy di Michael Feathers

Difficile sapere se implementare un modello di fabbrica farà qualcosa di buono, dipende da cosa sta facendo il codice :)

Altri suggerimenti

Lavorare in modo efficace con il codice legacy di Michael Feathers (disponibile anche in Safari se hai un abbonamento) è un'ottima risorsa per il tuo compito. L'autore definisce il codice legacy come codice senza unit test, e fornisce procedure pratiche di lotti di tecniche conservative & necessarie # 8212; perché stai lavorando senza una rete di sicurezza & # 8212; per portare il codice sotto test. Indice:

Parte: I The Mechanics of Change
- Capitolo 1. Modifica del software
  - Quattro motivi per cambiare software
  - Cambiamento rischioso
- Capitolo 2. Lavorare con il feedback
  - Che cos'è il test unitario?
  - Test di livello superiore
  - Test Coverings
  - L'algoritmo di modifica del codice legacy
- Capitolo 3. Rilevamento e separazione
  - Faking Collaborators
- Capitolo 4. Il modello Seam
  - Un enorme foglio di testo
  - Le cuciture
  - Tipi di cucitura
- Capitolo 5. Strumenti
  - Strumenti di refactoring automatizzati
  - Oggetti finti
  - Cablaggi unit-test
  - Cablaggi di prova generali
Parte: II Cambio software
- Capitolo 6. Non ho molto tempo e devo cambiarlo
  - Metodo Sprout
  - Classe di germogli
  - Metodo di avvolgimento
  - Classe di avvolgimento
  - Sommario
- Capitolo 7. Ci vuole sempre una modifica
  - Understanding
  - Lag Time
  - Ultime dipendenze
  - Sommario
- Capitolo 8. Come posso aggiungere una funzione?
  - Sviluppo test-driven (TDD)
  - Programmazione per differenza
  - Sommario
- Capitolo 9. Non riesco a mettere questa classe in un cablaggio di prova
  - Il caso del parametro irritante
  - Il caso della dipendenza nascosta
  - Il caso del BLOB di costruzione
  - Il caso della dipendenza globale irritante
  - Il caso delle dipendenze orribili include
  - Il caso del parametro Onion
  - Il caso del parametro con alias
- Capitolo 10. Non riesco a eseguire questo metodo in un cablaggio di prova
  - Il caso del metodo nascosto
  - Il caso di " Utile " Funzione lingua
  - Il caso dell'effetto collaterale non rilevabile
- Capitolo 11. Devo apportare una modifica. Quali metodi devo testare?
  - Ragionamento sugli effetti
  - Reasoning Forward
  - Propagazione dell'effetto
  - Strumenti per il ragionamento degli effetti
  - Imparare dall'analisi degli effetti
  - Semplificazione degli schizzi ad effetto
- Capitolo 12. Devo apportare molte modifiche in un'unica area. Devo interrompere le dipendenze per tutte le classi coinvolte?
  - Punti di intercettazione
  - Giudicare il design con i punti di presa
  - Trappole a pizzico
- Capitolo 13. Devo apportare una modifica, ma non so quali test scrivere Test di caratterizzazione
  - Classi caratterizzanti
  - Test mirati
  - Un euristico per scrivere test di caratterizzazione
- Capitolo 14. Dipendenze dalle biblioteche mi stanno uccidendo
- Capitolo 15. La mia applicazione è tutte le chiamate API
- Capitolo 16. Non capisco bene il codice abbastanza per cambiarlo
  - Note / schizzo
  - Marcatura elenco
  - Refactoring per i graffi
  - Elimina codice non utilizzato
- Capitolo 17. La mia applicazione non ha struttura
  - Raccontare la storia del sistema
  - CRC nudo
  - Controllo della conversazione
- Capitolo 18. Il mio codice di prova è in mezzo
  - Convenzioni di denominazione delle classi
  - Posizione test
- Capitolo 19. Il mio progetto non è orientato agli oggetti. Come posso apportare modifiche sicure?
  - Un caso facile
  - Un caso difficile
  - Aggiunta di nuovi comportamenti
  - Sfruttare l'orientamento agli oggetti
  - È tutto orientato agli oggetti
- Capitolo 20. Questa classe è troppo grande e non voglio che sia più grande
  - Vedere le responsabilità
  - Altre tecniche
  - Andare avanti
  - Dopo la classe di estrazione
- Capitolo 21. Sto cambiando lo stesso codice ovunque
  - Primi passi
- Capitolo 22. Devo cambiare un metodo Monster e non riesco a scrivere test per questo
  - Varietà di mostri
  - Lotta ai mostri con supporto al refactoring automatizzato
  - La sfida del refactoring manuale
  - Strategia
- Capitolo 23. Come faccio a sapere che non sto rompendo nulla?
  - Modifica di Hyperaware
  - Modifica a singolo obiettivo
  - Conserva firme
  - Appoggiati al compilatore
- Capitolo 24. Ci sentiamo sopraffatti. Non migliorerà
Parte: III Tecniche di rottura delle dipendenze
- Capitolo 25. Tecniche di rottura delle dipendenze
  - Adatta parametro
  - Oggetto metodo breakout
  - Completamento delle definizioni
  - Incapsula riferimenti globali
  - Esporre metodo statico
  - Estrai e sostituisci chiamata
  - Estrai e sostituisci metodo di fabbrica
  - Estrai e sostituisci Getter
  - Estrai Implementer
  - Estrai interfaccia
  - Introduzione al delegatore di istanza
  - Introduzione al settatore statico
  - Sostituzione link
  - Parametrizza costruttore
  - Parametrizza metodo
  - Primitivize Parameter
  - Funzione pull up
  - Push Down Dependency
  - Sostituisci funzione con puntatore a funzione
  - Sostituisci riferimento globale con Getter
  - Metodo di sottoclasse e override
  - Sostituisci variabile di istanza
  - Ridefinizione modello
  - Ridefinizione testo
Appendice: refactoring
- Metodo di estrazione

È molto difficile avviare nuove pratiche di sviluppo a metà del progetto. In passato, quando ho lavorato su progetti che non sono stati testati dall'inizio, un buon approccio da adottare è stabilire la regola secondo cui "il nuovo codice deve avere test unitari" ma non esercitare pressioni sui test unitari in fase di scrittura per il vecchio codice.

Naturalmente, anche questo è difficile quando la struttura del progetto non è adatta alla testabilità.

La mia migliore raccomandazione sarebbe prenderla in piccoli passi.

Inizia creando il tuo assemblaggio unit test (o progetto o altro) senza test al suo interno. Quindi trova una singola piccola area di codice che è abbastanza ben definita e separata e scrivi alcuni test unitari per quell'area. Chiedi anche al tuo codecer di dare un'occhiata e inizia a mettere in pratica alcune "best practice", come eseguire i test unitari ogni volta che viene eseguito il check in di qualsiasi codice (automaticamente se possibile).

Una volta che hai funzionato, puoi lentamente iniziare ad aggiungere altro.

La chiave è lentamente. E come ho detto, è più facile esentare il vecchio codice dai test per cominciare. Puoi sempre tornare su di esso in seguito una volta che il tuo team ha compreso l'idea dei test unitari ed è diventato più bravo a scriverli.

Che ne dici di scrivere una serie di test in black box attorno a importanti funzionalità nel tuo codice? Dato che dici che è un progetto ASP.NET, puoi utilizzare un framework come WaitN o Selenium per automatizzare un browser web. Questo ti dà un set di funzionalità di base che dovrebbe rimanere costante indipendentemente da quanto cambia il codice.

Dopo aver fatto un buon numero di test per testare la funzionalità di alto livello del tuo progetto, inizierei a immergermi nel codice e, come menziona Simon P. Stevens, lavoro lentamente . Prendi una copia (gratuita!) Di Refactor! per Visual Basic , così sarai in grado di eseguire automaticamente alcuni refactoring di base, come il metodo Extract. Puoi aumentare drasticamente la testabilità senza modificare alcuna funzionalità semplicemente suddividendo blocchi di codice più grandi in blocchi più piccoli e più testabili.

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow