Introducción

Cypress es ampliamente conocido por sus capacidades de prueba de un extremo a otro, pero también es una poderosa herramienta para probar API. Las pruebas de API son una parte esencial para garantizar la confiabilidad, el rendimiento y la seguridad de las aplicaciones web modernas, ya que hoy en día muchas aplicaciones dependen en gran medida de los servicios backend y las API. Esta publicación lo guiará a través de los conceptos básicos de las pruebas de API con Cypress, incluida la configuración de pruebas de API, la realización de solicitudes, la validación de respuestas y la automatización del proceso.

¿Por qué utilizar Cypress para las pruebas de API?

1. Funciones integradas: Cypress tiene capacidades integradas para realizar solicitudes HTTP, afirmaciones y administrar pruebas asincrónicas.
2. Fácil integración: Puede integrar fácilmente pruebas de API en su conjunto de pruebas Cypress existente, junto con sus pruebas de UI.
3. Excelente experiencia para desarrolladores: Cypress ofrece una interfaz fácil de usar, comentarios rápidos y depuración en tiempo real.
4. Automatización: Puede automatizar las pruebas de API en su canal de CI/CD, garantizando que las API se prueben de manera consistente con cada implementación.

Comenzando con las pruebas de API en Cypress

Si ya tiene Cypress instalado para realizar pruebas de un extremo a otro, está listo para comenzar las pruebas de API. De lo contrario, siga los pasos de instalación a continuación.

Paso 1: Instalar Cypress

npm install cypress --save-dev

Una vez instalado, puedes ejecutar Cypress con el siguiente comando:

npx cypress open

Paso 2: Configurar tu primera prueba de API
Cypress proporciona un método cy.request() que puede utilizar para enviar solicitudes HTTP. A continuación se muestra un ejemplo básico de prueba de una API que devuelve una lista de usuarios:

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');
      });
  });
});

En este ejemplo, estamos probando una solicitud GET para recuperar una lista de usuarios. Cypress valida el código de estado de la respuesta y verifica que el cuerpo de la respuesta contenga 10 usuarios.

Métodos HTTP comunes en pruebas de API

A continuación se explica cómo puede realizar solicitudes HTTP comunes como GET, POST, PUT y DELETE en Cypress.

Solicitud OBTENER
Las solicitudes GET se utilizan para recuperar datos del servidor. Por ejemplo:

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);
  });

Solicitud POST
Las solicitudes POST se utilizan para crear nuevos recursos en el servidor. Aquí se explica cómo probar una solicitud 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');
  });

Solicitud PUT
Las solicitudes PUT se utilizan para actualizar los recursos existentes. Ejemplo:

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');
  });

BORRAR Solicitud
Las solicitudes DELETE se utilizan para eliminar recursos. Ejemplo:

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

Técnicas avanzadas de prueba de API

Una vez que haya dominado las solicitudes API básicas, puede pasar a técnicas de prueba de API más avanzadas, como manejar la autenticación, probar fallas de API y encadenar llamadas de API.

Manejo de autenticación
Algunas API requieren autenticación mediante tokens o claves API. Cypress puede manejar la autenticación configurando encabezados personalizados. Por ejemplo:

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);
  });

Aquí, el encabezado de Autorización se utiliza para enviar un token junto con la solicitud.

Probando fallas de API
Es esencial probar cómo se comporta su API cuando algo sale mal, como entradas no válidas o recursos faltantes. Por ejemplo, probando un error 404:

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

Al configurar failOnStatusCode: false, Cypress no fallará la prueba automáticamente para respuestas que no sean 2xx, lo que le permitirá validar respuestas de error.

Encadenamiento de llamadas API
A veces, es necesario encadenar varias llamadas API, por ejemplo, crear un recurso y luego usarlo en una prueba posterior:

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');
    });
});

En este ejemplo, la solicitud POST crea una nueva publicación y la solicitud GET recupera esa publicación según el ID devuelto por la primera llamada.

Automatización de pruebas API en canalizaciones de CI/CD

Para garantizar la estabilidad de sus API, es crucial ejecutar sus pruebas de API como parte de su proceso de integración/implementación continua (CI/CD). Cypress se puede integrar fácilmente en herramientas CI/CD como Jenkins, GitHub Actions o Travis CI.

Aquí hay un ejemplo de un flujo de trabajo de GitHub Actions que ejecuta pruebas de Cypress en cada impulso:

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 flujo de trabajo garantiza que las pruebas de API se ejecuten automáticamente cada vez que se envía código a la rama principal.

Mejores prácticas para pruebas de API con Cypress

Para garantizar que sus pruebas de API sean confiables, fáciles de mantener y eficientes, siga estas mejores prácticas:

1. Usar variables de entorno: Almacene datos confidenciales como claves API, tokens o URL base en variables de entorno.
2. Respuestas simuladas cuando sea necesario: Si no desea acceder a la API real cada vez, simule las respuestas de la API usando cy.intercept().
3. Manejar límites de velocidad: Si su API tiene límites de velocidad, asegúrese de que sus pruebas los manejen adecuadamente agregando reintentos o retrasos entre solicitudes.
4. Mantenga las pruebas independientes: Asegúrese de que cada prueba de API sea independiente de las demás, para que puedan ejecutarse en cualquier orden sin problemas de dependencia.
5. Céntrese en los casos extremos: Pruebe tanto el camino feliz como los casos extremos (por ejemplo, entradas no válidas, grandes conjuntos de datos, limitación de velocidad) para cubrir todos los escenarios potenciales.

Conclusión

Las pruebas de API son una parte esencial para garantizar que su aplicación funcione sin problemas, incluso cuando depende de servicios externos o API de backend. Cypress proporciona una forma sencilla pero potente de probar las API junto con las pruebas de la interfaz de usuario, lo que la convierte en una excelente opción para los desarrolladores que trabajan con aplicaciones JavaScript modernas. Al aprovechar funciones como cy.request(), aserciones e integración de CI/CD, puede crear un conjunto de pruebas de API sólido y confiable que detecte problemas de manera temprana y garantice la calidad de sus API.

¡Comience a probar sus API con Cypress hoy y mejore su flujo de trabajo de desarrollo con pruebas automatizadas y confiables!