Das äußerst empfehlenswerte Buch "Pragmatic Unit Testing in Java 8
with JUnit" wird im Buchclub in der achtundneunzigsten Episode des
Anwendungsentwickler-Podcasts besprochen. TL;DR Mit "Pragmatic Unit
Testing in Java 8 with JUnit" arbeite ich bereits im ersten
Ausbildungsjahr, sobald du erste Java-Kenntnisse hast. Das Buch
führt dich Schritt für Schritt an automatisierte Tests heran und
gibt dir Merkhilfen, mit denen du passende Testfälle findest. Du
erfährst außerdem, wie Tests das Refactoring absichern und mit
Mocking sowie testgetriebener Entwicklung zusammenhängen. Viele der
beschriebenen Prinzipien lassen sich auf andere Programmiersprachen
übertragen. Kapitelmarken [00:00:00] Einstieg in den Buchclub
[00:01:22] Das Buch im ersten Ausbildungsjahr [00:03:20]
Verständlichkeit und Erfahrungen mit IT-Azubis [00:06:07] Die vier
Teile des Buchs [00:06:42] Warum automatisierte Tests zum
Entwickeln gehören [00:07:53] JUnit in der Entwicklungsumgebung
einrichten [00:08:48] Erste Testfälle und der JUnit-Testablauf
[00:09:38] Englische Fachliteratur und Fachbegriffe [00:10:41]
Assertions, Hamcrest und Exceptions [00:12:52] Tests strukturieren
und als Dokumentation lesen [00:14:08] Merkhilfen und ihre
Prüfungsrelevanz [00:15:00] FIRST: Eigenschaften guter Unit-Tests
[00:17:01] Right BICEP: Geeignete Testfälle finden [00:19:08]
CORRECT: Grenzfälle berücksichtigen [00:20:33] Refactoring mit
vorhandenen Tests [00:22:01] SOLID und Single Responsibility
[00:22:48] Mocks, Stubs und Mockito [00:25:37] Testcode
refaktorisieren [00:27:04] Test-Driven Development und
Softwareentwurf [00:28:06] Nebenläufigen Code und Datenbankzugriffe
testen [00:29:24] Tests im Projektalltag, Continuous Integration
und Code Coverage [00:30:44] Testprinzipien auf andere
Programmiersprachen übertragen [00:31:57] Weiterführende
Literaturempfehlungen [00:32:59] Fragen für Episode 100 [00:33:42]
Newsletter und Checklisten für die Projektarbeit Inhalt Das Buch
ist meine absolute Empfehlung für jeden Azubi. Meine eigenen Azubis
lesen es schon direkt im 1. Ausbildungsjahr, kurz nachdem sie ihre
ersten Java-Aufgaben gelöst haben. Für mich gehört Unit-Testing
einfach mit zur Ausbildung dazu und man kann gar nicht früh genug
damit anfangen. Bislang waren die Rückmeldungen zum Buch sehr
positiv. Alle Azubis haben es gut verstanden und konnten die
Inhalte auch direkt in die Praxis umsetzen. Wir haben uns für das
Durcharbeiten meistens ca. 2 Wochen Zeit genommen. Das Buch ist
sehr verständlich geschrieben, enthält tolle Beispiele - und zwar
endlich einmal auch in Java 8 - und ist dank des geringen Umfangs
von knapp 200 Seiten sehr schnell zu lesen. Die Bücher aus dem
Hause Pragmatic Programmers kann man eigentlich ausnahmslos
empfehlen. Sie haben u.a. auch das "Standardwerk" zum Einstieg in
Ruby on Rails* oder POODR* veröffentlicht. Pragmatic Unit Testing
in Java 8 with JUnit* reiht sich - meiner Meinung nach - hier
perfekt ein. Grundlagen Das Buch führt auf knapp 50 Seiten zunächst
in das Thema Unit-Tests ein und erklärt die Funktionsweise von
JUnit. Schritt für Schritt wird ein lauffähiger Unit-Test erstellt
und dabei werden auch die neuen Entwicklungen in JUnit
berücksichtigt - also keine alten test*-Methoden mehr, sondern
vernünftige Annotations. Dabei wird auch gleich das berühmte AAA
zum Aufbau der Test-Methoden erläutert und @Before und @After
eingeführt. Ich kann mir in Zukunft meine eigenen Erklärungen
sparen und lasse meine Azubis diese ersten 50 Seiten lesen. Danach
sollten sie alle wichtigen Begriffe und Ideen zum Thema Unit-Tests
und Junit kennen :-) Das Buch startet mit einem schönen Überblick,
warum man überhaupt testen sollte. Außerdem enthält es
Schritt-für-Schritt-Anleitungen, um Unit-Test mit Eclipse zu
erstellen. Im Anhang wird aber auch auf IntelliJ und Netbeans
eingegangen, sodass man unabhängig von der konkreten IDE mitmachen
kann. Die zu testenden Codebeispiele werden ebenfalls ausführlich
erläutert. Es können also auch absolute Anfänger mitarbeiten. Als
nächstes werden Assertions im Detail vorgestellt. Auch die
Hamcrest-Matcher gehören dazu, um sprechende Tests zu schreiben,
und die unterschiedlichen Möglichkeiten z.B. mittels Annotationen
werden vorgestellt. Akronyme Der nächste Teil (ca. 40 Seiten) ist
dann ganz den "Mnemonics" gewidmet. Das hilft in der Praxis, ist
aber nicht prüfungsrelevant. FIRST: fast, isolated, repeatable,
self-validating, timely. Right-BICEP: right, boundary conditions,
inverse relationships, cross-checking, error conditions,
performance. CORRECT: conformance, ordering, range, reference,
existence, cardinality, time. Anhand dieser einprägsamen Akronyme
geht Jeff Langr die Eigenschaften guter Unit-Tests durch und bringt
den Lesern damit gleich bei, worauf sie bei der Programmierung
ihrer Tests achten sollten, um keine falsche Sicherheit zu
erreichen. Design Im dritten Teil (ca. 60 Seiten) widmet sich das
Buch den "großen" Themen Refactoring und Mock-Objekte. Es wird
intensiv geschildert, warum Refactoring wichtig ist und warum
Unit-Tests unabdingbare Voraussetzung für das Refactoring des
eigenen Codes sind. Außerdem wird erklärt, wofür man Mock-Objekte
braucht und wann man sie besser nicht einsetzen sollte. Das Kapitel
wird abgerundet mit einer stimmigen Liste von Test Smells, die auf
ein nötiges Refactoring des Test-Codes hindeuten. Somit wird dem
Leser gleich an die Hand gegeben, dass auch der Test-Code den
gleichen Qualitätskriterien genügen sollte wie der Produktivcode.
Sogar ein Kurzausflug in die SOLID-Prinzipien ist enthalten. Als
nächstes werden Mock-Objekte vorgestellt und die Unterschiede
zwischen Stubs und Mocks erläutert. Der Teil schließt mit einem
Kapitel zum Refactoring des Test-Codes. Das ist ein Vorgang, der zu
jedem testgetriebenen Entwicklungsprozess gehören sollte. Big
Picture Der letzte Teil des Buchs (ca. 50 Seiten) geht dann konkret
auf Test Driven Development ein und auch auf das Testen schwieriger
Probleme wie zum Beispiel Multithreading und Datenbanken. Ganz zum
Schluss werden dann auch noch weitere wichtige Begriffe erläutert
wie z.B. Continuous Integration und Code Coverage. Es ist also auch
etwas für fortgeschrittene Tester dabei. Fazit Ich konnte Pragmatic
Unit Testing in Java 8 with JUnit* gut von vorn bis hinten
durchlesen. Es ist durchgängig interessant geschrieben und enthält
viele lehrreiche Tipps. Es ist daher meine Empfehlung für alle
Azubis (oder auch Ausbilder ;-) ), die sich dem Thema Unit-Tests
widmen möchten (oder müssen). Es gehört für mich ab sofort zur
Standardbibliothek für meine Azubis. Tipp für Ausbilder Ich würde
neuen Auszubildenden das Buch nach ca. drei Monaten Einarbeitung
zur Lektüre empfehlen. Dann sollten sie bereits einige (negative)
Erfahrungen mit der Programmierung gemacht haben und schnell
einsehen, warum automatische Tests so wichtig sind. Die
Java-Vorkenntnisse sollten dann auch ausreichen, um das Buch ohne
Probleme zu verstehen. Literaturempfehlungen Logisch, oder? :-) *
Die perfekte Ergänzung für einen noch tieferen Einstieg in das
Testen deiner Software: * Links Permalink zu dieser Podcast-Episode
RSS-Feed des Podcasts JUnit Unit Testing with JUnit - Tutorial
JUnit Cheat Sheet Zusammenfassung Das Buch in der IT-Ausbildung Mit
meinen IT-Azubis arbeite ich "Pragmatic Unit Testing in Java 8 with
JUnit" durch, sobald sie erste kleine Java-Programme geschrieben
haben. Das 2015 erschienene Buch umfasst rund 200 Seiten und
berücksichtigt Java-8-Funktionen wie Lambda-Ausdrücke. Etwas
Programmiererfahrung reicht für den Einstieg aus. Anhand
ausführlich erklärter Beispiele kannst du sowohl den getesteten
Code als auch die Tests nachvollziehen. Meine IT-Azubis kamen mit
ihrem Vorwissen gut zurecht. Von den 14 Kapiteln sind etwa zehn
schon im ersten Ausbildungsjahr verständlich; Themen wie
nebenläufiger Code brauchen weitere Vorkenntnisse. Nach dem Lesen
bespreche ich mit meinen IT-Azubis offene Fragen und prüfe, was sie
gelernt haben. Ich empfehle dir die englische Ausgabe, weil du
englische Fachbegriffe als Fachinformatiker:in
Anwendungsentwicklung im Arbeitsalltag brauchst. Einige davon
können auch in der Prüfung vorkommen. Teil 1: Erste Unit-Tests
schreiben Durch automatisierte Tests prüfst du, ob dein Programm
das erwartete Verhalten zeigt. Bei späteren Änderungen helfen dir
Regressionstests, Fehler zu erkennen, die durch das Überarbeiten
des Codes entstehen. Das Buch zeigt mit Screenshots, wie du JUnit
in Eclipse einrichtest. Für IntelliJ und NetBeans gibt es
Anleitungen im Anhang. Die behandelten Testprinzipien gelten
unabhängig von deiner Entwicklungsumgebung. An einer Beispielklasse
lernst du, welche Methoden und Pfade durch den Code du testen
kannst. Dabei begegnen dir auch die JUnit-Methoden Before und
After, die vor beziehungsweise nach jedem Test laufen. Damit
bereitest du einen Test vor und räumst anschließend wieder auf. Mit
Assertions vergleichst du erwartete Werte mit den Ergebnissen
deines Codes. Hamcrest-Matcher machen solche Vergleiche wie
englische Sätze lesbar. Dadurch ist leichter zu erkennen, welcher
Wert erwartet wird und welcher aus dem Programm stammt. Wenn du
diese Werte vertauschst, werden Fehlermeldungen schwerer
verständlich. Auch Exceptions gehören zu den Testfällen: Du prüfst
beispielsweise, ob bei einem bestimmten Fehlerzustand die erwartete
Exception auftritt. Tests strukturieren und als Dokumentation lesen
Mit Arrange, Act, Assert (AAA) gliederst du einen Test in die
Schritte Vorbereiten, Ausführen und Prüfen. Dieses Wissen habe ich
bereits in Prüfungen abgefragt. Das Buch behandelt außerdem, wie
die getestete Klasse und ihre Testklasse zusammenarbeiten und
welche Rolle die Sichtbarkeit von Methoden spielt. An sprechenden
Testnamen und den beschriebenen Fällen kannst du ablesen, wie sich
der Code fachlich verhalten soll. Tests helfen dir dadurch auch,
eine fremde Anwendung zu verstehen. Teil 2: Passende Testfälle
finden Wenn du mit dem Testen anfängst,...
Kommentare (0)
Melde dich an, um einen Kommentar zu schreiben.