Java Marco de pruebas Mock Mockito

Java 常用类库Bibliotecas comunes de Java


¿Qué es la prueba Mock?

En el desarrollo de software, las pruebas unitarias son un medio importante para verificar la funcionalidad del código. Sin embargo, cuando nuestro código depende de sistemas externos (como bases de datos, servicios de red, etc.), realizar pruebas directamente presenta varios problemas:

  1. Las dependencias externas pueden ser inestables o no estar disponibles
  2. La velocidad de ejecución de las pruebas se vuelve más lenta
  3. Es difícil simular varias condiciones límite

La prueba Mock (prueba simulada) resuelve estos problemas creando "suplentes" de los objetos. Los objetos Mock pueden:

  • Simular el comportamiento de objetos reales
  • Verificar si las interacciones ocurren como se esperaba
  • No ejecutar la lógica real de los objetos reales

¿Por qué elegir Mockito?

Mockito es actualmente el marco de pruebas Mock más popular en el ecosistema Java, y tiene las siguientes ventajas:

  1. API concisa: Curva de aprendizaje suave, fácil de empezar
  2. Funciones potentes: Admite verificación de llamadas a métodos, configuración de valores de retorno, lanzamiento de excepciones, etc.
  3. Buena legibilidad: El código de prueba es intuitivo y fácil de entender
  4. Comunidad activa: Actualización y mantenimiento continuos, documentación completa

Conceptos principales de Mockito

1. Crear objetos Mock

Ejemplo

// Método 1: Usar método estático
List mockedList = Mockito.mock(List.class);

// Método 2: Usar anotaciones (se requiere MockitoJUnitRunner)
@Mock
List mockedList;

2. Configurar el comportamiento de los métodos

Ejemplo

// Devuelve 100 cuando se llama a mockedList.size()
when(mockedList.size()).thenReturn(100);

// Devuelve "first" cuando se llama a mockedList.get(0)
when(mockedList.get(0)).thenReturn("first");

// Lanza una excepción cuando se llama a mockedList.get(1)
when(mockedList.get(1)).thenThrow(new RuntimeException());

3. Verificar interacciones

Ejemplo

// Verificar que mockedList.add("one") se llamó una vez
verify(mockedList).add("one");

// Verificar que mockedList.clear() nunca se llamó
verify(mockedList, never()).clear();

// Verificar que mockedList.add("two") se llamó al menos dos veces
verify(mockedList, atLeast(2)).add("two");

Ejemplo de aplicación práctica de Mockito

Probar el servicio de usuario

Supongamos que tenemos unUserServiceque depende deUserRepository:

Ejemplo

public class UserService {
    private UserRepository userRepository;
   
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
   
    public User getUserById(Long id) {
        return userRepository.findById(id)
            .orElseThrow(() -> new UserNotFoundException("User not found"));
    }
}

Realizar pruebas con Mockito:

Ejemplo

public class UserServiceTest {
    @Mock
    private UserRepository userRepository;
   
    @InjectMocks
    private UserService userService;
   
    @Before
    public void setup() {
        MockitoAnnotations.initMocks(this);
    }
   
    @Test
    public void testGetUserById_Success() {
        // Preparar datos de prueba
        User mockUser = new User(1L, "testUser");
       
        // Configurar el comportamiento del Mock
        when(userRepository.findById(1L))
            .thenReturn(Optional.of(mockUser));
       
        // Ejecutar la prueba
        User result = userService.getUserById(1L);
       
        // Verificar el resultado
        assertEquals("testUser", result.getUsername());
        verify(userRepository).findById(1L);
    }
   
    @Test(expected = UserNotFoundException.class)
    public void testGetUserById_NotFound() {
        when(userRepository.findById(2L))
            .thenReturn(Optional.empty());
       
        userService.getUserById(2L);
    }
}

Características avanzadas de Mockito

1. Coincidencia de parámetros

Ejemplo

// Cualquier parámetro entero
when(mockedList.get(anyInt())).thenReturn("element");

// Parámetros de un tipo específico
when(mockedList.contains(anyString())).thenReturn(true);

// Coincidencia personalizada
when(mockedList.add(argThat(arg -> arg.length() > 5))).thenReturn(true);

2. Verificar el orden de las llamadas

Ejemplo

InOrder inOrder = inOrder(mockedList);

inOrder.verify(mockedList).add("first");
inOrder.verify(mockedList).add("second");

3. Mock parcial (Spy)

Ejemplo

List realList = new ArrayList();
List spyList = spy(realList);

// Llamar al método real
spyList.add("real");

// Simular un método específico
doReturn(100).when(spyList).size();

Mejores prácticas

  1. No uses Mock en exceso: Solo haz Mock de las dependencias necesarias, mantén la autenticidad de las pruebas
  2. Verifica las interacciones con moderación: Concéntrate en las interacciones importantes, no verifiques cada llamada a método
  3. Mantén las pruebas concisas: Cada método de prueba debe probar solo un punto funcional
  4. Organiza el código de prueba de manera razonable: Usa @Before para la configuración común
  5. Combina con otras herramientas de prueba: Úsalo junto con JUnit, AssertJ, etc.

Preguntas frecuentes

P: ¿Cuál es la diferencia entre Mockito y PowerMock?

R: Mockito se usa principalmente para el Mock de objetos ordinarios, mientras que PowerMock puede hacer Mock de métodos estáticos, constructores, etc. Sin embargo, PowerMock rompe el aislamiento de las pruebas, por lo que se recomienda usar Mockito primero.

P: ¿Cuándo debería usar Spy en lugar de Mock?

R: Usa Spy cuando necesites la mayor parte del comportamiento real y solo modifiques unos pocos métodos. Si necesitas controlar completamente el comportamiento del objeto, usa Mock.

P: ¿Se puede usar Mockito para clases o métodos finales?

R: Desde Mockito 2.1.0, es posible hacer Mock de clases y métodos finales mediante configuración, pero es necesario agregar lamockito-inlinedependencia.


Enlaces relacionados

  1. Documentación oficial de Mockito
  2. Repositorio de Mockito en GitHub

Java 常用类库Bibliotecas comunes de Java

Otras extensiones