giuseppe-trisciuoglio/unit-test-application-events

O que unit-test-application-events faz?

Fornece padrões para teste unitário de eventos de aplicação Spring. Valida a publicação de eventos com ApplicationEventPublisher, testa o comportamento da anotação @EventListener e verifica o tratamento assíncrono de eventos. Use ao escrever testes para ouvintes de eventos, simulando eventos de aplicação ou verificando se eventos foram publicados em seus serviços Spring Boot.

Visão Geral

Este skill ajuda você a testar unitariamente eventos de aplicação no Spring, garantindo que:

• Eventos sejam publicados corretamente via ApplicationEventPublisher.
• Listeners anotados com @EventListener respondam adequadamente.
• Eventos assíncronos sejam tratados conforme esperado.

Pré-requisitos

• Projeto Spring Boot com dependências de teste (JUnit 5, Mockito).
• Conhecimento básico sobre eventos no Spring.

Padrões de Teste

1. Testando Publicação de Eventos

Use Mockito para simular o ApplicationEventPublisher e verificar se o evento foi publicado.

@ExtendWith(MockitoExtension.class)
class MyServiceTest {

    @Mock
    private ApplicationEventPublisher publisher;

    @InjectMocks
    private MyService myService;

    @Test
    void shouldPublishEvent() {
        myService.doSomething();

        verify(publisher).publishEvent(any(MyCustomEvent.class));
    }
}

2. Testando Listeners com @EventListener

Crie um evento de teste e verifique se o listener foi chamado.

@ExtendWith(MockitoExtension.class)
class MyEventListenerTest {

    @Mock
    private MyService myService;

    @InjectMocks
    private MyEventListener listener;

    @Test
    void shouldHandleEvent() {
        MyCustomEvent event = new MyCustomEvent(this, "data");

        listener.handleEvent(event);

        verify(myService).processEvent(event);
    }
}

3. Testando Eventos Assíncronos

Para testar eventos assíncronos, use @Async e certifique-se de que o contexto de teste está configurado corretamente.

@SpringBootTest
@EnableAsync
class AsyncEventListenerTest {

    @Autowired
    private ApplicationEventPublisher publisher;

    @Autowired
    private AsyncEventListener listener;

    @Test
    void shouldHandleAsyncEvent() throws Exception {
        MyCustomEvent event = new MyCustomEvent(this, "data");

        publisher.publishEvent(event);

        // Aguarda um pouco para o processamento assíncrono
        Thread.sleep(1000);

        assertThat(listener.getProcessedEvents()).contains(event);
    }
}

Considerações Importantes

• Para testar eventos assíncronos, é recomendado usar Awaitility para aguardar condições de forma mais robusta, evitando Thread.sleep().
• Lembre-se de limpar o estado compartilhado entre testes, se houver.
• Em testes de integração, certifique-se de que o contexto Spring seja carregado corretamente com @SpringBootTest.

Exemplo Completo

@ExtendWith(MockitoExtension.class)
class EventServiceTest {

    @Mock
    private ApplicationEventPublisher publisher;

    @InjectMocks
    private EventService eventService;

    @Test
    void shouldPublishAndHandleEvent() {
        String data = "test-data";

        eventService.createAndPublishEvent(data);

        ArgumentCaptor<MyCustomEvent> captor = ArgumentCaptor.forClass(MyCustomEvent.class);
        verify(publisher).publishEvent(captor.capture());

        assertThat(captor.getValue().getData()).isEqualTo(data);
    }
}

Recursos Adicionais

• Documentação oficial do Spring: Testing
• Guia sobre eventos no Spring: Application Events