earlybirdhw2015 Hier klicken Jetzt Mitglied werden lagercrantz Cloud Drive Photos UHD TVs Learn More praktisch Kühlen und Gefrieren Fire HD 6 Shop Kindle Sparpaket Autorip SummerSale

Kundenrezensionen

11
4,5 von 5 Sternen
5 Sterne
9
4 Sterne
1
3 Sterne
0
2 Sterne
0
1 Stern
1
Ihre Bewertung(Löschen)Ihre Bewertung


Derzeit tritt ein Problem beim Filtern der Rezensionen auf. Bitte versuchen Sie es später noch einmal.

5 von 7 Kunden fanden die folgende Rezension hilfreich.
am 24. Dezember 2013
Das Buch erzählt die Geschichte von JUnit 3 wie die meisten wahrscheinlich kennen. Dieser Teil liest sich leicht und dient dem Grundverständnis für das Folgende. Richtig interessant ist Kapitel 3, in dem es um JUnit 4 geht. Jeder, der seit Jahren JUnit verwendet, sich aber nicht mit den neuen Features von JUnit 4 beschäftigt hat, muss das lesen. Ich habe gleich drei der neuen Features in meinem Projekt verwenden können, um die Tests zu verbessern. Rules sind so ein Thema.

Zwar findet man alles auch irgendwie bei Google, aber da JUnit schon zehn Jahre alt ist, sind darunter auch immer viele veraltete Suchergebnisse. In diesem Buch ist alles auf dem neuesten Stand und aus einem Guss.

Schön ist auch, dass der Verlag ein deutsches Buch herausgebracht hat. Denn auf Englisch gibt es, anders als sonst, kein vergleichbar aktuelles Buch zu JUnit 4.

Die hinteren Kapitel habe ich nur überflogen, weil sie eigentlich nicht zum Titel es Buches - JUnit - passen und weil ich mich damit genügend auskenne. Da geht es um Test-driven Developement, Mock-Objekte und andere mit dem Testen verwandete Themen. Das hätte nicht sein müssen, aber ich verstehe schon, dass der Teil über JUnit 4 alleine nicht ausreicht für ein Buch. Wer diese Themen sucht, wird da sicher gut bedient.

Also, die ersten 100 Seiten sind wirkich Zucker und verdienen volle 5 Sterne. Kaufempfehlung!
0KommentarWar diese Rezension für Sie hilfreich?JaNeinSenden von Feedback...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte versuchen Sie es später noch einmal.
Missbrauch melden
5 von 7 Kunden fanden die folgende Rezension hilfreich.
am 23. November 2013
... für Einsteiger in JUnit und vermutlich auf für Entwickler, die bereits damit vertraut sind. Auch das Kapitel über Mockito ist für Neulinge mit dieser Technik lesenswert. Man bekommt beim Lesen richtig Lust darauf, das gelerne gleich in die Tat umzusetzen.
Einzig eine Downloadmöglichkeit für die Beispiele fehlt mir.
0KommentarWar diese Rezension für Sie hilfreich?JaNeinSenden von Feedback...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte versuchen Sie es später noch einmal.
Missbrauch melden
1 von 2 Kunden fanden die folgende Rezension hilfreich.
am 19. April 2015
Seit meiner Schulzeit, die ich in einer kaufmännischen Sekundar-Stufe verbringen durfte, hat mich der Computer und besonders dessen Programmierung fasziniert. Durch Bücher und dem aufkommenden Internet hab ich mir so einige Programmiersprachen (u.a. Java, C/C++, Python, ...) selber beigebracht, die ich letzten Endes auch im Studium der Wirtschaftsinformatik angewendet und weiter vertieft habe. Seit wenigen Jahren bin ich nun auch professionell als Software-Engineer tätig und habe so zwangsläufig mit softwaregesteuerten Tests der produzierten Klassen und Methoden zu tun. Auf der Uni war Software-Testen zwar ein Fach, jedoch eher stiefmütterlich behandelt, sodass man zwar den Sinn dahinter mitbekam aber eher als nice-2-have abgestempelt hat.

Im professionellen Umfeld kommt den Tests jedoch eine viel größere Bedeutung zu, da ganze Software-Releases davon abhängig sind ob die Tests grün sind oder nicht. In dem Startup-Unternehmen in dem ich momentan tätig bin, wird "Unit-Test" sehr weitläufig verstanden. Hier findet man neben (wenigen) klassischen Unit-Tests auch sehr viele Integration-Tests (Camel & Spring-lastiges Framework) wie auch ein paar End-To-End Tests. Um die Build-Time vorallem der Integration-Tests zu reduzieren hab ich nach geeigneten Büchern zum Software-Testen gesucht und bin schließlich bei diesem Buch hier gelandet, welches mich positiv überrascht hat, da gute deutschsprachige Bücher im Bereich Software-Entwicklung leider eher Mangelware sind.

Vorallem die Bereiche über custom Hamcrest-Matcher, paralleles Testing und den AAA-Ansatz um in sich abgeschlossene Tests, die leicht nachvollzogen werden können ohne in zig (vererbten) Klassen herum zu springen haben meine Testmethoden auf ein ganz neues Level gebracht. Das viele Test-Examples aus einigen Open-Source Frameworks stammen hat mich persönlich nicht gestört, da es vielmehr um die Vermittlung und Veranschaulichung des erwähnten Konzeptes geht. Die Bad-Case Examples hätte man ev. sogar noch etwas ausbauen können, da es hier wohl mehr als genügend Material gibt.

Warum ich das Buch mit 4/5 bewerte liegt an den folgenden Punkten, die für mich etwas zu kurz kamen:

*) Gerade wenn man Spring-lastige Komponenten testen möchte muss man hier entweder einen Spring-Context mit hochfahren (langsam) oder einen anderen Weg finden, die durch Spring injecteten Werte in die Instanz zu bekommen. Es wurde im Buch zwar PowerMockito erwähnt, ebenso ein verständliches Beispiel anhand einer JavaMailFacade Klasse gezeigt, jedoch das "Injecten" von Objekten in private oder static Felder (ohne dafür jetzt extra bestehende Klassen um public-accessible getter/setter zu erweitern) nicht näher erwähnt. Hier hätte ich mir ein kurzes Beispiel für Whitebox.setInternalState(mockObject, privateFieldName, valueToInject); gewünscht. Ebenso wie man mittels Powermock von void-Methoden zurückgeworfene Exceptions testen kann (zB: doThrow(exception).when(mockObject).methodName(methodParameter))

*) Mich hat das Konzept von TDD (noch) nicht wirklich überzeugt. Für mich persönlich ist TDD nur in bestimmten Situationen anwendbar, zB wenn ich eine konkrete Anforderung bekomme, dass eine Methode zu implementieren ist die für Parameter A und B X zurückliefert bzw. Y in diesem Fall oder Z in den anderen Fällen. Wenn ich jedoch als Task ein komplexeres System bekomme, dann ist mein erster Schritt der, dass ich mir das zugrundeliegende Pattern herausarbeite, ein erstes Konstrukt implementiere, einen Sunny-Case-Test schreibe, den ich zum Debuggen verwende und mich dann um die Fehler-Tests kümmere. Ebenso fehlt mir ein wenig eine Abgrenzung was genau (und wie) getestet werden soll: externe Methoden-Aufrufe sollen gemockt werden, wie sieht es jedoch mit Methodenaufrufe in der selben Klasse/Elternklasse aus? Mocken bzw. Fake-Objekte beinhalten des weiteren immer die Gefahr, dass zwar für den Test erforderliche Inhalt abgefragt werden jedoch dieser Fall in der Realität gar nicht vorkommen kann (zB gewisse Usereingaben werden bereits durch das UI abgefangen, dennoch beinhaltet der Test für eine weiter darunter liegende Methoden (noch einmal) die Tests auf falsche Usereingaben (sehr vereinfachtes Beispiel). Ebenso könnte ein Fake-Object eine andere Logik verwenden als das eigentliche Objekt und daher dennoch fehlerhaften Code in die Production Environment zulassen.

*) Ein weiterer Punkt der mir in dem Buch abgeht ist die praktische Nicht-Erwähnung von Test-Plänen bzw. wie man möglichst alle (möglichen) Szenarien abdecken kann. (Im Kapitel über ATDD wird es kurz einmal erwähnt aber überhaupt nicht darauf eingegangen) Gerade wenn man eine Testklasse mit mehreren tausend Zeilen Code vor sich hat, kann man schnell einmal den Überblick verlieren. Getestet wird hier eben nur, wofür auch Tests vorhanden sind. Wenn ich also einen schlechten Tag habe (oder einen nicht so kreativen; wie man will), könnte mir der eine oder andere Fall hier ev. abgehen und somit dennoch in der Live-Umgebung dann zu Problemen führen. Den Akzeptanz-Test hätte ich hier auch nur als eine Übereinkunft mit dem Auftraggeber gesehen, welche Testfälle abgedeckt gehören - in der Praxis sieht man leider aber immer wieder (erscheckend eigentlich) wie wenig Ahnung bzw. Wissen die Auftraggeber über das bzw. von dem Resultat haben (daher kommen oft nachträglich neue Anforderungen bzw. Korrekturen)

*) Mir persönlich fehlt ein bisschen der Nachdruck der Wichtigkeit von Tests wenn man Code refactored und wie das Refactoring mit guten Tests zusammen hängt. Gerade wenn man viel agil programmieren muss, ist dies ein wesentliches Kriterium. Hier würde zB ein Blick in "Refactoring: Improving the Design of Existing Code" von Martin Fowler at all weitere Argumente für das Schreiben von Unit-Tests (bzw. was wirklich getestet gehört) liefern. Auch wenn dies JUnit sehr rudimentär behandeln und bei weitem nicht auf dem Niveau von dem hier rezesierten Buch.

Das Buch kann man dennoch ohne schlechtes Gewissen einem jeden neuen Software-Entwickler in die Hand drücken. Ich bin mir sicher, dass selbst langjährige Software-Entwickler, die sich nie intensiver mit JUnit beschäftigt haben, hier noch einiges Brauchbares aus dem Buch entnehmen können.
0KommentarWar diese Rezension für Sie hilfreich?JaNeinSenden von Feedback...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte versuchen Sie es später noch einmal.
Missbrauch melden
7 von 11 Kunden fanden die folgende Rezension hilfreich.
am 24. April 2014
Für mich ist das ein enttäuschendes Buch und überflüssiges Buch. Mir ist die Zielgruppe auch nicht klar. Einem Einsteiger fehlen funktionierende Beispiele und hilfreiche Erklärungen. Ein Profi vermisst Themen wie Datenbank, Netzwerk und GUI-Tests und bekommt gerade in den lezten Kapiteln (5 bis 10) viel Füllwerk.

Das größte Manko an dem Buch ist, dass der Quellcode zu den Beispielen nicht verfügbar ist. Es nützt auch nichts, die Beispiele abzutippen, weil sie nicht vollständig abgedruckt sind.
Der Autor hat einfach irgendwelche JUnit-Tests aus Open Source Projekten genommen und Teile davon herausgezogen. Dabei hat er sich leider nicht auf ein Projekt bezogen, sondern mehrere (Spring, Selenium etc.). Darf ich jetzt jedes Projekt aus dem Internet laden und die Stelle, auf die er sich bezieht, suchen? Danke. Dafür habe ich kein Buch gekauft. Dann hätte ich das Geld sparen können und gleich die genannten Projekte als Vorlage nehmen können.
Ein weiterer Kritikpunkt ist, dass er nichts richtig erklärt. Ein Beispiel sind die Kapitel 5.1 bis 5.3 zu Hamcrest. Auf der einen Seite versucht er, die Innereien von irgendwelchen Implementierungen zu erklären. Die benötige ich aber gar nicht, um eine Bibliothek zu nutzen. Eine Aufzählung der Hamcrest-Methoden oder wenigstens eine Übersicht fehlt. Dafür gib er mir einen Link auf eine Webseite von Marc Philipp, die eine Zusammenfassung der Hamcrest-Methoden bietet. Ja! Das hätte ich im Buch erwartet!
Gerade die letzten Kapitel (8, 9 und 10) sind sehr schwach. Da reicht es aus, die jeweilige Zusammenfassung zu lesen. Das Kapitel selbst bietet auch nicht mehr.
Lediglich das Kapitel 4 "Testgetriebene Entwicklung" ist ganz gut. Daher ein Stern dafür. Deswegen habe ich das Buch aber nicht gekauft.
Der Autor spricht einige Patterns fürs Testen an. Wen das interessiert, sollte gleich das Buch xUnit Test Patterns: Refactoring Test Code von Gerard Meszaros kaufen.
Wenn Tests erst interessant und schwierig werden, nämlich wenn Datenbanken, GUIs oder Netzwerkkomunikation getestet werden sollen, ist im Buch Funkstille. Die Themen werden mit keinem Wort erwähnt. Schade eigentlich - schließlich lautet der Titel großspurig "JUnit-Profiwissen". Hier hätten Frameworks wie DBUnit, Jemmy, Marathon oder ähnliche vorgestellt werden können. Er erwähnt zwar das Testframework Selenium, zeigt aber nicht die Verwendung für Tests von Webseiten, sondern zeigt einen JUnit-Test, um ein Feature für JUnit 4 zu zeigen. Komplizierter geht es nicht.
Auf das Testen von Webapplikationen geht der Autor auch nicht ein.
Da ist das Buch "Qualitätssicherung durch Softwaretests" von Stephan Kleuker um Längen besser. Besagte Punkte werden dort verständlich und mit vernüftigen Beispielen dargestellt.
22 KommentareWar diese Rezension für Sie hilfreich?JaNeinSenden von Feedback...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte versuchen Sie es später noch einmal.
Missbrauch melden
1 von 2 Kunden fanden die folgende Rezension hilfreich.
am 19. April 2014
Endlich mal ein Buch übers Thema, dass sich nicht ewig an TDD Propaganda abarbeitet sondern gleich praktisch wird, nachdem in wenigen Sätzen das Vorgehen motiviert wird.

Der Author schafft auf nüchterne (aber nicht trockene) Weise einen recht vollständigen Überblick über die gesamte State-of-the-Art Tool-Sammlung zum Thema Testen von Java Software. JUnit steht dabei zwar im Zentrum, erhält aber nicht mehr Aufmerkasamkeit als notwendig. Statt dessen wird nach nach ein wenig Theorie und Motivation eine sehr gelungene Einführung in das Thema Mocking und eine Historie durch die Entwicklung der Mock-Frameworks angeboten.
Auch Assertion-Frameworks wie Hamcrest oder FEST bekommen ihr eigenes Kapitel.

Das dritte Viertel des Buches ist besonders gelungen: Hier werden „Best Practices“ zum Schreiben von Tests diskutiert (AAA, perfomante Tests, nicht funktionale Tests, etc). Auch hier wird wieder kurz motiviert und etwas Theorie eingeschoben, dann aber sofort in der praktischen Anwendung gezeigt.

Der letzte Teil des Buches beschäftigt sich dann wieder mit Tooling, wie MoreUnit, Ant, Maven, JaCoCo etc.

Vor allem gelungen an dem Buch finde ich, dass der Author sich nicht in Test-Theorien verliert (das gibt’s zuhauf in anderen Büchern zum Thema).

Sprachlicher Stil des Buches: Nüchtern, aber nicht trocken (sehr sympathisches Zitat: „Fragen Sie mich nicht wozu das gut sein soll, ich weiß es auch nicht.“)

Fazit: Bestes Buch zum Thema Testen in deutscher Sprache, das mir bisher untergekommen ist.
22 KommentareWar diese Rezension für Sie hilfreich?JaNeinSenden von Feedback...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte versuchen Sie es später noch einmal.
Missbrauch melden
3 von 5 Kunden fanden die folgende Rezension hilfreich.
am 14. Dezember 2013
Jeder Java Entwickler der Interesse oder Verantwortung dafür hat, guten Code zu schreiben kommt um das Thema Testen nicht herum. Mittlerweile gibt es für diesen Zweck eine Reihe von Bibliotheken, aber vor JUnit hat sich hier zu einer Art Industriestandard entwickelt. Das vorliegende Buch gibt einen vollständigen Überblick über JUnit und damit verbunde Frameworks, Pattern und Paradigmen.

Es ist damit gleichermaßen für Einsteiger, Umsteiger von anderen Test-Frameworks aber auch (und vor allem) für Fortgeschrittene "Tester" geeignet. Gerade letztere Zielgruppe kann im Buch von Michael Tamm noch viele neue Details entdecken und eigenes Wissen validieren - denn wer hat schon alle Mockframeworks in der Tiefe kennengelernt?

Fazit: Klare Kaufempfehlung für jeden, der mit JUnit testet.
0KommentarWar diese Rezension für Sie hilfreich?JaNeinSenden von Feedback...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte versuchen Sie es später noch einmal.
Missbrauch melden
1 von 2 Kunden fanden die folgende Rezension hilfreich.
am 20. Februar 2014
Das beste Buch zu JUnit Tests und den verwandten Themen, die ich jemals gelesen habe. Sowohl für Beginner als auch Fortgeschrittene Test-Master geeignet. Viele Code-Beispiele, Design-Entscheidungen, Fallstricke, Vorstellung alternativen Test-Bibliotheken für "flüssige" Tests, usw. 5 Sterne!
0KommentarWar diese Rezension für Sie hilfreich?JaNeinSenden von Feedback...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte versuchen Sie es später noch einmal.
Missbrauch melden
2 von 4 Kunden fanden die folgende Rezension hilfreich.
am 12. Januar 2014
Das Buch liefert einen weiten Überblick über das Thema der Testautomatisierung. Einsteiger werden sich durch die gut verständlichen Beispiele leicht in die Thematik einarbeiten können.

Für Fortgeschrittene ist insbesondere der zweite Teil des Buches interessant. In diesem Teil geht es über das Schreiben von "Unit- Tests" hinaus. Es werden Techniken gezeigt, mit denen es möglich ist, Softwaretests über sämtliche Schichten zu schreiben.

Da einige der im Buch erwähnten Konzepte und Techniken prinzipiell Programmiersprachen und Framework unabhängig sind, empfiehlt sich das Buch auch für xUnit User.
0KommentarWar diese Rezension für Sie hilfreich?JaNeinSenden von Feedback...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte versuchen Sie es später noch einmal.
Missbrauch melden
0 von 1 Kunden fanden die folgende Rezension hilfreich.
am 29. Mai 2014
Aus meiner Sicht ist das vorliegende Buch das zur Zeit aktuellste und beste deutschsprachige Buch zu JUnit. Es werden sowohl Themen für Anfänger als auch für Fortgeschrittene behandelt. Sehr gut ist auch der Teil bzgl. Mocking mit Mockito. Am Rande werden auch Themen wie UI-Tests behandelt. Da dies ein Buch mit Schwerpunkt JUnit ist reicht das auch aus. Von mir gibt es hier eine klare Kaufempfehlung.
0KommentarWar diese Rezension für Sie hilfreich?JaNeinSenden von Feedback...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte versuchen Sie es später noch einmal.
Missbrauch melden
0 von 1 Kunden fanden die folgende Rezension hilfreich.
am 13. Juni 2014
Ich habe mir dieses Buch für die Erstellung meiner Bachelorarbeit gekauft. Zum Erlernen der Theorie hinter JUnit und für die Praktische Umsetzung ist dieses Buch sehr geeignet. Es ist chronologisch und thematisch sehr gut gegliedert und der gute Schreibstil ermuntert zum Weiterlesen.

Das Buch ist auf jeden Fall empfehlenswert!
0KommentarWar diese Rezension für Sie hilfreich?JaNeinSenden von Feedback...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte versuchen Sie es später noch einmal.
Missbrauch melden
     
 
Kunden, die diesen Artikel angesehen haben, haben auch angesehen
Der Weg zum Java-Profi: Konzepte und Techniken für die professionelle Java-Entwicklung
Der Weg zum Java-Profi: Konzepte und Techniken für die professionelle Java-Entwicklung von Michael Inden (Gebundene Ausgabe - 5. Februar 2015)
EUR 49,90