Introdução

Cypress é amplamente conhecido por seus recursos de teste ponta a ponta, mas também é uma ferramenta poderosa para testar APIs. O teste de API é uma parte essencial para garantir a confiabilidade, o desempenho e a segurança dos aplicativos da Web modernos, já que muitos aplicativos hoje dependem fortemente de serviços de back-end e APIs. Esta postagem orientará você nos fundamentos dos testes de API usando Cypress, incluindo configuração de testes de API, realização de solicitações, validação de respostas e automatização do processo.

Por que usar Cypress para testes de API?

1. Recursos integrados: Cypress possui recursos integrados para fazer solicitações HTTP, asserções e gerenciar testes assíncronos.
2. Fácil integração: Você pode integrar facilmente testes de API em seu conjunto de testes Cypress existente, junto com seus testes de UI.
3. Ótima experiência do desenvolvedor: Cypress oferece uma interface amigável, feedback rápido e depuração em tempo real.
4. Automação: Você pode automatizar testes de API em seu pipeline de CI/CD, garantindo que as APIs sejam testadas consistentemente em cada implantação.

Primeiros passos com testes de API no Cypress

Se você já tem o Cypress instalado para testes ponta a ponta, você está pronto para iniciar os testes de API. Caso contrário, siga as etapas de instalação abaixo.

Etapa 1: Instale o Cypress

npm install cypress --save-dev

Depois de instalado, você pode executar o Cypress com o seguinte comando:

npx cypress open

Etapa 2: configurando seu primeiro teste de API
Cypress fornece um método cy.request() que você pode usar para enviar solicitações HTTP. Aqui está um exemplo básico de teste de uma API que retorna uma lista de usuários:

describe('API Testing with Cypress', () => {
  it('should retrieve a list of users', () => {
    cy.request('GET', 'https://jsonplaceholder.typicode.com/users')
      .then((response) => {
        // Validate the status code
        expect(response.status).to.eq(200);

        // Validate the response body
        expect(response.body).to.have.length(10);
        expect(response.body[0]).to.have.property('name');
      });
  });
});

Neste exemplo, estamos testando uma solicitação GET para recuperar uma lista de usuários. Cypress valida o código de status da resposta e verifica se o corpo da resposta contém 10 usuários.

Métodos HTTP comuns em testes de API

Veja como você pode realizar solicitações HTTP comuns como GET, POST, PUT e DELETE no Cypress.

Solicitação GET
Solicitações GET são usadas para recuperar dados do servidor. Por exemplo:

cy.request('GET', 'https://jsonplaceholder.typicode.com/posts/1')
  .then((response) => {
    expect(response.status).to.eq(200);
    expect(response.body).to.have.property('id', 1);
  });

Solicitação POST
As solicitações POST são usadas para criar novos recursos no servidor. Veja como testar uma solicitação POST:

cy.request('POST', 'https://jsonplaceholder.typicode.com/posts', {
  title: 'New Post',
  body: 'This is the content of the new post.',
  userId: 1
})
  .then((response) => {
    expect(response.status).to.eq(201);
    expect(response.body).to.have.property('title', 'New Post');
  });

Solicitação PUT
Solicitações PUT são usadas para atualizar recursos existentes. Exemplo:

cy.request('PUT', 'https://jsonplaceholder.typicode.com/posts/1', {
  id: 1,
  title: 'Updated Post Title',
  body: 'Updated content',
  userId: 1
})
  .then((response) => {
    expect(response.status).to.eq(200);
    expect(response.body).to.have.property('title', 'Updated Post Title');
  });

Excluir solicitação
Solicitações DELETE são usadas para remover recursos. Exemplo:

cy.request('DELETE', 'https://jsonplaceholder.typicode.com/posts/1')
  .then((response) => {
    expect(response.status).to.eq(200);
  });

Técnicas avançadas de teste de API

Depois de dominar as solicitações básicas de API, você pode passar para técnicas de teste de API mais avançadas, como tratamento de autenticação, teste de falhas de API e encadeamento de chamadas de API.

Tratamento de autenticação
Algumas APIs requerem autenticação por meio de tokens ou chaves de API. Cypress pode lidar com a autenticação definindo cabeçalhos personalizados. Por exemplo:

cy.request({
  method: 'GET',
  url: 'https://api.example.com/protected',
  headers: {
    Authorization: `Bearer ${Cypress.env('auth_token')}`
  }
})
  .then((response) => {
    expect(response.status).to.eq(200);
  });

Aqui, o cabeçalho Authorization é usado para enviar um token junto com a solicitação.

Testando falhas de API
É essencial testar como sua API se comporta quando algo dá errado, como entradas inválidas ou recursos ausentes. Por exemplo, testando um erro 404:

cy.request({
  method: 'GET',
  url: 'https://jsonplaceholder.typicode.com/posts/9999',
  failOnStatusCode: false
})
  .then((response) => {
    expect(response.status).to.eq(404);
  });

Ao definir failOnStatusCode: false, o Cypress não falhará no teste automaticamente para respostas diferentes de 2xx, permitindo que você valide respostas de erro.

Encadeamento de chamadas de API
Às vezes, você precisa encadear várias chamadas de API, por exemplo, criando um recurso e depois usá-lo em um teste subsequente:

cy.request('POST', 'https://jsonplaceholder.typicode.com/posts', {
  title: 'Post for chaining',
  body: 'Chained post content',
  userId: 1
}).then((postResponse) => {
  cy.request('GET', `https://jsonplaceholder.typicode.com/posts/${postResponse.body.id}`)
    .then((getResponse) => {
      expect(getResponse.body).to.have.property('title', 'Post for chaining');
    });
});

Neste exemplo, a solicitação POST cria uma nova postagem e a solicitação GET recupera essa postagem com base no ID retornado da primeira chamada.

Automatizando testes de API em pipelines de CI/CD

Para garantir a estabilidade de suas APIs, é crucial executar seus testes de API como parte de seu pipeline de Integração Contínua/Implantação Contínua (CI/CD). Cypress pode ser facilmente integrado a ferramentas de CI/CD como Jenkins, GitHub Actions ou Travis CI.

Aqui está um exemplo de fluxo de trabalho do GitHub Actions que executa testes Cypress em cada push:

name: CI

on:
  push:
    branches:
      - main

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Set up Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '14'

      - name: Install dependencies
        run: npm install

      - name: Run Cypress tests
        run: npx cypress run

Este fluxo de trabalho garante que os testes de API sejam executados automaticamente sempre que o código for enviado para a ramificação principal.

Melhores práticas para testes de API com Cypress

Para garantir que seus testes de API sejam confiáveis, fáceis de manter e eficientes, siga estas práticas recomendadas:

1. Usar variáveis ​​de ambiente: Armazene dados confidenciais, como chaves de API, tokens ou URLs base em variáveis ​​de ambiente.
2. Respostas simuladas quando necessário: Se você não quiser acessar a API real todas as vezes, simule as respostas da API usando cy.intercept().
3. Lidar com limites de taxa: Se sua API tiver limites de taxa, certifique-se de que seus testes os tratem adequadamente, adicionando novas tentativas ou atrasos entre as solicitações.
4. Manter os testes independentes: Garanta que cada teste de API seja independente dos outros, para que possam ser executados em qualquer ordem sem problemas de dependência.
5. Foco em casos extremos: Teste o caminho feliz e os casos extremos (por exemplo, entradas inválidas, grandes conjuntos de dados, limitação de taxa) para cobrir todos os cenários potenciais.

Conclusão

O teste de API é uma parte essencial para garantir que seu aplicativo funcione perfeitamente, mesmo quando depende de serviços externos ou APIs de back-end. Cypress fornece uma maneira simples, mas poderosa de testar APIs junto com seus testes de UI, tornando-o uma excelente escolha para desenvolvedores que trabalham com aplicativos JavaScript modernos. Ao aproveitar recursos como cy.request(), asserções e integração CI/CD, você pode criar um conjunto de testes de API robusto e confiável que detecta problemas antecipadamente e garante a qualidade de suas APIs.

Comece a testar suas APIs com Cypress hoje mesmo e melhore seu fluxo de trabalho de desenvolvimento com testes automatizados e confiáveis!