Wie weit mit Unit-Tests gehen

Eine Frage, die schon oft gestellt wurde, aber mit einer bestimmten Neigung zur Entwicklung von MVCs.

Ich war ein sehr guter Junge und habe alle meine Controller-Aktionen mit entsprechenden Unit-Tests codiert, was großartig war (wenn sich manchmal ein wenig [viel lesen] wiederholt). Um ehrlich zu sein, habe ich tatsächlich eine kleine T4-Vorlage erstellt, um die meisten Knochen der ersten Komponententests zu schreiben, und sie dann je nach Verwendung entsprechend angepasst. Ich gebe zu, nicht ganz sicher zu sein, wie man Tests in Ansichten behandelt, die Teilansichten enthalten - aber das ist eine Geschichte für eine andere Frage.

Nun ist es für mich schwierig zu entscheiden, wie tief die Abdeckung in meiner Serviceschicht sein sollte. Der Grund dafür ist, dass einige meiner Servicemethoden (zum Guten oder Schlechten) tatsächlich eine Vielzahl von Linq-Abfragen ausführen, die dann der nachfolgenden Logik innerhalb der Methode diskrete Informationen liefern. Ich weiß, dass ich diese Methoden aufschlüsseln könnte (sollte ??), um nur die erforderliche Logik für jede linq-Anweisung aufzurufen und sie dann innerhalb der Methode anzuwenden. In vielen Fällen gibt es jedoch nie eine Wiederverwendung der linq-Funktionen, und daher scheint dies den Code eine Ebene zu weit zu überarbeiten.

Ich frage, ob komplexe Logik innerhalb einer Methode "gut genug" ist, um eine Testmethode zu haben, die einfach das erforderliche Ergebnis und / oder den erwarteten Fehler bestätigt, oder ob jede Logikzeile gleichzeitig ausgeführt und getestet werden sollte. So wie ich es sehe, um die Tests korrekt durchzuführen, sollte die Methodenlogik (Zeile für Zeile) auch eine gewisse Abdeckung erhalten. Dies könnte jedoch (meiner naiven Meinung nach) zu einem nie endenden Zyklus führen, in dem versucht wird, den Test und die implementierte Methode so eng aufeinander abzustimmen (was ich weiß, dass sie sein sollten), dass in den Tests selbst eine Heimindustrie entsteht.

Ich weiß, dass meine Frage einige der TDD-Anhänger beleidigen kann, die dies als Kinderspiel ansehen werden. Da ich nicht im TDD-Lager bin, ist dies für mich ein "Ja-Klacks", daher die Frage.

Übrigens - hatte dies auf Ideen überprüft:

http://dotnetslackers.com/articles/aspnet/Built-in-Unit-Test-for-ASP-NET-MVC-3-in-Visual-Studio-2010-Part-1.aspx

Ich freue mich jetzt auf die stetigen Abstimmungen :)

[edit] - zum Wohle des Single (na ja im Moment Single !!) 'enger' Wähler. Diese Frage ist nicht subjektiv. Ich bin auf der Suche nach einem Konsens über ein sehr fokussiertes Thema. Ich versuche nicht, negative Leidenschaften zu wecken, ich versuche nicht, Fehler in der Technologie aufzudecken - ich bin ein RIESIGER Fan. Bitte hinterlassen Sie einen höflichen Kommentar zu meinem Vorteil, wenn Sie abstimmen, da dies mir helfen kann, die Frage neu zu strukturieren, wenn Unklarheiten oder Fehlinformationen vorliegen. Diese Frage könnte einem großen Teil der MVC-Bevölkerung zugute kommen.

Danke!!

Jim

Zunächst einmal klingt das, worüber Sie sprechen, nicht ganz nach TDD. TDD impliziert einen ersten Testansatz, bei dem das Design Ihres Systems nach dem Muster von Test-> Code-> Refactor gesteuert wird . Vielleicht ist Ihr erstes Problem der Zweck Ihrer Tests. Schreiben Sie sie beim Codieren? Wenn ja, würde ich erwarten, dass sich so ziemlich die gesamte Logik in Ihrem Test auf einen Komponententest bezieht. Eine hohe Codeabdeckung ist daher ein indirektes Ergebnis der Anwendung von TDD.

Wenn Sie TDD ausführen, schreiben Sie genügend Testcode, um den Code zu motivieren, den Sie schreiben möchten. Sie stellen außerdem sicher, dass der Test zuerst fehlschlägt . Fragen Sie sich grundsätzlich, was diese Methode tun muss. Dann codieren Sie es, aber gerade genug, um den Test zu bestehen. Wenn es nicht das ist, wonach Sie suchen, schreiben Sie zusätzliche Tests und überarbeiten dann die Methode.

Die nachträgliche Codeabdeckung ist keine wirksame Methode, um Ihre Einhaltung von TDD zu messen. In Code, der mit TDD geschrieben wurde, ist jedoch normalerweise eine sehr hohe Codeabdeckung festzustellen, da der gesamte Code durch einen Test hätte motiviert sein müssen.

TDD-Tests dienen dazu, sowohl das Design als auch das Dokument zu steuern und anderen das Design im Klartext zu erklären (daher ist es sehr wichtig, wie Sie Ihre Tests benennen).

Keines dieser Probleme beantwortet Ihre Frage jedoch direkt, sodass ich nur sagen sollte, dass Sie eine ziemlich hohe Codeabdeckung für Service-Code (Nicht-UI-Code) anstreben sollten, insbesondere dort, wo es keine Trival-Logik gibt, und noch besser, wenn die Tests durchgeführt werden zuerst geschrieben ;-). Tatsache ist (obwohl einige anderer Meinung sein mögen), dass mehr Tests im Allgemeinen besser sind. Viele Open Source-Projekte von hoher Qualität enthalten weitaus mehr Testcode als Code.

Darüber hinaus sollten Tests immer dann geschrieben werden, wenn:

1. Wenn Sie neuen Code schreiben, sollten Tests Ihr Design steuern und dokumentieren und Ihre Annahmen darüber erläutern, was der Code tun soll. Das sollte geschrieben werden, bevor Sie codieren.

2. Sie haben einen Fehler gefunden. Ein fehlgeschlagener Test sollte den Fehler demonstrieren. Wenn der Fehler behoben ist, sollte der Test bestanden werden.

3. Sie ändern den Code so, dass sich die Art und Weise ändert, wie eine Methode oder Klasse funktioniert (wenn jedoch viele Tests fehlschlagen, wenn sich ein Bereich des Codes ändert, kann dies auf spröde Tests hinweisen). Dadurch dokumentieren die Tests den Code korrekt.

Persönlich habe ich festgestellt, dass das Erlernen von TDD eine interessante Herausforderung ist und es Zeit braucht, um ein gutes "Bauchgefühl" dafür zu entwickeln. Üben, üben, üben war für mich der beste Weg zu lernen. Das und Lesen von Testcode aus Open Source-Projekten und jetzt auch dazu beitragen, während neue Tests mit meinen Änderungen geschrieben werden.

Es ist offensichtlich, dass das Testen nur des Rückgabewerts einer Methode weniger leistungsfähig ist als das Testen aller darin enthaltenen Zweige. Alternative Eingaben garantieren kein korrektes Verhalten.

Andererseits haben Sie möglicherweise nicht genug Zeit oder Geduld, um alles zu testen.

Sie können entscheiden, wie viel Code Sie mit Tests abdecken möchten (80-90% oder was auch immer), und dies mithilfe automatisierter Tools erzwingen, die dies überprüfen.
Ein "nie endender Zyklus" von Schreibtests tritt nur auf, wenn der Code-Schreibzyklus auch nie endet :)

Wie sicher möchten Sie sein, dass Ihr Code ordnungsgemäß funktioniert? Unit-Tests sind lediglich ein Werkzeug in der Tasche des Programmierers, mit dem überprüft werden kann, ob Ihre Implementierung das tut, was die Spezifikation vorschreibt. Sie benötigen wahrscheinlich keine 100% ige Abdeckung, sollten jedoch Komponententests schreiben, um die kritischeren Teile Ihres Codes abzudecken. Es ist immer gut sicherzustellen, dass Ihre Methoden gut zusammenarbeiten, nicht nur alleine. Sie sollten daher versuchen, einige Tests zu schreiben, die einige Ihrer kritischeren "Logiklinien" abdecken.

Wenn Sie Unit-Tests mit aktivierter Codeabdeckung in Visual Studio ausführen, sollten Sie einen guten (und grafischen) Hinweis darauf erhalten, wie gut Ihr Code abgedeckt ist.

Wenn Sie das integrierte MSTest-Framework nicht verwenden, müssen Sie sich möglicherweise ein Code-Coverage-Produkt eines Drittanbieters ansehen, um mit NUnit zu arbeiten, oder den Anweisungen hier folgen: /programming/2665799/does-vs2010-code -coverage-support-nunit