DevLog #04 – Testing e Validação: Garantindo Confiabilidade

📅 Data: 27 de Janeiro de 2026

✍️ Autor: Luís Gabriel Marchió Batista

---

Uma Arquitetura Robusta Precisa de Testes Robustos

Observabilidade e resiliência são fundamentais, mas precisamos validar que tudo funciona antes de ir para produção.

1. Unit Tests para Lógica de Negócio

Testamos cada componente isoladamente com xUnit:

[Fact]
public async Task ProcessOrder_WithValidPayload_ShouldCreateEvent()
{
    // Arrange
    var handler = new OrderProcessingHandler(_logger, _mediator);
    var command = new ProcessOrderCommand { OrderId = 123, Amount = 100 };

    // Act
    await handler.Handle(command, CancellationToken.None);

    // Assert
    _mediator.Verify(m => m.Publish(
        It.IsAny<OrderCreatedEvent>(), 
        It.IsAny<CancellationToken>()),
        Times.Once);
}

2. Integration Tests com Testcontainers

Testamos com infraestrutura real (RabbitMQ, databases) usando Testcontainers:

public class OrderPipelineIntegrationTests : IAsyncLifetime
{
    private readonly RabbitMQContainer _container = 
        new RabbitMQBuilder().WithImage("rabbitmq:3-management").Build();

    public async Task InitializeAsync() => await _container.StartAsync();
    public async Task DisposeAsync() => await _container.StopAsync();

    [Fact]
    public async Task OrderEvent_PublishedToQueue_ShouldBeConsumed()
    {
        // Arrange
        var connection = new ConnectionFactory { Uri = _container.GetConnectionString() };
        
        // ... test implementation
    }
}

3. Chaos Engineering com Gremlin

Simulamos falhas em produção de forma controlada:

// Simular latência aleatória
var chaosPolicy = Policy
    .Handle<HttpRequestException>()
    .Or<TimeoutException>()
    .InjectLatencyAsync(
        delay: TimeSpan.FromSeconds(5),
        injectionRate: 0.1, // 10% das requisições
        enabled: () => _isLoadTest);

4. Load Testing com k6

Testamos sob carga para identificar gargalos:

import http from 'k6/http';
import { check, sleep } from 'k6';

export let options = {
  vus: 100,
  duration: '5m',
  thresholds: {
    http_req_duration: ['p(95)<500'],
    http_req_failed: ['rate<0.1'],
  },
};

export default function() {
  let response = http.post('http://order-pipeline/api/orders', {
    productId: 123,
    quantity: 5,
  });
  check(response, {
    'status is 201': (r) => r.status === 201,
  });
  sleep(1);
}

Resultados: Um Sistema de Confiança

Com esses testes em lugar, temos:

• ✅ Confiabilidade verificada em cada commit
• ✅ Comportamento sob carga documentado
• ✅ Recuperação de falhas testada
• ✅ Regressões evitadas automaticamente

Conclusão

Construímos um Order Pipeline robusto, observável e resiliente. Este DEVLOG explorou:

1. 🏗️ Arquitetura Event-Driven Serverless
2. 📈 Observabilidade com Traces, Logs e Métricas
3. 🛡️ Padrões de Resiliência
4. 🪨 Testing e Validação

Próximos passos? Deploy em produção com confiança! 🚀