Nel caso del test delle unità, sto testando il maggior numero di casi possibile quando faccio X , Y succede.
In alcuni casi sono anche preoccupato che quando faccio X , Z non accade.
Ma per motivi di protezione, potrei anche verificare che A, B, C ... non accada neanche. E andando in quella direzione, potrei fondamentalmente testare un miliardo di cose che non dovrebbero accadere e, in molti casi, non accadrà mai.
La mia domanda è, a che punto pensi di essere troppo difensivo e quando è ancora considerato utile?
Usiamo questo bit di pseudo codice come esempio
void MyFunction()
{
if (X)
{
A();
}
else
{
B();
}
C();
}
void AnotherFunction()
{
//Irrelevant code
}
Ecco i test che posso avere:
- A succede quando X è vero
- A non succede quando X è falso
- B non si verifica quando X è vero
- B si verifica quando X è falso
- C si verifica quando X è vero
- C si verifica quando X è falso
Questo è quello che farei. Ma seguendo questo ragionamento potrei anche provare che AnotherFunction non viene chiamato quando X è vero e falso, proprio come sto testando che C viene chiamato quando X è vero e falso o che A / B non viene chiamato quando X è falso / true.
E percorrendo quella strada potrei letteralmente testare un milione di cose che non dovrebbero accadere per ogni caso di test che riesco a trovare. Solo per assicurarti che i prossimi sviluppatori non infrangeranno il codice.
Nel mio esempio potresti dire "questo è troppo ovvio per essere testato" ma sono sicuro che puoi immaginare un punto in cui il codice potrebbe essere così fragile / complesso da poter provare molte cose diverse che non dovrebbero accadere. La mia domanda è: dovrebbe essere testato, e quanto lontano?
C'è qualche tipo di regola? Mi manca qualcosa nell'unità di test delle conoscenze?
Da un lato sento che questo è più sicuro e offre una buona difesa contro praticamente qualsiasi cosa a cui possa pensare. D'altra parte questo è troppo difensivo e abominevole da mantenere, mentre richiede molto tempo dal momento che si arriva al codice 'qualsiasi cosa si possa pensare'.
Si noti che l'ho applicato alle chiamate alle funzioni, ma si estende a tutto ciò che segue la linea di "testare cose che non dovrebbero accadere".
Dove si dovrebbe smettere di testare in quella direzione?