Was ist der Unit-Test?
Hallo zusammen, wir haben mit meinem Teamkollegen Fatmagul Polat einen kleinen Artikel über unsere Erfahrungen im Unit Testing geschrieben . Viel Spaß beim Lesen :)
Unit-Tests sind eine Methode, die das Verhalten einer Software überprüft, indem sie isoliert von allen Abhängigkeiten ihrer kleinsten Einheit ausgeführt wird. Mithilfe von Unit-Tests können wir das Verhalten des von uns geschriebenen Codes überprüfen. Da es sich um den kleinsten testbaren Teil der Software handelt, werden Unit-Tests von Entwicklern entwickelt.
Was ist TDD?
Testgetriebene Entwicklung ist eine Praxis, von der wir in den letzten Jahren oft gehört haben und die sich allmählich verbreitet. Im Grunde sagt er, dass sein Test geschrieben werden muss, bevor der Anwendungscode geschrieben wird.
Warum entwickeln wir Unit-Tests und Vorteile?
Es gibt viele Vorteile, Unit-Tests schreiben zu können, wir werden versuchen, darüber zu sprechen.
Die Entwicklung mit dem TDD-Ansatz erfordert eine gründliche Prüfung der Anforderungen oder des Designs, bevor Funktionscode geschrieben wird. Wir beginnen damit, Unit-Tests für die Entwicklung zu schreiben. Dieser Prozess führt dazu, dass wir intensiver über die Funktionen nachdenken, die wir entwickeln werden, und können uns nur auf die Anforderungen konzentrieren. Wenn wir direkt mit dem Codieren beginnen, kann es für uns etwas schwieriger sein, uns während der Entwicklung auf das Design und den Ablauf des Codes zu konzentrieren . Dieser Prozess wird uns helfen, weniger Fehler zu machen und einfacheren und saubereren Code zu schreiben, wobei wir uns nur auf die Anforderungen konzentrieren.
Ein Vorteil des Schreibens von Unit-Tests besteht darin, dass Sie die Fehler erkennen können, die in der Entwicklungsphase auftreten können, und die Möglichkeit haben, diese zu korrigieren. Je mehr Zeit zwischen dem Auftreten eines Fehlers und seiner Entdeckung vergeht, desto höher sind die Kosten für die Behebung des Fehlers. Unit Test wird uns helfen, diesen Kostenanstieg zu verhindern.
Unsere Software entwickelt sich ständig weiter und verändert sich, daher müssen wir Änderungen an den von uns geschriebenen Methoden vornehmen. Wenn Verbesserungen oder Änderungen einen unerwarteten Fehler verursachen, wird dieser Fehler durch Tests, die wir zuvor für diesen Code geschrieben haben, erfasst und wir können dies erkennen und in der Entwicklungsphase Maßnahmen ergreifen. Wenn wir einer Klasse, deren Tests geschrieben werden, eine neue Funktion hinzufügen, konzentrieren wir uns normalerweise auf das Testen der hinzugefügten Funktion. Selbst wenn diese neue Funktion ordnungsgemäß funktioniert, kann es dazu führen, dass diese Klasse eine Funktion nicht ausführt, die sie derzeit ausführen kann. Wir werden nicht immer in der Lage sein, vorher festgelegte Cashewnüsse zu testen. In solchen Fällen schützen vorab geschriebene Tests vorhandener Funktionen vor unerwünschten oder übersehenen Fehlern.
Jede hinzugefügte Funktion führt dazu, dass unsere bestehenden Unit-Tests fehlschlagen, und wenn wir diese Unit-Tests neu anordnen müssen, verstößt dies tatsächlich gegen den Buchstaben „O“ der SOLID-Prinzipien, d. h. unsere Methode ist nicht offen für Änderungen.
Das Schreiben eines Komponententests ermutigt Sie, die Komplexität des Codes zu reduzieren und Code von besserer Qualität zu schreiben. Es wird sehr schwierig sein, den Test für Methoden zu schreiben, die komplex sind und viel Logik enthalten.
Dadurch können wir unseren Code in kleinere Methoden schreiben, um testbaren Code zu schreiben, mit nur einer Aufgabe in jeder Methode. Mit der Zeit werden diese Ansätze bei uns eine Kultur der Softwareentwicklung schaffen.
Beim Testen unserer Codes müssen wir vollständig von externen Abhängigkeiten isoliert sein, denn was uns interessiert, ist der Code in der Einheit, die wir testen möchten. Das Verhalten externer Abhängigkeiten interessiert uns nicht. Die Notwendigkeit, unabhängig und isoliert von den Codeteilen zu testen, von denen die von uns geschriebenen Einheiten abhängig sind, ermöglicht es uns, diese Einheiten zu abstrahieren und Code in wiederverwendbare kleine Teile zu entwerfen. Beispiele für externe Abhängigkeiten sind Methoden, mit denen Operationen in die Datenbank aufgerufen werden, Outsourcing-Endpunkte usw.
Indem wir testbaren Code schreiben, beginnen wir tatsächlich, mehr SOLID-Prinzipien anzuwenden.
Gut geschriebene Komponententests enthalten gute Beispiele dafür, welche Ausgaben erfolgen, wenn der von uns untersuchten Funktion oder Komponente welche Eingaben gegeben werden. Es ermöglicht uns zu sehen, wie der getestete Code als Happy Path funktioniert, mit Beispielen für die Endszenarien. Wir können leicht verstehen, wie unsere Methoden reagieren, indem wir Unit-Tests untersuchen. Diese Tests können dokumentspezifisch für das Projekt sein. Durch die Untersuchung der Tests kann es erheblich hilfreich sein, die Funktionsweise der Methoden zu verstehen.
Wie entwickelt man einen Unit-Test?
Die Schritte im TDD-Ansatz sind wie folgt;
1. Unit-Test entwickeln.
2. Der Test schlägt fehl.
3. Der Test ist auf Erfolg codiert.
4. Der Test wird erfolgreich sein.
5. Der Code wird überarbeitet.
Bevor Sie mit diesen Schritten beginnen, müssen Sie die Klassen und Methoden deklarieren, deren Test wir schreiben werden. Zuerst sollten wir den Test der Methoden schreiben und dann feststellen, dass dieser Test fehlgeschlagen ist, die entsprechende Methode codieren und den Prozess fortsetzen, nachdem der Test erfolgreich war.
Nachdem wir diese Prozesse für unsere vorhandenen Methoden abgeschlossen haben, führen wir alle unsere Tests durch und erwarten, dass unsere Testmethoden erfolgreich funktionieren. Die Verbesserung, die wir vornehmen, damit eine Testmethode erfolgreich ist, kann dazu führen, dass andere Tests fehlschlagen. In diesem Fall werden wir den Code umgestalten und den Vorgang abschließen, nachdem die Tests erneut erfolgreich waren.
Neben dem TDD-Ansatz beginnen wir mit dem Schreiben von Unit-Test-Methoden im traditionellen Softwareentwicklungsprozess.
Um zusammenzufassen;
Letztendlich sollte der Zweck von Unit-Tests nicht nur darin bestehen, zu sagen, dass wir Unit-Tests in unserem Projekt haben. Das Schreiben von Unit-Testing-Methoden, die unseren Zweck wirklich erfüllen, wird uns viele Dinge bringen. Auf diese Weise werden wir eine Kultur der Codeentwicklung von besserer Qualität erreichen, indem wir versuchen, testbaren Code zu schreiben. Es soll uns helfen, Fehler im frühesten Stadium zu erkennen, indem es antizipiert, wie sich eine Verbesserung unseres Codes auf andere Verhaltensweisen auswirkt und wo Fehler auftreten könnten.
In unserem nächsten Artikel werden wir versuchen zu erklären, wie wir Unit-Test-Methoden entwickeln und die damit verbundenen Prozesse anhand von Stichproben erklären. Bis bald
Unsere E-Mail-Adressen für Rückmeldungen und Vorschläge:
Berkin – [email protected] Fatmagül – [email protected]
Link zum türkischen Artikel:
![Was ist überhaupt eine verknüpfte Liste? [Teil 1]](https://post.nghiatu.com/assets/images/m/max/724/1*Xokk6XOjWyIGCBujkJsCzQ.jpeg)
