La pestaña Tests de Postman ejecuta aserciones en JavaScript contra cada respuesta, y pm.environment.set() es lo que encadena las peticiones: una petición de login guarda su token en el entorno, y cada petición siguiente de la colección lo toma automáticamente. Sin ese patrón, estás copiando tokens entre peticiones a mano en cada ejecución. Este artículo cubre cómo enviar tu primera petición, escribir aserciones con pm.test, variables de entorno para cambiar entre local y staging, encadenamiento de peticiones, scripts pre-petición para datos de prueba únicos, y cómo ejecutar colecciones en CI con Newman.

Qué es Postman

Postman es una herramienta gráfica para hacer peticiones HTTP. En vez de escribir comandos curl o código, completas una URL, eliges el método (GET, POST, etc.) y haces clic en Send. Ves la respuesta de inmediato.

Más allá de las peticiones simples, Postman te permite escribir aserciones de tests en JavaScript, encadenar peticiones (usar la respuesta de la petición A en la petición B), ejecutar colecciones de peticiones automáticamente, compartir colecciones con el equipo y generar documentación de APIs.

Configuración inicial

1. Descárgalo desde postman.com

2. Crea una cuenta gratuita (necesaria para la sincronización y colaboración)

3. Abre la app: verás un workspace con un editor de peticiones

Tu primera petición

Petición GET

1. Haz clic en la pestaña + para abrir una nueva petición

2. Deja el método como GET

3. Ingresa la URL: https://jsonplaceholder.typicode.com/users

4. Haz clic en Send

Recibes de vuelta un array JSON con 10 usuarios. Eso es todo: acabas de hacer una petición a una API.

Partes del panel de respuesta

  • Body: los datos devueltos
  • Status: código de estado HTTP (200 OK, 404 Not Found, etc.)
  • Time: cuánto tardó la petición
  • Size: tamaño de la respuesta en bytes

Colecciones y carpetas

Las colecciones son la forma de organizar peticiones. Piénsalas como carpetas para llamadas a la API.

Crear una colección

1. Haz clic en Collections en la barra lateral izquierda

2. Haz clic en + y luego en New Collection

3. Dale un nombre (ej.: "BecomeQA API Tests")

Agregar una petición a una colección

1. Abre una pestaña de petición

2. Haz clic en Save y elige tu colección

3. Nombra la petición (ej.: "Obtener todos los usuarios")

Organizar con carpetas

Por ejemplo: Auth/ (login, logout, refresh token), Users/ (operaciones CRUD) y Products/ (gestión de productos).

Variables de entorno

Hardcodear URLs y tokens hace que las colecciones sean frágiles. Usa variables de entorno.

Crear un entorno

1. Haz clic en Environments en la barra lateral izquierda

2. Haz clic en + y luego en New Environment

3. Nómbralo "Local" o "Staging"

4. Agrega las variables:

| Variable | Valor |

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

| baseUrl | http://localhost:3000 |

| userEmail | admin@test.com |

| userPassword | AdminPass1 |

| authToken | (déjalo vacío: lo llena la petición de login) |

Usar variables en las peticiones

{{baseUrl}}/api/users

La sintaxis {{nombreVariable}} sustituye el valor en tiempo de ejecución.

Autenticación

La mayoría de las APIs requieren autenticación. El flujo común: login primero, obtener un token, usarlo en las peticiones siguientes.

Petición de login

  • Método: POST
  • URL: {{baseUrl}}/api/auth/login
  • Body (JSON):

{
  "email": "{{userEmail}}",
  "password": "{{userPassword}}"
}

Guardar el token automáticamente

En la pestaña Tests de la petición de login (JavaScript):

const response = pm.response.json();
pm.environment.set('authToken', response.token);

Cada vez que ejecutes la petición de login, el token se guarda en el entorno.

Usar el token en otras peticiones

En la pestaña Authorization de la petición:

  • Type: Bearer Token
  • Token: {{authToken}}

O en la pestaña Headers:

Authorization: Bearer {{authToken}}

Escribir tests

La pestaña Tests en cada petición te permite escribir aserciones en JavaScript. Postman provee el objeto pm (Postman) con todo lo que necesitas.

Verificar el código de estado

pm.test('El estado es 200', function() {
  pm.response.to.have.status(200);
});

pm.test('El estado es 201 Created', function() {
  pm.response.to.have.status(201);
});

Verificar el cuerpo de la respuesta

pm.test('La respuesta tiene objeto de usuario', function() {
  const body = pm.response.json();
  pm.expect(body).to.have.property('id');
  pm.expect(body).to.have.property('email');
  pm.expect(body.role).to.equal('member');
});

Respuesta en array

pm.test('Devuelve array de usuarios', function() {
  const users = pm.response.json();
  pm.expect(users).to.be.an('array');
  pm.expect(users.length).to.be.greaterThan(0);
});

pm.test('Cada usuario tiene los campos requeridos', function() {
  const users = pm.response.json();
  users.forEach(user => {
    pm.expect(user).to.have.property('id');
    pm.expect(user).to.have.property('email');
  });
});

Tiempo de respuesta

pm.test('Tiempo de respuesta menor a 500ms', function() {
  pm.expect(pm.response.responseTime).to.be.below(500);
});

Headers de respuesta

pm.test('Content-Type es JSON', function() {
  pm.response.to.have.header('Content-Type', 'application/json; charset=utf-8');
});

Scripts pre-petición

Los scripts pre-petición se ejecutan ANTES de que se envíe la petición. Útiles para generar datos dinámicos.

// Generar email único en cada ejecución
const email = `test_${Date.now()}@example.com`;
pm.environment.set('testEmail', email);
pm.environment.set('testPassword', 'ValidPass1');

El body de la petición puede usar {{testEmail}}:

{
  "email": "{{testEmail}}",
  "password": "{{testPassword}}"
}

Encadenamiento de peticiones

Usar la salida de una petición como entrada de la siguiente.

Petición 1: Crear un usuario

Pestaña Tests:

const user = pm.response.json();
pm.environment.set('createdUserId', user.id);

Petición 2: Obtener ese usuario

URL: {{baseUrl}}/api/users/{{createdUserId}}

Postman completa el ID de la petición anterior automáticamente.

Petición 3: Eliminar ese usuario

URL: {{baseUrl}}/api/users/{{createdUserId}}

Método: DELETE

Ejecutar colecciones

El Collection Runner ejecuta todas las peticiones de una colección automáticamente.

1. Haz clic en tu colección y luego en Run collection

2. Elige el entorno (Local, Staging, etc.)

3. Configura las iteraciones (cuántas veces ejecutar)

4. Haz clic en Run [Nombre de la Colección]

Ves los resultados: pasado/fallido para cada test en cada petición.

Newman: la CLI de Postman

Newman ejecuta colecciones de Postman desde la línea de comandos. Es necesario para los pipelines de CI.

Instalación

npm install -g newman

Exportar la colección

Colección → tres puntos → Export → guardar como api-tests.json.

Exportar el entorno

Environments → tres puntos → Export → guardar como local-env.json.

Ejecutar

newman run api-tests.json -e local-env.json

Con reporte HTML

newman run api-tests.json -e local-env.json --reporters html --reporter-html-export results.html

Un flujo de trabajo realista

Así usa Postman un QA engineer en un proyecto real:

1. Explorar la API primero

Envía peticiones manualmente y lee las respuestas, entiende el flujo de autenticación, y comprende qué datos devuelve cada endpoint.

2. Construir una colección

Carpeta Auth (Login, Logout, Refresh), carpeta Users (Create, Get, Update, Delete), y casos negativos como login inválido o acceso no autorizado.

3. Agregar tests a cada petición

Aserciones de código de estado, campos requeridos en la respuesta, y lógica de negocio (el rol es correcto, hay timestamps).

4. Configurar los entornos

Local en http://localhost:3000, staging en https://staging.myapp.com, y producción en https://myapp.com (solo tests de solo lectura).

5. Ejecutar en CI con Newman

Exporta colección y entorno, agrega newman run al pipeline, y parsea la salida JUnit para los resultados de los tests.

Postman vs testing de API con Playwright

| | Postman | Playwright API Testing |

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

| Curva de aprendizaje | Menor | Mayor (código) |

| Integración con CI | Newman CLI | Nativa |

| Reutilización de código | Limitada | TypeScript completo |

| UI + API combinados | No | Sí |

| Compartir con el equipo | Nube de Postman | Git |

Para exploración simple de APIs y testing manual: Postman.

Para suites de regresión automatizadas que comparten código con tests de UI: Playwright.

Muchos equipos usan ambos: Postman para exploración y documentación, Playwright para regresión automatizada.

→ See also: API Testing 101: Todo lo que Todo QA Engineer Necesita Saber en 2026 | Migrando Tests de API de Postman a Playwright | Pruebas de API con el APIRequestContext de Playwright (Sin Postman)