Was ist Unit-Testing?

Hallo zusammen, wir haben mit meinem Teamkollegen Berkin Ergürbüz einen kleinen Artikel über unsere Erfahrungen im Unit Testing geschrieben .

Viel Spaß beim Lesen euch allen

Unit-Tests sind eine Methode zur Überprüfung des Verhaltens der kleinsten testbaren Softwareeinheit, indem sie isoliert von all ihren Abhängigkeiten ausgeführt wird. Mithilfe von Unit-Tests können wir das Verhalten des von uns geschriebenen Codes überprüfen, indem wir Code erneut schreiben. Da es sich um den kleinsten testbaren Teil der Software handelt, werden Unit-Tests von Softwareentwicklern entwickelt.

WAS IST TDD?

Testgetriebene Entwicklung ist eine Praxis, von der wir in den letzten Jahren häufig gehört haben und die sich zunehmend verbreitet. Grundsätzlich heißt es, dass der Test geschrieben werden muss, bevor der Anwendungscode geschrieben wird.

Warum schreiben wir Unit-Tests und was bringt uns das?

Die Möglichkeit, Unit-Tests schreiben zu können, hat viele Vorteile, 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 die Entwicklung mit dem Schreiben von Unit-Tests. Dieser Prozess wird uns dazu veranlassen, stärker über die Funktion nachzudenken, die wir entwickeln werden, und es uns ermöglichen, uns nur auf die Anforderungen zu konzentrieren. Wenn wir direkt mit dem Code 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, indem wir uns nur auf die Anforderungen konzentrieren.

Einer der Vorteile eines Unit-Test-Autors besteht darin, dass er die Fehler erkennen kann, die während der Entwicklungsphase auftreten können, und dass er die Möglichkeit hat, diese Fehler zu korrigieren. Je mehr Zeit zwischen dem Auftreten eines Fehlers und seiner Erkennung vergeht, desto höher sind die Kosten für die Behebung des Fehlers. Mithilfe von Unit Test können wir verhindern, dass diese Kosten steigen.

Unsere Software befindet sich in einer sich ständig weiterentwickelnden und verändernden Struktur. Aus diesem Grund müssen wir Änderungen an unseren Methoden vornehmen, die wir geschrieben haben. Wenn die vorgenommenen Verbesserungen oder Änderungen einen unerwarteten Fehler verursachen, wird dieser Fehler von den Tests, die wir zuvor für diesen Code geschrieben haben, erkannt und wir können diese Situation während der Entwicklungsphase erkennen und die notwendigen Maßnahmen ergreifen. Wenn wir einer Klasse, deren Tests geschrieben werden, eine neue Funktion hinzufügen, konzentrieren wir uns normalerweise auf die Tests der hinzugefügten Funktion. Selbst wenn diese neue Funktion ordnungsgemäß funktioniert, kann es dazu führen, dass diese Klasse eine Funktion nicht erfüllt, die sie in ihrem aktuellen Zustand erfüllen kann. Es wird uns nicht immer möglich sein, die vorgegebenen Fälle 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. Wenn wir diese Unit-Tests neu anordnen müssen, ist dies tatsächlich der Buchstabe „O“ des SOLID-Prinzips, d. h . unsere Methode ist offen für Entwicklung und verstößt gegen das Seinsprinzip Für Änderungen geschlossen.

Das Schreiben von Unit-Tests fördert die Reduzierung der Codekomplexität und das Schreiben von Code mit besserer Qualität. Es wird sehr schwierig sein, Tests für Methoden zu schreiben, die komplex sind und viel Logik enthalten.

Um testbaren Code zu schreiben, können wir unseren Code in kleineren Methoden und mit nur einer Aufgabe in jeder Methode schreiben. Mit der Zeit werden diese Ansätze es uns ermöglichen, eine Softwareentwicklungskultur für uns zu schaffen.

Während wir unsere Codes testen, müssen wir vollständig von externen Abhängigkeiten isoliert sein, da das Thema, an dem wir interessiert sind, der Code in der Einheit ist, die wir testen möchten. Das Verhalten externer Abhängigkeiten beschäftigt uns nicht. Die Notwendigkeit, unabhängig und isoliert von den Codeteilen zu testen, von denen die zu testenden Einheiten abhängen, ermöglicht es uns, diese Einheiten zu abstrahieren und den Code in kleinen wiederverwendbaren Teilen zu entwerfen. Als Beispiel für externe Abhängigkeiten; Methoden, externe Quellendpunkte usw.

Indem wir testbaren Code schreiben, beginnen wir tatsächlich, die SOLID-Prinzipien stärker anzuwenden.

Wie schreiben wir einen Unit-Test?

Die Stufen des TDD-Ansatzes sind wie folgt;

1. Der Test wird entwickelt.

2. Der Test schlägt fehl.

3. Die Codierung erfolgt so, dass der Test erfolgreich ist.

4. Der Test ist erfolgreich.

5. Der Code wird überarbeitet.

Bevor Sie mit diesen Schritten beginnen, müssen Sie die Klassen und Methoden deklarieren, für die wir den Test schreiben. Wir müssen zuerst den Test der Methoden schreiben, dann feststellen, dass dieser Test fehlschlägt, die entsprechende Methode codieren und den Prozess fortsetzen, nachdem der Test erfolgreich ist.

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. Unsere Entwicklung für den Erfolg einer Testmethode kann dazu führen, dass andere Tests fehlschlagen. In diesem Fall schließen wir den Prozess durch Umgestaltung des Codes ab, nachdem die erneuten Tests erfolgreich waren.

Abgesehen vom TDD-Ansatz beginnen wir mit dem Schreiben, nachdem wir die Unit-Tests-Methode im traditionellen Softwareentwicklungsprozess geschrieben haben.

In Summe;

Letztendlich sollte der Sinn von Unit-Tests nicht nur darin bestehen, zu sagen, dass wir Unit-Tests in unserem Projekt haben. Das Schreiben von Unit-Test-Methoden, die ihren Zweck wirklich erfüllen, wird uns viele Vorteile bringen. Wenn wir also versuchen, testbaren Code zu schreiben, werden wir eine Kultur der Codeentwicklung von besserer Qualität erreichen. Es soll dazu dienen, Fehler frühzeitig zu erkennen, indem es vorhersagt, wie sich eine Verbesserung unseres Codes auf andere Verhaltensweisen auswirkt und wo wir Fehler bekommen können.

In unserem nächsten Artikel werden wir versuchen zu erklären, wie wir Unit-Test-Methoden und Beispiele für verwandte Prozesse entwickeln. Bis bald

Unsere E-Mail-Adressen für alle Ihre Vorschläge und Rückmeldungen;

Berkin – [email protected] Fatmagul – [email protected]

Englische Version des Artikels:

https:///@berkinergurbz/what-is-the-unit-test-4bc4178cdd30