Mockito mit CodeCover

Erweitertes Beispiel: Mockito mit CodeCover

Einleitung:

Dieses Beispiel soll das Zusammenspiel von Mockito mit CodeCover demonstrieren. Der Test basiert zu großen Teilen auf dem einführendem Beispiel. Die einzigen Änderungen sind eine echte Klasse, die das zuvor zum Mocken genutzte Interface implementiert. Alle Methoden bis auf getRandomValue, sind nicht implementiert und ihre Funktionalität soll auch weiterhin mit Hilfe von Mockito simuliert werden. Die getRandomValue Methode hat in diesem Beispiel nun eine simple Implementierung.

Vorbereitung:

Ausgehend von dem einführenden Beispiel, muss die Klasse "MyMap" angelegt werden und wie von CodeCover gewohnt für Überdeckungstests aktiviert werden. Die alte Testklasse kann dann gegen die neue "MockitoTests" Klasse ausgetauscht werden.

Resultierende Projektstruktur:

Projektstruktur

Klasse: MyMap.java

package mockitobeispiel;

import java.util.Random;

public class MyMap implements MyMapInterface{

	@Override
	public void put(Object key, Object value) {
		System.out.println("Wird am echten Objekt aufgerufen, " +
				"auch wenn Stub beim Mockito Spy definiert wurde");

	}

	@Override
	public Object get(Object key) {
		System.out.println("get Methode aufgerufen");
		return null;
	}

	@Override
	public Object[] getAllKeys() {
		System.out.println("Wird am echten Objekt aufgerufen " +
				"- bei definiertem Stub bei Mockito, werden aber" +
				"die dort definierten Rueckgabewerte geliefert");
		return null;
	}

	@Override
	public Object getRandomValue() {
	    Random generator = new Random();
		int randomIndex = generator.nextInt( 10 );
		return new StringBuilder("Val").append(randomIndex).toString();
	}
}

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 {

	//Eine echte Klasse und eine Spy Klasse mit Mockito Mocks.
    MyMapInterface myMockMap;
    MyMapInterface myRealMap;

    @Before
    public void setUp() {
		//Echte Klasse wird angelegt.
    	myRealMap = new MyMap();
		//Ein spy wird von der echten Klasse angelegt
        //und kann wie eine Mockito Mock-Klasse behandelt werden.
        myMockMap=Mockito.spy(myRealMap);
    }

    @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() {
        //Verhalten wird nicht mehr gemockt, Return-Werte werden von der echten Klasse kommen.
        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;
        }
    }

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

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

Ergebnis:

Mockito erlaubt es, teilimplementierte Klassen zu mocken und funktioniert zusammen mit CodeCover. Eine Feststellung ist, dass Mockito auch Methoden deren Verhalten gemockt wird, trotzdem aufruft. Die Rückgabewerte der Methoden werden in dem Falle die bei Mockito definierten sein, aber CodeCover registriert den Aufruf und die in den Methoden enthaltenen Befehle (z.B. print lines) werden ausgeführt und als überdeckt angesehen.

Ergebnis

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