Beginnend TDD - Herausforderungen? Lösungen? Empfehlungen? [geschlossen]

StackOverflow https://stackoverflow.com/questions/24965

Frage

OK, ich weiß, es wird bereits Fragen zu immer mit TDD gestartet .. aber ich glaube, ich weiß, Art der allgemeinen Konsensus zu tun sie es einfach , aber ich scheinen die folgenden Probleme zu haben, meine immer Kopf in das Spiel:

  • Wenn Sie mit Sammlungen arbeiten, nicht testen noch auf offensichtliche hinzufügen / entfernen / fügt erfolgreich, wenn auch auf Basis von Generics usw., wo wir Art von „wissen“, dessen Weg zur Arbeit?
  • scheinen Einige Tests für immer nehmen zu implementieren .. Zum Beispiel, wenn mit Stringausgabe arbeitet, gibt es eine „bessere“ Art und Weise über diese Art der Sache zu gehen? (Zum Beispiel das Objektmodell testen, bevor das Parsen, brechen Parsen in kleine ops und testen dort) In meinem Kopf sollten Sie immer das „Endergebnis“ testen, aber das kann stark variieren und langwierig sein, bis zu setzen.
  • Ich habe nicht eine Test-Framework zu verwenden (Arbeit wird nicht für einen zahlen), so kann ich „Praxis“ mehr. Gibt es gute diejenigen, die frei für die kommerzielle Nutzung sind? (Im Moment verwende ich gut ‚ol Debug.Assert :)
  • Wahrscheinlich die größte .. Manchmal weiß ich nicht, was zu erwarten ist nicht passieren .. Ich meine, Sie Ihr grünes Licht bekommen, aber ich bin immer besorgt, dass ich einen Test fehlen. . Haben Sie tiefer graben Sie den Code, um zu versuchen und zu brechen, oder lassen Sie es für sie alle umfallen später sein und warten (was mehr kostet) ..

Also im Grunde, was ich suche hier ist kein „ tun Sie es einfach “, aber mehr „ ich das tat, hatte Probleme mit diesem, gelöst sie durch diese “ .. Die persönlich Erfahrung:)

War es hilfreich?

Lösung

Als erstes ist es in Ordnung und normale frustriert zu fühlen, wenn Sie zum ersten Mal versuchen, beginnen TDD in Ihrem Coding Stil zu verwenden. Nur nicht entmutigen und beenden, müssen Sie es einige Zeit geben. Es ist ein wichtiger Paradigmenwechsel, wie wir denken über ein Problem in Code zu lösen. Ich mag es gerne glauben, wenn wir aus verfahren geschaltet orientierten Programmierung zu widersprechen.

Zweitens glaube ich, dass Testgetriebene Entwicklung in erster Linie ein Design-Aktivität, die durch die Schaffung einer Prüfung der Konstruktion eines Bauteils zu konkretisieren verwendet wird, die zuerst die API beschreibt es wird belichten und wie Sie gehen zu konsumieren es ist Funktionalität. Der Test wird mitzugestalten und das System Under Test Form, bis Sie in der Lage gewesen, genug Funktionalität zu verkapseln zu erfüllen, was auch immer Aufgaben, die Sie passieren auf zu arbeiten.

Unter dem obigen Absatz im Kopf, lassen Sie sich auf Ihren Fragen aussehen:

  1. Wenn ich eine Sammlung in meinem testende System verwenden, dann werde ich Setup eine Erwartung, um sicherzustellen, dass der Code aufgerufen wurde das Element einzufügen und dann die Zählung der Sammlung geltend machen. Ich teste nicht unbedingt die Add-Methode auf meiner internen Liste. Ich mache nur sicher, dass es genannt wurde, als die Methode, die das Element fügt aufgerufen wird. Ich tue dies, indem ein Mockframework in den Mix, mit meinem Test-Framework.
  2. Test Strings als Ausgang kann langwierig sein. Sie können nicht für jedes Ergebnis erklären. Sie können nur testen, was Sie basiert auf der Funktionalität des zu testenden Systems erwarten. Sie sollten immer Ihre Tests brechen bis ins kleinste Element, das es Testen ist. Was bedeutet, Sie viele Tests haben, aber Tests, die klein und schnell und nur testen, was sie sollten, sonst nichts.
  3. Es gibt viele Open-Source-Test-Frameworks zur Auswahl. Ich werde nicht streiten, was am besten ist. Finden Sie einfach ein Sie verwenden es mögen und starten.
  4. Alles, was Sie tun können, ist Setup Ihre Tests zur Rechenschaft für das, was Sie wollen passieren. Wenn ein Szenario aufgeht, dass ein Fehler in Ihrer Funktionalität einführt, haben Sie zumindest einen Test um die Funktionalität dieses Szenario in den Test hinzufügen und dann Ihre Funktionalität ändern, bis der Test bestanden. Ein Weg, um herauszufinden, wo wir einen Test verpasst haben kann, ist die Verwendung Code Coverage .

habe ich Sie zu dem spöttischen Ausdruck in der Antwort auf Frage eins. Wenn Sie introduce in Ihrem Arsenal für TDD spöttisch, macht es dramatisch Tests einfacher zu abstrahieren die Teile, die nicht Teil des zu testenden Systems sind. Hier sind einige Ressourcen auf die spöttischen Frameworks da draußen sind:

Eine Möglichkeit, sich mit der TDD zu helfen, außer über den Prozess zu lesen, ist die Menschen es tun zu beobachten. Ich empfehle den Bildschirm Abgüsse von JP Boodhoo in der Beobachtung auf DNRTV . Überprüfen Sie diese aus:

OK, diese wird Ihnen helfen, zu sehen, wie die Begriffe, die ich eingeführt werden verwendet. Es wird auch ein anderes Werkzeug einführen genannt ReSharper und wie es den TDD-Prozess erleichtern kann. Ich konnte dieses Tool nicht genug empfehlen, wenn TDD tun. Scheint, als ob Sie den Prozess lernen, und Sie sind nur einige der Probleme zu finden, die bereits mit der Verwendung von anderen Werkzeugen gelöst wurden.

Ich glaube, ich würde eine Ungerechtigkeit für die Gemeinschaft tun, wenn ich nicht diese neue Serie Kent Becks aktualisiert wurde durch Zugabe auf Test Driven Development auf Pragmatische Programmierer .

Andere Tipps

Aus meiner eigenen Erfahrung:

  1. Nur Ihren eigenen Code testen, nicht der Code des zugrunde liegenden Rahmen. Also, wenn Sie eine generische Liste mit sind, dann gibt es keine Notwendigkeit, hinzufügen zu testen, entfernen etc.

  2. Es gibt keine 2. Schauen Sie da drüben! Monkeys !!!

  3. NUnit ist der Weg zu gehen.

  4. Sie können auf jeden Fall nicht jedes Ergebnis testen. Ich teste für das, was ich erwarte, passieren, und dann ein paar Grenzfälle testen, wo ich erwarte, dass Ausnahmen oder ungültige Antworten zu erhalten. Wenn ein Fehler, weil etwas auf der Strecke kommt vergessen hat, zu testen, das erste, was Sie (bevor Sie versuchen, den Fehler zu beheben) tun sollen, ist einen Test schreiben, um zu beweisen, dass der Fehler vorhanden ist.

Meine Meinung dazu ist folgende:

  • 1 für nicht Framework-Code zu testen, aber Sie müssen noch Klassen von Framework-Klassen abgeleitet testen.
  • Wenn einig Klasse / Methode ist umständlich zu testen, kann seine starker Hinweis darauf, dass etwas mit Desing falsch ist. Ich versuche, „Klasse 1 - 1 Verantwortung, 1-Methode - 1 Aktion“ folgen Prinzip. Auf diese Weise werden Sie testen können in kleineren Portionen komplexe Methoden viel einfacher durch das zu tun.
  • 1 für xUnit. Für Java können Sie auch TestNG betrachten.
  • TDD ist nicht einziges Ereignis es ist ein Prozess. Also versuchen Sie nicht alles von Anfang an, sich vorzustellen, aber stellen Sie sicher, dass jeder Fehler im Code gefunden tatsächlich von Test abgedeckt ist einmal entdeckt.

Ich denke, das Wichtigste mit (und tatsächlich eine der großen Ergebnisse der in etwas rekursiv) TDD ist ein erfolgreiches Management von Abhängigkeiten. Sie müssen sicherstellen, dass die Module in Isolation ohne aufwändige Einrichtung erforderlich getestet werden. Zum Beispiel, wenn Sie eine Komponente zu test, die schließlich eine E-Mail sendet, macht den E-Mail-Absender eine Abhängigkeit, so dass Sie es in Ihren Tests verspotten. Dies führt zu einem zweiten Punkt - Mocks Ihre Freunde sind. Lassen Sie sich mit spöttischen Frameworks vertraut gemacht und den Stil von Tests, die sie fördern (Verhaltens-, im Gegensatz zu den klassischen Zustand basiert), und die Design-Entscheidungen, die sie fördern (die "Sagen Sie, nicht fragen" Prinzip).

fand ich, dass die dargestellten Prinzipien in der drei Karteikarten auf einfache Weise die Essenz von TDD Denken Sie daran, ist ein guter Leitfaden.

Wie auch immer, beantworten Ihre Fragen

  1. Sie müssen nicht etwas testen Sie „wissen“ funktionieren wird, wenn Sie es geschrieben haben. Sie haben nicht schreiben Generika, Microsoft habe;)
  2. Wenn Sie so viel für Ihren Test tun müssen, vielleicht Ihr Objekt / Methode ist zu viel als auch zu tun.
  3. Download TestDriven.NET sofort Unit-Tests auf dem Visual Studio zu starten, (es sei denn, es ist eine Express-Edition)
  4. Just testen Sie die richtig, was passieren wird . Sie müssen nicht Notwendigkeit alles zu testen, die schief gehen können. Sie müssen warten, bis die Tests für das zum Scheitern verurteilt

Im Ernst, tun Sie es einfach, Alter. :)

Ich bin kein Experte auf TDD, mit irgendwelchen Mitteln, aber hier ist meine Ansicht:

  • Wenn es ganz trivial ist (Getter / Setter, etc.) tun es nicht testen, es sei denn, Sie aus irgendeinem Grund im Code haben kein Vertrauen.
  • Wenn es eine ganz einfache, aber nicht triviale Methode ist, testen Sie es. Der Test ist wahrscheinlich einfach irgendwie zu schreiben.
  • Wenn es darum geht, was nicht passieren zu erwarten, würde ich sagen, dass, wenn ein gewisses potentielles Problem in der Verantwortung der Klasse ist, die Sie testen, müssen Sie testen, ob sie es richtig behandelt. Wenn es nicht die aktuelle Klasse ist die Verantwortung, nicht testen.

Die Gerüste xUnit Tests sind oft kostenlos zu benutzen, wenn Sie also ein .Net Typ sind Besuche NUnit, und wenn Java ist Ihre Sache JUnit überprüfen.

Der obige Rat ist gut, und wenn Sie eine Liste der freien Frameworks wollen, müssen Sie nicht weiter schauen als die xUnit Frameworks Liste auf Wikipedia. Hoffe, das hilft:)

Meiner Meinung nach (der Leistung kann variieren):

1- Wenn Sie es nicht schreiben Sie es nicht testen. Wenn Sie es geschrieben hat, und Sie haben nicht einen Test für sie es nicht existiert.

3- Wie jeder sagte, xUnit die frei und groß.

2 & 4- genau entscheiden, was zu testen ist eines jener Dinge, die Sie mit sich selbst immer die Debatte über können. Ich versuche, diese Linie durch Vertrag von Design unter Verwendung der Prinzipien zu ziehen. Check out ‚Object Oriented Software Construction“ oder "Der Pragmatische Programmierer" für Details über sie.

Halten Sie Tests kurz "atomare". Testen Sie die kleinste Annahme in jedem Test. Machen Sie jeden Testmethod unabhängig, für Integrationstests ich auch eine neue Datenbank für jede Methode erstellen. Wenn Sie einige Daten für jeden Test zu bauen brauchen eine „Init“ Methode verwenden. Verwenden spottet der Klasse Ihre Tests zu isolieren daraus Abhängigkeiten ist.

Ich denke immer, „was die minimale Menge an Code, das ich schreiben müssen, um zu beweisen, dies für alle Fälle funktioniert?“

Im letzten Jahr habe ich mehr und mehr von den Vorteilen überzeugt von TDD werden. Die Dinge, die ich auf dem Weg gelernt: 1) Dependency Injection ist dein Freund. Ich rede nicht über Inversion of Control Container und Frameworks Plugin-Architekturen zu montieren, nur Abhängigkeiten in den Konstruktor des Objekts unter Test bestanden. Das zahlt sich riesige Dividenden in der Testbarkeit des Codes zurück. 2) setze ich mit der Leidenschaft / zealotry des Konvertiten und griff nach einem Mockframework und setzen über Mocks für alles, was mit ich konnte. Dies führte zu spröde Tests, die viel schmerzhaften Satzes und würde umfallen, sobald erforderlich, wie ich jedes Refactoring gestartet. Verwenden Sie die richtige Art von Test doppelt. Fakes, wo Sie brauchen nur eine Schnittstelle, Stubs zu ehren Daten zurück an den zu prüfenden Objekt zu füttern, verspotten nur dann, wenn Sie Interaktion kümmern. 3) Test sollte klein sein. Ziel ist es für eine Assertion oder Wechselwirkung in jedem Test getestet. Ich versuche, dies zu tun und vor allem dort bin ich. Hier geht es um die Robustheit des Codes testen und auch über die Höhe der Komplexität in einem Test, wenn Sie brauchen es später erneut.

Das größte Problem, das ich hatte mit TDD mit einer Spezifikation von einer Normungsorganisation und eine Dritten Umsetzung dieser Normen gearbeitet hat, dass der De-facto-Standard. Ich codierte viele wirklich schöne Unit-Tests auf das Schreiben der Spezifikation finden nur, dass die Umsetzung auf der anderen Seite des Zauns als eher beratenden Dokument den Standard sah. Sie spielten ganz locker mit ihm. Der einzige Weg, dies zu beheben war bei der Umsetzung sowie die Komponententests zu testen und die Tests und Code wie nötig Refactoring. Das eigentliche Problem war der Glaube an meinem Teil, solange ich hatte Code und Unit-Tests alle waren gut. Nicht so. Sie müssen die tatsächlichen Ausgaben werden Aufbau und Funktionsprüfung zur gleichen Zeit durchführen, wie Sie Unit-Tests sind. Kleine Stücke von Vorteil den ganzen Weg durch den Prozess -. In Benutzer oder Interessengruppen Hände

Nur als Ergänzung zu diesem, dachte ich, ich würde sagen, dass ich ein TDD - Erste Schritte mit Test gestartet -driven Entwicklung .“- ich habe einige großartige Feedback so weit gekommen und würde wirklich zu schätzen mehr, dass euch zu bieten haben

Ich hoffe, das hilft! :)

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top