Migrando Tests de API de Postman a Playwright

Una colección de Postman corriendo en CI requiere Newman, y la paralelización por encima del nivel gratuito requiere Postman Cloud. Migrar al fixture request de Playwright significa el mismo runner, el mismo comando de CI (npx playwright test), y el mismo sistema de fixtures que ya usan tus tests de UI. Este artículo cubre la traducción concepto por concepto de Postman a Playwright, el fixture de auth que reemplaza pm.environment.set(), y por qué debes reescribir en vez de traducir automáticamente al migrar colecciones grandes.

La traducción conceptual

| Concepto de Postman | Equivalente en Playwright |

|---|---|

| Colección | Archivo de tests |

| Request | request.get(), request.post(), etc. |

| Script pre-petición | Hook beforeEach o setup de fixture |

| Script de test (pm.test) | Aserciones con expect() |

| Variable de entorno | process.env.VARIABLE |

| Variable de colección | Fixture de test o constante compartida |

| Authorization → Bearer Token | Header en request.post({ headers: { Authorization: ... } }) |

| Newman (runner CLI) | npx playwright test |

Tu primer test de Postman reescrito en Playwright

Postman

// POST {{baseUrl}}/auth/login
// Body: { "email": "{{email}}", "password": "{{password}}" }
// Pestaña Tests:
pm.test("El estado es 200", function() {
    pm.response.to.have.status(200);
});
pm.test("Devuelve token", function() {
    const body = pm.response.json();
    pm.expect(body.token).to.be.a('string');
    pm.environment.set("authToken", body.token);
});

Playwright

import { test, expect } from '@playwright/test';

test('el login devuelve un token de auth', async ({ request }) => {
  const response = await request.post(`${process.env.BASE_URL}/auth/login`, {
    data: {
      email: process.env.TEST_EMAIL,
      password: process.env.TEST_PASSWORD,
    },
  });

  expect(response.status()).toBe(200);

  const body = await response.json();
  expect(typeof body.token).toBe('string');
  expect(body.token.length).toBeGreaterThan(0);
});

Más limpio. Con control de versiones. Sin dependencia de la nube.

Compartir el token de auth entre tests

En Postman, establecías una variable de entorno en un test y la usabas en el siguiente. En Playwright, usas un fixture o un setup global.

Enfoque 1: Setup global (para toda la suite)

// global-setup.ts
import { request } from '@playwright/test';
import fs from 'fs';

export default async function globalSetup() {
  const ctx = await request.newContext();
  const response = await ctx.post(`${process.env.BASE_URL}/auth/login`, {
    data: {
      email: process.env.TEST_EMAIL,
      password: process.env.TEST_PASSWORD,
    },
  });
  const { token } = await response.json();

  // Guardar para que lo usen los tests
  process.env.AUTH_TOKEN = token;
  await ctx.dispose();
}

Enfoque 2: Fixture de auth (por test)

// fixtures/auth.ts
import { test as base, APIRequestContext } from '@playwright/test';

type AuthFixtures = {
  authedRequest: APIRequestContext;
  authToken: string;
};

export const test = base.extend<AuthFixtures>({
  authToken: async ({ request }, use) => {
    const response = await request.post('/auth/login', {
      data: {
        email: process.env.TEST_EMAIL!,
        password: process.env.TEST_PASSWORD!,
      },
    });
    const { token } = await response.json();
    await use(token);
  },

  authedRequest: async ({ playwright, authToken }, use) => {
    const context = await playwright.request.newContext({
      baseURL: process.env.BASE_URL,
      extraHTTPHeaders: {
        Authorization: `Bearer ${authToken}`,
      },
    });
    await use(context);
    await context.dispose();
  },
});

Tests:

import { test } from '../fixtures/auth';
import { expect } from '@playwright/test';

test('obtener perfil de usuario (autenticado)', async ({ authedRequest }) => {
  const response = await authedRequest.get('/user/profile');
  expect(response.status()).toBe(200);

  const user = await response.json();
  expect(user.email).toBeDefined();
});

Migrar colecciones de Postman

Para colecciones grandes, la estrategia de migración:

1. Exporta la colección como JSON desde Postman

2. Identifica los caminos críticos: no todas las peticiones de Postman necesitan convertirse en un test de Playwright. Enfócate en las que ejecutas como regresión

3. Traduce petición por petición, empezando con las más simples (peticiones GET sin auth)

4. Agrúpalas por recurso: un archivo por dominio de la API (users.spec.ts, orders.spec.ts, payments.spec.ts)

No intentes traducir automáticamente. El modelo de scripting de Postman no se mapea limpiamente a Playwright, y la traducción mecánica produce tests ilegibles. Reescríbelos.

Lo que Postman sigue haciendo mejor

Postman todavía tiene ventajas para ciertos flujos de trabajo:

Testing exploratorio

La interfaz de Postman es más rápida para peticiones puntuales durante el desarrollo. No necesitas escribir código para probar un endpoint.

Documentación

Las colecciones de Postman pueden generar documentación de la API. Los tests de Playwright no.

Colaboración con personas sin experiencia en código

Un product manager o un desarrollador que no se siente cómodo con código puede usar Postman.

La división práctica: Postman para explorar y documentar APIs durante el desarrollo. Playwright para las suites de regresión automatizadas que corren en CI. Se complementan.

Ejecutar tests de API en CI

Una vez que migraste los tests a Playwright, el CI es simple: igual que cualquier otra suite de Playwright.

# .github/workflows/api-tests.yml
jobs:
  api-tests:
    runs-on: ubuntu-latest
    env:
      BASE_URL: ${{ vars.STAGING_URL }}
      TEST_EMAIL: ${{ secrets.TEST_EMAIL }}
      TEST_PASSWORD: ${{ secrets.TEST_PASSWORD }}
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      - run: npm ci
      - run: npx playwright test tests/api/

Sin Newman. Sin Postman Cloud. Sin plan pago para CI. Solo npx playwright test.