Ullrich: Ullrich verschob die Seite Partielle Mocks nach Mockito: Partielle Mocks

2023-03-09T17:40:30Z

Ullrich verschob die Seite Partielle Mocks nach Mockito: Partielle Mocks

← Nächstältere Version	Version vom 9. März 2023, 17:40 Uhr
(kein Unterschied)

Ullrich: Ullrich verschob die Seite Partieller Mock nach Partielle Mocks, ohne dabei eine Weiterleitung anzulegen

2021-04-21T20:41:19Z

Ullrich verschob die Seite Partieller Mock nach Partielle Mocks, ohne dabei eine Weiterleitung anzulegen

← Nächstältere Version	Version vom 21. April 2021, 20:41 Uhr
(kein Unterschied)

Ullrich: Die Seite wurde neu angelegt: „Kategorie:Java Kategorie:Mockito = Mock vs. Spy = Neben dem hier beschriebenen Mocks giebt es ein weiteres Konzept in Mockito, das dem Mocki sehr ähnl…“

2021-04-21T19:25:01Z

Die Seite wurde neu angelegt: „Kategorie:Java Kategorie:Mockito = Mock vs. Spy = Neben dem hier beschriebenen Mocks giebt es ein weiteres Konzept in Mockito, das dem Mocki sehr ähnl…“

Neue Seite

[[Kategorie:Java]]
[[Kategorie:Mockito]]
= Mock vs. Spy =
Neben dem hier beschriebenen Mocks giebt es ein weiteres Konzept in Mockito, das dem Mocki sehr ähnlich ist: der Spy.
Bei einem Spy handelt es sich um ein Objekt, das um ein anderes Objekt herumgewickelt wird. Gewöhnlich wird es verwendet
um Laufzeit-Informationen über das Objekt zu sammeln. Man kann damit etwa überprüfen, ob eine Methode des Objekts aufgerufen
wurde oder nicht -- sehr praktisch in Unit-Tests. Ein Spy wird so erzeugt:
{{java|code=
Foo foo = new Foo();
Foo spiedFoo = Mockito.spy(foo);
}}
Im Gegensatz zum Mock benötigt der Spy für die Erzeugung ein Objekt. Das entstehende Spy-Objekt hat den gleichen Typ
wie das umwickelte Objekt. Wie der Mock entsteht dabei eine Unterklasse. Einen Mock braucht man nicht mit einem Spy zu
umwickeln, er hat bereits die gleiche Funktionalität die der Spy erzeugt. Im Folgenden geht es um die unterschiedliche
Verwendung von Mock und Spy, Für die Untersuchung des Aufrufverhaltens giebt es eine eigene Seite.

= Zwei extreme Mocks =
Die Klasse, die hier mit der mock-Methode erzeugt wird
{{java|code=Echt mock = Mockito.mock(Echt.class);}}
ersetzt alle Methoden der Klasse {{java|Echt}} durch gemockte Methoden. Man kann also getrost von einem ''totalen Mock''
sprechen. Ein Objekt der Klasse {{java|Echt}} ist ein gewissermaßen ein ''echtes'' Objekt und hingegen erwartungsgemäß keine
einzige Methode der Klasse. Man könnte in ihr einen entartetetn Mock sehen und als ''Null-Mock'' bezeichnen.

Objekte der originalen Klasse können nicht unmittelbar mit Mockito manipuliert werden, man umwickelt sie daher mit
einem Mockito-Proxy-Objekt, einem Spy:
{{java|code=Echt spy = Mockito.spy(new Echt());}}
Zwischen diesen beiden Extremen, dem "Alles" des totalen Mock und dem "Nichts" des Null-Mock liegt ein weites
Feld von Möglichkeiten um Teile der Original-Klasse durch mock-Methoden zu ersetzt und Teile davon unberührt
zu lassen: das sind die partiellen Mocks.

Um einen partiellen Mock zu bauen gibt es zwei diametrale Vorgehensweisen: Entweder man beginnt beim totalen
Mock und läßt einzelne Methoden die Funktionalität der Original-Klasse ausführen; oder man beginnt beim Null-Mock
und mockt einzelne Methoden, deren originale Funktionalität nicht ausgeführt werden soll. Für welches Vorgehen
man sich entscheidet hängt vom Anwendungsfall ab.

== Den totalen Mock aufweichen ==
die Klasse {{java|Echt}} sei so definiert:
{{java|code=
class Echt {
int eins() {
return 1;
}
int zwei(int x) {
return x + 3;
}
}
}}
Der eingangs erzeugte Mock mockt beide Methoden. Die Methode {{java|eins}} soll nun ''nicht mehr'' gemockt werden,
das geht so:
{{java|code=
Echt mock = Mockito.mock(Echt.class);
Mockito.when(mock.eins()).thenCallRealMethod();
}}
Mehr ist dazu eigentlich nicht zu sagen. Der Aufruf von {{java|eins()}} liefert nun wie erwartet den Wert ''1'', während der
Aufruf von {{java|zwei()}} für jedes Argument den Wert ''0'' liefert.
Man hat nun für jede Methode drei Möglichkeiten die man nach belieben anwenden kann:
*Nichts tun und die gemockte Methode behalten
*Die echte Methode der Superklasse aufrufen
*Die Methode mit speziellem Mock-Verhalten ausstatten
Die Mock-Anweisungen lassen sich beliebig mischen, wie dieses Beispiel mit Methode {{java|zwei}} der Klasse {{java|Echt}} zeigt:
{{java|code=
Echt mock = Mockito.mock(Echt.class);
Mockito.when(mock.drei(Mockito.anyInt())).thenCallRealMethod();
Mockito.when(mock.drei(Mockito.eq(5))).thenReturn(4711);
}}
Bei Aufruf von {{java|mock.zwei(5)}} erhalten wir den Wert ''4711'' aus dem Mock und in allen anderen Fällen das Ergebnis
der echten Methode. Auch hier ist zu beachten, daß allgemeinere Matcher vor spezielleren Matchern kommen.
In diesem Falle also {{java|.anyInt()}} vor {{java|.eq(5)}}.

== Den Null-Mock aushöhlen ==
Wir beginnen nun mit dem Spy, der als Null-Mock das komplette Original-Verhalten der Klasse {{java|Echt erhält}}.
Diesmal möchten wir die Methode {{java|eins}} mocken, während die Methode {{java|zwe)}} weiterhin das reale Verhalten aufweist:
{{java|code=
Echt spy= Mockito.spy(new Echt());
Mockito.when(spy.eins()).thenReturn(3);
}}
Und fertig ist die Laube.

Mockito: Partielle Mocks - Versionsgeschichte

Ullrich: Ullrich verschob die Seite Partielle Mocks nach Mockito: Partielle Mocks

Ullrich: Ullrich verschob die Seite Partieller Mock nach Partielle Mocks, ohne dabei eine Weiterleitung anzulegen

Ullrich: Die Seite wurde neu angelegt: „Kategorie:Java Kategorie:Mockito = Mock vs. Spy = Neben dem hier beschriebenen Mocks giebt es ein weiteres Konzept in Mockito, das dem Mocki sehr ähnl…“