Quando scrivere test per una nuova classe usando BDD?

4

Ho praticato lo sviluppo guidato dal comportamento (BDD). Capisco che devi scrivere test che testano il comportamento del codice e questo permetterà al design del tuo codice di evolversi e prendere forma.

Quando faccio BDD e trovo che ho bisogno di rifattorizzare il mio codice in un design migliore, e che refactor coinvolge l'estrazione di codice in una nuova classe, quando inizio a scrivere test per quella nuova classe?

Oppure i test non sono necessari per quella classe poiché si tratta di un dettaglio di implementazione e il suo comportamento dovrebbe essere già testato con la copertura del test esistente?

    
posta Bobby Lei 20.06.2013 - 06:47
fonte

3 risposte

3

Suppongo che tu esegua il refactoring perché la classe sta violando SRP, cioè ha una funzione extra che non appartiene a questo. Quindi, quello che succederà è che la funzione si sposterà da una classe esistente a una nuova classe. Il modo in cui l'ho gestito in passato è:

  1. Verifica di avere test atomici che coprono quella funzione.
  2. Refactor ed estrai la classe. A questo punto i test atomici diventano test di integrazione.
  3. Refactor / sposta quei test, in modo che non siano più test di integrazione sulla classe originale, ma test atomici sulla nuova classe
  4. Correggere eventuali test esistenti sulla vecchia classe che ora hanno dipendenze sulla nuova classe che ha bisogno di simulazione.

Il modo in cui guardo questo è il numero di funzioni e test nella base di codice è rimasto lo stesso, sono stati appena riorganizzati.

    
risposta data 20.06.2013 - 10:13
fonte
2

Parte della gioia del BDD si sta allontanando da quella parola, "test".

Al contrario, abbiamo esempi che illustrano come si comporta il codice, sia a livello di sistema che a livello di unità.

Questi esempi ci consentono di stabilire se il comportamento del codice è appropriato. Ad esempio, potremmo avere una classe "Shop" che è responsabile per la registrazione delle scorte e per gli ordini.

Quando guardiamo gli esempi, possiamo vedere i seguenti comportamenti illustrati:

should Record Stock
should Take Orders

Una delle cose che possiamo fare quando smettiamo di pensare ai "test" è pensare, "dovrebbe? Dovrebbe davvero?"

Possiamo vedere che si tratta di due diversi aspetti del comportamento, quindi sappiamo che forse il negozio dovrebbe delegare tali aspetti. Possiamo iniziare a pensare a cosa dovrebbe fare davvero un negozio.

Qual è lo scopo di un negozio? Bene, è per fare soldi per il proprietario e per fornire beni ai clienti. Registrare le scorte e prendere ordini sono solo parte di ciò.

Quindi forse un negozio:

should Make Money
should Provide Goods for Customers

Wow. Abbiamo la possibilità di prendere ordini e registrare azioni, ma non abbiamo in realtà alcun modo di scoprire se stiamo facendo soldi o fornendo i beni corretti. Forse dovremmo farlo anche noi ...

Usando il linguaggio naturale e parlando di ciò che un codice dovrebbe fare, possiamo avere conversazioni con la nostra attività per vedere se comprendiamo correttamente i loro requisiti, quindi portare il linguaggio che usano nel codice.

A quel punto, molte cose diventano più ovvie.

  • Se il nostro codice non sta facendo quello che dice dovrebbe, potrebbe essere il codice sbagliato.
  • Se il nostro codice sta facendo ciò che dovrebbe, ma non dice che lo sta facendo, dobbiamo refactoring cose come metodo e nomi di variabili, e forse anche estrarre alcuni metodi.
  • Se qualcos'altro dovrebbe fare ciò che sta facendo il nostro codice, dobbiamo spostare le cose in classi diverse.
  • Se la nostra applicazione non sta facendo ciò che dovrebbe, possiamo invece chattare con l'azienda su ciò che vogliono realmente che faccia.

Usare un negozio è un esempio piuttosto semplice, ma spero che tu possa vederlo pensando al codice non in termini di "test" e "how to test", ma in termini di "come dovrebbe comportarsi", finiamo utilizzando il principio della responsabilità unica ... beh, più responsabilmente. E probabilmente impareremo molto sul nostro dominio, creando allo stesso tempo codice leggibile e gestibile.

Questo è il cuore di BDD. Trovo che i BDDer esperti abbiano bisogno di rifattorizzare di meno, perché finiscono per creare cose che aderiscono all'SRP per cominciare.

    
risposta data 21.07.2013 - 18:45
fonte
1

When doing BDD and I find I need to refactor my code into a better design, and that refactor happens to involve extracting some code into a new class, when do I start writing tests for that new class?

Avvia il refactoring non appena identifica il problema. Se vedi che puoi estrapolare alcune funzionalità in una nuova classe, fallo subito, ma prima assicurati che tutti i test stiano passando.

Or are tests not needed for that class at all since it's a implementation detail and the behaviour of it should already be tested with the existing test coverage?

Sì, è necessario testare anche quella classe. Test extra non faranno del male e potrebbero rilevare possibili bug che sono stati superati in vecchi test.

Se stai seguendo SOLID e utilizzi le classi di simulazione per testare il comportamento, dovrai modificare i test esistenti. In caso contrario, lascia i test così come sono.

    
risposta data 20.06.2013 - 07:49
fonte

Leggi altre domande sui tag