Was ist Test Driven Development (TDD)? Tutorial mit Beispiel

Testgesteuerte Entwicklung beginnt mit dem Entwerfen und Entwickeln von Tests für jede kleine Funktionalität einer Anwendung. TDD weist Entwickler an, nur dann neuen Code zu schreiben, wenn ein automatisierter Test fehlgeschlagen ist. Dies vermeidet die Vervielfältigung von Code. Die vollständige Form von TDD ist die testgetriebene Entwicklung.

Das einfache Konzept von TDD besteht darin, die fehlgeschlagenen Tests vor dem Schreiben zu schreiben und zu korrigieren neuer Code (vor der Entwicklung). Dies hilft, Doppelarbeit zu vermeiden, da wir jeweils eine kleine Menge Code schreiben, um die Tests zu bestehen. (Tests sind nichts anderes als Anforderungsbedingungen, die wir testen müssen, um sie zu erfüllen.)

Testgesteuerte Entwicklung ist ein Prozess zum Entwickeln und Ausführen von Automatisierung Test vor der eigentlichen Entwicklung der Anwendung. Daher wird TDD manchmal auch als Test First Development bezeichnet.

In diesem Tutorial erfahren Sie mehr über

• Durchführen eines TDD-Tests
• TDD Vs. Traditionelles Testen
• Was ist Akzeptanz-TDD und Entwickler-TDD?
• Skalieren von TDD über Agile Model Driven Development (AMDD)
• Test Driven Development (TDD) Vs. Agile Model Driven Development (AMDD)
• Beispiel für TDD
• Vorteile von TDD

Durchführen eines TDD-Tests

Die folgenden Schritte definieren, wie ein TDD-Test durchgeführt wird:

1. Fügen Sie einen Test hinzu.
2. Führen Sie alle Tests aus und prüfen Sie, ob ein neuer Test fehlschlägt.
3. Schreiben Sie einige Code.
4. Führen Sie Tests und Refactor-Code aus.
5. Wiederholen Sie.

TDD-Zyklus definiert

1. Schreibe einen Test
2. Lass ihn laufen.
3. Ändere den Code Um es richtig zu machen, z. B. Refactor.
4. Vorgang wiederholen.

Einige Erläuterungen zu TDD:

• Bei TDD geht es weder um „Testen“. noch über „Design“.
• TDD bedeutet nicht „einige der Tests schreiben und dann ein System erstellen, das die Tests besteht.
• TDD bedeutet nicht“ viele Tests durchführen „. „

TDD vs. traditionelles Testen

Der TDD-Ansatz ist in erster Linie eine Spezifikationstechnik. Er stellt sicher, dass Ihr Quellcode bei der Bestätigung gründlich getestet wird Niveau.

• Bei herkömmlichen Tests werden bei einem erfolgreichen Test ein oder mehrere Fehler festgestellt. Es ist dasselbe wie bei TDD. Wenn ein Test fehlschlägt, haben Sie Fortschritte erzielt, weil Sie wissen, dass Sie das Problem beheben müssen.
• TDD stellt sicher, dass Ihr System tatsächlich die dafür definierten Anforderungen erfüllt. Dies hilft, Ihr Vertrauen in Ihr System zu stärken.
• In TDD liegt der Schwerpunkt mehr auf dem Produktionscode, der überprüft, ob das Testen ordnungsgemäß funktioniert. Bei herkömmlichen Tests liegt der Schwerpunkt mehr auf dem Design von Testfällen. Gibt an, ob der Test die ordnungsgemäße / nicht ordnungsgemäße Ausführung der Anwendung zur Erfüllung der Anforderungen anzeigt.
• In TDD erreichen Sie einen 100% igen Abdeckungstest. Im Gegensatz zu herkömmlichen Tests wird jede einzelne Codezeile getestet.
• Die Kombination von herkömmlichen Tests und TDD führt dazu, dass das System eher getestet als perfektioniert werden muss.
• In Agile Modeling (AM) sollten Sie „mit einem Zweck testen“. Sie sollten wissen, warum Sie etwas testen und auf welcher Ebene es getestet werden muss.

Was ist Akzeptanz-TDD und Entwickler-TDD?

Es gibt zwei TDD-Ebenen

1. Akzeptanz-TDD (ATDD): Mit ATDD schreiben Sie einen einzelnen Akzeptanztest. Dieser Test erfüllt die Anforderungen der Spezifikation oder das Verhalten des Systems. Schreiben Sie danach gerade genug Produktions- / Funktionscode, um diesen Abnahmetest zu erfüllen. Der Abnahmetest konzentriert sich auf das Gesamtverhalten des Systems. ATDD wurde auch als Behavioral Driven Development (BDD) bezeichnet.
2. Entwickler-TDD: Mit Entwickler-TDD schreiben Sie einen einzelnen Entwicklertest, d. h. einen Komponententest, und dann gerade genug Produktionscode, um diesen Test zu erfüllen. Der Unit-Test konzentriert sich auf jede kleine Funktionalität des Systems. Entwickler-TDD wird einfach als TDD bezeichnet.

   Das Hauptziel von ATDD und TDD besteht darin, detaillierte, ausführbare Anforderungen für Ihre Lösung auf Just-in-Time-Basis (JIT) festzulegen. JIT bedeutet, nur die Anforderungen zu berücksichtigen, die im System benötigt werden. Steigern Sie also die Effizienz.

Skalieren von TDD über agile modellgetriebene Entwicklung (AMDD)

TDD ist sehr gut in der detaillierten Spezifikation und Validierung. Es kann keine größeren Probleme wie das Gesamtdesign, die Verwendung des Systems oder die Benutzeroberfläche durchdenken.AMDD behebt die Probleme der agilen Skalierung, die TDD nicht hat.

Somit wird AMDD für größere Probleme verwendet.

Der Lebenszyklus von AMDD.

In der modellgetriebenen Entwicklung (MDD) werden umfangreiche Modelle vor dem erstellt Quellcode wird geschrieben. Welche wiederum haben einen agilen Ansatz?

In der obigen Abbildung repräsentiert jedes Feld eine Entwicklungsaktivität.

Das Vorstellen ist einer der TDD-Prozesse zum Vorhersagen / Vorstellen von Tests, die in der ersten Projektwoche durchgeführt werden. Das Hauptziel der Vorstellung ist es, den Umfang des Systems und die Architektur des Systems zu identifizieren. Für eine erfolgreiche Vorstellung werden allgemeine Anforderungen und Architekturmodelle erstellt.

Es ist der Prozess, bei dem keine detaillierte Spezifikation der Software / des Systems vorgenommen wird, sondern die Anforderungen der Software / des Systems untersucht werden, die die Gesamtstrategie des Projekts definieren.

1. Iteration 0: Vorstellung

Es gibt zwei Hauptunteraktivierungen.

1. Erste Anforderungen.

   Es kann mehrere Tage dauern, bis die allgemeinen Anforderungen und der Umfang des Systems ermittelt sind. Das Hauptaugenmerk liegt auf der Untersuchung des Nutzungsmodells, des anfänglichen Domänenmodells und des Benutzeroberflächenmodells (UI).

2. Erste architektonische Vorstellung.

   Es dauert auch mehrere Tage, um die Architektur des Systems zu identifizieren. Hier können Sie technische Anweisungen für das Projekt festlegen. Das Hauptaugenmerk liegt auf der Untersuchung von Technologiediagrammen, Benutzeroberflächenabläufen, Domänenmodellen und Änderungsfällen.

1. Iterationsmodellierung:

   Hier muss das Team die Arbeit planen, die für jede Iteration ausgeführt wird.

• Für jede Iteration wird ein agiler Prozess verwendet, dh während jeder Iteration wird ein neues Arbeitselement mit Priorität hinzugefügt.
• Zuerst mit höherer Priorität Arbeit wird berücksichtigt. Hinzugefügte Arbeitselemente können jederzeit neu priorisiert oder aus dem Elementstapel entfernt werden.
• Das Team erläutert, wie die einzelnen Anforderungen implementiert werden. Zu diesem Zweck wird die Modellierung verwendet.
• Die Modellanalyse und das Design werden für jede Anforderung durchgeführt, die für diese Iteration implementiert werden soll.

1. Modellsturm:

   Dies wird auch als Just-in-Time-Modellierung bezeichnet.

• An dieser Modellierungssitzung ist ein Team von 2/3 Mitgliedern beteiligt, die Probleme auf Papier oder Whiteboard diskutieren.
• Ein Teammitglied wird ein anderes fragen mit ihnen zu modellieren. Diese Modellierungssitzung dauert ungefähr 5 bis 10 Minuten. Wo sich Teammitglieder versammeln, um Whiteboard / Papier zu teilen.
• Sie untersuchen Probleme, bis sie die Hauptursache des Problems nicht mehr finden. Pünktlich, wenn ein Teammitglied das gewünschte Problem identifiziert Um dies zu beheben, wird er / sie schnell Hilfe von anderen Teammitgliedern in Anspruch nehmen.
• Andere Gruppenmitglieder untersuchen dann das Problem und dann fahren alle wie zuvor fort. Dies wird auch als Stand-up-Modellierung oder Kunden-QS-Sitzung bezeichnet .

1. Test Driven Development (TDD).

• Es fördert das Bestätigungstest Ihres Anwendungscodes und die detaillierte Spezifikation.
• Sowohl der Abnahmetest (detaillierte Anforderungen) als auch der Entwicklertest (Komponententest) sind Eingaben für TDD.
• TDD macht den Code einfacher und klarer. Dadurch kann der Entwickler weniger Dokumentation verwalten.

1. Überprüfungen.

• Dies ist optional. Es umfasst Code-Inspektionen und Modellüberprüfungen.
• Dies kann sein erfolgt für jede Iteration oder für das gesamte Projekt.
• Dies ist eine gute Option, um Feedback für das Projekt zu geben.

Test Driven Development (TDD) Vs. Agile Model Driven Development (AMDD)

Beispiel für TDD

In diesem Beispiel definieren wir ein Klassenkennwort. Für diese Klasse werden wir versuchen, die folgenden Bedingungen zu erfüllen.

Voraussetzung für die Annahme des Passworts:

• Das Passwort sollte zwischen 5 und 10 Zeichen lang sein.

Zuerst schreiben wir den Code das erfüllt alle oben genannten Anforderungen.

Szenario 1: Um den Test auszuführen, erstellen wir die Klasse PasswordValidator ();

Wir werden die Klasse TestPassword () ausführen.

Die Ausgabe wird wie unten gezeigt PASSIERT.

Ausgabe:

Szenario 2: Hier können wir In der Methode TestPasswordLength () muss keine Instanz der Klasse PasswordValidator erstellt werden. Instanz bedeutet, ein Klassenobjekt zu erstellen, um auf die Mitglieder (Variablen / Methoden) dieser Klasse zu verweisen.

Wir werden die Klasse PasswordValidator pv = new PasswordValidator () aus dem Code entfernen. Wir können die isValid () -Methode direkt über PasswordValidator aufrufen. IsValid („Abc123“).(Siehe Bild unten)

Wir überarbeiten (Code ändern) wie folgt:

Szenario 3: Nach dem Refactoring zeigt die Ausgabe den Status „Fehlgeschlagen“ an (siehe Abbildung unten). Dies liegt daran, dass wir die Instanz entfernt haben. Es gibt also keinen Verweis auf die nicht statische Methode isValid ().

Also Wir müssen diese Methode ändern, indem wir „statisches“ Wort vor Boolean als öffentlichen statischen Booleschen Wert isValid (String password) hinzufügen. Refactoring Class PasswordValidator (), um den obigen Fehler zu entfernen und den Test zu bestehen.

Ausgabe:

Nach Änderungen an der Klasse PassValidator () Wenn wir den Test ausführen, wird die Ausgabe wie unten gezeigt PASSIERT.

Vorteile von TDD

• Früher Fehler Benachrichtigung.

  Entwickler testen ihren Code, aber in der Datenbankwelt besteht dies häufig aus manuellen Tests oder einmaligen Skripten. Mit TDD erstellen Sie im Laufe der Zeit eine Reihe automatisierter Tests, die Sie und jeder andere Entwickler nach Belieben erneut ausführen können.

• Besser gestalteter, sauberer und erweiterbarer Code.
  • Es hilft zu verstehen, wie der Code verwendet wird und wie er mit anderen Modulen interagiert.
  • Dies führt zu einer besseren Entwurfsentscheidung und einem besser wartbaren Code.
  • TDD Ermöglicht das Schreiben von kleinerem Code mit einer einzigen Verantwortung anstelle von monolithischen Prozeduren mit mehreren Verantwortlichkeiten. Dies erleichtert das Verständnis des Codes.
  • TDD erzwingt außerdem, nur Produktionscode zu schreiben, um Tests basierend auf Benutzeranforderungen zu bestehen.
• Vertrauen in Refactor
  • Wenn Sie Code umgestalten, kann es zu Unterbrechungen des Codes kommen. Mit einer Reihe automatisierter Tests können Sie diese Unterbrechungen vor der Veröffentlichung beheben. Die richtige Warnung wird ausgegeben, wenn bei Verwendung automatisierter Tests Unterbrechungen festgestellt werden.
  • Die Verwendung von TDD sollte zu schnellerem, erweiterbarem Code mit weniger Fehlern führen, die mit minimalen Risiken aktualisiert werden können.
• Gut für Teamarbeit

  Wenn kein Teammitglied vorhanden ist, können andere Teammitglieder den Code problemlos abrufen und bearbeiten. Es unterstützt auch den Wissensaustausch und macht das Team dadurch insgesamt effektiver.

• Gut für Entwickler

  Obwohl Entwickler mehr Zeit für das Schreiben von TDD-Testfällen aufwenden müssen, dauert das Debuggen und Entwickeln neuer Funktionen viel weniger. Sie schreiben saubereren, weniger komplizierten Code.

Zusammenfassung:

• TDD steht für testgetriebene Entwicklung. Es handelt sich um einen Prozess zum Ändern des Codes, um einen zuvor entworfenen Test zu bestehen.
• Der Schwerpunkt liegt eher auf Produktionscode als auf Testfalldesign.
• Testgesteuerte Entwicklung ist ein Prozess zum Ändern des Codes, um einen zuvor entworfenen Test zu bestehen.
• In der Softwareentwicklung wird er manchmal als „Test First Development“ bezeichnet.
• TDD umfasst das Refactoring eines Codes, dh das Ändern / Hinzufügen einer gewissen Menge an Code zum vorhandenen Code, ohne das Verhalten des Codes zu beeinflussen.
• TDD Bei Verwendung wird der Code klarer und einfacher verstehen.

Dieser Artikel wurde von Kanchan Kulkarni

verfasst