Use Mockito para simular el método estático en Java

Este tutorial demuestra cómo podemos usar el mockito para simular el método estático en Java.

Método estático simulado en Java

Se requieren métodos estáticos simulados cuando se realizan pruebas unitarias en Java. Antes de la versión Mockito 3.4.0, necesitamos usar PowerMock para simular los métodos estáticos y privados.

Con Mockito 3.4.0, podemos simular directamente los métodos estáticos. Este tutorial demuestra cómo simular métodos estáticos usando mockito en Java.

Agregar dependencia de Maven

Antes de comenzar con mockito, debemos agregarlo a nuestro sistema. Para simular el método estático, requerimos inline mock-making de mockito inline mocking.

El mockito-inline se desarrolla por separado para los comentarios de la comunidad, lo que proporciona la función de simulación para los métodos estáticos y la clase final, que antes no se podían burlar; aquí está la dependencia maven para la burla en línea mockito:

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

Agregue esta dependencia a pom.xml de su sistema maven, y estará listo para comenzar.

Diferentes ejemplos de código que utilizan la simulación en línea Mockito

Primero decidamos un sistema que podamos aplicar para simular métodos estáticos. Creemos una clase simple con dos métodos, uno con argumentos y otro sin argumentos. Ver ejemplo:

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();
  }
}

El código anterior contiene una clase simple que tiene dos métodos:

1. El primer método devuelve el valor delftstack y no acepta ningún argumento.
2. El segundo método toma argumentos y devuelve su suma.

Clase estática simulada

Antes de burlarnos del método estático, necesitamos burlarnos de la clase estática. Aquí está el ejemplo de código de cómo simular una clase estática usando mockito en Java:

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

El MockedStatic en el código anterior representa los simulacros activos y de ámbito de los métodos estáticos de tipo. El mockStatic se utiliza para verificar las invocaciones de métodos estáticos.

Método estático simulado sin argumentos

Intentemos burlarnos del primer método, get_Value(), que no acepta argumentos y devuelve el valor delftstack. Intentaremos burlarnos del método get_Value() y devolver el valor delftstack1; ver el ejemplo:

@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());
}

El código anterior se burla del método estático get_Value(),, y ahora, fuera del alcance, el método devolverá delftstack, y dentro del alcance, devolverá delftstack1.

Método estático simulado con argumentos

No hay mucha diferencia entre burlarse de un método estático con argumentos y un método estático sin argumentos.

Para simular un método estático con argumentos, podemos usar coincidencias de argumentos flexibles en expectativas y expresión lambda para invocar los métodos; ver ejemplo:

@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));
}

El código anterior se burla del método estático con argumentos del código anterior.

El código anterior devolverá la suma de los argumentos dados, ya que se burla de IntStream.of(args).sum(), que se utiliza para calcular la suma de los argumentos dados. Fuera del ámbito, el método devolverá la suma 3, y dentro del ámbito, debería devolver el valor 10.