0Pricing
Java Academy · Aula

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 — stubbed

Anotaçã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 interaction

Verificaçã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 send

Correspondentes 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

  1. Testes parametrizados com @CsvSource e @MethodSource
  2. Mockito avançado: capturadores de argumentos e spies
  3. Fatias de teste do Spring Boot: @WebMvcTest e @DataJpaTest
  4. Testcontainers: testes de integração com banco de dados real
← Voltar para Java Academy