Java Marco de pruebas Mock Mockito
¿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:
- Las dependencias externas pueden ser inestables o no estar disponibles
- La velocidad de ejecución de las pruebas se vuelve más lenta
- 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:
- API concisa: Curva de aprendizaje suave, fácil de empezar
- Funciones potentes: Admite verificación de llamadas a métodos, configuración de valores de retorno, lanzamiento de excepciones, etc.
- Buena legibilidad: El código de prueba es intuitivo y fácil de entender
- Comunidad activa: Actualización y mantenimiento continuos, documentación completa
Conceptos principales de Mockito
1. Crear objetos Mock
Ejemplo
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
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
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
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
@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
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.verify(mockedList).add("first");
inOrder.verify(mockedList).add("second");
3. Mock parcial (Spy)
Ejemplo
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
- No uses Mock en exceso: Solo haz Mock de las dependencias necesarias, mantén la autenticidad de las pruebas
- Verifica las interacciones con moderación: Concéntrate en las interacciones importantes, no verifiques cada llamada a método
- Mantén las pruebas concisas: Cada método de prueba debe probar solo un punto funcional
- Organiza el código de prueba de manera razonable: Usa @Before para la configuración común
- 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.
Bibliotecas comunes de Java