Mockito avançado: capturadores de argumentos e spies
Capture argumentos de métodos com ArgumentCaptor e faça mocks parciais de objetos reais com Mockito.spy.
Mockito avançado: capturadores de argumentos e spies é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.
ArgumentCaptor: capturando argumentos de métodos
ArgumentCaptor captura os argumentos passados a um método simulado para que possa fazer asserções sobre eles. É útil quando o argumento é construído dentro do sistema em teste e não pode ser acessado diretamente.
Criando e usando ArgumentCaptor
Crie um capturador para o tipo do argumento, passe captor.capture() como correspondência de argumento em verify() e, em seguida, chame captor.getValue() para obter o argumento capturado.
@Test
void sends_correct_email() {
ArgumentCaptor<EmailMessage> captor = ArgumentCaptor.forClass(EmailMessage.class);
userService.register(new CreateUserRequest("alice@example.com"));
verify(emailService).send(captor.capture());
EmailMessage msg = captor.getValue();
assertEquals("alice@example.com", msg.getTo());
assertTrue(msg.getSubject().contains("Welcome"));
}Anotação @Captor
Use @Captor com @ExtendWith(MockitoExtension.class) para evitar chamadas extensas a ArgumentCaptor.forClass().
@ExtendWith(MockitoExtension.class)
class UserServiceTest {
@Mock EmailService emailService;
@Captor ArgumentCaptor<EmailMessage> emailCaptor;
@Test
void captures_email() {
// ...
verify(emailService).send(emailCaptor.capture());
assertEquals("Welcome!", emailCaptor.getValue().getSubject());
}
}Capturando várias chamadas
Use captor.getAllValues() quando o método for chamado várias vezes. Ele retorna uma lista de todos os valores capturados na ordem das chamadas.
verify(emailService, times(3)).send(emailCaptor.capture());
List<EmailMessage> messages = emailCaptor.getAllValues();
assertEquals(3, messages.size());
assertEquals("Confirmation", messages.get(0).getSubject());Spies do Mockito: simulação parcial
Mockito.spy() envolve um objeto real. Todos os métodos se comportam normalmente, a menos que você os configure explicitamente. Use-o quando precisar testar uma classe que tenha algumas dependências difíceis de testar, mas funcione em sua maior parte.
List<String> realList = new ArrayList<>();
List<String> spy = Mockito.spy(realList);
spy.add("hello"); // calls real ArrayList.add()
System.out.println(spy.size()); // 1 — real method called
doReturn(42).when(spy).size(); // stub just size()
System.out.println(spy.size()); // 42 — stubbedAnotação @Spy
Use @Spy com @ExtendWith(MockitoExtension.class) para criar spies. O campo deve ser inicializado, diretamente ou por meio de @Spy UserService svc = new UserService(repo);.
@ExtendWith(MockitoExtension.class)
class OrderServiceTest {
@Spy
OrderService orderService = new OrderService(mockRepo, mockEmail);
}Usando spies em beans do Spring com @SpyBean
Nos testes do Spring Boot, @SpyBean envolve um bean existente do Spring em um spy do Mockito — o comportamento real é mantido, a menos que seja configurado. Ele é usado em conjunto com @SpringBootTest.
@SpringBootTest
class IntegrationTest {
@SpyBean EmailService emailService;
@Test
void order_sends_email() {
orderService.placeOrder(cart);
verify(emailService).sendConfirmation(any());
}
}doReturn versus when().thenReturn() para spies
Para spies, use doReturn(value).when(spy).method() em vez de when(spy.method()).thenReturn(value). A forma when(spy.method()) realmente chama o método real, o que pode causar efeitos colaterais.
// Correct for spies:
doReturn(List.of()).when(spy).findAll();
// WRONG for spies — calls real findAll() first:
when(spy.findAll()).thenReturn(List.of()); // real method called!Verificando a ausência de interações
Use verifyNoInteractions(mock) para afirmar que um objeto simulado nunca foi chamado e verifyNoMoreInteractions(mock) após todas as chamadas esperadas para detectar chamadas inesperadas.
verifyNoInteractions(emailService); // never called
verify(repo).save(any());
verifyNoMoreInteractions(repo); // save() was the only interactionVerificação em ordem
Use InOrder para afirmar que os métodos simulados foram chamados em uma ordem específica.
InOrder inOrder = inOrder(repo, emailService);
inOrder.verify(repo).save(any());
inOrder.verify(emailService).send(any()); // save happened BEFORE sendCorrespondentes de argumentos
Combine capturadores com correspondentes: any(), eq(), anyString(), argThat(predicate). Se algum argumento usar um correspondente, todos deverão usar correspondentes.
verify(repo).save(argThat(user ->
user.getEmail().endsWith("@example.com") &&
user.getStatus() == UserStatus.ACTIVE));Verificação rápida
Por que usar doReturn em vez de when().thenReturn() ao configurar o comportamento de um spy?
Recapitulação
ArgumentCaptor captura argumentos para permitir asserções após a chamada. Spies envolvem objetos reais e delegam a eles, a menos que sejam configurados. Use doReturn com spies. Use @SpyBean em testes de integração do Spring. Verifique a ordem das chamadas com InOrder.
Perguntas Frequentes
A aula “Mockito avançado: capturadores de argumentos e spies” é grátis?
Sim — o texto completo de “Mockito avançado: capturadores de argumentos e spies” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.
O que vou aprender em “Mockito avançado: capturadores de argumentos e spies”?
Capture argumentos de métodos com ArgumentCaptor e faça mocks parciais de objetos reais com Mockito.spy. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Java Academy?
Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “Mockito avançado: capturadores de argumentos e spies”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Java Academy?
Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Testes parametrizados com @CsvSource e @MethodSource
- Mockito avançado: capturadores de argumentos e spies
- Fatias de teste do Spring Boot: @WebMvcTest e @DataJpaTest
- Testcontainers: testes de integração com banco de dados real