M

MLOG

Español

Una guía completa sobre pruebas de integración centrada en las pruebas de API con Supertest, que cubre la configuración, mejores prácticas y técnicas avanzadas.

Pruebas de Integración: Dominando las Pruebas de API con Supertest

En el mundo del desarrollo de software, asegurar que los componentes individuales funcionen correctamente de forma aislada (pruebas unitarias) es crucial. Sin embargo, es igualmente importante verificar que estos componentes trabajen juntos sin problemas. Aquí es donde entran en juego las pruebas de integración. Las pruebas de integración se centran en validar la interacción entre diferentes módulos o servicios dentro de una aplicación. Este artículo profundiza en las pruebas de integración, centrándose específicamente en las pruebas de API con Supertest, una biblioteca potente y fácil de usar para probar aserciones HTTP en Node.js.

¿Qué son las Pruebas de Integración?

Las pruebas de integración son un tipo de prueba de software que combina módulos de software individuales y los prueba como un grupo. Su objetivo es exponer defectos en las interacciones entre las unidades integradas. A diferencia de las pruebas unitarias, que se centran en componentes individuales, las pruebas de integración verifican el flujo de datos y el flujo de control entre los módulos. Los enfoques comunes de pruebas de integración incluyen:

En el contexto de las APIs, las pruebas de integración implican verificar que diferentes APIs funcionen correctamente juntas, que los datos pasados entre ellas sean consistentes y que el sistema en general funcione como se espera. Por ejemplo, imagina una aplicación de comercio electrónico con APIs separadas para la gestión de productos, la autenticación de usuarios y el procesamiento de pagos. Las pruebas de integración asegurarían que estas APIs se comuniquen correctamente, permitiendo a los usuarios navegar por los productos, iniciar sesión de forma segura y completar compras.

¿Por qué son Importantes las Pruebas de Integración de API?

Las pruebas de integración de API son cruciales por varias razones:

Considera una plataforma global de reservas de viajes. Las pruebas de integración de API son primordiales para garantizar una comunicación fluida entre las APIs que manejan las reservas de vuelos, las reservas de hotel y las pasarelas de pago de varios países. La falta de una integración adecuada de estas APIs podría llevar a reservas incorrectas, fallos de pago y una mala experiencia de usuario, impactando negativamente la reputación y los ingresos de la plataforma.

Presentando Supertest: Una Herramienta Potente para Pruebas de API

Supertest es una abstracción de alto nivel para probar solicitudes HTTP. Proporciona una API conveniente y fluida para enviar solicitudes a tu aplicación y hacer aserciones sobre las respuestas. Construido sobre Node.js, Supertest está diseñado específicamente para probar servidores HTTP de Node.js. Funciona excepcionalmente bien con frameworks de pruebas populares como Jest y Mocha.

Características Clave de Supertest:

Configurando tu Entorno de Pruebas

Antes de comenzar, configuremos un entorno de pruebas básico. Asumiremos que tienes Node.js y npm (o yarn) instalados. Usaremos Jest como nuestro framework de pruebas y Supertest para las pruebas de API.

  1. Crea un proyecto de Node.js:
mkdir api-testing-example
cd api-testing-example
npm init -y
  1. Instala las dependencias:
npm install --save-dev jest supertest
npm install express  # O tu framework preferido para crear la API
  1. Configura Jest: Añade lo siguiente a tu archivo package.json:
{
  "scripts": {
    "test": "jest"
  }
}
  1. Crea un endpoint de API simple: Crea un archivo llamado app.js (o similar) con el siguiente código:
const express = require('express');
const app = express();
const port = 3000;

app.get('/hello', (req, res) => {
  res.send('Hello, World!');
});

app.listen(port, () => {
  console.log(`Example app listening at http://localhost:${port}`);
});

module.exports = app; // Exportar para las pruebas

Escribiendo tu Primera Prueba con Supertest

Ahora que tenemos nuestro entorno configurado, escribamos una prueba simple con Supertest para verificar nuestro endpoint de API. Crea un archivo llamado app.test.js (o similar) en la raíz de tu proyecto:

const request = require('supertest');
const app = require('./app');

describe('GET /hello', () => {
  it('responde con 200 OK y devuelve "Hello, World!"', async () => {
    const response = await request(app).get('/hello');
    expect(response.statusCode).toBe(200);
    expect(response.text).toBe('Hello, World!');
  });
});

Explicación:

Para ejecutar la prueba, ejecuta el siguiente comando en tu terminal:

npm test

Si todo está configurado correctamente, deberías ver que la prueba pasa.

Técnicas Avanzadas de Supertest

Supertest ofrece una amplia gama de características para pruebas de API avanzadas. Exploremos algunas de ellas.

1. Enviando Cuerpos de Solicitud (Request Bodies)

Para enviar datos en el cuerpo de la solicitud, puedes usar el método .send(). Por ejemplo, creemos un endpoint que acepte datos JSON:

app.post('/users', express.json(), (req, res) => {
  const { name, email } = req.body;
  // Simula la creación de un usuario en una base de datos
  const user = { id: Date.now(), name, email };
  res.status(201).json(user);
});

Así es como puedes probar este endpoint usando Supertest:

describe('POST /users', () => {
  it('crea un nuevo usuario', async () => {
    const userData = {
      name: 'John Doe',
      email: 'john.doe@example.com',
    };

    const response = await request(app)
      .post('/users')
      .send(userData)
      .expect(201);

    expect(response.body).toHaveProperty('id');
    expect(response.body.name).toBe(userData.name);
    expect(response.body.email).toBe(userData.email);
  });
});

Explicación:

2. Estableciendo Encabezados (Headers)

Para establecer encabezados personalizados en tus solicitudes, puedes usar el método .set(). Esto es útil para establecer tokens de autenticación, tipos de contenido u otros encabezados personalizados.

describe('GET /protected', () => {
  it('requiere autenticación', async () => {
    const response = await request(app).get('/protected').expect(401);
  });

  it('devuelve 200 OK con un token válido', async () => {
    // Simula la obtención de un token válido
    const token = 'valid-token';

    const response = await request(app)
      .get('/protected')
      .set('Authorization', `Bearer ${token}`)
      .expect(200);

    expect(response.text).toBe('Protected Resource');
  });
});

Explicación:

3. Manejando Cookies

Supertest también puede manejar cookies. Puedes establecer cookies usando el método .set('Cookie', ...), o puedes usar la propiedad .cookies para acceder y modificar cookies.

4. Probando Subida de Archivos

Supertest se puede usar para probar endpoints de API que manejan la subida de archivos. Puedes usar el método .attach() para adjuntar archivos a la solicitud.

5. Usando Bibliotecas de Aserciones (Chai)

Aunque la biblioteca de aserciones incorporada de Jest es suficiente para muchos casos, también puedes usar bibliotecas de aserciones más potentes como Chai con Supertest. Chai proporciona una sintaxis de aserción más expresiva y flexible. Para usar Chai, necesitarás instalarlo:

npm install --save-dev chai

Luego, puedes importar Chai en tu archivo de prueba y usar sus aserciones:

const request = require('supertest');
const app = require('./app');
const chai = require('chai');
const expect = chai.expect;

describe('GET /hello', () => {
  it('responde con 200 OK y devuelve "Hello, World!"', async () => {
    const response = await request(app).get('/hello');
    expect(response.statusCode).to.equal(200);
    expect(response.text).to.equal('Hello, World!');
  });
});

Nota: Es posible que necesites configurar Jest para que funcione correctamente con Chai. Esto a menudo implica agregar un archivo de configuración que importa Chai y lo configura para que funcione con el expect global de Jest.

6. Reutilizando Agentes

Para las pruebas que requieren configurar un entorno específico (p. ej., autenticación), a menudo es beneficioso reutilizar un agente de Supertest. Esto evita código de configuración redundante en cada caso de prueba.

describe('Pruebas de API Autenticada', () => {
  let agent;

  beforeAll(() => {
    agent = request.agent(app); // Crea un agente persistente
    // Simula la autenticación
    return agent
      .post('/login')
      .send({ username: 'testuser', password: 'password123' });
  });

  it('puede acceder a un recurso protegido', async () => {
    const response = await agent.get('/protected').expect(200);
    expect(response.text).toBe('Protected Resource');
  });

  it('puede realizar otras acciones que requieren autenticación', async () => {
    // Realiza otras acciones autenticadas aquí
  });
});

En este ejemplo, creamos un agente de Supertest en el hook beforeAll y autenticamos al agente. Las pruebas posteriores dentro del bloque describe pueden luego reutilizar este agente autenticado sin tener que volver a autenticarse para cada prueba.

Mejores Prácticas para Pruebas de Integración de API con Supertest

Para asegurar pruebas de integración de API efectivas, considera las siguientes mejores prácticas:

Errores Comunes a Evitar

Conclusión

Las pruebas de integración de API son una parte esencial del proceso de desarrollo de software. Usando Supertest, puedes escribir fácilmente pruebas de integración de API completas y fiables que ayudan a asegurar la calidad y estabilidad de tu aplicación. Recuerda centrarte en probar flujos de trabajo de extremo a extremo, usar datos realistas, aislar tus pruebas y automatizar tu proceso de pruebas. Siguiendo estas mejores prácticas, puedes reducir significativamente el riesgo de problemas de integración y entregar un producto más robusto y fiable.

A medida que las APIs continúan impulsando las aplicaciones modernas y las arquitecturas de microservicios, la importancia de las pruebas de API robustas, y especialmente las pruebas de integración, seguirá creciendo. Supertest proporciona un conjunto de herramientas potente y accesible para que los desarrolladores de todo el mundo aseguren la fiabilidad y calidad de sus interacciones de API.