wake-up-neo.com

Unterschied zwischen @Mock, @MockBean und Mockito.mock ()

Was ist der Unterschied zwischen diesen drei Ansätzen, wenn Sie Tests erstellen und Abhängigkeiten verspotten?

  1. @MockBean:

    @MockBean
    MyService myservice;
    
  2. @Spotten:

    @Mock
    MyService myservice;
    
  3. Mockito.mock ()

    MyService myservice = Mockito.mock(MyService.class);
    
90
Doug

Einfache Mockito-Bibliothek

import org.mockito.Mock;
...
@Mock
MyService myservice;

und

import org.mockito.Mockito;
...
MyService myservice = Mockito.mock(MyService.class);

stammen aus der Mockito-Bibliothek und sind funktional gleichwertig.
Sie ermöglichen es, eine Klasse oder eine Schnittstelle zu verspotten und das Verhalten aufzuzeichnen und zu überprüfen.

Die Verwendung von Anmerkungen ist kürzer, daher vorzuziehen und oft vorzuziehen.


Beachten Sie, dass zum Aktivieren von Mockito-Annotationen während der Testausführung die statische Methode MockitoAnnotations.initMocks(this) aufgerufen werden muss.
Um Nebenwirkungen zwischen den Tests zu vermeiden, wird empfohlen, dies vor jeder Testdurchführung zu tun:

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

Eine andere Möglichkeit, Mockito-Annotationen zu aktivieren, besteht darin, die Testklasse mit @RunWith Zu annotieren, indem Sie das MockitoJUnitRunner angeben, das diese Aufgabe ausführt, sowie weitere nützliche Dinge:

@RunWith(org.mockito.runners.MockitoJUnitRunner.class)
public MyClassTest{...}

Spring Boot-Bibliothek, die die Mockito-Bibliothek umschließt

Dies ist in der Tat eine Spring Boot-Klasse :

import org.springframework.boot.test.mock.mockito.MockBean;
...
@MockBean
MyService myservice;

Die Klasse ist in der Bibliothek spring-boot-test Enthalten.

Es erlaubt das Hinzufügen von Mockito-Mocks in einem Spring ApplicationContext.
Wenn eine Bean, die mit der deklarierten Klasse kompatibel ist, im Kontext vorhanden ist, ersetzt sie durch den Schein.
Wenn dies nicht der Fall ist, fügt es den Schein im Kontext als Bean hinzu .

Javadoc-Referenz:

Anmerkung, mit der einem Spring ApplicationContext Mocks hinzugefügt werden können.

...

Wenn eine vorhandene einzelne Bean desselben Typs, der im Kontext definiert ist, durch die Schein-Bean ersetzt wird, wird eine neue Bean hinzugefügt, wenn keine vorhandene Bean definiert ist.


Wann wird klassisches/einfaches Mockito verwendet und wann wird @MockBean Von Spring Boot verwendet?

Komponententests dienen dazu, eine Komponente isoliert von anderen Komponenten zu testen. Außerdem müssen Komponententests hinsichtlich der Ausführungszeit so schnell wie möglich sein, da diese Tests täglich ein Dutzend Mal auf den Entwicklercomputern ausgeführt werden können.

Folglich ist hier eine einfache Richtlinie:

Wenn Sie einen Test schreiben, der keine Abhängigkeiten vom Spring Boot-Container benötigt, ist der klassische/einfache Mockito der richtige Weg: Er ist schnell und begünstigt die Isolierung der getesteten Komponente.
Wenn sich Ihr Test auf den Spring Boot-Container und stützen muss, möchten Sie auch einen der Container-Beans hinzufügen oder verspotten: @MockBean Von Spring Boot ist übrigens.


Typische Verwendung von Spring Boot @MockBean

Während wir eine Testklasse schreiben, die mit @WebMvcTest (Web Test Slice) kommentiert ist.

Die Spring Boot Dokumentation fasst das sehr gut zusammen:

Häufig wird @WebMvcTest Auf einen einzelnen Controller beschränkt und in Kombination mit @MockBean Verwendet, um für erforderliche Mitarbeiter Scheinimplementierungen bereitzustellen.

Hier ist ein Beispiel :

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@RunWith(SpringRunner.class)
@WebMvcTest(FooController.class)
public class FooControllerTest {

    @Autowired
    private MockMvc mvc;

    @MockBean
    private FooService fooServiceMock;

    @Test
    public void testExample() throws Exception {
         Foo mockedFoo = new Foo("one", "two");

         Mockito.when(fooServiceMock.get(1))
                .thenReturn(mockedFoo);

         mvc.perform(get("foos/1")
            .accept(MediaType.TEXT_PLAIN))
            .andExpect(status().isOk())
            .andExpect(content().string("one two"));
    }

}
134
davidxxx

Am Ende ist es einfach zu erklären. Wenn Sie sich nur die Javadocs der Anmerkungen ansehen, werden Sie die Unterschiede sehen:

@Mock: (org.mockito.Mock)

Markiere ein Feld als Mock.

  • Ermöglicht die Erstellung von Kurzmustern.
  • Minimiert sich wiederholenden Mock-Erstellungscode.
  • Verbessert die Lesbarkeit der Testklasse.
  • Erleichtert das Ablesen des Überprüfungsfehlers, da der Feldname zur Identifizierung des Modells verwendet wird.

@MockBean: (org.springframework.boot.test.mock.mockito.MockBean)

Anmerkung, mit der einem Spring ApplicationContext Mocks hinzugefügt werden können. Kann als Annotation auf Klassenebene oder für Felder in Klassen @Configuration Oder Testklassen, die @RunWith Der SpringRunner sind, verwendet werden.

Mocks können nach Typ oder nach Bean-Namen registriert werden. Jede existierende einzelne Bean desselben Typs, die im Kontext definiert ist, wird durch den Mock ersetzt. Wenn keine existierende Bean definiert ist, wird eine neue hinzugefügt.

Wenn @MockBean In einem Feld verwendet und im Anwendungskontext registriert wird, wird der Schein ebenfalls in das Feld eingefügt.

Mockito.mock ()

Es ist nur die Darstellung eines @Mock.

9
Patrick