Schritte zu ergreifen, langsam Komponententests in ein Projekt integrieren

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

Frage

Ich bin zur Zeit auf einem Co-op Begriff an einem Projekt arbeitet mit einem anderen Co-op Studenten kurz vor dem Abschluss. Da dieses Projekt von Co-op weitergegeben wurde KOOP, haben schlechte Praktiken auf dem Weg getroffen worden und Tests haben bis zum Ende gelassen worden. Ich habe beschlossen, ich mag einheits Tests schreiben, etwas Neues beim Testen zu lernen.

Allerdings arbeite ich an einem 3-Tiere, eng gekoppelt App, dem Unit-Tests in seiner jetzigen Form nicht möglich zu sein scheint. Ich will nicht über Nacht durch Refactoring den Code bis zur Unkenntlichkeit der anderen Co-op Schüler ohne Kenntnis irgendeiner diese Konzepte abzuwerfen. Also, welche Schritte sollte ich langsam den Code in Richtung Einheit-Testbarkeit ziehen? Sollte ich zum ersten Mal eine Fabrik Muster implementieren und lassen Sie die anderen Schüler sich damit vertraut machen, bevor voran?

Ich entschuldige mich, wenn mein Wissen fehlerhaft ist, und es sollte überhaupt kein Problem sein. Ich bin neu in diesem:)

War es hilfreich?

Lösung

Effektives Arbeiten mit Legacy Code von Michael Feathers

Schwer zu wissen, ob eine Fabrik Muster Umsetzung wird etwas Gutes tun, hängt davon ab, was der Code tut:)

Andere Tipps

Effektives Arbeiten mit Legacy Code von Michael Feathers (auch in Safari wenn Sie ein Abonnement haben) ist eine hervorragende Ressource für Ihre Aufgabe. Der Autor definiert Legacy-Code als Code ohne Unit-Tests, und er gibt praktische Lösungen von Partien von konservativen Techniken-notwendig, weil Sie ohne Netz-für die Arbeit sind im Test befindlichen Code zu bringen. Inhaltsverzeichnis:

  • Teil: I The Mechanics of Change
    • Kapitel 1. Ändern Software
      • Vier Gründe ändern Software
      • Risky Ändern
    • Kapitel 2. Arbeiten mit Feedback zur
      • Was ist Unit Testing?
      • Übergeordneten Testing
      • Test Deckungen
      • The Legacy-Code ändern Algorithmus
    • Kapitel 3. Sensorik und Trennung
      • Faking Mitarbeiter
    • Kapitel 4. Die Naht Modell
      • A Huge Blatt Text
      • Die Nähte
      • Nahttypen
    • Kapitel 5. Werkzeuge
      • Automatische Refactoring Tools
      • Mock Objects
      • Unit-Testing Geschirre
      • General Test Geschirre
  • Teil: II ändern Software
    • Kapitel 6. ich habe nicht viel Zeit, und ich habe es zu ändern
      • Sprout Methode
      • Sprout Klasse
      • Wrap-Methode
      • Wrap Klasse
      • Zusammenfassung
    • Kapitel 7. Es dauert ewig, eine Änderung vorzunehmen
      • Verstehen
      • Verzögerungszeit
      • Breaking Abhängigkeiten
      • Zusammenfassung
    • Kapitel 8. Wie kann ich eine Funktion hinzufügen?
      • Test-Driven Development (TDD)
      • Programmieren von Difference
      • Zusammenfassung
    • Kapitel 9. Ich kann diese Klasse in einem Test-Gurtzeug
      • Der Fall der Reiz Parameter
      • Der Fall der versteckten Abhängigkeit
      • Der Fall der Konstruktion Blob
      • Der Fall der Reiz globale Abhängigkeit
      • Der Fall des Horrible Fügen Sie Abhängigkeiten
      • Der Fall der Zwiebel Parameter
      • Der Fall des Aliased Parameter
    • Kapitel 10. Ich kann nicht diese Methode in einer Testumgebung ausführen
      • Der Fall der versteckten Methode
      • Der Fall der "Hilfreich" Language Eigenschaft
      • Der Fall der Unaufdeckbar Side Effect
    • Kapitel 11. Ich benötige eine Änderung vornehmen. Welche Methoden sollten getestet werden?
      • Reasoning über Effekte
      • Reasoning Vorwärts
      • Effekt Propagation
      • Tools für Effect Reasoning
      • Lernen von Einfluss-Analyse
      • Vereinfachen Effect Sketch
    • Kapitel 12. Ich benötige viele Änderungen in einem Bereich zu machen. Alle Muss ich Abhängigkeiten brechen für die Klassen beteiligt?
      • Interception Punkte
      • Judging Entwurf mit Pinch-Punkte
      • Pinch-Point-Traps
    • Kapitel 13. Ich benötige eine Änderung vornehmen, aber ich weiß nicht, was zu schreiben Tests Charakterisierungstests
      • Charakterisieren Klassen
      • Gezielte Testing
      • Eine Heuristik für das Schreiben Charakterisierungstests
    • Kapitel 14. Abhängigkeiten von Bibliotheken sind Killing Me
    • Kapitel 15. Meine Anwendung ist es, alle API-Aufrufe
    • Kapitel 16. Ich verstehe den Code gut genug nicht zu ändern
      • Notes / Sketching
      • Listing Markup
      • Scratch Refactoring
      • Löschen von nicht verwendeten Code
    • Kapitel 17. Meine Anwendung hat keine Struktur
      • Die Geschichte erzählen des Systems
      • Naked CRC
      • Conversation Überprüfung
    • Kapitel 18. Mein Testcode im Weg
      • Klasse Naming Conventions
      • Test Location
    • Kapitel 19. Mein Projekt ist nicht objektorientiert. Wie stelle ich sicher Änderungen?
      • Ein Easy Case
      • A Hard Case
      • Hinzufügen Neues Verhalten
      • Unter Nutzung der Objektorientierung
      • Es ist alles ObjOriented ect
    • Kapitel 20. Diese Klasse ist zu groß und ich will es nicht größer werden
      • Sehen Aufgaben
      • Andere Techniken
      • Moving Forward
      • Nach dem Auszug der Klasse
    • Kapitel 21. Ich wechsle den gleichen Code ganz über den Platz
      • Erste Schritte
    • Kapitel 22. Ich benötige eine Monster-Methode zu ändern und ich kann nicht Tests für es schreiben
      • Varieties of Monsters
      • Angreifen Monster mit automatisierter Refactoring Unterstützung
      • Das Handbuch Refactoring Herausforderung
      • Strategie
    • Kapitel 23. Wie weiß ich, dass ich nichts brechen bin?
      • HyperAware Bearbeiten
      • Single-Tor Bearbeiten
      • Preserve Signaturen
      • Lean auf dem Compiler
    • Kapitel 24. Wir fühlen sich überfordert. Es wird nicht besser
      • Get
  • Teil: III Dependency-Brechen Techniques
    • Kapitel 25. Dependency-Brechen Techniques
      • Anpassen Parameter
      • Break Out Methode Object
      • Definition Completion
      • kapseln Globale Referenzen
      • Expose Statische Methode
      • Extrahieren und Überschreiben Anruf
      • Extrahieren und Überschreiben Factory Method
      • Extrahieren und Überschreiben Getter
      • Auszug Implementer
      • Schnittstelle extrahieren
      • Führen Instanz Delegator
      • Stellen Static Setter
      • Link Substitution
      • parametrieren Constructor
      • parametrieren Methode
      • Primitivize Parameter
      • Pull Up Funktion
      • Drücken Sie runter Abhängigkeit
      • Ersetzen-Funktion mit Funktionspointer
      • Ersetzen Global Reference mit Getter
      • Unterklasse und überschreiben Methode
      • SUPERSEDE Instanz Variable
      • Template Neudefinition
      • Text Neudefinition
  • Anhang: Refactoring
    • Methode extrahieren

Es ist sehr schwierig, neue Entwicklungspraktiken auf halben Weg durch ein Projekt zu starten. In der Vergangenheit, als ich an Projekten gearbeitet habe, die nicht Einheit von Anfang an getestet haben, ist ein guter Ansatz zu ergreifen, um die Regel zu setzen fest, dass ‚neuer Code Unit-Tests haben muss‘, aber keinen Druck auf Unit-Tests setzen wobei für alten Code geschrieben.

Natürlich, auch das ist schwierig, wenn die Struktur des Projektes nicht zu Testbarkeit geeignet ist.

Meine beste Empfehlung es in kleinen Schritten nehmen würde.

Beginnen Sie mit Ihrem Gerät Testanordnung zu schaffen, (oder ein Projekt oder was auch immer) ohne Tests darin. Dann finden Sie einen einzigen kleinen Bereich des Code, der recht gut definiert und getrennt, und einige Unit-Tests für diesen Bereich schreiben. Holen Sie sich Ihre Co-Coder einen Blick zu nehmen zu und beginnt einige ‚best practices‘ in Gang zu bringen, wie das Gerät läuft jedes Mal überprüft wird jeder Code eingecheckt (automatisch wenn möglich).

Wenn Sie diese Arbeits haben, können Sie langsam mehr hinzuzufügen beginnen.

Der Schlüssel ist, langsam. Und wie ich schon sagte, ist es einfacher, alter Code befreit von der Prüfung zu machen, mit zu beginnen. Sie können jederzeit darauf zurückkommen später einmal Ihr Team die Idee der Unit-Tests ergriffen hat und besser auf sie zu schreiben.

Wie sei es eine Reihe von Black-Box-Tests rund um die großen Stücke von Funktionalität in Ihrem Code zu schreiben? Da Sie erwähnen, dass es ein ASP.NET-Projekt ist, können Sie einen Rahmen wie WaitN oder Selenium einen Web-Browser zu automatisieren. Dies gibt Ihnen eine Basis Reihe von Funktionen, die konstant, egal wie viel die Code-Änderungen bleiben sollten.

Wenn Sie eine komfortable Anzahl von Tests haben die Prüfung der High-Level-Funktionalität Ihres Projekts, dann würde ich das Tauchen in den Code starten, und als Simon P. Stevens erwähnt, Arbeit langsam . Schnappen Sie sich eine (kostenlose) Kopie von Umgestalten! für Visual Basic , so dass Sie in der Lage sein, automatisch einige grundlegende Refactoring, wie Extract Method auszuführen. Sie können drastisch Testbarkeit erhöhen, ohne jede Funktionalität nur zu ändern, indem größere Teile des Codes Aufspaltung in kleinere, besser prüfbar Brocken.

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