Pruebas de API: Lista de verificación y Pruebas automáticas

Lista de verificación para pruebas de API: Desde códigos de estado hasta automatización impulsada por IA

Las pruebas de API requieren un enfoque sistemático: validar códigos de estado, estructura de respuestas, casos límite y autenticación. Postman destaca en pruebas manuales, mientras que Jest + axios se integra sin problemas en pipelines CI/CD. La inteligencia artificial acelera la generación de casos de prueba a partir de especificaciones OpenAPI, analiza respuestas y detecta patrones de datos extremos.

Categorías clave de pruebas de API

Las pruebas de API abarcan múltiples áreas críticas. Omitir cualquiera conlleva riesgo de errores no detectados en producción.

Códigos de estado

Verifica que el código coincida con el escenario esperado:

| Escenario | Código esperado |

|----------|----------------|

| Creación exitosa | 201 |

| Recurso no encontrado | 404 |

| Permisos insuficientes | 403 |

| No autenticado | 401 |

| Datos inválidos | 400/422 |

| Error del servidor | 500 |

Error común: devolver 200 con un error en el cuerpo—esto viola los principios REST.

Estructura de respuesta

• Los campos obligatorios están presentes.
• Los tipos de datos coinciden con lo esperado (por ejemplo, número en lugar de cadena).
• Los objetos anidados no son nulos.
• Los arreglos no se confunden con objetos.

Casos límite

Prueba condiciones extremas:

• Cuerpo de solicitud vacío.
• Campo requerido faltante.
• Cadena vacía en un campo.
• Números: 0, valores negativos, MAX_INT.
• Cadenas: 1 carácter, longitud máxima, caracteres especiales, cargas SQL/XSS.

Autenticación y encabezados

• Sin token: 401.
• Token expirado: 401.
• Token inválido: 403.
• Usuario de solo lectura en operación de escritura: 403.

Encabezados: Content-Type, CORS, limitación de tasa.

Pruebas en Postman

Utiliza la pestaña Tests para scripts en JavaScript tras recibir una respuesta.

Afirmaciones básicas

// Estado y tiempo de respuesta
pm.test("Estado 200", () => {
    pm.response.to.have.status(200);
});

pm.test("Respuesta <500ms", () => {
    pm.expect(pm.response.responseTime).to.be.below(500);
});

// Tipo de contenido
pm.test("JSON", () => {
    pm.response.to.have.header("Content-Type", "application/json; charset=utf-8");
});

Estructura y tipos

const response = pm.response.json();

pm.test("id presente", () => {
    pm.expect(response).to.have.property("id");
});

pm.test("id es un número", () => {
    pm.expect(response.id).to.be.a("number");
});

pm.test("email no está vacío", () => {
    pm.expect(response.email).to.be.a("string").and.not.empty;
});

Negativo: Sin token

pm.test("401 sin token", () => {
    pm.response.to.have.status(401);
});

const response = pm.response.json();
pm.expect(response).to.have.property("message");

Guarda el token de /login en una variable de entorno: pm.environment.set("auth_token", response.token);. Ábrelo como {{auth_token}} en los encabezados.

Pruebas automatizadas con Jest + axios

Para CI/CD, escribe pruebas directamente en código. Ejemplo para /users/:id:

const axios = require("axios");

const BASE_URL = "https://api.example.com";
const TOKEN = process.env.API_TOKEN;

const client = axios.create({
    baseURL: BASE_URL,
    headers: { Authorization: `Bearer ${TOKEN}` }
});

describe("GET /users/:id", () => {

    test("Obtener usuario por ID", async () => {
        const response = await client.get("/users/1");

        expect(response.status).toBe(200);
        expect(response.data).toMatchObject({
            id: expect.any(Number),
            email: expect.any(String),
            name: expect.any(String),
        });
    });

    test("404 para usuario inexistente", async () => {
        await expect(client.get("/users/999999"))
            .rejects.toMatchObject({
                response: { status: 404 }
            });
    });

    test("401 sin token", async () => {
        await expect(axios.get(`${BASE_URL}/users/1`))
            .rejects.toMatchObject({
                response: { status: 401 }
            });
    });

});

Ejecuta con: npx jest user.test.js.

Lista de verificación universal

Escenarios positivos:

• Datos válidos → código correcto.
• Estructura de respuesta coincide con la documentación.
• Campos obligatorios presentes.
• Tipos de datos correctos.
• Tiempo de respuesta dentro de límites.

Casos negativos:

• Sin autenticación → 401.
• Token incorrecto → 403.
• Campo faltante → 400/422.
• Tipo incorrecto → 400/422.
• Recurso inexistente → 404.
• Cuerpo vacío → error de validación.

Casos límite:

• Valores mínimos/máximos.
• Números cero o negativos.
• Cadenas vacías.
• Caracteres especiales/Unicode.
• Cadenas largas.

Seguridad:

• Inyección SQL.
• XSS.
• IDOR (adivinanza de IDs).

Automatización impulsada por IA

La IA genera casos de prueba desde especificaciones OpenAPI—positivos, negativos y de borde—en formato Jest.

Prompt: "Genera pruebas para POST /users basado en el esquema [schema]. Usa datos realistas."

Análisis automático de respuestas con LLMs:

async function validateWithAI(prompt, response) {
    // Llama a Claude/GPT para evaluar relevancia
    // ...
    return data.content[0].text.trim() === "YES";
}

Generación de datos extremos: la IA sugiere texto RTL, emojis, caracteres Unicode invisibles.

La IA no reemplaza el entendimiento del negocio (por ejemplo, descuento ≤ 100 para usuarios no premium).

Lo más importante

• Valida estrictamente los códigos de estado según el escenario—nunca uses 200 para errores.
• Prueba la estructura y tipos de respuesta usando afirmaciones similares a JSONPath.
• Automatiza casos negativos y de borde en CI/CD con Jest/axios.
• Aprovecha la IA para tareas repetitivas: generación de pruebas, análisis, datos extremos.
• Usa la lista de verificación como plantilla obligatoria para cada endpoint.

— Editorial Team