Boas Práticas Nathan Geeksman

Testes de contrato com Pact: validando integrações entre serviços

Testes de contrato com Pact: validando integrações entre serviços

Testes de contrato com Pact: validando integrações entre serviços

Introdução

Os sistemas distribuídos, que integram múltiplos serviços para atender às necessidades de negócios em tempo real, ganham destaque em projetos atualmente. No entanto, a complexidade aumenta quando esses serviços precisam se comunicar entre si.

A integração eficaz entre os sistemas é crucial para garantir que as requisições e respostas fluam sem obstruções, desde a solicitação da interface de usuário até o retorno à interface do usuário. Para atender às exigências das aplicações modernas, uma abordagem sólida e flexível é essencial.

Neste artigo, vamos explorar como os testes de contrato podem ser implementados usando o Pact para validar as integrações entre serviços em sistemas distribuídos. Ao final desta leitura, você terá compreendido a importância dos testes de contrato na garantia da integridade das interações entre serviços, bem como será capaz de aplicar práticas de desenvolvimento mais robustas em seu próprio trabalho.

O que é e por que importa

Os testes de contrato, também conhecidos como contracts tests ou API contracts tests, são uma técnica de teste de software focada em validar as interações entre sistemas, garantindo que os serviços sejam executados corretamente ao comunicar-se entre si. Esses testes simulam as requisições e respostas dos serviços, verificando se a implementação atende aos acordos definidos nos contratos de API.

A motivação por trás dos testes de contrato é prevenir erros de integração e garantir que os sistemas funcionem corretamente em diferentes ambientes. Ao simular as interações entre serviços, esses testes permitem que os desenvolvedores:

  • Verifiquem se a API pública está atendendo às expectativas do cliente;
  • Validem se a implementação interna dos serviços está correta;
  • Detectem mudanças nas APIs e nos contratos de integração.

Além disso, os testes de contrato proporcionam:

  • Maturidade do código: Comprovando que o sistema é robusto e correto;
  • Regressão: Identificando mudanças indesejadas na implementação de serviços ao longo do tempo;
  • Desenvolvimento baseado em evidências: Permitindo que os equipes façam alterações com confiança, sabendo que essas mudanças serão verificadas durante o processo de validação.

Os testes de contrato não substituem outros tipos de teste, mas sim complementam a abordagem de desenvolvimento e integração contínua. Ao integrar os testes de contrato à prática de desenvolvimento, as equipes podem melhorar significativamente a qualidade do código, reduzir o número de erros de integração e garantir que os sistemas sejam executados corretamente em diferentes ambientes.

Como funciona na prática

Os testes de contrato são executados utilizando uma biblioteca específica, como o Pact, que é um framework popular para a criação e execução desses testes. O processo geralmente segue as seguintes etapas:

Definição dos Contratos

  • Criar os arquivos de contrato: Os desenvolvedores definem os contratos de API em arquivos, que especificam o formato da requisição e resposta.
  • Definir a estrutura dos dados: É essencial determinar como os dados são estruturados para serem entendidos pelas APIs.

Simulação das Requisições

  • Simular requisições à API: A biblioteca executa as requisições simuladas ao servidor da API, enviando a solicitação com base nos contratos definidos.
  • Verificar respostas: Em seguida, o sistema verifica se a resposta recebida é conforme o especificado no contrato de API.

Execução e Comparação dos Resultados

  • Comparar resultado simulado com real: A biblioteca compara o resultado da simulação com o resultado obtido ao realizar a requisição real.
  • Gerar relatórios e indicadores: Geralmente, os testes de contrato fornecem relatórios detalhados sobre as diferenças encontradas entre os resultados simulados e reais.

Integração aos Ciclos de Desenvolvimento

  • Integrar com o fluxo de trabalho: Os desenvolvedores integram esses testes à pipeline de CI/CD para garantir que os sistemas sejam executados corretamente em diferentes ambientes.
  • Feedback contínuo: Além disso, é crucial que os desenvolvedores forneçam feedback contínuo sobre as melhorias e atualizações feitas nos testes de contrato.

Exemplo real

Um exemplo prático para entender melhor como funciona a integração dos testes de contrato com Pact é o caso de uma empresa de logística que está desenvolvendo um sistema para gerenciar os pedidos e envios.

Contrato entre Serviços de Pedidos e Entrega

// pact.json (contrato entre os serviços de pedidos e entrega)
{
  "consumer": {
    "name": "pedido"
  },
  "provider": {
    "name": "entrega"
  },
  "interactions":
  [
    {
      "request":
      {
        "method": "GET",
        "path": "/entregar-pedido/{pedidoId}",
        "headers":
        {
          "Content-Type": "application/json"
        }
      },
      "response":
      {
        "status": 200,
        "body": "Pedido {pedidoId} entregue com sucesso!"
      }
    }
  ]
}

Nesse exemplo, o contrato define que o serviço de pedidos (pedido) deve enviar uma requisição GET para o serviço de entrega (entrega) com a URL /entregar-pedido/{pedidoId}, onde {pedidoId} é o ID do pedido. A resposta esperada é um status 200 e o corpo da resposta deve incluir a mensagem "Pedido {pedidoId} entregue com sucesso!".

Simulação e Verificação

Ao executar os testes de contrato, a biblioteca simula a requisição ao serviço de entrega e verifica se a resposta recebida é conforme o especificado no contrato.

// PedidoServiceTest.java (simulando requisição e verificando resposta)
public class PedidoServiceTest {
  
  @Test
  public void testEntregarPedido() {
    // Simular requisição ao serviço de entrega
    Request request = new Request("GET", "/entregar-pedido/12345");
    
    // Verificar resposta recebida
    Response response = deliveryService.send(request);
    
    // Validar se a resposta é conforme o contrato
    Assert.assertEquals(200, response.getStatus());
    Assert.assertTrue(response.getBody().contains("Pedido 12345 entregue com sucesso!"));
  }
}

Nesse exemplo, o teste testEntregarPedido simula uma requisição ao serviço de entrega e verifica se a resposta recebida é conforme o contrato. Se a resposta não atender aos requisitos do contrato, o teste falhará e fornecerá informações detalhadas sobre os erros encontrados.

Essa integração dos testes de contrato com Pact permite que os desenvolvedores tenham certeza de que os serviços estão funcionando corretamente em diferentes ambientes e que as requisições são atendidas conforme esperado.

Boas práticas

  • Defina contratos claros: Certifique-se de que os contratos estejam bem definidos e contemplem todos os cenários possíveis, incluindo erros e exceções.
  • Use a notação Pact para formatar contratos: Utilize a notação Pact para formatar os contratos, o que torna mais fácil ler e entender os termos do contrato.
  • Integre testes de contrato com a pipeline de build: Integre os testes de contrato com a pipeline de build para garantir que os testes sejam executados após cada mudança no código.

Armadilhas comuns

  • Não restringa o ambiente de teste: Não restrinja o ambiente de teste ao ambiente de desenvolvimento, pois isso pode levar a resultados falsos negativos e false positivos.
  • Não esqueça de simular requisições não solicitadas: Não esqueça de simular requisições não solicitadas, como requisições GET em APIs que só aceitam POST, para garantir que as APIs sejam corretamente testadas.

Conclusão

Integrar testes de contrato com Pact é uma prática recomendada para garantir que os serviços estejam funcionando corretamente em diferentes ambientes e atendendo às requisições conforme esperado. Ao definir contratos claros, usar a notação Pact para formatá-los e integrá-los à pipeline de build, os desenvolvedores podem ter certeza da qualidade dos seus sistemas.

Para levar adiante essa abordagem, é recomendável revisar e refinar os contratos existentes e implementar os testes de contrato em novos projetos. Além disso, não se esqueça de manter a integração dos testes de contrato com a pipeline de build atualizada para garantir que todos os serviços estejam sendo adequadamente testados.

No entanto, é importante lembrar que a integração dos testes de contrato também deve considerar cenários como requisições não solicitadas e diferentes ambientes de execução. Além disso, é recomendável revisar a notação Pact em uso para garantir que esteja atualizada e seguir as melhores práticas.

Por fim, lembre-se de que os testes de contrato devem ser uma parte integrante da pipeline de build e não apenas um processo adicional a executar antes do deploy. Com isso, você poderá garantir que seus sistemas estejam funcionando corretamente em diferentes ambientes e atendendo às requisições conforme esperado.

Referências

  • Martin Fowler. Patterns of Enterprise Application Architecture. Disponível em: https://martinfowler.com/books/eaa.html. Acesso: 2024.
  • OWASP. Testing API Security. Disponível em: https://owasp.org/www-project-api-security/testing-api-security/. Acesso: 2024.
  • Pact Project. Pact Documentation. Disponível em: https://docs.pact.io/. Acesso: 2024.
  • Thoughtworks.com. Contract Testing with Pact. Disponível em: https://www.thoughtworks.com/insights/blog/contract-testing-pact. Acesso: 2024.
  • 12factor.net. API Design. Disponível em: https://12factor.net/api-design. Acesso: 2024.