Pruebas de REST API: la guía completa para desarrolladores

Introducción

Las APIs REST (Transferencia de Estado Representacional) son la columna vertebral de las aplicaciones web y móviles modernas. Desde la obtención de perfiles de usuario hasta el procesamiento de pagos, casi todas las aplicaciones se comunican con los servicios backend a través de endpoints de API RESTful. Probar estas APIs es fundamental para garantizar la confiabilidad, el rendimiento y la seguridad.

Esta guía cubre todo lo que necesita saber sobre las pruebas de REST API, desde los fundamentos de los métodos HTTP hasta las estrategias avanzadas de automatización. Ya sea que usted sea un desarrollador escribiendo su primera prueba de API o un ingeniero de QA construyendo una suite de pruebas completa, encontrará técnicas prácticas y ejemplos de código que puede usar de inmediato.

¿Qué son las pruebas de REST API?

Las pruebas de REST API son el proceso de validar los servicios web RESTful para garantizar que devuelvan respuestas correctas, manejen los errores con elegancia, funcionen dentro de límites aceptables y permanezcan seguros contra ataques.

A diferencia de las pruebas de UI (que prueban lo que ven los usuarios), las pruebas de API verifican la capa de lógica de negocio directamente, lo que las hace más rápidas, más confiables y más fáciles de automatizar.

Qué se prueba en una REST API

• Códigos de estado HTTP: ¿La API devuelve 200, 201, 400, 401, 404, 500 correctamente?
• Cuerpo de la respuesta: ¿El JSON/XML coincide con el esquema y los valores esperados?
• Encabezados: ¿Los encabezados content-type, cache-control y CORS son correctos?
• Autenticación: ¿Los endpoints protegidos rechazan las solicitudes no autorizadas?
• Rendimiento: ¿Con qué rapidez responde la API bajo carga normal e intensa?
• Manejo de errores: ¿La API devuelve mensajes de error significativos?

Métodos HTTP y qué probar

Las REST APIs usan métodos HTTP estándar. Cada método tiene requisitos de prueba específicos:

GET: recuperar recursos

# Fetch a single user
curl -X GET https://api.example.com/users/1 \
  -H "Authorization: Bearer YOUR_TOKEN"
# Expected: 200 OK with user data
# Test: Verify response schema, field types, and values

Lista de verificación de pruebas para GET:

• Devuelve 200 para recursos existentes
• Devuelve 404 para recursos inexistentes
• La paginación funciona correctamente (limit, offset, cursor)
• El filtrado y la ordenación devuelven resultados precisos
• Los encabezados de respuesta incluyen las directivas de almacenamiento en caché adecuadas

POST: crear recursos

# Create a new user
curl -X POST https://api.example.com/users \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d '{
    "name": "Jane Doe",
    "email": "jane@example.com",
    "role": "developer"
  }'
# Expected: 201 Created with the new resource

Lista de verificación de pruebas para POST:

• Devuelve 201 con el recurso creado
• Valida los campos requeridos (devuelve 400 para campos faltantes)
• Rechaza las entradas duplicadas apropiadamente (409 Conflict)
• Sanea la entrada para prevenir ataques de inyección
• Devuelve el ID del recurso creado en la respuesta

PUT/PATCH: actualizar recursos

# Full update (PUT)
curl -X PUT https://api.example.com/users/1 \
  -H "Content-Type: application/json" \
  -d '{"name": "Jane Smith", "email": "jane.smith@example.com", "role": "lead"}'
# Partial update (PATCH)
curl -X PATCH https://api.example.com/users/1 

-H "Content-Type: application/json" 

-d '{"role": "lead"}'

DELETE: eliminar recursos

# Delete a user
curl -X DELETE https://api.example.com/users/1 \
  -H "Authorization: Bearer YOUR_TOKEN"
# Expected: 204 No Content or 200 OK

Configuración de su primera suite de pruebas de REST API

Construyamos una suite de pruebas práctica usando dos enfoques populares: JavaScript (Node.js) y Python.

JavaScript con Jest y Axios

// tests/users.test.js
const axios = require('axios');
const API_URL = 'https://api.example.com';
const TOKEN = process.env.API_TOKEN;
const client = axios.create({
baseURL: API_URL,
headers: { Authorization: Bearer ${TOKEN} },
});
describe('Users API', () => {
let createdUserId;
test('POST /users creates a new user', async () => {
const response = await client.post('/users', {
name: 'Test User',
email: 'test@example.com',
role: 'developer',
});
expect(response.status).toBe(201);
expect(response.data).toHaveProperty('id');
expect(response.data.name).toBe('Test User');
createdUserId = response.data.id;

});
test('GET /users/:id returns the created user', async () => {
const response = await client.get(/users/${createdUserId});
expect(response.status).toBe(200);
expect(response.data.email).toBe('test@example.com');

});
test('GET /users/:id returns 404 for non-existent user', async () => {
try {
await client.get('/users/99999');
} catch (error) {
expect(error.response.status).toBe(404);
}
});
test('PATCH /users/:id updates user role', async () => {
const response = await client.patch(/users/${createdUserId}, {
role: 'lead',
});
expect(response.status).toBe(200);
expect(response.data.role).toBe('lead');
});
test('DELETE /users/:id removes the user', async () => {
const response = await client.delete(/users/${createdUserId});
expect(response.status).toBe(204);
});
});

Python con pytest y requests

# tests/test_users.py
import os
import pytest
import requests
API_URL = "https://api.example.com"
HEADERS = {
"Authorization": f"Bearer {os.environ['API_TOKEN']}",
"Content-Type": "application/json",
}
class TestUsersAPI:
created_user_id = None
def test_create_user(self):
    response = requests.post(
        f"{API_URL}/users",
        json={"name": "Test User", "email": "test@example.com", "role": "developer"},
        headers=HEADERS,
    )
    assert response.status_code == 201
    data = response.json()
    assert "id" in data
    TestUsersAPI.created_user_id = data["id"]

def test_get_user(self):
    response = requests.get(
        f"{API_URL}/users/{self.created_user_id}",
        headers=HEADERS,
    )
    assert response.status_code == 200
    assert response.json()["email"] == "test@example.com"

def test_get_nonexistent_user(self):
    response = requests.get(f"{API_URL}/users/99999", headers=HEADERS)
    assert response.status_code == 404

def test_delete_user(self):
    response = requests.delete(
        f"{API_URL}/users/{self.created_user_id}",
        headers=HEADERS,
    )
    assert response.status_code == 204

Mejores prácticas para las pruebas de REST API

1. Pruebe el contrato, no la implementación

Sus pruebas deben validar que la API cumpla con su contrato (esquema, códigos de estado, formato de respuesta), no cómo el backend lo implementa internamente. Esto hace que las pruebas sean resistentes a las refactorizaciones.

2. Use variables de entorno para la configuración

Nunca codifique de forma fija las URLs de API, tokens o credenciales en sus pruebas. Use variables de entorno o archivos de configuración.

3. Implemente el aislamiento de datos de prueba

Cada prueba debe crear sus propios datos y limpiarlos después. Nunca dependa de datos preexistentes que otra prueba o usuario pueda modificar.

4. Valide los esquemas de respuesta

No se limite a verificar los códigos de estado; valide toda la estructura de respuesta usando validación de esquema JSON:

const Ajv = require('ajv');
const ajv = new Ajv();
const userSchema = {
type: 'object',
required: ['id', 'name', 'email', 'role'],
properties: {
id: { type: 'integer' },
name: { type: 'string' },
email: { type: 'string', format: 'email' },
role: { type: 'string', enum: ['developer', 'lead', 'admin'] },
},
};
test('GET /users/:id matches schema', async () => {
const response = await client.get('/users/1');
const validate = ajv.compile(userSchema);
expect(validate(response.data)).toBe(true);
});

5. Pruebe la autenticación y la autorización

• La solicitud sin token devuelve 401
• La solicitud con token vencido devuelve 401
• La solicitud con permisos insuficientes devuelve 403
• La solicitud con token válido devuelve los datos esperados

6. Pruebe las respuestas de error

Las rutas de error son tan importantes como las rutas felices. Verifique que su API devuelva mensajes de error claros y consistentes con los códigos de estado apropiados.

7. Cubra los casos extremos

• Cuerpos de solicitud vacíos
• Cadenas extremadamente largas
• Caracteres especiales y Unicode
• Valores límite para campos numéricos
• Valores nulos e indefinidos
• Solicitudes concurrentes al mismo recurso

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

Las pruebas manuales de API durante el desarrollo son un punto de partida, pero las aplicaciones en producción necesitan pruebas automatizadas que se ejecuten en cada cambio de código.

Ejemplo con GitHub Actions

name: REST API Tests
on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]
jobs:
api-tests:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: '20'
- run: npm ci
- run: npm run start:test &
- run: npx wait-on http://localhost:3000/health
- run: npm run test:api
env:
API_URL: http://localhost:3000

Automatización con Qodex.ai

Si desea omitir la escritura manual de código de prueba, Qodex.ai puede analizar su especificación de API y generar automáticamente suites de pruebas completas. El agente de IA crea pruebas para rutas felices, casos extremos, manejo de errores y vulnerabilidades de seguridad, y luego se integra en su pipeline de CI/CD.

Comparación de herramientas de prueba de REST API

Para una comparación detallada, consulte nuestra comparación de herramientas de prueba de API. Resumen rápido para las pruebas de REST:

Técnicas avanzadas de prueba de REST API

Pruebas de contrato

Las pruebas de contrato garantizan que el proveedor y el consumidor de la API estén de acuerdo sobre el contrato de la API. Herramientas como Pact le permiten definir las expectativas del consumidor y verificarlas contra el proveedor. Esto es fundamental para las pruebas de integración en microservicios.

Pruebas de rendimiento

Use herramientas de prueba de carga como k6 o JMeter para verificar que su REST API maneje el tráfico esperado. Métricas clave: latencia p50/p95/p99, rendimiento (RPS), tasa de error bajo carga.

Pruebas de seguridad

Las REST APIs son objetivos comunes de ataques. Pruebe las vulnerabilidades cubiertas en la guía de pruebas de seguridad de API: inyección SQL, autenticación rota, exposición excesiva de datos, limitación de velocidad y configuración incorrecta de CORS.

REST frente a otras arquitecturas de API

REST no es la única opción. Dependiendo de sus requisitos, también podría considerar GraphQL para consultas flexibles, gRPC para la comunicación de alto rendimiento entre servicios, o SOAP para sistemas empresariales con contratos estrictos.

Preguntas frecuentes

¿Cuál es la diferencia entre las pruebas de REST API y las pruebas de UI?

Las pruebas de REST API validan la lógica del backend directamente enviando solicitudes HTTP y verificando las respuestas. Las pruebas de UI interactúan con la interfaz de usuario a través de un navegador. Las pruebas de API son más rápidas, más estables y más fáciles de automatizar porque omiten la capa de renderizado.

¿Cómo pruebo una REST API sin escribir código?

Herramientas como Postman, Insomnia y Hoppscotch proporcionan interfaces visuales para las pruebas. Qodex.ai va más allá al generar automáticamente suites de pruebas a partir de su especificación de API, sin necesidad de codificación.

¿Qué debo probar en una REST API?

Como mínimo: códigos de estado HTTP, estructura del cuerpo de la respuesta, autenticación/autorización, manejo de errores, validación de entrada y rendimiento. Consulte la lista de verificación de pruebas de API para obtener más detalles.

¿Cómo automatizo las pruebas de REST API?

Escriba pruebas usando un framework como Jest, pytest o REST Assured, y luego intégrelas en su pipeline de CI/CD. O use Qodex.ai para generar y ejecutar pruebas automáticamente.

¿Cuál es la mejor herramienta para las pruebas de REST API?

Depende de su stack. Para la exploración manual, Postman o Insomnia. Para las pruebas automatizadas basadas en código, REST Assured (Java) o pytest (Python). Para la automatización impulsada por IA, Qodex.ai. Consulte nuestra comparación completa de herramientas de prueba de API.

¿En qué se diferencian las pruebas de REST API de las pruebas de SOAP API?

REST usa JSON sobre HTTP mientras que SOAP usa XML con esquemas WSDL estrictos. Las pruebas de REST son más simples ya que cualquier cliente HTTP funciona. Las pruebas de SOAP a menudo requieren herramientas especializadas como SoapUI que comprenden WSDL y los espacios de nombres XML.