Name

jMock

Homepage

http://www.jmock.org

Lizenz

jMock Project License

Untersuchte Version

JMock 2.5.0 vom 14. Juli 2008

Letzter Untersuchungszeitpunkt

02.11.2010

Kurzbeschreibung

JMock ist eine Bibliothek zur testgetriebenen Softwareentwicklung. Dabei werden sogenannte Mock-Objekte als Dummy Objekte verwendet. Mock steht im englischen für vortäuschen. Die Mock-Objekte werden als Platzhalter für echte Objekte innerhalb von Unit-Tests verwendet. Die Mock-Objekte implementieren dabei die Schnittstellen, über die das zu testende Objekt auf seine Umgebung zugreift. Mocks stellen dabei sicher, dass die erwarteten Methodenaufrufe vollständig mit den korrekten Parametern und in der richtigen Reihenfolge aufgerufen bzw. durchgeführt werden.

Fazit

JMock bietet eine einfache Möglichkeit nicht vorhandene Klassen durch sogenannte Mock-Objekte zu testen, in dem diese vorgetäuscht werden. Die Bibliothek ist sehr einfach und intuitiv zu nutzen. Die mitgelieferte Dokumentation auf der Herstellerwebseite ist sehr gut und sehr umfangreich und bietet gerade unerfahrenen Nutzern einen sehr guten Einstieg. Besonders hilfreich ist die Rubrik "Cheat Sheet". In diesem Bereich werden alle wichtigen Funktionen und Befehle von jMock in einem Überblick dargestellt.

Einsatzgebiete

JMock wird von Softwareentwicklern und -testern in der testgetriebenen Softwareentwicklung eingesetzt, um nicht vorhandene Objekte mit Mocks vorzutäuschen. Die jMock Version 2.5.0 ist kompatibel zu Java 1.5, JUnit 3 und 4.

Einsatzumgebungen

JMock kann in jeder beliebigen Entwicklungsumgebung genutzt werden, dazu müssen die verschiedenen Jar-Dateien dem Projektklassenpfad hinzugefügt werden.

Installation

Die Installation ist sehr einfach. Es muss kein Installer ausgeführt werden, lediglich die heruntergeladenen Jar-Datein müssen dem Projektklassenpfad hinzugefügt werden.

Eclipse: Projekt -> Properties -> Java Build Path -> Add external Jar -> *.jar auswählen
Netbeans: Projekt -> Properties -> Libraries -> Add Jar -> *.jar auswählen

Für JUnit 4 sind folgende Jar-Dateien dem Klassenpfad hinzuzufügen:

Dokumentation

Die Dokumentation von jMock befindet sich ausschließlich auf der Herstellerwebseite und liegt in englischer Sprache vor. Bestandteile der sehr guten und ausführlichen Dokumentation sind:

Bereits auf der Startseite von jMock wird man direkt auf zwei sehr gute Rubriken hingewiesen, diese sind Get Started und Get Training. Im Bereich Get Started wird ein einführendes Beispiel vorgestellt, dabei hat man die Möglichkeit zwischen verschiedenen Testumgebungen zu wählen (JUnit 3, 4 oder andere). Je nach Auswahl der Testumgebung verändert sich das Beispiel entsprechend. Auf dieser Seite erhält man bereits einen sehr guten Einblick über die Funktionalität von jMock. Im Bereich Get Training wird man auf die Seite von www.mockobjects.com verlinkt. Dort wird in verschiedenen Kapiteln der Umgang mit Mocks erläutert. Um den gesamten Umfang von jMock kennenzulernen, wird auf der Webseite die Rubrik Cookbook angeboten. Dieser Bereich ist sehr umfangreich und gut beschrieben und zeigt alle Möglichkeiten von jMock. Der Aufbau dieser Rubrik ist sehr gut, jede Funktion wird mit Hilfe von sprechenden Beispielen erläutert. Die Seite Cheat Sheet bietet einen Überblick zu den Methoden von jMock und deren Funktionalität. Dieser Überblick erweist sich gerade zu Beginn für Einsteiger als sehr nützlich, da alle Methoden auf einen Blick mit Erklärungen sichtbar sind. Des Weiteren befinden sich auf der Webseite die API Dokumentation, verschiedene Artikel über jMock und ein RSS News Feed der abonniert werden kann, um bei jeder Änderung am Projekt informiert zu werden. Die gesamte Dokumentation von jMock ist sehr gut und übersichtlich gestaltet. Die Funktionalität wird mit sprechenden Beispielen dokumentiert und beschrieben.

Wartung der Projektseite

Die Projektseite von jMock ist sehr übersichtlich gestaltet, alle wichtigen Informationen sind vorhanden und leicht zugänglich. Bereits auf der Startseite erhält man einen Überblick über jMock, sowie eine erste Navigationshilfe zu sehr guten und relevanten Themen, wenn man noch nie mit jMock gearbeitet hat. Die Projektseite wird stetig mit jedem Release weiterentwickelt.

Nutzergruppen und Support

Auf der Projektseite befindet sich eine Rubrik User Support. In diesem Bereich wird eine Mailing-Liste angeboten, ein Trainings Bereich in dem man auf eine andere Webseite verlinkt wird, die einen Einblick in die Mockentwicklung bietet. Im Bereich Issue Tracker wird auf die Webseite von codehaus.org verlinkt, wo ein Bug Tracker System eingerichtet ist, indem man Bugs berichten und einsehen kann. Zusätzlich befindet sich auf dieser Seite eine Roadmap mit einer Übersicht auf zukünftige Entwicklungen. Ein weiteres nettes Feature im Bereich User Support ist der RSS News Feed zur jMock-Projektseite. Dieser Nachrichtendienst kann abonniert werden, um bei Änderungen und Neuigkeiten über jMock automatisch informiert zu werden.

Intuitive Nutzbarkeit

Die intuitive Nutzbarkeit von jMock ist sehr einfach und gut. Mit Hilfe von jMock werden nicht vorhandene Klassen getestet. Für die Umsetzung wird ein Interface benötigt, welches getestet werden soll. Um dieses Interface entsprechend zu testen, wird ein Mock Objekt von diesem Interface angelegt. Mit Hilfe des Mock Objektes und Expectations (Erwartungen) wird dann die Funktionalität getestet. Da jMock auf JUnit aufsetzt, können Ergebnisse mit Assert-Methoden einfach überprüft werden. Das Ergebnis wird in der JUnit üblichen Übersicht dargestellt.

Automatisierung

Eine Automatisierung ist mit Hilfe von JUnit 3 oder JUnit 4 möglich.

ANT
Die Automatisierung von JMock ähnelt stark der Automatisierung von JUnit-Tests. Da JMock auch das JUnit-Framework verwendet, müssen keine großen Änderungen vorgenommen werden, falls ein JUnit-Testablauf mit Hilfe von Ant definiert wurde. Zum Kompilieren der Sourcen müssen allerdings weitere externe Bibliotheken eingebunden werden. Diese sind im folgenden Abschnitt "Einführendes Beispiel" aufgelistet. Zu dem verhält sich der Testablauf mit Hilfe des JMock-Frameworks gleich mit dem Ablauf von normalen JUnit-Tests. Dadurch können die vorhandenen Features eines JUnit-Testablaufs wie z. B. die automatische Report-Generierung genutzt werden.
Eine Beispielautomatisierung ist hier zu finden.
Maven
Die Automatisierung der JMock Testfälle ähnelt stark der Ausführung von JUnit-Testfällen. Der JMock-Testfall wird in diesem Szenario durch einen JUnit-Testfall angestoßen und ist somit für den Maven-Prozess nicht direkt relevant. Die Sourcen müssen zwar beim Kompilieren und bei der Ausführung auf die JMock-Bibliotheken zugreifen, dies ist allerdings leicht mit Hilfe des <dependency>-Elements realisiert. Davor müssen die JMock-Bibliotheken noch in das lokale Repository von Maven übertragen werden. Die folgenden Befehle erledigen diesen Aspekt:
mvn install:install-file -DgroupId=hamcrest-core -DartifactId=hamcrest-core -Dversion=1.1 -Dfile=hamcrest-core-1.1.jar -Dpackaging=jar -DgeneratePom=true
mvn install:install-file -DgroupId=hamcrest-library -DartifactId=hamcrest-library -Dversion=1.1 -Dfile=hamcrest-library-1.1.jar -Dpackaging=jar -DgeneratePom=true
mvn install:install-file -DgroupId=jmock -DartifactId=jmock -Dversion=2.5.1 -Dfile=jmock-2.5.1.jar -Dpackaging=jar -DgeneratePom=true
mvn install:install-file -DgroupId=jmock-junit4 -DartifactId=jmock-junit4 -Dversion=2.5.1 -Dfile=jmock-junit4-2.5.1.jar -Dpackaging=jar -DgeneratePom=true

Hierbei müssen sich im aktuellen Ordner die Jar-Dateien befinden und die Version ist an die aktuelle Nutzung anzupassen.
Die Ausführung des Tests ähnelt somit stark der Ausführung eines normalen JUnit-Testfalls. Durch den Aufruf mvn test wird der Testfall angestoßen und ausgeführt. Die Ergebnisse lassen sich dann im Target-Verzeichnis finden.
Ein einfaches Automatisierungsbeispiel ist hier zu finden.
Vergleich Ant und Maven
Der Aufwand ist initial bei Maven höher da erst noch die vier benötigten JAR-Archive in das lokale Repository übertragen werden müssen. Danach ähneln sich der Ablauf von Maven und Ant sehr. Die Testfälle werden jeweils von den JUnit-Testfällen angestoßen und sind somit leicht integrierbar.

Einführendes Beispiel

Als einführendes Beispiel wird das Beispiel von der jMock-Webseite aufgegriffen. Hierbei handelt es sich um eine Subscriber/Publisher Funktion wie sie aus dem Observer Observable Pattern bekannt ist. Das vollständige Eclipseprojekt kann hier heruntergeladen werden: Als erstes legt man in Eclipse ein einfaches Java-Projekt an und fügt die entsprechenden Jar-Dateien dem Build Path hinzu.

buildpath

Im nächsten Schritt wird das Interface erzeugt, welches hier eine nicht vorhandene Klasse darstellt. Das Interface wird nicht implementiert, sondern durch ein Mock Objekt vorgetäuscht:

interface

Bevor ein Mock Objekt erzeugt werden kann, müssen verschiedene Imports von JMock und JUnit vorgenommen werden. Um anschließend Mocks nutzen zu können, wird ein sogenanntes "Mockery Objekt" benötigt. Dieses Objekt stellt den Kontext dar, in welchem das Mock existiert:

mockery

Im nächsten Schritt wird die Testmethode implementiert, in welcher zu Beginn ein Mock Objekt des Interfaces Subscriber erstellt wird. Anschließend wird ein Subscriber beim Publisher registriert:

setup

Im letzten Schritt der Testmethode wird ein sehr wichtiger Teil von jMock implementiert, die sogenannten Expectations (Erwartungen). Hier können verschiedene Bedingungen je nach Programm und Funktionalität getestet werden. In diesem Beispiel wird einmal der Aufruf der Methode "receive();" getestet. Somit wird festgelegt, dass im weiteren Testverlauf "receive();" einmal aufgerufen werden muss:

expectation

Mit den bekannten JUnit Assertmethoden kann zusätzlich geprüft werden, ob Daten richtig Übertragen oder berechnet wurden:

execute

Um sicher zu gehen, dass die erwartete Methode auch tatsächlich einmal aufgerufen wurde, muss context.assertIsSatisfied(); ausgeführt werden.
Die komplette Testmethode sieht somit so aus:

 @Test
    public void oneSubscriberReceivesAMessage() {
        // set up - Erstellen des Mocks
        final Subscriber subscriber = context.mock(Subscriber.class);

        Publisher publisher = new Publisher();
        publisher.add(subscriber);

        final String message = "message";

        // expectations
        // Wird einmal geprueft, ob das Mock Objekt die Nachricht erhalten hat
        // Erwartet das receive() noch einmal aufgerufen wird
        context.checking(new Expectations() {{
            one (subscriber).receive(message);
        }});

        // execute
        // Alle Subscriber werden ueber die neue Nachricht informiert
        publisher.publish(message);

        // wurde receive() einmal ausgefuehrt? (In diesem Fall ueber publisher.publish(message);)
        context.assertIsSatisfied();

        // Wird geprueft, ob auch die richtige Nachricht angekommen ist
        assertSame(message, publisher.getString());
    }
 

Die geschriebenen Testfälle lassen sich einfach über Rechtsklick auf die Testklasse -> "Run as" -> "JUnit" ausführen.
Wurde der Test erfolgreich abgeschlossen, erscheint der grüne JUnit-Balken. Treten während des Tests Fehler auf, werden diese an der entsprechenden Stelle aufgezeigt.

result

Zum Schluss wird noch die Publisherklasse implementiert, welche für die Verteilung der Daten von registrierten Subscribern zuständig ist:

publisher

Detaillierte Beschreibung

Siehe Dokumentationen und Tutorials auf der Webseite des Herstellers.

Literatur

keine

Zurück zur Werkzeugübersicht
Zurück zur CSI-Hauptseite