Saltar al contenido principal

Capítulo 3: Mocking con Mockito

Introducción​

¿Cómo probar un UserService que depende de un UserRepository? Sin la base de datos, la prueba falla. La solución: Mockear el repositorio para simular su comportamiento.

🎯 Objetivos del Capítulo​

Al final de este capítulo, usted sabrá:

  1. ✅ Comprender por qué y cuándo mockear
  2. ✅ Crear mocks con @Mock y @InjectMocks
  3. ✅ Configurar el comportamiento con when().thenReturn()
  4. ✅ Verificar las llamadas con verify()
  5. ✅ Utilizar argument matchers

1. ¿Por qué Mockear?​

El Problema​

// Esta clase depende de UserRepository
@Service
public class UserService {
    private final UserRepository userRepository;
    
    public User findById(Long id) {
        return userRepository.findById(id)
            .orElseThrow(() -> new UserNotFoundException(id));
    }
}

// ¿Cómo probar sin base de datos?
@Test
void shouldFindUserById() {
    UserService service = new UserService(???);  // ¡Se necesita un repositorio!
}

La Solución: Mocking​

@Test
void shouldFindUserById() {
    // Crear un repositorio FALSO
    UserRepository mockRepo = mock(UserRepository.class);
    
    // Decirle qué retornar
    when(mockRepo.findById(1L)).thenReturn(Optional.of(new User("John")));
    
    // Probar el servicio
    UserService service = new UserService(mockRepo);
    User user = service.findById(1L);
    
    assertEquals("John", user.getName());
}

2. Configuración Básica​

Con Anotaciones (Recomendado)​

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)  // ← Activa Mockito
class UserServiceTest {

    @Mock  // ← Crea un mock
    private UserRepository userRepository;

    @InjectMocks  // ← Inyecta los mocks
    private UserService userService;

    @Test
    void shouldFindUserById() {
        // when/then aquí
    }
}

Flujo de Inyección​

@Mock userRepository ─────┐
                          ├──→ @InjectMocks userService
@Mock anotherDep ─────────┘

3. when().thenReturn()​

Retornar un Valor​

@Test
void shouldReturnUser() {
    // Configurar el mock
    User mockUser = new User(1L, "John", "john@email.com");
    when(userRepository.findById(1L)).thenReturn(Optional.of(mockUser));
    
    // Probar
    User result = userService.findById(1L);
    
    // Verificar
    assertEquals("John", result.getName());
}

Retornar Diferentes Valores​

@Test
void shouldReturnDifferentUsers() {
    when(userRepository.findById(1L)).thenReturn(Optional.of(new User("John")));
    when(userRepository.findById(2L)).thenReturn(Optional.of(new User("Jane")));
    when(userRepository.findById(99L)).thenReturn(Optional.empty());
    
    assertEquals("John", userService.findById(1L).getName());
    assertEquals("Jane", userService.findById(2L).getName());
    assertThrows(UserNotFoundException.class, () -> userService.findById(99L));
}

Llamadas Consecutivas​

@Test
void shouldReturnDifferentValuesOnConsecutiveCalls() {
    when(userRepository.count())
        .thenReturn(0L)
        .thenReturn(1L)
        .thenReturn(2L);
    
    assertEquals(0L, userRepository.count());  // 1ª llamada
    assertEquals(1L, userRepository.count());  // 2ª llamada
    assertEquals(2L, userRepository.count());  // 3ª llamada
    assertEquals(2L, userRepository.count());  // Después: último valor
}

4. thenThrow() - Simular Excepciones​

@Test
void shouldThrowException() {
    when(userRepository.findById(anyLong()))
        .thenThrow(new DatabaseException("Connection failed"));
    
    assertThrows(DatabaseException.class, () -> userService.findById(1L));
}

@Test
void shouldThrowThenSucceed() {
    when(userRepository.save(any()))
        .thenThrow(new RuntimeException("First call fails"))
        .thenReturn(new User("Saved"));
    
    // 1ª llamada: excepción
    assertThrows(RuntimeException.class, () -> userService.save(new User()));
    
    // 2ª llamada: éxito
    User saved = userService.save(new User());
    assertNotNull(saved);
}

5. Argument Matchers​

any(), anyLong(), anyString()​

@Test
void shouldAcceptAnyId() {
    when(userRepository.findById(anyLong()))  // Cualquier Long
        .thenReturn(Optional.of(new User("Generic")));
    
    assertEquals("Generic", userService.findById(1L).getName());
    assertEquals("Generic", userService.findById(999L).getName());
}

Matchers Disponibles​

any()           // Cualquier objeto
any(User.class) // Cualquier User
anyLong()       // Cualquier long
anyInt()        // Cualquier int
anyString()     // Cualquier String
anyList()       // Cualquier List
anyMap()        // Cualquier Map
eq(value)       // Igualdad exacta (con otros matchers)
isNull()        // Null
isNotNull()     // No null

Regla Importante: Todo o Nada​

// ❌ ERROR: Mezcla matcher y valor exacto
when(service.process(anyString(), "fixed"))  // ¡ERROR!

// ✅ OK: Usar eq() para el valor exacto
when(service.process(anyString(), eq("fixed")))

argThat() - Matcher Personalizado​

@Test
void shouldMatchCustomCondition() {
    when(userRepository.save(argThat(user -> 
        user.getName() != null && user.getName().length() > 3
    ))).thenReturn(new User("Saved"));
    
    // Funciona
    User saved = userService.save(new User("John"));
    assertNotNull(saved);
    
    // No coincide -> retorna null (comportamiento por defecto del mock)
    User notSaved = userService.save(new User("Jo"));
    assertNull(notSaved);
}

6. verify() - Verificar las Llamadas​

Verificación Simple​

@Test
void shouldCallRepository() {
    userService.delete(1L);
    
    // Verifica que deleteById fue llamado con 1L
    verify(userRepository).deleteById(1L);
}

Número de Llamadas​

@Test
void shouldCallRepositoryCorrectTimes() {
    userService.processAll();
    
    verify(userRepository, times(3)).save(any());       // Exactamente 3 veces
    verify(userRepository, atLeast(2)).findById(any()); // Al menos 2 veces
    verify(userRepository, atMost(5)).count();          // Como máximo 5 veces
    verify(userRepository, never()).delete(any());      // Nunca llamado
}

Orden de las Llamadas​

@Test
void shouldCallInOrder() {
    userService.createAndNotify(new User("John"));
    
    InOrder inOrder = inOrder(userRepository, emailService);
    
    // Verifica el orden
    inOrder.verify(userRepository).save(any());      // Primero save
    inOrder.verify(emailService).sendWelcome(any()); // Luego email
}

verifyNoMoreInteractions​

@Test
void shouldOnlyCallSpecificMethods() {
    userService.findById(1L);
    
    verify(userRepository).findById(1L);
    verifyNoMoreInteractions(userRepository);  // Ninguna otra llamada
}

7. @Spy - Mock Parcial​

Diferencia Mock vs Spy​

// Mock: Todas las llamadas son simuladas (retornan null/0/false por defecto)
@Mock
private UserService mockService;

// Spy: Implementación real, pero se pueden sobrescribir algunos métodos
@Spy
private UserService spyService;

Uso​

@ExtendWith(MockitoExtension.class)
class PartialMockTest {

    @Spy
    private ArrayList<String> spyList = new ArrayList<>();

    @Test
    void testSpy() {
        // Llamada real
        spyList.add("one");
        spyList.add("two");
        assertEquals(2, spyList.size());
        
        // Sobrescribir el comportamiento
        when(spyList.size()).thenReturn(100);
        assertEquals(100, spyList.size());
        
        // El elemento realmente está ahí
        assertEquals("one", spyList.get(0));
    }
}

doReturn() vs when() con Spy​

@Spy
private UserService userService;

@Test
void testSpy() {
    // ❌ PROBLEMA: when() llama al método real primero!
    when(userService.riskyMethod()).thenReturn("safe");
    
    // ✅ SOLUCIÓN: doReturn() no llama al método real
    doReturn("safe").when(userService).riskyMethod();
}

8. Capturar los Argumentos​

ArgumentCaptor​

@Test
void shouldCaptureArgument() {
    ArgumentCaptor<User> userCaptor = ArgumentCaptor.forClass(User.class);
    
    userService.register("John", "john@email.com", "password");
    
    verify(userRepository).save(userCaptor.capture());
    
    User savedUser = userCaptor.getValue();
    assertEquals("John", savedUser.getName());
    assertEquals("john@email.com", savedUser.getEmail());
    assertNotNull(savedUser.getPassword());  // Codificado
}

Con Anotación​

@Captor
private ArgumentCaptor<User> userCaptor;

@Test
void shouldCaptureMultipleArgs() {
    userService.saveAll(List.of(new User("A"), new User("B")));
    
    verify(userRepository, times(2)).save(userCaptor.capture());
    
    List<User> capturedUsers = userCaptor.getAllValues();
    assertEquals(2, capturedUsers.size());
    assertEquals("A", capturedUsers.get(0).getName());
    assertEquals("B", capturedUsers.get(1).getName());
}

9. Ejemplo Completo​

@ExtendWith(MockitoExtension.class)
class OrderServiceTest {

    @Mock
    private OrderRepository orderRepository;
    
    @Mock
    private ProductService productService;
    
    @Mock
    private EmailService emailService;
    
    @InjectMocks
    private OrderService orderService;
    
    @Captor
    private ArgumentCaptor<Order> orderCaptor;

    @Test
    void shouldCreateOrderSuccessfully() {
        // Arrange
        Product product = new Product(1L, "Laptop", 1000.0);
        when(productService.findById(1L)).thenReturn(Optional.of(product));
        when(orderRepository.save(any())).thenAnswer(inv -> {
            Order order = inv.getArgument(0);
            order.setId(100L);
            return order;
        });
        
        // Act
        Order order = orderService.createOrder(1L, 2, "john@email.com");
        
        // Assert
        assertNotNull(order);
        assertEquals(100L, order.getId());
        assertEquals(2000.0, order.getTotal());
        
        // Verify
        verify(productService).findById(1L);
        verify(orderRepository).save(orderCaptor.capture());
        verify(emailService).sendOrderConfirmation(eq("john@email.com"), any());
        
        Order savedOrder = orderCaptor.getValue();
        assertEquals(2, savedOrder.getQuantity());
    }

    @Test
    void shouldThrowWhenProductNotFound() {
        // Arrange
        when(productService.findById(anyLong())).thenReturn(Optional.empty());
        
        // Act & Assert
        assertThrows(ProductNotFoundException.class, 
            () -> orderService.createOrder(999L, 1, "test@email.com"));
        
        // Verify no order was saved
        verify(orderRepository, never()).save(any());
        verify(emailService, never()).sendOrderConfirmation(anyString(), any());
    }
}

10. Resumen​

Anotaciones​

AnotaciónDescripción
@MockCrea un mock
@InjectMocksInyecta los mocks en la clase bajo prueba
@SpyMock parcial (implementación real)
@CaptorCaptura los argumentos
@ExtendWith(MockitoExtension.class)Activa Mockito

Métodos Clave​

// Configuración
when(mock.method()).thenReturn(value);
when(mock.method()).thenThrow(exception);
doReturn(value).when(spy).method();

// Verificación
verify(mock).method();
verify(mock, times(3)).method();
verify(mock, never()).method();
verifyNoMoreInteractions(mock);

// Matchers
any(), anyLong(), anyString()
eq(value)
argThat(condition)

🎯 Próximo Paso​

Mockito es perfecto para pruebas unitarias, pero a veces usted necesita probar con recursos reales. Ese es el rol de las pruebas de integración.

➡️ Capítulo 4: Pruebas de Integración

⬅️ Volver al Módulo 9