Fluxo de Trabalho TDD com Quarkus

Orientação de TDD para serviços Quarkus 3.x com mais de 80% de cobertura (unitária + integração). Otimizado para arquiteturas orientadas a eventos com Apache Camel.

Quando Usar

• Novos recursos ou endpoints REST
• Correções de bugs ou refatorações
• Adicionando lógica de acesso a dados, regras de segurança ou fluxos reativos
• Testando rotas do Apache Camel e manipuladores de eventos
• Testando serviços orientados a eventos com RabbitMQ
• Testando lógica de fluxo condicional
• Validando operações assíncronas do CompletableFuture
• Testando a propagação do LogContext

Fluxo de Trabalho

1. Escreva os testes primeiro (eles devem falhar)
2. Implemente o código mínimo para passar
3. Refatore com os testes verdes
4. Garanta a cobertura com JaCoCo (meta de 80%+)

Testes Unitários com Organização @Nested

Siga esta abordagem estruturada para testes abrangentes e legíveis:

@ExtendWith(MockitoExtension.class)
@DisplayName("OrderService Unit Tests")
class OrderServiceTest {

  @Mock
  private OrderRepository orderRepository;

  @Mock
  private EventService eventService;

  @Mock
  private FulfillmentPublisher fulfillmentPublisher;

  @InjectMocks
  private OrderService orderService;

  private CreateOrderCommand validCommand;

  @BeforeEach
  void setUp() {
    validCommand = new CreateOrderCommand(
        "customer-123",
        List.of(new OrderLine("sku-123", 2))
    );
  }

  @Nested
  @DisplayName("Tests for createOrder")
  class CreateOrder {

    @Test
    @DisplayName("Should persist order and publish fulfillment event")
    void givenValidCommand_whenCreateOrder_thenPersistsAndPublishes() {
      // ARRANGE
      doNothing().when(orderRepository).persist(any(Order.class));

      // ACT
      OrderReceipt receipt = orderService.createOrder(validCommand);

      // ASSERT
      assertThat(receipt).isNotNull();
      assertThat(receipt.customerId()).isEqualTo("customer-123");
      verify(orderRepository).persist(any(Order.class));
      verify(fulfillmentPublisher).publishAsync(receipt);
      verify(eventService).createSuccessEvent(receipt, "ORDER_CREATED");
    }

    @Test
    @DisplayName("Should reject missing customer id")
    void givenMissingCustomerId_whenCreateOrder_thenThrowsBadRequest() {
      // ARRANGE
      CreateOrderCommand invalid = new CreateOrderCommand("", validCommand.lines());

      // ACT & ASSERT
      WebApplicationException exception = assertThrows(
          WebApplicationException.class,
          () -> orderService.createOrder(invalid)
      );

      assertThat(exception.getResponse().getStatus()).isEqualTo(400);
      verify(orderRepository, never()).persist(any(Order.class));
      verify(fulfillmentPublisher, never()).publishAsync(any());
    }

    @Test
    @DisplayName("Should record error event when persistence fails")
    void givenPersistenceFailure_whenCreateOrder_thenRecordsErrorEvent() {
      // ARRANGE
      doThrow(new PersistenceException("database unavailable"))
          .when(orderRepository).persist(any(Order.class));

      // ACT & ASSERT
      PersistenceException exception = assertThrows(
          PersistenceException.class,
          () -> orderService.createOrder(validCommand)
      );

      assertThat(exception.getMessage()).contains("database unavailable");
      verify(eventService).createErrorEvent(
          eq(validCommand),
          eq("ORDER_CREATE_FAILED"),
          contains("database unavailable")
      );
      verify(fulfillmentPublisher, never()).publishAsync(any());
    }

    @Test
    @DisplayName("Should reject null commands")
    void givenNullCommand_whenCreateOrder_thenThrowsNullPointerException() {
      // ACT & ASSERT
      assertThrows(
          NullPointerException.class,
          () -> orderService.createOrder(null)
      );

      verify(orderRepository, never()).persist(any(Order.class));
    }
  }
}

Padrões Chave de Teste

1. Classes @Nested: Agrupe testes pelo método que está sendo testado
2. @DisplayName: Forneça descrições de teste legíveis para relatórios
3. Convenção de Nomenclatura: givenX_whenY_thenZ para clareza
4. Padrão AAA: Comentários explícitos de // ARRANGE, // ACT, // ASSERT
5. @BeforeEach: Configure dados de teste comuns para reduzir duplicação
6. assertDoesNotThrow: Teste cenários de sucesso sem capturar exceções
7. assertThrows: Teste cenários de exceção com validação de mensagem usando AssertJ
8. Cobertura Abrangente: Teste caminhos felizes, entradas nulas, casos extremos, exceções
9. Verificar Interações: Use Mockito verify() para garantir que os métodos sejam chamados corretamente

…