Test delle unità e domande relative allo sviluppo guidato da test

7

Sto lavorando su un sito Web ASP.NET MVC che esegue calcoli relativamente complessi come una delle sue funzioni.

Questa funzionalità è stata sviluppata qualche tempo fa (prima che iniziassi a lavorare sul sito Web) e si sono verificati dei difetti in cui i calcoli non vengono calcolati correttamente (in pratica questi calcoli vengono applicati a ciascun utente che ha alcuni flag sul proprio record, ecc.).

Nota; questi difetti sono stati osservati solo dagli utenti fino ad ora e non sono stati ancora analizzati nel codice durante il debug.

Le mie domande sono:

  • Poiché i test di unità esistenti passano tutti e quindi non indicano che i difetti che sono stati segnalati esistono; questo suggerisce che il codice originale che è stato implementato non è corretto? o i requisiti erano errati e sono stati codificati di conseguenza o semplicemente non codificati in quanto avrebbero dovuto essere codificati?

  • Se utilizzo l'approccio TDD, ignorerei i test delle unità esistenti in quanto non mostrano alcun problema con la funzionalità dei calcoli - e comincio effettuando alcuni test dell'unità guasti che test / dimostrano che ci sono questi problemi si verificano e quindi aggiungere il codice per farli passare?

Nota; se si tratta semplicemente di un bug che si può verificare durante il debug del codice, i test delle unità devono essere aggiornati poiché stanno già passando?

    
posta Theomax 23.09.2012 - 11:25
fonte

4 risposte

5

Risposta breve: Molto probabilmente i test di unità non sono ben progettati per coprire gli scenari di calcolo critici. Inoltre, potrebbero esserci modifiche / modifiche delle regole aziendali che non sono contemplate nei test unitari esistenti, a causa di milioni di motivi che potrebbero essere affrontati in un ambiente di sviluppo strettamente pianificato.

Come è stato anche menzionato:

Automatic unit testing doesn't imply that the final tests will cover all cases and code will be absolutely correct and bug-free. It is easy not to see some complex use-cases and possible bug.

Potrebbero esserci milioni di motivi per cui NON è stato eseguito correttamente . Il mio punto è che devi coprire questi casi con product owner , quindi passare attraverso ogni unit test e verificare l'implementazione applicando la denominazione corretta di ogni unit test, e aggiungendo i missing una volta.

If I use the TDD approach, would I disgregard the existing unit tests as they don't show there are any problems with the calculations functionality - and I start by making some failing unit tests which test/prove there are these problems occuring, and then add code to make them pass?

TDD (sviluppo basato su test) sarà di sicuro di aiuto, ma io NON scarterebbe l'attuale serie di test unitari fino a quando fanno ciò che dovrebbero fare.

    
risposta data 23.09.2012 - 20:54
fonte
9

L'utilizzo del TDD e dei test automatici delle unità non implica che i test finali copriranno tutti i casi e il codice sarà assolutamente corretto e privo di errori. È facile non vedere alcuni casi d'uso complessi e possibili errori.

TDD d'altra parte rende più facile introdurre cambiamenti per quei casi non pensati prima. Basta ripetere TDD come se si stesse sviluppando:

  1. Scrivi un nuovo test case, che fallisce
  2. Codice di implementazione, che renderà il test riuscito
  3. Codice del refactore per rimuovere le duplicazioni e introdurre buone astrazioni mantenendo il passaggio di tutti i test
risposta data 23.09.2012 - 11:34
fonte
3

Questo è esattamente il motivo per cui si desidera prendere in considerazione lo sviluppo guidato dallo sviluppo del comportamento e lo sviluppo guidato dal test di accettazione - i test unitari non sono una garanzia sul fatto che il sistema stia facendo ciò che si suppone - controlla solo se fa ciò che era progettato da fare. Il rovescio della medaglia è che i proprietari di prodotti / analisti aziendali non possono rivedere questi test molto facilmente per verificare che siano corretti.

D'altra parte, se usi i test di accettazione, allora possono essere facilmente verificati dagli analisti di business o da altre persone non tecnologiche. Questo può essere abbastanza utile.

Nel tuo caso specifico, direi che il product owner dovrebbe decidere se questi sono bug o meno - se lo sono, allora ovviamente i test esistenti sono errati o per lo meno insufficienti - e dovrai scrivere nuovi (in mancanza) e forse anche cancellare alcuni di quelli vecchi (che si aspettano cose sbagliate) prima di scrivere il codice che supera i nuovi test.

    
risposta data 23.09.2012 - 14:51
fonte
1

Non credo che i test unitari necessariamente testino i requisiti: 1) i test unitari operano contro componenti di livello molto basso (metodi / classi / interfacce / eccetera) testati come unità stand-alone; 2) i requisiti devono essere testati mentre il tecnico di prova progetta i test di integrazione / sistema durante la fase di progettazione dei requisiti; 3) funzionalità, requisiti e specifiche sono testati (di nuovo) una volta che il sistema si trova in uno stato operativo; e 4) utilizzando un approccio di sviluppo software iterativo, vengono rivisitate molte fasi del ciclo di vita dello sviluppo per rafforzare i requisiti, la progettazione e lo sviluppo - i processi che si verificano nuovamente.

Perché il test dell'unità non è appropriato per i requisiti di test . I test unitari non necessariamente rivelano un problema di requisiti per una serie di motivi. Uno, se un requisito è stato scarsamente comunicato, è probabile che il requisito sia stato incorporato nella progettazione del software e nello sviluppo successivo; di conseguenza, se il test dell'unità segue l'esempio, seguendo correttamente un requisito errato, il test dell'unità non presenterà nulla. Due, se il requisito è stato adeguatamente documentato e il team di sviluppo ha erroneamente interpretato il requisito, in modo simile al punto 1, la mancata interpretazione verrà sottoposta al test dell'unità. Tre, per quanto riguarda la mia esperienza, il test unitario è svolto dallo sviluppatore e fa parte del ciclo di vita dello sviluppo: il test dell'unità è di basso livello e probabilmente non rappresenterà un requisito, a meno che ogni requisito completo non sia rappresentato dal suo stesso metodo, che è molto, molto improbabile.

Esempio . Considerare i test unitari in termini di metodi. Il test unitario verifica in gran parte che, date le pre-conduzioni, le post-condizioni rimangono valide dopo l'esecuzione del metodo sotto test. Lo scopo del testing unitario è testare / verificare i metodi, eccetera, di un sistema software, partendo dai metodi più atomici o primitivi, progredendo verso quelli più complessi. Testando ogni metodo di basso livello, si verifica se funziona, una cosa senza senso. A questo punto, lo sviluppatore non ha bisogno di ripetere il test del metodo di basso livello come unità indipendente. Mentre si spostano verso l'alto in complessità verso metodi di livello superiore, il test unitario verifica questi metodi, dimostrando che i metodi primitivi, da cui sono composti i livelli superiori, lavorano insieme. Per quanto ne so, questo è più o meno il punto in cui i test unitari si fermano.

Come vengono testati i requisiti . In un progetto ben pianificato, il test engineer (un tester integrato / di sistema) inizia a progettare i test mentre vengono scritti i requisiti. Attraverso questa attività, i requisiti vengono verificati, prima della progettazione del sistema, e molto prima che venga scritto un punto di codice. Una volta che il sistema diventa disponibile in una forma utilizzabile, i requisiti vengono verificati tramite test funzionale / di integrazione / di sistema.

    
risposta data 25.09.2012 - 20:05
fonte

Leggi altre domande sui tag