Welchen Wert hat das Einchecken in nicht bestandenen Komponententests?

Es gibt zwar Möglichkeiten, die Ausführung von Komponententests zu verhindern, aber welchen Wert hat die Überprüfung fehlgeschlagener Komponententests?

Ich werde ein einfaches Beispiel verwenden: Groß- und Kleinschreibung. Der aktuelle Code unterscheidet zwischen Groß- und Kleinschreibung. Eine gültige Eingabe in die Methode ist "Cat" und würde eine Enumeration von Animal.Cat zurückgeben. Die gewünschte Funktionalität der Methode sollte jedoch nicht zwischen Groß- und Kleinschreibung unterscheiden. Wenn also die beschriebene Methode "cat" bestanden würde, könnte sie möglicherweise so etwas wie Animal.Null anstelle von Animal.Cat zurückgeben, und der Unit-Test würde fehlschlagen. Zwar würde eine einfache Codeänderung dazu führen, dass dies funktioniert, ein komplexeres Problem kann jedoch Wochen dauern, aber die Identifizierung des Fehlers mit einem Komponententest könnte eine weniger komplexe Aufgabe sein.

Die Anwendung, die derzeit analysiert wird, verfügt über 4 Jahre Code, der "funktioniert". Jüngste Diskussionen zu Komponententests haben jedoch Mängel im Code ergeben. Einige benötigen lediglich eine explizite Implementierungsdokumentation (z. B. Groß- / Kleinschreibung beachten oder nicht beachten) oder Code, der den Fehler basierend auf dem aktuellen Aufruf nicht ausführt. Es können jedoch Komponententests erstellt werden, die bestimmte Szenarien ausführen, in denen der Fehler angezeigt wird und gültige Eingaben sind.

Welchen Wert hat das Einchecken von Komponententests, die den Fehler beheben, bis jemand den Code korrigieren kann?

Sollte dieser Komponententest mit Ignorieren, Priorität, Kategorie usw. gekennzeichnet werden, um zu bestimmen, ob ein Build auf der Grundlage der ausgeführten Tests erfolgreich war? Schließlich sollte der Komponententest erstellt werden, um den Code auszuführen, sobald er behoben wurde.

Einerseits zeigt es, dass identifizierte Fehler nicht behoben wurden. Auf der anderen Seite könnten Hunderte von fehlgeschlagenen Komponententests in den Protokollen auftauchen und diejenigen aussortieren, die aufgrund eines Code-Check-ins fehlschlagen oder ausfallen sollten.

Ich mag es nicht, wenn kaputte Unittests eingecheckt werden, weil sie unnötigen Lärm verursachen. Nach jedem unittest müsste ich alle fehlgeschlagenen Probleme überprüfen (rot). Ist es rot, weil es ein neues Problem gibt oder weil es ein altes offenes gibt, um es zu tun / zu beheben. Dies ist nicht in Ordnung, wenn es mehr als 20 Unittests gibt.

Stattdessen benutze ich

• [Ignore("Reason")]Attribut, das das Ergebnis gelb oder gelb macht
• throw new NotImplementedException()das macht das Ergebnis grau

Hinweis: Ich verwende NUnit für .net. Ich bin mir nicht sicher, ob die "graue" Funktion in anderen unittesten Frameworks vorhanden ist.

Ich mag die folgende Bedeutung von Unit-Testergebnissen.

• grün: alles fertig
• grau: Geplante neue Funktionen, die mit niedriger Priorität ausgeführt werden müssen
• gelb: Fehler sind noch nicht behoben. Sollte bald behoben sein
• rot: neue Bugs. Sollte sofort behoben werden

Alles außer "rot" kann eingecheckt werden.

Um die Frage zu beantworten: Das Einchecken von "rot-nicht bestanden-Test" ist schädlicher als der Wert, aber das Einchecken von "gelb-ignoriert-Test" oder "grau-nicht implementiert-Test" kann als ToDo-Liste nützlich sein.

Ich werde nicht so tun, als wäre dies Industriestandard, aber ich überprüfe unterbrochene Tests, um mich oder meine anderen Projektmitglieder daran zu erinnern, dass es immer noch ein Problem mit dem Code oder dem Komponententest selbst gibt.

Ich nehme an, Sie sollten berücksichtigen, ob Ihre Entwicklungsrichtlinien fehlgeschlagene Tests ohne Nachteile zulassen. Ich habe einen Freund, der in einem Geschäft arbeitet, das testgetriebene Entwicklung betreibt, daher beginnen sie immer mit nicht bestandenen Tests ...

Fehlgeschlagene Komponententests geben dem Entwicklungsteam Einblick in die Maßnahmen, die zur Einhaltung der vereinbarten Spezifikationen erforderlich sind.

Kurz gesagt, die fehlgeschlagenen Unit Tests geben dem Team eine "TODO" -Liste.

Aus diesem Grund sind nicht bestandene Komponententests weitaus besser als gar keine Komponententests. *
Das Fehlen von Komponententests lässt das Entwicklerteam im Dunkeln. Spezifikationen müssen wiederholt manuell bestätigt werden .

[* Vorausgesetzt, die Unit-Tests testen tatsächlich etwas Nützliches.]

Der Zweck von Unit-Tests besteht darin, das erwartete Verhalten eines Systems zu bestätigen und keine Mängel zu dokumentieren. Wenn wir Unit-Tests verwenden, um Fehler zu dokumentieren, wird deren Nützlichkeit für die Behauptung des erwarteten Verhaltens verringert. Die Antwort auf die Frage "Warum ist dieser Test fehlgeschlagen?" ist kein einfaches "Oh, etwas ist kaputt, was ich nicht erwartet hätte kaputt zu sein." Es ist nicht bekannt, ob der Testfehler erwartet oder unerwartet ist.

Hier ist ein Absatz vom Anfang von Kapitel 13 von Effektiv mit Legacy-Code arbeiten :

Automatisierte Komponententests sind ein sehr wichtiges Werkzeug, aber nicht für die Fehlersuche - zumindest nicht direkt. Im Allgemeinen sollten automatisierte Tests ein Ziel festlegen, das wir erreichen möchten, oder versuchen, das bereits vorhandene Verhalten beizubehalten. Im natürlichen Fluss der Entwicklung werden Tests, die spezifizieren, zu Tests, die erhalten bleiben . Sie werden Fehler finden, aber normalerweise nicht beim ersten Ausführen eines Tests. Sie finden Fehler in späteren Läufen, wenn Sie das Verhalten ändern, mit dem Sie nicht gerechnet haben.

Aber die defekten, die Fehler in einem neuen Projekt identifizieren, werden als solche bezeichnet. Auf diese Weise können Sie sehen, dass sie brechen MÜSSEN ... Während sie repariert werden, werden sie grün und in die normale Testsuite verschoben.

ANMERKUNG: Dieses Projekt muss so eingestellt werden, dass es nicht auf dem Build-Server erstellt wird, wenn Ihr Build-Server das Einchecken verhindert, das den Build unterbricht (vorausgesetzt, Sie definieren einen fehlerhaften Build als einen, bei dem nicht alle Tests bestanden werden).

Unit-Tests sollten zusätzlich zu Erfolgsfällen einer Funktion auf Fehlerfälle testen. Eine Funktion sollte falsche Eingaben explizit ablehnen oder über eine Dokumentation verfügen, in der erläutert wird, welche Eingaben als gültig angesehen werden.

Wenn Sie eine Funktion haben, die keine dieser Funktionen ausführt, handelt es sich um einen Fehler, und Sie sollten eine Möglichkeit haben, die Existenz dieser Funktion aufzuzeichnen. Das Erstellen eines Komponententests, der dieses Problem demonstriert, ist eine Möglichkeit, dies zu tun. Das Einreichen eines Bug-Tickets ist eine weitere Option.

Der Punkt des Unit-Tests ist, nicht zu 100% erfolgreich zu sein, sondern Fehler im Code zu finden und zu beheben. Keine Tests durchzuführen ist ein einfacher Weg, um 100% Erfolg zu haben, aber das ist für das Projekt nicht sehr vorteilhaft.

Reichen Sie für jeden Fehler einen Fehler ein und notieren Sie dies im Testergebnis. Wenn Sie sich dann jemals zusammensetzen und den Fehler beheben, besteht Ihr Test und Sie löschen ihn aus dem Testergebnis. Ignoriere niemals nur Probleme.

Wie ich TDD beim Implementieren von Tests für einen unfertigen Code sehe, schreiben Sie zuerst Tests mit dem Attribut [ExpectedException] oder ähnlichem. Dies sollte zunächst passieren, da der unvollständige Code keine Logik enthält und einen neuen Exception () - Code enthält. Obwohl eine durchgehende Ausnahme falsch ist, würde dies zumindest dazu führen, dass die Tests anfänglich bestanden und für das Einchecken geeignet sind. Wir können einen ignorierten Test vergessen, aber den unvollständigen Code definitiv aufräumen oder ausfüllen. Wenn wir dies tun, schlägt der entsprechende Test, der eine Aufforderung erwartete, automatisch fehl und Sie werden alarmiert, dies zu beheben. Dies kann eine geringfügige Änderung des Tests beinhalten, um ExpectException zu entfernen und stattdessen echte Asserts durchzuführen. CI, Dev, Tester und Kunden alle glücklich und eine Win-Win-Situation?