Wie viele Komponententests sollte ich pro Funktion/Methode schreiben?

Question

Schreiben Sie einen Test pro Funktion/Methode, mit mehreren Überprüfungen im Test oder einem Test für jede Überprüfung?

Answer 1

Ein Test pro Scheck und Supernamen, pro Instanz:

@Test 
public void userCannotVoteDownWhenScoreIsLessThanOneHundred() { 
... 
} 

Sowohl nur eine Behauptung und mit guten Namen gibt mir einen besseren Bericht, wenn ein Test fehlschlägt. Sie schreien zu mir: "Du hast diese Regel gebrochen!".

Answer 2

Ein Testfall für jede Prüfung. Es ist granularer. Es macht es viel einfacher zu sehen, welcher spezifische Testfall fehlgeschlagen ist.

Answer 3

BDD (Behavior Driven Development)

Obwohl ich bin immer noch lernen, ist es im Grunde organisiert TDD/fokussiert um, wie Sie Ihre Software tatsächlich verwendet werden ... nicht, wie es weiterentwickelt werden wird/gebaut.

Wikipedia General Info

BTW so weit wie, ob mehrere pro Testmethode zu tun behauptet ich empfehlen würde es in beiden Richtungen zu versuchen. Manchmal werden Sie sehen, wo eine Strategie Sie in einer Bindung verlassen hat und es wird Sinn machen, warum Sie normalerweise nur eine Assert pro Methode verwenden.

Answer 4

Ich würde für jeden Scheck einen Testfall vorschlagen. Je mehr Sie atomar halten, desto besser sind Ihre Ergebnisse!

Wenn Sie mehrere Prüfungen in einem einzelnen Test durchführen, können Sie einen Bericht erstellen, der angibt, wie viele Funktionen korrigiert werden müssen.

Keeping atomic test case wird Ihnen die Gesamtqualität zeigen!

Answer 5

Ein Testcase pro Prüfung. Wenn Sie die Methode entsprechend benennen, kann dies einen wertvollen Hinweis auf das Problem liefern, wenn einer dieser Tests einen Regressionsfehler verursacht.

Answer 6

Ich habe einen Test pro Fähigkeit die Funktion bietet. Jeder Test kann jedoch mehrere Assertionen haben. Der Name des Testcases zeigt die zu testende Fähigkeit an.

Im Allgemeinen, für eine Funktion, habe ich mehrere "sonniger Tag" Tests und ein oder ein paar "Regentag" -Szenario, abhängig von seiner Komplexität.

Answer 7

Ich schreibe mindestens einen Test pro Methode und manchmal mehr, wenn die Methode eine andere Einstellung benötigt, um die guten Fälle und die schlechten Fälle zu testen.

Aber Sie sollten nie Test mehr als eine Methode in einem Einheitstest. Es reduziert die Menge an Arbeit und Fehler in Fixing Ihren Test für den Fall, dass Ihre API ändert.

Answer 8

Ich versuche, Datenbank Tests und Business Logic Tests (unter Verwendung BDD wie andere hier empfehlen) zu trennen, die ersten Datenbank sicherstellt, dass Ihre Datenbank in einem guten Zustand ist, bevor Sie Ihre Anwendung bitten, damit zu spielen.

Es gibt eine gutes podcast show with Andy Leonard on what it involves and how to do it, und wenn man ein bisschen mehr Informationen erhalten mag, habe ich einen blog post on the subject (schamlosen Stecker; o) geschrieben

Answer 9

Im Allgemeinen eines Testfall pro Scheck. Wenn Tests um eine bestimmte Funktion gruppiert werden, erschwert das Refactoring (z. B. Entfernen oder Aufteilen) diese Funktion, da die Tests ebenfalls viele Änderungen erfordern. Es ist viel besser, die Tests für jede Art von Verhalten, das Sie von der Klasse möchten, zu schreiben. Manchmal ist es beim Testen eines bestimmten Verhaltens sinnvoll, mehrere Prüfungen pro Testfall durchzuführen. Da die Tests jedoch komplizierter werden, ist es schwieriger, sie zu ändern, wenn sich etwas in der Klasse ändert.

Answer 10

In Java/Eclipse/JUnit verwende ich zwei Quellverzeichnisse (src und test) mit demselben Baum. Wenn ich ein src/com/mycompany/was auch immer/TestMePlease mit Methoden im Wert von Tests (zB deleteAll (List <? > Zeug) wirft MyException) Ich erstelle ein Test/com/mycompany/was/TestMePleaseTest mit Methoden zum Testen verschiedener Anwendungsfälle/Szenarien:

@Test 
public void deleteAllWithNullInput() { ... } 

@Test(expect="MyException.class") // not sure about actual syntax here :-P 
public void deleteAllWithEmptyInput() { ... } 

@Test 
public void deleteAllWithSingleLineInput() { ... } 

@Test 
public void deleteAllWithMultipleLinesInput() { ... } 

Verschiedene Überprüfungen sind für mich einfacher zu handhaben.

Nichtsdestoweniger, da jeder Test konsistent sein sollte, wenn ich möchte, dass meine anfänglichen Daten unverändert bleiben, habe ich manchmal zum Beispiel Sachen zu erstellen und sie in der gleichen Prüfung zu löschen, um sicherzustellen, dass jeder andere Test den Datensatz unberührt findet :

@Test 
public void insertAndDelete() { 
    assertTrue(/*stuff does not exist yet*/); 
    createStuff(); 
    assertTrue(/*stuff does exist now*/); 
    deleteStuff(); 
    assertTrue(/*stuff does not exist anymore*/); 
} 

Sie wissen nicht, ob es intelligentere Wege sind, das zu tun, um die Wahrheit zu sagen ...

Answer 11

Ich mag einen Test pro Scheck in einem Verfahren haben und einen meaningfull Namen für die Testmethode. Zum Beispiel:

testAddUser_shouldThrowIllegalArgumentExceptionWhenUserIsNull

Answer 12

denke ich, dass die Regel der einzigen Behauptung ein wenig zu streng ist. In meinen Komponententests versuche ich, die Regel einzelne Gruppe von Zusicherungen zu befolgen - Sie können mehr als eine Behauptung in einer Testmethode verwenden, solange Sie die Prüfungen nacheinander durchführen (Sie ändern den Zustand nicht der getesteten Klasse zwischen den Behauptungen).

Also, in Python, glaube ich, ein Test wie dieser ist richtig:

def testGetCountReturnsCountAndEnd(self): 
    count, endReached = self.handler.getCount() 
    self.assertEqual(count, 0) 
    self.assertTrue(endReached) 

aber dies sollte in zwei Testmethoden aufgeteilt sein:

def testGetCountReturnsOneAfterPut(self): 
    self.assertEqual(self.handler.getCount(), 0) 
    self.handler.put('foo') 
    self.assertEqual(self.handler.getCount(), 1) 

Natürlich Im Falle langer und häufig verwendeter Gruppen von Assertions möchte ich benutzerdefinierte Assertion-Methoden erstellen - diese sind besonders nützlich für den Vergleich komplexer Objekte.