Verwenden Sie Mockito, um die statische Methode in Java zu simulieren

Dieses Tutorial zeigt, wie wir mit mockito die statische Methode in Java nachahmen können.

Scheinstatische Methode in Java

Mocking Static Methods sind erforderlich, wenn Einheitentests in Java durchgeführt werden. Vor der Version Mockito 3.4.0 müssen wir PowerMock verwenden, um die statischen und privaten Methoden zu simulieren.

Mit Mockito 3.4.0 können wir die statischen Methoden direkt mocken. Dieses Tutorial zeigt, wie man statische Methoden mit mockito in Java mockt.

Maven-Abhängigkeit hinzufügen

Bevor wir mit mockito beginnen, müssen wir es unserem System hinzufügen. Um die statische Methode zu mocken, benötigen wir inline mock-making von mockito inline mocking.

Das mockito-inline wird separat für Community-Feedback entwickelt, das die Mocking-Möglichkeit für statische Methoden bereitstellt, und the final class, die vorher nicht mockbar waren; Hier ist die Maven-Abhängigkeit für das Inline-Mocking von mockito:

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-inline</artifactId>
    <version>4.6.1</version>
    <scope>test</scope>
</dependency>

Fügen Sie diese Abhängigkeit zu pom.xml Ihres Maven-Systems hinzu, und Sie können loslegen.

Verschiedene Codebeispiele mit Mockito Inline-Mocking

Entscheiden wir uns zunächst für ein System, das wir auf simulierte statische Methoden anwenden können. Lassen Sie uns eine einfache Klasse mit zwei Methoden erstellen, eine mit Argumenten und eine ohne Argumente. Siehe Beispiel:

package delftstack;

import java.util.stream.IntStream;

class Mock_Static_Method {
  public static String get_Value() {
    return "delftstack";
  }

  public static int addition(int... args) {
    return IntStream.of(args).sum();
  }
}

Der obige Code enthält eine einfache Klasse mit zwei Methoden:

1. Die erste Methode gibt den Wert delftstack zurück und nimmt kein Argument entgegen.
2. Die zweite Methode nimmt Argumente und gibt ihre Summe zurück.

Statische Mock-Klasse

Bevor wir die statische Methode verspotten, müssen wir die statische Klasse verspotten. Hier ist das Codebeispiel, wie man eine statische Klasse mit mockito in Java mockt:

try (MockedStatic Mock_Static_Class = mockStatic(AppStatic.class)) {
  // Here, we can record mock expectations, test code, and verify mock
}

Das MockedStatic im obigen Code repräsentiert die bereichsbezogenen und aktiven Mocks von statischen Methoden des Typs. Das mockStatic wird verwendet, um statische Methodenaufrufe zu verifizieren.

Scheinstatische Methode ohne Argumente

Versuchen wir, die erste Methode, get_Value(), zu verspotten, die keine Argumente akzeptiert und den Wert delftstack zurückgibt. Wir werden versuchen, die Methode get_Value() zu simulieren und den Wert delftstack1 zurückzugeben; siehe Beispiel:

@Test
public void Testing_Get_Value() {
  // Outside the scope
  assertEquals("delftstack", Mock_Static_Method.get_Value());

  try (MockedStatic Mock_Static = mockStatic(Mock_Static_Method.class)) {
    Mock_Static.when(Mock_Static_Method::get_Value).thenReturn("delftstack1");

    // Inside the scope
    assertEquals("delftstack1", Mock_Static_Method.get_Value());
    Mock_Static.verify(Mock_Static_Method::get_Value);
  }

  // Outside the scope
  assertEquals("delftstack", Mock_Static_Method.get_Value());
}

Der obige Code verspottet die statische Methode get_Value(),, und jetzt gibt die Methode außerhalb des Gültigkeitsbereichs delftstack zurück, und innerhalb des Gültigkeitsbereichs gibt sie delftstack1 zurück.

Scheinstatische Methode mit Argumenten

Es gibt keinen großen Unterschied zwischen dem Spotten einer statischen Methode mit Argumenten und einer statischen Methode ohne Argumente.

Um eine statische Methode mit Argumenten zu simulieren, können wir flexible Argumentübereinstimmungen in Erwartungen und Lambda-Ausdrücken verwenden, um die Methoden aufzurufen. siehe Beispiel:

@Test
public void Testing_Addition() {
  assertEquals(3, Mock_Static_Method.addition(1, 2));

  try (MockedStatic Mock_Static = mockStatic(Mock_Static_Method.class)) {
    Mock_Static.when(() -> Mock_Static_Method.addition(anyInt(), anyInt())).thenReturn(10);

    assertEquals(10, Mock_Static_Method.addition(1, 2));
    Mock_Static.verify(() -> ClassWithStaticMethod.addition(1, 2));
  }

  assertEquals(3, Mock_Static_Method.addition(1, 2));
}

Der obige Code verspottet die statische Methode mit Argumenten aus dem obigen Code.

Der obige Code gibt die Summe der angegebenen Argumente zurück, da er IntStream.of(args).sum() verspottet, der zur Berechnung der Summe der angegebenen Argumente verwendet wird. Außerhalb des Gültigkeitsbereichs gibt die Methode die Summe 3 zurück, und innerhalb des Gültigkeitsbereichs sollte sie den Wert 10 zurückgeben.