Wie benutze ich Mockito zum Verspotten in Java?

Um Mockito effektiv für Java-Unit-Tests zu verwenden, müssen Sie zuerst Mockito-Abhängigkeiten hinzufügen, das Maven-Projekt fügt Mockito-Core-Abhängigkeiten in pom.xml hinzu, und das Gradle-Projekt fügt Testimplementation hinzu. Erstellen Sie dann Mock -Objekte über @mock Annotation (kombiniert mit @extendWith (mockitoextension.class)) oder Mock () -Methode; Verwenden Sie dann, wann (...). DhetReturn (...) und andere Methoden, um das Methodenverhalten des Scheinobjekts zu beflügeln, und Sie können auch Ausnahmegleitungen oder mehrere Rückgabewerte konfigurieren. Verify () nach dem Testen verifizieren Sie die Nummer und Methodenaufrufe, z. B. verifizieren (Mock, Zeiten (2)). Methode (); Für komplexe Verhaltensweisen kann eine teilweise Logik realer Objekte simuliert werden, und eine teilweise Simulation wird mit @SPY implementiert, wobei Sie aufmerksam sind, um unerwartete reale Anrufe zu vermeiden. Die Verwendung von @injectMocks kann automatisch Scheinobjekte in die zu testende Klasse injizieren, was Konstruktoren, Setter oder Feldinjektion unterstützt. Schließlich vermeiden Sie nach Best Practices, nicht verspotteten Wertobjekten, die Übersesimulation, die Priorisierung der Verifizierung des Zustands gegenüber der Interaktion und die präzise und stabile Haltung des Tests. Die ordnungsgemäße Verwendung von Mockito ermöglicht schnelle, zuverlässige, isolierte Einheiten -Tests.

Mockito ist ein beliebtes Verspottungsgerüst in Java, das für Unit -Tests verwendet wird. Sie können Mock -Objekte erstellen und konfigurieren, um das Verhalten realer Abhängigkeiten zu simulieren und Ihre Tests schneller, zuverlässiger und isolierter zu gestalten. Hier erfahren Sie, wie Sie Mockito effektiv verwenden.

1. Fügen Sie Mockito -Abhängigkeit hinzu

Fügen Sie zunächst Mockito in Ihr Projekt auf. Wenn Sie Maven verwenden, fügen Sie dies zu Ihrem pom.xml hinzu:

 <De vorangehen>
    <CruupId> org.mockito </gruppeId>
    <artifactid> mockito-core </artifactid>
    <version> 5.7.0 </Version>
    <Schops> Test </Scope>
</abhängig>

Für Gradle:

 Testimplementation 'org.Mockito: Mockito-Core: 5.7.0'

Die meisten modernen Test -Setups (wie Spring Boot oder Junit 5) umfassen bereits Mockito. Überprüfen Sie daher Ihre vorhandenen Abhängigkeiten.

2. Erstellen Sie Scheinobjekte

Verwenden Sie Mockito.mock() oder die @Mock -Annotation, um Mocks zu erstellen.

Verwenden Sie @Mock (empfohlen mit @ExtendWith(MockitoExtension.class) ):

 import org.junit.jupiter.api.test;
import org.junit.jupiter.api.extension.extendwith;
import org.mockito.mock;
import org.mockito.junit.jupiter.mockitoextesion;

importieren java.util.list;

import static org.junit.jupiter.api.asserions.assertequals;
statische org.mockito.mockito.when;

@ExtendWith (Mockitoextension.class)
öffentliche Klasse myTest {

    @Verspotten
    private Liste <string> Liste;

    @Prüfen
    public void testmock () {
        wenn (list.get (0)). threturn ("Hallo");
        AssertEquals ("Hallo", list.get (0));
    }
}

Hinweis: @ExtendWith(MockitoExtension.class) initialisiert die @Mock -Anmerkungen.

Verwenden der mock() -Methode:

 Liste <String> list = Mock (list.class);
wenn (list.get (0)). threturn ("Hallo");

3. Stubbing -Methoden

Sie können definieren, was eine verspottete Methode mit dem zurückgeführt wird, when(...).thenReturn(...) .

 wenn (list.size ()). threturn (100);
wenn (list.isempty ()). threturn (true);

Sie können auch Ausnahmen werfen:

 wenn (list.get (1)). Thenthrow (neuer IndexoutOfBoundSexception ());

Oder verwenden Sie unterschiedliche Verhaltensweisen:

 wenn (list.get (0)). threturn ("zuerst"). threturn ("zweite");
// Der erste Anruf gibt "First" zurück, der zweite Anruf kehrt "zweite" zurück.

4. Überprüfen Sie die Interaktionen

Überprüfen Sie nach dem Ausführen Ihres Codes, dass bestimmte Methoden genannt wurden:

 list.add ("eins");
list.add ("zwei");

// Methoden überprüften, wurden genannt
verifizieren (Liste) .Add ("eins");
Überprüfen Sie (Liste, Zeiten (2)). Hinzufügen (irgendein () ()); // zweimal mit einer Zeichenfolge angerufen
überprüfen (listen, nie ()). clear (); // sicherstellen, dass Clear () nie gerufen wurde

Andere Bestätigungsoptionen:

• atLeastOnce()
• atMost(3)
• timeout(100) - für asynchrische Anrufe

5. Scheinrealistisches Verhalten

Für Schnittstellen oder Klassen mit komplexer Logik können Sie mehrere Verhaltensweisen stoßen:

 Karte <String, Integer> map = mock (map.class);

wenn (map.get ("key")). threturn (1);
wenn (map.containsKey ("key")). threturn (true);

Wenn Sie ein teilweise Spott benötigen (reale Methodenaufrufe mit einigen verspotteten), verwenden Sie @Spy :

 List <String> spylist = Spy (NeuarrayList <> ());
Spylist.Add ("Real Item");

wenn (spylist.get (0)). threturn ("verspottetes Element"); // überschreien nur (0)

Seien Sie vorsichtig mit @Spy - echte Methoden werden aufgerufen, es sei denn, stumpf.

6. Mocks mit @InjectMocks injizieren

Verwenden Sie @InjectMocks , um verspottete Abhängigkeiten in die zu testende Klasse zu injizieren.

 Klassenservice {
    Private Final Repository Repository;

    öffentlicher Dienst (Repository Repository) {
        this.Repository = repository;
    }

    public String getData () {
        return repository.fetchData ();
    }
}

@ExtendWith (Mockitoextension.class)
Klasse servicetest {

    @Verspotten
    privates Repository -Repository;

    @InjectMocks
    Privatservice;

    @Prüfen
    void shartReturnMockedData () {
        wenn (repository.fetchData ()). threeturn ("test");

        String result = service.getData ();
        Assertequals ("Test", Ergebnis);
    }
}

Mockito versucht, Mocks über Konstruktor, Setter oder Feldinjektion zu injizieren.

Best Practices

• Verspottete Objekte nicht (wie String, Ganzzahl, DTOS).
• Vermeiden Sie es, Bibliotheken von Drittanbietern zu verspotten, es sei denn, dies ist unbedingt erforderlich.
• Bevorzugen Sie die Zustandsüberprüfung gegenüber der Interaktionsprüfung nach Möglichkeit.
• Halten Sie Mocks einfach -Übermaän können Tests zerbrechlich machen.
• Verwenden Sie in einigen Fällen try-with-mocks (Mockito 5) für die Reinigung von Reinigung.

Durch die Verwendung von Mockito können Sie saubere, fokussierte Unit -Tests schreiben, die die Logik überprüfen, ohne sich auf externe Systeme zu verlassen. Mit Stubbing und Überprüfung erhalten Sie die volle Kontrolle über Abhängigkeiten.

Im Grunde genommen verspotten Sie, was Sie nicht kontrollieren, überprüfen Sie, was Sie erwarten, und halten Sie Ihre Tests schnell und bestimmen.

Das obige ist der detaillierte Inhalt vonWie benutze ich Mockito zum Verspotten in Java?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!