Mockito

Letzter Untersuchungszeitpunkt

25.06.2011

Mockito ist ein Framework zum Erstellen und Benutzen von simplen Mocks in Softwaretests. Es bietet die Möglichkeit, Verhalten von noch nicht implementierten Klassen und Methoden rudimentär zu simulieren, um so das zu testende System, trotz fehlender Teile, testen zu können.

Fazit

Mockito ist sehr simpel in der Anwendung und kommt für die meisten Aufgaben mit nur wenigen Zeilen Code aus. Diese Eigenschaften machen das Framework sowohl für Einsteiger, als auch für Fortgeschrittene interessant. Es legt den Schwerpunkt auf unkomplizierte und intuitive Schnittstellen und überschaubare Funktionsvielfalt, weshalb die Einarbeitungszeit besonders kurz ist und Tests teilweise leserlicher und kürzer ausfallen als bei ähnlichen Frameworks, wie zum Beispiel EasyMock.

Einsatzgebiete

Mockito soll simple Mock-ups für Unit-Tests erzeugen, um die Verifizierung des korrekten Verhaltens von noch unvollständig implementierter Software zu ermöglichen.

Einsatzumgebungen

Das Framework ist nicht an andere Werkzeuge oder IDEs gebunden, der gemeinsame Einsatz mit einem Unit-Test Framework wie JUnit, ist jedoch sehr naheliegend.

Installation

Zur Installation muss lediglich die Mockito .jar Datei in das Projekt eingebunden werden.

Dokumentation

Die Dokumentation wird in Java-Doc Form mit dem Download mitgeliefert. Außerdem gibt es Codebeispiele zu den verschiedenen Funktionalitäten des Frameworks, auf den Mockito Webseiten.

Wartung der Projektseite

Die Projektseite macht einen gut gepflegten Eindruck. Der Aktivitäts-Tracker und die Versionsgeschichte zeigen ein aktives Projekt und stetige Arbeit an kommenden Releases.

Nutzergruppen und Support

Auf den Webseiten von Mockito befinden sich ein Wiki, eine Mailing-Liste und ein Issue-Tracking-System. Der Projektleiter und die meisten Mitwirkenden, haben ihre E-Mail Adressen gelistet.

Intuitive Nutzbarkeit

Die Nutzung ist sehr intuitiv und die Schnittstellen einfach zu verstehen. Da Mockito dem Programmierer eine relativ simple API zur Verfügung stellt, reichen schon sehr kurze Beispiele zum Nachvollziehen der Arbeitsabläufe.

Automatisierung

Mockito kann in Kombination mit Unit-Test Frameworks wie JUnit eingesetzt werden. Außerdem wird das Build-Management-Tool "Maven" unterstützt.

Einführendes Beispiel

Einleitung:

Dieses Beispiel soll einen knappen Überblick über die Benutzung von Mockito vermitteln. Für die Tests wird ein Interface als Grundlage für eine Mock-Klasse verwendet. Das Interface soll eine extrem simple Map darstellen, deren Verhalten Mockito simulieren soll. Die Tests in diesem Beispiel sind JUnit 4 konform, sollten aber im Prinzip ohne weiteres mit anderen Unit-Test Frameworks umsetzbar sein.

Vorbereitung:

Nach dem Anlegen eines neuen Java Projekts, ist es erforderlich, in dieses die neueste Version von Mockito einzubinden. Als nächstes sind das folgende Interface und die Testklasse anzulegen:

Interface: MyMapInterface.java

package mockitobeispiel;

public interface MyMapInterface {

    public void put(Object key, Object value);
    public Object get(Object key);
    public Object[] getAllKeys();
    public Object getRandomValue();
}

Testklasse: MockitoTests.java

package mockitobeispiel;

import org.mockito.MockitoAnnotations;
import org.mockito.Mock;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;

/**
 *
 * @author Andre Heidt
 */
//@RunWith(MockitoJUnit44Runner.class)
public class MockitoTests {

    @Mock
    MyMapInterface myMockMap;

    @Before
    public void setUp() {
        MockitoAnnotations.initMocks(this);
    }

    @Test
    public void mockTestBasic() {
        myMockMap.put("id1", "val1");
        myMockMap.put("id2", "val2");
        myMockMap.put("id3", "val3");

        Mockito.verify(myMockMap).put("id2", "val2");

    }

    @Test
    public void mockTestVerification() {
        for (int i = 1; i < 4; i++) {
            myMockMap.put("id" + i, "sameValue");
        }
        Mockito.verify(myMockMap, Mockito.times(3)).put(Mockito.anyString(), Mockito.eq("sameValue"));
        // eq() Argument Matcher hier notwendig - sobald ein Matcher
        // benutzt wurde (z.B. anyString()) muessen die anderen Parameter
        // ebenfalls Matcher sein.
    }

    @Test
    public void mockTestStubbingAndVerification() {
        String[] keys = {"id1", "id2", "id3"};
        Object[] allKeys;
        Mockito.when(myMockMap.getAllKeys()).thenReturn(keys);
        allKeys = myMockMap.getAllKeys();

        Assert.assertTrue(keys.equals(allKeys));
        Mockito.verify(myMockMap, Mockito.atLeastOnce()).getAllKeys();
        Mockito.verify(myMockMap, Mockito.atLeast(1)).getAllKeys();
        Mockito.verify(myMockMap, Mockito.atMost(1)).getAllKeys();
        Mockito.verify(myMockMap, Mockito.never()).put(Mockito.anyString(), Mockito.anyString());
        Mockito.verifyNoMoreInteractions(myMockMap);
    }

    @Test
    public void mockTestDifferentResult() {
        //Gibt vor welche Werte und in welcher Reihenfolge, 
        //bei einer Reihe von Aufrufen zurueckgegeben werden.
        Mockito.when(myMockMap.getRandomValue()).thenReturn("val3","val1","val4","val2");
        String value, value2;
        value = (String) myMockMap.getRandomValue();
        for(int i=0;i<3;i++){
            value2 = (String) myMockMap.getRandomValue();
            //Ueberprueft ob letzter Wert nicht gleich neuem Wert ist.
            Assert.assertTrue(!value.equals(value2));
            value=value2;
        }

        //Jeder weitere Aufruf, gibt den letzten Wert erneut zurueck.
        value2 = (String) myMockMap.getRandomValue();
        Assert.assertTrue(value.equals(value2));


    }

    @Test(expected = RuntimeException.class)
    public void mockTestExceptions() {
        Mockito.when(myMockMap.get(Mockito.anyString())).thenReturn("val1").thenThrow(new RuntimeException());

        myMockMap.get("id1");
        myMockMap.get("id2");
    }
}

Resultierende Projektstruktur:

Projektstruktur

Durchführung:

Die Testklasse kann wie ein normaler JUnit Test durchgeführt werden.

Testfälle:

Die Testfälle "mockTestBasic" und "mockTestVerification" demonstrieren einfaches aufrufen von Methoden und die zugehörigen Verifikationen.

Der Testfall "mockTestStubbingAndVerification" zeigt, wie Rückgabewerte festgelegt und die Anzahl der Methodenaufrufe überprüft werden können. Aus Platzgründen sind hier verschiedene "verify" Befehle, die teilweise dieselben Aussagen machen, kombiniert in einem Test zusammengefasst.

Der Testfall "mockTestDifferentResult" zeigt die von den Mockito Entwicklern empfohlene Art, unterschiedliche Rückgabewerte bei erneuten Aufrufen einer Methode zu realisieren.

Der Testfall "mockTestExceptions" demonstriert, wie eine Kette von Rückgabewerten und das Werfen von Exceptions realisiert werden können.

Sonstiges:

Die Mock-Klasse in dem Beispiel ist mit der Anweisung "mock(MyMapInterface.class);" angelegt worden. Darüber hinaus besteht die Möglichkeit Mocks über Annotationen zu instanziieren:

package mockitobeispiel;

import org.mockito.MockitoAnnotations;
import org.mockito.Mock;
import org.junit.Before;

public class MockitoTests {

    @Mock MyMapInterface myMockMap;

    @Before
    public void setUp() {
         MockitoAnnotations.initMocks(this);
    }
}

Detaillierte Beschreibung

Erweitertes Beispiel: Mockito mit CodeCover

Literatur

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

Name

Homepage

Lizenz

Untersuchte Version