Módulo 09: Testing de APIs con Postman

Objetivos del módulo

• Instalar y dominar la interfaz de Postman
• Crear y organizar colecciones de peticiones
• Usar variables y entornos
• Escribir tests automáticos en Postman
• Ejecutar colecciones con Newman (CLI)

---

1. ¿Qué es Postman?

Postman es la herramienta más popular para probar APIs. Permite enviar peticiones HTTP, inspeccionar respuestas y automatizar pruebas.

Instalación

1. Descarga desde postman.com/downloads
2. Instala y crea una cuenta gratuita
3. Entorno: Desktop (recomendado) o Web

Interfaz principal

┌─────────────────────────────────────────────────────────────┐
│ [GET ▼] [https://api.ejemplo.com/usuarios      ] [Send]    │
├───────────────────────┬─────────────────────────────────────┤
│ Params │ Auth │ Headers│ Body │ Pre-req │ Tests │ Settings│  │
├───────────────────────┼─────────────────────────────────────┤
│                    Body (JSON)                              │
│  {                                                          │
│    "nombre": "Ana",                                         │
│    "email": "ana@mail.com"                                  │
│  }                                                          │
├─────────────────────────────────────────────────────────────┤
│ Response: 200 OK    Time: 145ms    Size: 256 B              │
│ Body │ Headers │ Tests │                                     │
│  { "id": 1, "nombre": "Ana", ... }                         │
└─────────────────────────────────────────────────────────────┘

---

2. Primera petición

GET — Obtener datos

1. Método: GET
2. URL: https://jsonplaceholder.typicode.com/users/1
3. Clic en Send

Respuesta esperada (200 OK):

{
  "id": 1,
  "name": "Leanne Graham",
  "username": "Bret",
  "email": "Sincere@april.biz",
  "address": {
    "street": "Kulas Light",
    "city": "Gwenborough"
  }
}

POST — Crear un recurso

1. Método: POST
2. URL: https://jsonplaceholder.typicode.com/posts
3. Tab Body → raw → JSON
4. Contenido:

{
  "title": "Mi primer post",
  "body": "Contenido del post de prueba",
  "userId": 1
}

1. Clic en Send

Respuesta esperada (201 Created):

{
  "id": 101,
  "title": "Mi primer post",
  "body": "Contenido del post de prueba",
  "userId": 1
}

---

3. Colecciones

Una colección agrupa peticiones relacionadas.

Crear colección

1. Panel izquierdo → New Collection
2. Nombre: API Usuarios
3. Descripción: Tests de CRUD de usuarios

Organizar en carpetas

📁 API Usuarios
  📁 Auth
    POST - Login
    POST - Register
  📁 Usuarios
    GET - Listar usuarios
    GET - Obtener usuario por ID
    POST - Crear usuario
    PUT - Actualizar usuario
    DELETE - Eliminar usuario
  📁 Productos
    GET - Listar productos
    GET - Buscar productos

---

4. Variables

Las variables evitan repetir valores y facilitan cambiar entre entornos.

Tipos de variables

Ámbito	Uso	Prioridad
Global	Disponible en todas las colecciones	Menor
Collection	Disponible dentro de la colección
Environment	Cambian según el entorno
Data	Vienen de archivo CSV/JSON
Local	Solo durante la ejecución	Mayor

Usar variables

URL: {{baseUrl}}/api/usuarios/{{userId}}
Header: Authorization: Bearer {{token}}

Crear entornos

Entorno: Desarrollo

Variable	Valor
baseUrl	http://localhost:5000
adminEmail	admin@dev.com
adminPassword	dev123

Entorno: Producción

Variable	Valor
baseUrl	https://api.miapp.com
adminEmail	admin@miapp.com
adminPassword	prod_secure_123!

💡 Consejo: Nunca guardes contraseñas reales de producción en Postman. Usa variables de tipo “secret” que no se sincronizan.

---

5. Tests automáticos

Postman permite escribir tests en JavaScript que se ejecutan después de cada petición.

Pestaña “Tests”

// Verificar código de estado
pm.test("Status code es 200", function () {
    pm.response.to.have.status(200);
});

// Verificar que la respuesta tiene JSON
pm.test("La respuesta es JSON", function () {
    pm.response.to.be.json;
});

// Verificar estructura de la respuesta
pm.test("La respuesta tiene los campos esperados", function () {
    var json = pm.response.json();
    pm.expect(json).to.have.property("id");
    pm.expect(json).to.have.property("name");
    pm.expect(json).to.have.property("email");
});

// Verificar valores específicos
pm.test("El nombre es correcto", function () {
    var json = pm.response.json();
    pm.expect(json.name).to.eql("Leanne Graham");
});

// Verificar tipo de dato
pm.test("El id es un número", function () {
    var json = pm.response.json();
    pm.expect(json.id).to.be.a("number");
});

// Verificar tiempo de respuesta
pm.test("Respuesta en menos de 500ms", function () {
    pm.expect(pm.response.responseTime).to.be.below(500);
});

Tests para arrays

pm.test("La lista tiene al menos 1 elemento", function () {
    var json = pm.response.json();
    pm.expect(json).to.be.an("array");
    pm.expect(json.length).to.be.above(0);
});

pm.test("Todos los usuarios tienen email", function () {
    var json = pm.response.json();
    json.forEach(function(user) {
        pm.expect(user).to.have.property("email");
        pm.expect(user.email).to.include("@");
    });
});

Tests para errores

// Para un POST con datos inválidos
pm.test("Retorna 400 Bad Request", function () {
    pm.response.to.have.status(400);
});

pm.test("El error tiene mensaje descriptivo", function () {
    var json = pm.response.json();
    pm.expect(json).to.have.property("errors");
});

---

6. Pre-request Scripts

Scripts que se ejecutan antes de la petición. Útiles para generar datos dinámicos o autenticarse.

Generar datos dinámicos

// Generar email aleatorio
var randomEmail = "user_" + pm.variables.replaceIn("{{$randomInt}}") + "@test.com";
pm.variables.set("randomEmail", randomEmail);

// Timestamp
pm.variables.set("timestamp", new Date().toISOString());

Flujo de autenticación automática

Petición Pre-request (obtener token):

// Pre-request script en las peticiones que necesitan auth
pm.sendRequest({
    url: pm.variables.get("baseUrl") + "/api/auth/login",
    method: "POST",
    header: { "Content-Type": "application/json" },
    body: {
        mode: "raw",
        raw: JSON.stringify({
            email: pm.variables.get("adminEmail"),
            password: pm.variables.get("adminPassword")
        })
    }
}, function (err, response) {
    var token = response.json().token;
    pm.variables.set("token", token);
});

Guardar datos entre peticiones

En POST Crear Usuario (Tests):

pm.test("Guardar ID del usuario creado", function () {
    var json = pm.response.json();
    pm.collectionVariables.set("userId", json.id);
});

En GET Obtener Usuario (URL):

GET {{baseUrl}}/api/usuarios/{{userId}}

---

7. Collection Runner

Ejecuta todos los tests de una colección de forma secuencial.

Configurar el Runner

1. Botón Run en la colección
2. Seleccionar entorno
3. Configurar iteraciones y delay
4. Opcionalmente cargar archivo de datos (CSV/JSON)

Data-driven testing

Archivo usuarios.csv:

nombre,email,password
Ana García,ana@test.com,Pass123!
Carlos López,carlos@test.com,Pass456!
María Ruiz,maria@test.com,Pass789!

En la petición POST:

{
  "nombre": "{{nombre}}",
  "email": "{{email}}",
  "password": "{{password}}"
}

Runner: 3 iteraciones, una por fila del CSV.

---

8. Newman (CLI)

Newman ejecuta colecciones de Postman desde la línea de comandos. Es ideal para CI/CD.

Instalación

npm install -g newman
npm install -g newman-reporter-htmlextra

Ejecución

# Exportar colección desde Postman (JSON)
# Exportar entorno (JSON)

# Ejecutar
newman run mi-coleccion.json -e entorno-dev.json

# Con reporte HTML
newman run mi-coleccion.json \
  -e entorno-dev.json \
  -r htmlextra \
  --reporter-htmlextra-export reporte.html

# Con iteraciones y datos
newman run mi-coleccion.json \
  -e entorno-dev.json \
  -d usuarios.csv \
  -n 3

Salida de Newman

┌─────────────────────────┬─────────────┬────────────┐
│                         │   executed   │    failed  │
├─────────────────────────┼─────────────┼────────────┤
│      iterations         │       1     │      0     │
├─────────────────────────┼─────────────┼────────────┤
│        requests         │      12     │      0     │
├─────────────────────────┼─────────────┼────────────┤
│    test-scripts         │      12     │      0     │
├─────────────────────────┼─────────────┼────────────┤
│      assertions         │      36     │      2     │
├─────────────────────────┼─────────────┼────────────┤
│ total run duration: 4.2s                            │
└─────────────────────────────────────────────────────┘

---

9. Flujo completo de testing de API

Ejemplo: CRUD de productos

1. POST /api/auth/login        → Obtener token     → Guardar en variable
2. POST /api/productos         → Crear producto     → Guardar ID
3. GET  /api/productos/{{id}}  → Verificar creación → Comprobar datos
4. PUT  /api/productos/{{id}}  → Actualizar precio  → Comprobar cambio
5. GET  /api/productos         → Listar todos       → Verificar que aparece
6. DELETE /api/productos/{{id}} → Eliminar          → Verificar 204
7. GET  /api/productos/{{id}}  → Verificar borrado  → Debe retornar 404

Cada petición incluye tests que verifican el estado y los datos de la respuesta.

---

10. Ejercicios

Ejercicio 1

Crea una colección en Postman para la API https://jsonplaceholder.typicode.com/ con peticiones GET, POST, PUT, DELETE para el recurso /posts. Escribe al menos 3 tests por petición.

Ejercicio 2

Crea un entorno con variable baseUrl y escribe un pre-request script que genere datos aleatorios para un POST.

Ejercicio 3

Exporta la colección del ejercicio 1 y ejecútala con Newman. Genera un reporte HTML.

Ejercicio 4

Crea un archivo CSV con 5 posts de prueba y ejecuta la colección con data-driven testing.

---

Resumen

Concepto	Descripción
Postman	Herramienta para testing de APIs
Colección	Grupo organizado de peticiones
Variables	{{variable}} para reutilizar valores
Entornos	Distintos valores por entorno (dev/prod)
Tests	Scripts JavaScript tras cada petición
Pre-request	Scripts antes de la petición
Collection Runner	Ejecuta toda la colección secuencialmente
Newman	CLI para ejecutar colecciones en CI/CD

---

Navegación
← Módulo anterior: Servicios web	Siguiente módulo: Selenium →