Nas arquiteturas modernas de microsserviços, os aplicativos dependem fortemente da comunicação entre serviços, geralmente por meio de APIs. É fundamental garantir que essas APIs continuem funcionando conforme esperado durante o desenvolvimento e após as alterações. Uma maneira eficaz de conseguir isso é através do Consumer Driven Contract Testing (CDCT). CDCT é um método que garante que os serviços (produtores) cumpram as expectativas estabelecidas pelos serviços que consomem suas APIs (consumidores).

Neste guia, exploraremos o que é CDCT, como funciona, sua importância para garantir interações confiáveis ​​de microsserviços e como você pode implementá-lo usando ferramentas como o Pact.

O que são testes de contrato orientados ao consumidor?
O teste de contrato orientado ao consumidor é uma estratégia de teste que garante que a comunicação entre serviços em uma arquitetura distribuída cumpra os contratos acordados. Ele difere dos testes tradicionais de API porque se concentra nas necessidades do consumidor, em vez de apenas garantir que a própria API funcione corretamente. O contrato entre o consumidor e o fornecedor da API é definido pelas expectativas do consumidor, e este contrato é verificado em relação à implementação do fornecedor.

Termos principais:
• Consumidor: o serviço que consome a API.
• Provedor (Produtor): O serviço que fornece a API.
• Contrato: um acordo formal entre o consumidor e o fornecedor que especifica o comportamento esperado da API.

Como funciona?

1. O consumidor define o contrato: O consumidor define suas expectativas sobre como a API do provedor deve se comportar (por exemplo, quais endpoints, formatos de dados e códigos de status de resposta ele espera).
2. O contrato é compartilhado: O consumidor compartilha este contrato com o fornecedor. Este contrato serve como uma especificação do que o fornecedor deve cumprir.
3. O fornecedor verifica o contrato: O fornecedor se testa em relação ao contrato do consumidor, garantindo que ele atenda às expectativas do consumidor.
4. Ciclo de feedback contínuo: Quaisquer alterações significativas na API do provedor serão detectadas antecipadamente, pois o provedor deve validar os contratos de todos os consumidores. Isto cria uma rede de segurança para garantir que as mudanças no fornecedor não afetem negativamente os consumidores.

Importância dos testes de contrato orientados ao consumidor
Em arquiteturas distribuídas, especialmente com microsserviços, o gerenciamento de dependências entre serviços torna-se mais complexo. O CDCT ajuda a aliviar essa complexidade de várias maneiras:

1. Evita quebras na produção
Como os consumidores definem o que precisam, as alterações na API do provedor que não atendem às expectativas do consumidor são detectadas no início do pipeline de desenvolvimento. Isso reduz o risco de quebra dos sistemas de produção devido a alterações incompatíveis.

2. Desacoplamento do Desenvolvimento
Os testes de contratos orientados pelo consumidor permitem que consumidores e fornecedores se desenvolvam de forma independente. Isto é especialmente útil quando equipes ou serviços evoluem separadamente. Os contratos servem como uma interface garantindo que a integração funcione conforme o esperado, sem a necessidade de testes completos de integração durante cada ciclo de desenvolvimento.

3. Ciclos de desenvolvimento mais rápidos
Com o CDCT, tanto o consumidor como o fornecedor podem ser desenvolvidos e testados em paralelo, acelerando o desenvolvimento. Os provedores podem testar o contrato do consumidor antes mesmo que o consumidor implemente totalmente sua funcionalidade.

4. Detecção precoce de violações de contrato
As alterações no fornecedor que violam o contrato são detectadas no início do processo de desenvolvimento, permitindo que os desenvolvedores resolvam os problemas antes que se tornem críticos.

Como implementar testes de contrato orientados ao consumidor
Várias ferramentas estão disponíveis para implementar o CDCT, sendo o Pact uma das mais populares. O Pacto permite que os consumidores definam seus contratos e os fornecedores os verifiquem.

Aqui está um guia passo a passo para implementar o CDCT usando o Pact:
Etapa 1: Definir as expectativas do consumidor
Primeiro, no atendimento ao consumidor, defina o contrato. Isso geralmente inclui o seguinte:
• O endpoint que o consumidor chamará.
• O método de solicitação (GET, POST, PUT, etc.).
• O corpo ou parâmetros da solicitação esperados.
• O corpo da resposta esperado e o código de status.
Aqui está um exemplo de definição de um contrato em um teste de consumidor usando Pact em JavaScript:

const { Pact } = require('@pact-foundation/pact');
const path = require('path');

const provider = new Pact({
    consumer: 'UserService',
    provider: 'UserAPI',
    port: 1234,
    log: path.resolve(process.cwd(), 'logs', 'pact.log'),
    dir: path.resolve(process.cwd(), 'pacts'),
});

describe('Pact Consumer Test', () => {
    beforeAll(() => provider.setup());

    afterAll(() => provider.finalize());

    it('should receive user details from the API', async () => {
        // Define the expected interaction
        await provider.addInteraction({
            state: 'user exists',
            uponReceiving: 'a request for user details',
            withRequest: {
                method: 'GET',
                path: '/users/1',
                headers: {
                    Accept: 'application/json',
                },
            },
            willRespondWith: {
                status: 200,
                headers: {
                    'Content-Type': 'application/json',
                },
                body: {
                    id: 1,
                    name: 'John Doe',
                },
            },
        });

        // Make the actual request and test
        const response = await getUserDetails(1);
        expect(response).toEqual({ id: 1, name: 'John Doe' });
    });
});

Neste exemplo, o consumidor (UserService) espera que o provedor (UserAPI) retorne os detalhes do usuário ao fazer uma solicitação GET para /users/1.

Etapa 2: Publicar o contrato
Assim que o teste do consumidor for aprovado, o Pact gera um arquivo de contrato (arquivo Pact) que pode ser compartilhado com o provedor. Este contrato pode ser armazenado em um corretor do Pact ou em um sistema de controle de versão para que o provedor possa utilizá-lo para verificação.

Etapa 3: o fornecedor verifica o contrato
O fornecedor recupera o contrato e verifica se ele atende às expectativas do consumidor. Isso é feito executando um teste Pact por parte do provedor. Aqui está um exemplo de verificação de um contrato do Pacto em Java:

public class ProviderTest {

    @Test
    public void testProviderAgainstPact() {
        PactVerificationResult result = new PactVerifier()
            .verifyProvider("UserAPI", "pacts/UserService-UserAPI.json");

        assertThat(result, instanceOf(PactVerificationResult.Ok.class));
    }
}

O fornecedor executa este teste para garantir que cumpre o contrato especificado pelo consumidor.

Etapa 4: Integração Contínua
Depois que o CDCT estiver integrado ao seu pipeline de CI/CD, cada vez que um contrato for alterado, o provedor poderá verificar automaticamente o contrato. Isso garante que as alterações na API não superem as expectativas do consumidor, proporcionando uma rede de segurança para ambas as equipes.

Práticas recomendadas de CDCT

1. Contratos pequenos e focados: Garanta que seus contratos sejam pequenos e foquem apenas nas necessidades do consumidor. Isso evita complexidade desnecessária no contrato e simplifica a verificação.
2. Controle de versão de contrato: Sempre controle a versão de seus contratos. Isso permite que os provedores administrem diversas versões do mesmo contrato, ajudando você a oferecer suporte a diferentes consumidores em diferentes estágios de desenvolvimento.
3. Implantação independente: Certifique-se de que o CDCT faça parte do seu pipeline de CI/CD. Quaisquer alterações no consumidor ou fornecedor devem acionar testes de contrato para evitar quebras nos ambientes de produção.
4. Use um corretor do Pacto: Um corretor do Pacto é um repositório central que armazena seus contratos e permite que consumidores e fornecedores os recuperem. Ele também fornece uma UI para visualizar versões e dependências do contrato.

Quando usar testes de contrato orientados ao consumidor
O CDCT é particularmente útil quando:
• Você tem microsserviços ou arquiteturas distribuídas com vários serviços interagindo.
• As equipes que trabalham em diferentes serviços precisam se desenvolver de forma independente, sem testes de integração frequentes.
• É provável que os contratos de API mudem com frequência e você deseja evitar quebrar as expectativas do consumidor.
• Você precisa de ciclos de feedback rápidos para detectar violações de contrato no início do processo de desenvolvimento.

Conclusão
Os testes de contrato orientados ao consumidor oferecem uma maneira confiável de garantir que os serviços em um sistema distribuído se comuniquem de maneira eficaz, sem alterações significativas. Ao focar nas expectativas dos consumidores e validar o fornecedor em relação a elas, o CDCT ajuda as equipes a se desenvolverem de forma independente, garantindo ao mesmo tempo a estabilidade. Esteja você criando microsserviços, aplicativos baseados em API ou sistemas distribuídos, incorporar o CDCT em sua estratégia de testes melhorará a confiabilidade e a escalabilidade de seus serviços.