Das Mockito-Framework bietet eine Vielzahl von Methoden wie „mock()“, „verify()“, „when()“ usw., die zum Testen von Java-Anwendungen verwendet werden. Die Verwendung dieser vordefinierten Methoden macht das Testen sehr einfach.

Nachfolgend finden Sie eine kurze Beschreibung der Mockito-Methoden:

NPM Clean Cache Force

Mockito-Mock()-Methode

Es wird verwendet, um Scheinobjekte einer bestimmten Klasse oder Schnittstelle zu erstellen. Mockito enthält fünf verspotten() Methoden mit unterschiedlichen Argumenten. Wenn wir Mocks nichts zugewiesen haben, geben sie Standardwerte zurück. Alle fünf Methoden erfüllen die gleiche Funktion, nämlich die Objekte zu verspotten.

Im Folgenden sind die Mock()-Methoden mit unterschiedlichen Parametern aufgeführt:

Mock()-Methode mit Klasse:Es wird verwendet, um Scheinobjekte einer konkreten Klasse oder einer Schnittstelle zu erstellen. Als Parameter wird ein Klassen- oder Schnittstellenname benötigt.
Syntax: Mock(Klasse classToMock)Mock()-Methode mit Antwort:Es wird verwendet, um Scheinobjekte einer Klasse oder Schnittstelle mit einer bestimmten Prozedur zu erstellen. Es handelt sich um eine erweiterte Scheinmethode, die bei der Arbeit mit Legacy-Systemen verwendet werden kann. Es verwendet Answer als Parameter zusammen mit dem Klassen- oder Schnittstellennamen. Die Antwort ist eine Aufzählung vorkonfigurierter Scheinantworten.
Syntax: mock(Klasse classToMock, Antwort defaultAnswer)mock()-Methode mit MockSettings:Es wird verwendet, um Scheinobjekte mit einigen nicht standardmäßigen Einstellungen zu erstellen. Es verwendet MockSettings als zusätzlichen Einstellungsparameter zusammen mit dem Klassen- oder Schnittstellennamen. MockSettings ermöglicht die Erstellung von Scheinobjekten mit zusätzlichen Einstellungen.
Syntax: Mock(Klasse classToMock, MockSettings MockSettings)Mock()-Methode mit ReturnValues:Es ermöglicht die Erstellung von Scheinobjekten einer bestimmten Klasse oder Schnittstelle. Jetzt ist es veraltet, da ReturnValues ​​durch Answer ersetzt werden.
Syntax: mock(Klasse classToMock, ReturnValues ​​returnValues)Mock()-Methode mit String:Es wird verwendet, um Scheinobjekte durch Angabe der Scheinnamen zu erstellen. Beim Debuggen kann die Benennung von Scheinobjekten hilfreich sein, wohingegen die Verwendung bei großem und komplexem Code eine schlechte Wahl ist.
Syntax: mock(Klasse classToMock, String-Name)

Der folgende Codeausschnitt zeigt die Verwendung verspotten() Methode:

 ToDoService doService = mock(ToDoService.class); 

Mockito when()-Methode

Es ermöglicht Stubbing-Methoden. Es sollte verwendet werden, wenn wir vortäuschen möchten, bestimmte Werte zurückzugeben, wenn bestimmte Methoden aufgerufen werden. In einfachen Worten, ' Wann die XYZ()-Methode aufgerufen wird, Dann ABC zurückgeben.' Es wird hauptsächlich verwendet, wenn eine Bedingung ausgeführt werden muss.

Syntax: when(T methodCall)

Der folgende Codeausschnitt zeigt, wie die when()-Methode verwendet wird:

 when(mock.someCode ()).thenReturn(5); 

Im obigen Code, thenReturn() wird meist mit dem verwendet Wann() Methode.

Mockito-Verify()-Methode

Der verifizieren() Mit der Methode wird überprüft, ob bestimmte Methoden aufgerufen werden oder nicht. Vereinfacht ausgedrückt validiert es das bestimmte Verhalten, das einmal in einem Test aufgetreten ist. Es wird am Ende des Testcodes verwendet, um sicherzustellen, dass die definierten Methoden aufgerufen werden.

Das Mockito-Framework verfolgt alle Methodenaufrufe mit ihren Parametern zum Verspotten von Objekten. Nach dem Verspotten können wir mithilfe der Methode „Verify()“ überprüfen, ob die definierten Bedingungen erfüllt sind oder nicht. Diese Art von Tests wird manchmal als bezeichnet Verhaltenstests. Es prüft, ob eine Methode mit den richtigen Parametern aufgerufen wird, anstatt das Ergebnis eines Methodenaufrufs zu überprüfen.

Die Methode verify() wird auch verwendet, um die Anzahl der Aufrufe zu testen. So können wir die genaue Anzahl der Aufrufe testen, indem wir verwenden mal Methode, mindestens einmal Methode, Und höchstens Methode für eine verspottete Methode.

In der Mockito-Klasse stehen zwei Arten von verify()-Methoden zur Verfügung, die unten aufgeführt sind:

verify()-Methode:Es überprüft, ob ein bestimmtes Verhalten einmal aufgetreten ist.
Syntax: überprüfen (T-Mock)verify()-Methode mit VerificationMode:Es überprüft, ob ein Verhalten mindestens einmal, genau so oft oder nie aufgetreten ist.
Syntax: überprüfen(T-Mock, VerificationMode-Modus)

Mockito spy()-Methode

Mockito bietet eine Methode zum teilweisen Verspotten eines Objekts, die als „ Spion Methode. Bei Verwendung der Spionagemethode existiert ein reales Objekt und es werden Spione oder Stubs dieses realen Objekts erstellt. Wenn wir eine Methode nicht mit Spy blockieren, wird das tatsächliche Methodenverhalten aufgerufen. Die Hauptfunktion der Methode spy() besteht darin, dass sie die spezifischen Methoden des realen Objekts überschreibt. Eine der Funktionen der spy()-Methode besteht darin, den Aufruf einer bestimmten Methode zu überprüfen.

In der Mockito-Klasse stehen zwei Arten von spy()-Methoden zur Verfügung:

spy()-Methode:Es entsteht ein Spion des realen Objekts. Die Spionagemethode ruft die echten Methoden auf, es sei denn, sie sind blockiert. Wir sollten die echten Spione vorsichtig und gelegentlich einsetzen, zum Beispiel beim Umgang mit dem Legacy-Code.
Syntax: Spion (T-Objekt)spy()-Methode mit Klasse:Es erstellt ein Spionageobjekt basierend auf der Klasse anstelle eines Objekts. Die Methode spy(T object) ist besonders nützlich zum Ausspionieren abstrakter Klassen, da diese nicht instanziiert werden können.
Syntax: spy(Klasse classToSpy)

Der folgende Codeausschnitt zeigt, wie die spy()-Methode verwendet wird:

 List spyArrayList = spy(ArrayList.class); 

Mockito-Reset()-Methode

Zum Zurücksetzen der Mockitos wird die Methode Mockito reset() verwendet. Es wird hauptsächlich für die Arbeit mit in den Container eingespritzten Mocks verwendet. Normalerweise führt die Methode reset() zu einem langen Code und schlechten Tests. Es ist besser, neue Mocks zu erstellen, als die Methode reset() zu verwenden. Aus diesem Grund wird die Methode reset() beim Testen selten verwendet.

Die Signatur der Methode reset() lautet:

Inselbuchstabe Java

 public static void reset(T ... mocks) { MOCKITO_CORE.reset(mocks); } 

Mockito-VerifyNoMoreInteractions()-Methode

Es wird verwendet, um zu überprüfen, ob es bei den gegebenen Mocks ungeprüfte Interaktionen gibt. Wir können diese Methode verwenden, nachdem wir alle Mocks überprüft haben, um sicherzustellen, dass nichts anderes auf den Mocks aufgerufen wurde. Es erkennt auch die nicht überprüften Aufrufe, die vor der Testmethode erfolgen, beispielsweise in setup(), der @Before-Methode oder dem Konstruktor. Es ist eine optionale Methode und wir müssen sie nicht in jedem Test verwenden.

Die Signatur der Methode „verifyNoMoreInteractions()“ lautet:

 public static void verifyNoMoreInteractions(Object... mocks) { MOCKITO_CORE.verifyNoMoreInteractions(mocks); } 

Mockito verifyZeroInteractions()-Methode

Es überprüft, ob bei den angegebenen Mocks keine Interaktion stattgefunden hat. Es erkennt auch die Aufrufe, die vor der Testmethode erfolgt sind, beispielsweise in setup(), der @Before-Methode oder dem Konstruktor.

Die Signatur der Methode „verifyZeroInteractions()“ lautet:

 public static void verifyZeroInteractions(Object... mocks) { MOCKITO_CORE.verifyNoMoreInteractions(mocks); } 

Mockito doThrow()-Methode

Es wird verwendet, wenn eine void-Methode blockiert werden soll, um eine Ausnahme auszulösen. Für jeden Methodenaufruf wird eine neue Ausnahmeinstanz erstellt. In der Mockito-Klasse stehen zwei Arten von doThrow()-Methoden mit unterschiedlichen Parametern zur Verfügung, wie unten gezeigt:

doThrow()-Methode mit Throwable:Diese Methode wird verwendet, wenn wir eine void-Methode mit einer Ausnahme blockieren möchten. Syntax: doThrow(Throwable toBeThrown)
Die Signatur der doThrow()-Methode lautet:

 public static Stubber doThrow(Throwable toBeThrown) { return MOCKITO_CORE.doAnswer(new ThrowsException(toBeThrown)); } 

doThrow()-Methode mit Klasse:Diese Methode wird verwendet, wenn wir eine void-Methode blockieren möchten, um eine Ausnahme einer bestimmten Klasse auszulösen.
Syntax: doThrow(Klasse toBeThrown)
Die Signatur der doThrow()-Methode lautet:

 public static Stubber doThrow(Class toBeThrown) { return MOCKITO_CORE.doAnswer(new ThrowsExceptionClass(toBeThrown)); } 

Mockito doCallRealMethod()-Methode

Es wird verwendet, wenn wir die reale Implementierung einer Methode aufrufen möchten. Mit anderen Worten: Es wird verwendet, um Teilmodelle eines Objekts zu erstellen. Es wird in seltenen Situationen verwendet, beispielsweise zum Aufrufen der echten Methoden. Sie ähnelt der spy()-Methode und der einzige Unterschied besteht darin, dass sie zu komplexem Code führt.

Die Signatur der doCallRealMethod()-Methode lautet:

 public static Stubber doCallRealMethod() { return MOCKITO_CORE.doAnswer(new CallsRealMethods()); } 

Mockito doAnswer()-Methode

Es wird verwendet, wenn wir eine void-Methode mit einem generischen Antworttyp versehen möchten. Die Signatur der doAnswer()-Methode lautet:

 public static Stubber doAnswer(Answer answer) { return MOCKITO_CORE.doAnswer(answer); } 

Mockito doNothing()-Methode

Es wird verwendet, um Void-Methoden so festzulegen, dass sie nichts tun. Die Methode doNothing() wird in seltenen Situationen verwendet. Standardmäßig führen die void-Methoden auf Scheininstanzen nichts aus, d. h. es wird keine Aufgabe ausgeführt.

Die Signatur der doNothing()-Methode lautet:

 public static Stubber doNothing() { return MOCKITO_CORE.doAnswer(new DoesNothing()); } 

Mockito doReturn()-Methode

Es wird in den seltenen Fällen verwendet, in denen wir Mockito.when(object) nicht verwenden können. Die Methode „Mockito.when(object)“ wird für das Stubbing immer empfohlen, da sie argumenttypsicher und im Vergleich zur Methode „doReturn()“ besser lesbar ist.

Die Signatur der doReturn()-Methode lautet:

 public static Stubber doReturn(Object toBeReturned) { return MOCKITO_CORE.doAnswer(new Returns(toBeReturned)); } 

Mockito inOrder()-Methode

Es wird verwendet, um Objekte zu erstellen, die die Überprüfung von Mocks in einer bestimmten Reihenfolge ermöglichen. Die nacheinander durchgeführte Überprüfung ist flexibler, da wir nicht alle Interaktionen überprüfen müssen. Wir müssen nur die Interaktionen überprüfen, die am Testen interessiert sind (in der Reihenfolge). Wir können auch die Methode inOrder() verwenden, um ein inOrder-Objekt zu erstellen, das Mocks übergibt, die für die In-Order-Verifizierung relevant sind.

Die Signatur der Methode Mockito.inOrder() lautet:

 public static InOrder inOrder(Object... mocks) { return MOCKITO_CORE.inOrder(mocks); } 

Mockito-ignoreStubs()-Methode

Es wird verwendet, um die Stub-Methoden bestimmter Mocks zur Überprüfung zu ignorieren. Dies ist nützlich bei den Methoden „VerifyNoMoreInteractions()“ oder „Verification inOrder()“. Es hilft auch dabei, eine redundante Überprüfung von abgeblockten Anrufen zu vermeiden.

Die Signatur der Methode „ignoreStubs()“ lautet:

 public static Object[] ignoreStubs(Object... mocks) { return MOCKITO_CORE.ignoreStubs(mocks); } 

Mockito times()-Methode

Es wird verwendet, um die genaue Anzahl der Methodenaufrufe zu überprüfen, was bedeutet, dass es angibt, wie oft eine Methode aufgerufen wird. Die Signatur der times()-Methode lautet:

 public static VerificationMode times(int wantedNumberOfInvocations) { return VerificationModeFactory.times(wantedNumberOfInvocations); } 

Mockito never()-Methode

Es wird verwendet, um zu überprüfen, ob die Interaktion nicht stattgefunden hat. Die Signatur der never()-Methode lautet:

 public static VerificationMode never() { return times(0); } 

Mockito atLeastOnce()-Methode

Es wird verwendet, um den Aufruf mindestens einmal zu überprüfen, was bedeutet, dass die Methode mindestens einmal aufgerufen werden sollte.

Die Signatur der atLeastOnce()-Methode lautet:

 public static VerificationMode atLeastOnce() { return VerificationModeFactory.atLeastOnce(); } 

Mockito atLeast()-Methode

Es wird verwendet, um den Aufruf mindestens x-mal zu überprüfen. Wenn beispielsweise atLeast(3) gegeben ist, bedeutet dies, dass die Methode mindestens dreimal aufgerufen wird.

privates vs. öffentliches Java

Die Signatur der atLeast()-Methode lautet:

 public static VerificationMode atLeast(int minNumberOfInvocations) { return VerificationModeFactory.atLeast(minNumberOfInvocations); } 

Mockito atMost()-Methode

Es wird verwendet, um den Aufruf höchstens x-mal zu überprüfen. Wenn beispielsweise atMost(3) gegeben ist, bedeutet dies, dass die Methode maximal dreimal aufgerufen wird.

Die Signatur der atMost()-Methode lautet:

 public static VerificationMode atMost(int maxNumberOfInvocations) { return VerificationModeFactory.atMost(maxNumberOfInvocations); } 

Mockito-Calls()-Methode

Es ermöglicht eine nicht gierige Überprüfung der Reihenfolge. Es kann nur mit der Überprüfungsmethode inOrder() verwendet werden. Zum Beispiel inOrder.verify(mock,calls(3)).xyzMethod('...');

Die Signatur der Methode „calls()“ lautet:

 public static VerificationMode calls( int wantedNumberOfInvocations ){ return VerificationModeFactory.calls( wantedNumberOfInvocations ); } 

Mockito only()-Methode

Es prüft, ob die angegebene Methode die einzige aufgerufene Methode war. Die Signatur der only()-Methode lautet:

Operatoren in der Python-Programmierung

 public static VerificationMode only() { return VerificationModeFactory.only(); } 

Mockito timeout()-Methode

Es ermöglicht Mockito, eine Verifizierung mit Zeitüberschreitung durchzuführen. Es weist eine Überprüfung an, eine bestimmte Zeitspanne auf eine bestimmte Interaktion zu warten, anstatt sofort fehlzuschlagen. Es kann zum Testen in bestehenden Situationen nützlich sein.

Die Methode timeout() unterscheidet sich von der Methode after() darin, dass die Methode after() den gesamten Zeitraum abwartet, bis das Endergebnis deklariert wird, wohingegen die Methode timeout() stoppt, sobald die Überprüfung erfolgreich ist. Es wird selten beim Testen verwendet.

Die Signatur der timeout()-Methode lautet:

 public static VerificationWithTimeout timeout(long millis) { return new Timeout(millis, VerificationModeFactory.times(1)); } 

Mockito after()-Methode

Dadurch kann Mockito die Überprüfung über einen bestimmten Zeitraum durchführen. Wir haben bereits besprochen, dass sich die Methode after() von der Methode timeout() unterscheidet.

Die Signatur der after()-Methode lautet:

 public static VerificationAfterDelay after(long millis) { return new After(millis, VerificationModeFactory.times(1)); } 

Mockito-ValidateMockitoUsage()-Methode

Es wird zur expliziten Validierung des Framework-Status verwendet, um die ungültige Verwendung des Mockito-Frameworks zu erkennen. Es handelt sich um eine optionale Funktion von Mockito, da sie die Nutzung ständig validiert. Sowohl der integrierte Runner (MockitoJUnitRunner) als auch die Regel (MockitoRule) rufen nach jeder Testmethode die Methode „validateMockitoUsage()“ auf.

Die Signatur der Methode „validateMockitoUsage()“ lautet:

 public static void validateMockitoUsage() { MOCKITO_CORE.validateMockitoUsage(); } 

Mockito withSettings()-Methode

Es wird verwendet, um Mocks mit zusätzlichen Mock-Einstellungen zu erstellen. Es sollte gelegentlich zum Testen verwendet werden. Anstatt die Methode withSettings() zu verwenden, erstellen Sie einfache Tests mit einfachen Mocks. Die Hauptgründe für die Verwendung der MockSettings sind

• Durch die Verwendung von MockSetting können wir bei Bedarf problemlos weitere Mock-Einstellungen hinzufügen.
• Es kombiniert verschiedene Scheineinstellungen, ohne den Code durcheinander zu bringen.

Die Signatur der withSettings()-Methode lautet:

 public static MockSettings withSettings() { return new MockSettingsImpl().defaultAnswer(RETURNS_DEFAULTS); }