Unit Tests in der Mitte schreiben

Ist Unit Testing zu 100% oder überhaupt nicht?

Ich habe meine alten Projekte durchgesehen und angefangen, Funktionen hinzuzufügen, diesmal mit Unit-Tests. Ist dies jedoch letztendlich wertlos, wenn ich frühere Komponenten wiederverwenden möchte, für die es keine Komponententests gibt?

Muss ich Komponententests für alle vorherigen Klassen schreiben und mich überhaupt nicht darum kümmern, oder ist es in Ordnung, nur Komponententests für die neuen Inhalte zu schreiben, die ich hinzufüge?

Alle Unit-Tests sind besser als keine. Es ist also kein Alles-oder-Nichts-Geschäft.

In Ihrem Fall, da Test Driven Development nicht die Norm war, werden Sie sich fragen, wie die Tests von Nutzen sind.

Sie möchten sicherstellen, dass zukünftiger Code, den Sie schreiben, keine (aktuellen) Funktionen beeinträchtigt - und das ist der Punkt , an dem sich Ihre Unterfälle als nützlich erweisen. Wenn die gut geschriebenen Tests bestanden wurden, haben Sie höchstwahrscheinlich nichts beschädigt. Der nächste Entwickler, der mitkommt, wird sich für die Tests und die Dokumentation bedanken.

Sie können damit beginnen, wenn Sie eine gut aufgeteilte Schichtenarchitektur haben, die Datenzugriffsebenen aufgreifen und mit den Tests nach oben (in Richtung UI-Ebene) arbeiten. Wenn das Projekt über ein Domänenmodell verfügt, ist dies der wahrscheinlichste Kandidat für TDD, da dieser wahrscheinlich den größten Teil der Logik aufweist. Wenn die Dienst- (oder Geschäftslogik-) Schicht nur die Domänen- / Datenzugriffsschicht anruft, ist es sinnlos, die Dienstschicht in TDD-Weise auszuführen. Das sind flauschige Tests und nicht von großem Wert.

Hinzugefügt zu einem Code-Coverage-Tool wie Emma - und Sie können die Verbesserung der gesamten Testabdeckung kontinuierlich überwachen.

Ich habe an einer sehr großen Codebasis gearbeitet, die anfangs keine Komponententests hatte. Durch Befolgen einiger Übungen haben wir jetzt (nach einigen Jahren) den größten Teil der Codebasis durch Tests abgedeckt.

Jeder neue Code muss Unit-Tests haben.

Jedem geänderten Code müssen Komponententests hinzugefügt werden.

Die Art und Weise, wie wir Tests sicher zu altem Code hinzugefügt haben, ohne ihn zu beschädigen, ist in erster Linie die Verwendung des folgenden grundlegenden Ansatzes:

Wählen Sie einen kleinen Codeabschnitt aus, dessen Funktionalität Sie ändern möchten.

1. Versuchen Sie, Integrationstests auf Systemebene zu erstellen, um den Code zu umgeben. Aufgrund der kombinatorischen Komplexität des Testens auf dieser Ebene bilden diese Tests nur einen "Rauch" -Test, um größere Fehler aufzudecken.

2. Stellen Sie die Schnittstellen vor, die Sie benötigen, um den zu ändernden Code testen zu können. Verwenden Sie Refactoring-Techniken, die aus Sequenzen sehr kleiner Änderungen bestehen, bei denen Sie sich sicher sind, dass sie korrekt sind. Versuchen Sie, wenn möglich, Werkzeugunterstützung zu verwenden. Sie können dies beispielsweise tun, indem Sie die zu ändernde Methode auf ein eigenes Objekt verschieben / extrahieren. Überprüfen Sie Ihre Änderungen regelmäßig, damit Sie sie wiederherstellen können. Überprüfen Sie regelmäßig, wie Sie die Änderungen vorgenommen haben, indem Sie den Versionskontrollverlauf durchgehen.

   Versuchen Sie, die erforderlichen Änderungen so gering wie möglich zu halten, um die Abhängigkeiten zu beseitigen, die Sie vom Hinzufügen von Tests abhalten.

3. Schreiben Sie Tests, um die Funktionalität des Codes, den Sie ändern möchten, so weit wie möglich abzudecken. Checken Sie regelmäßig ein und überprüfen Sie alle Änderungen.
4. Schreiben Sie Tests für die neue Funktionalität / Funktionsänderung.
5. Implementieren Sie die Funktionalität (dies ist Ihr normaler TDD-Zyklus)
6. Stellen Sie sicher, dass Sie die Bereiche umgestalten, die Sie durch die Tests abgedeckt haben (Rot-Grün-Refaktor).

Wir stellten fest, dass es umso einfacher wurde, je mehr wir dies taten. Wie jedes Mal, wenn Sie zur Codebasis zurückkehren, ist es ein bisschen besser.

Wir haben einen massiven Rückgang der Anzahl der Fehler bei unseren QS-Testern festgestellt. Angesichts der Tatsache, dass Funktionsregressionen jetzt so gut wie unbekannt sind, hat sich die Mühe für uns gelohnt.

(wegen der mangelnden Kommentierbarkeit) Ich finde es besser als gar nicht zu testen. Es muss nicht jedes Snippet getestet werden, sondern nur das, was der Programmierer letztendlich verwenden wird. Das Testen der von Ihnen intern verwendeten Nutzungsfunktionen ist gut, aber nicht erforderlich, wenn Sie anschließend über eine saubere API auf alles zugreifen.

Wenn das alte Zeug jahrelang einwandfrei funktioniert hat, ist das Erstellen der Unit-Tests jetzt nicht obligatorisch, es sei denn, Sie ändern etwas am alten Zeug. Auf jeden Fall ist das Schreiben von Komponententests für die neuen Teile überhaupt nicht sinnlos. Die neuen Teile sind diejenigen, die am wahrscheinlichsten Fehler enthalten, und sie sind auch die Teile, die am wahrscheinlichsten geändert oder überarbeitet werden.

Sie können anfangen, Ihren aktuellen Code zu behandeln, und, wenn Sie etwas Zeit haben, beginnen Sie, die Kernfunktionalität des alten Codes zu behandeln. Du kannst auch deine Uhr um etwas mehr Zeit bitten =)

Ist Unit Testing zu 100% oder überhaupt nicht?

Absolut nicht! Testen Sie den neuen Code, den Sie hinzufügen. Sie werden enorme Vorteile daraus ziehen, auch wenn einige der älteren Komponenten keine Tests haben. Schreiben Sie einen Test, da Sie sich mit einer dieser Komponenten auseinandersetzen müssen oder einen Fehler darin finden. Mit der Zeit werden Sie mehr von dem älteren Code erhalten, der getestet wird.