Dominando las Pruebas de API con Postman: Ejemplos del Mundo Real

#api #testing #postman #automation

Introducción

En el desarrollo de software moderno, las APIs (Interfaces de Programación de Aplicaciones) son la columna vertebral de la comunicación entre sistemas. Postman se ha consolidado como una de las herramientas más populares y poderosas para probar, documentar y automatizar APIs. En este artículo, exploraremos cómo aplicar Postman en escenarios del mundo real, con ejemplos prácticos que puedes implementar inmediatamente.

¿Por qué Postman?

Postman no es solo un cliente HTTP; es una plataforma completa para el desarrollo de APIs que ofrece:

Interfaz intuitiva: Ideal para principiantes y expertos
Automatización de pruebas: Scripts JavaScript para validaciones complejas
Colecciones organizadas: Agrupa solicitudes relacionadas
Variables de entorno: Facilita el cambio entre dev, staging y producción
Integración CI/CD: Compatible con Newman para pipelines automatizados
Colaboración en equipo: Espacios de trabajo compartidos

Caso de Uso 1: Prueba de API RESTful de E-commerce

Imaginemos que estamos probando una API de una tienda en línea que gestiona productos.

Escenario: Obtener lista de productos

// GET https://api.tienda.com/v1/productos

// En la pestaña "Tests" de Postman:
pm.test("El código de estado es 200", function () {
    pm.response.to.have.status(200);
});

pm.test("La respuesta es JSON", function () {
    pm.response.to.be.json;
});

pm.test("La respuesta contiene productos", function () {
    const jsonData = pm.response.json();
    pm.expect(jsonData).to.be.an('array');
    pm.expect(jsonData.length).to.be.above(0);
});

pm.test("Cada producto tiene campos requeridos", function () {
    const productos = pm.response.json();
    productos.forEach(producto => {
        pm.expect(producto).to.have.property("id");
        pm.expect(producto).to.have.property("nombre");
        pm.expect(producto).to.have.property("precio");
        pm.expect(producto).to.have.property("stock");
    });
});

Escenario: Crear un nuevo producto (POST)

// POST https://api.tienda.com/v1/productos
// Body (JSON):
{
    "nombre": "Laptop Dell XPS 15",
    "precio": 1299.99,
    "categoria": "Electrónica",
    "stock": 25
}

// Tests:
pm.test("Producto creado exitosamente - 201", function () {
    pm.response.to.have.status(201);
});

pm.test("La respuesta contiene el ID del producto", function () {
    const jsonData = pm.response.json();
    pm.expect(jsonData).to.have.property("id");

    // Guardar el ID para usar en solicitudes posteriores
    pm.environment.set("producto_id", jsonData.id);
});

pm.test("El precio se guardó correctamente", function () {
    const jsonData = pm.response.json();
    pm.expect(jsonData.precio).to.eql(1299.99);
});

Caso de Uso 2: Autenticación y Autorización

Las APIs del mundo real requieren autenticación. Veamos cómo manejar tokens JWT.

Paso 1: Login y captura de token

// POST https://api.tienda.com/v1/auth/login
// Body:
{
    "email": "usuario@ejemplo.com",
    "password": "password123"
}

// Tests:
pm.test("Login exitoso", function () {
    pm.response.to.have.status(200);
});

pm.test("Token JWT recibido", function () {
    const jsonData = pm.response.json();
    pm.expect(jsonData).to.have.property("token");

    // Guardar el token en variable de entorno
    pm.environment.set("jwt_token", jsonData.token);

    // Guardar timestamp de expiración
    pm.environment.set("token_expiry", jsonData.expiresIn);
});

Paso 2: Usar el token en solicitudes protegidas

// GET https://api.tienda.com/v1/usuario/perfil
// Headers: Authorization: Bearer {{jwt_token}}

// Pre-request Script para verificar token:
const token = pm.environment.get("jwt_token");

if (!token) {
    throw new Error("No hay token de autenticación. Ejecuta primero el login.");
}

// Tests:
pm.test("Acceso autorizado al perfil", function () {
    pm.response.to.have.status(200);
});

pm.test("Datos del usuario son correctos", function () {
    const usuario = pm.response.json();
    pm.expect(usuario).to.have.property("email");
    pm.expect(usuario).to.have.property("nombre");
    pm.expect(usuario.rol).to.eql("admin");
});

Conclusiones

Postman es mucho más que una herramienta para enviar solicitudes HTTP. Como hemos visto en estos ejemplos del mundo real:

Validación robusta: Podemos verificar códigos de estado, estructura de datos y lógica de negocio
Flujos complejos: Encadenamiento de solicitudes con variables dinámicas
Automatización: Integración perfecta con pipelines CI/CD mediante Newman
Colaboración: Espacios de trabajo compartidos facilitan el trabajo en equipo
Documentación viva: Las colecciones sirven como documentación ejecutable

Recursos Adicionales

Sobre el autor: Este artículo forma parte del Trabajo de Investigación N° 02 sobre Comparación de Frameworks de Pruebas de API, desarrollado como parte del curso de Calidad y Pruebas de Software.

DEV Community