Cómo hacer pruebas de API con Playwright y Python: guía práctica

Por /

La mayoría de la gente conoce Playwright como una herramienta para automatizar tests de interfaz de usuario. Lo que mucha gente no sabe es que Playwright también tiene una API completa para hacer pruebas de APIs REST directamente, sin necesidad de abrir un navegador. En este artículo te explico cómo funciona y cuándo tiene sentido usarla.

Por qué Playwright para API testing

Playwright tiene un cliente HTTP integrado que permite hacer requests a APIs directamente desde tus tests. Esto abre una posibilidad muy interesante — combinar tests de UI y tests de API en el mismo proyecto, con las mismas herramientas y el mismo framework.

Ventajas concretas de usar Playwright para API testing frente a otras herramientas como Postman o requests de Python:

Puedes preparar el estado de la aplicación a través de la API antes de ejecutar un test de UI. Por ejemplo, crear un usuario mediante la API y luego probar el login desde el navegador — sin tener que hacerlo todo desde la interfaz.

Puedes verificar el estado de la API después de una acción en la UI. Por ejemplo, añadir un producto al carrito y verificar que la API de inventario refleja el cambio correctamente.

Todo en el mismo framework, con los mismos fixtures, los mismos reporters y el mismo pipeline de CI/CD.

APIRequestContext — el cliente HTTP de Playwright

Playwright proporciona el objeto APIRequestContext para hacer requests HTTP. Puedes acceder a él de dos formas.

Usando la request del contexto del navegador

Cuando tienes un test con la página abierta, puedes usar page.request para hacer requests HTTP que comparten el mismo contexto — incluyendo las cookies de sesión:

python

from playwright.sync_api import Page

def test_api_con_sesion(page: Page):
    # Primero hacemos login en la UI
    page.goto("https://miweb.com/login")
    page.fill("#email", "usuario@test.com")
    page.fill("#password", "password123")
    page.click("#btn-login")
    
    # Ahora usamos la misma sesión para hacer requests a la API
    response = page.request.get("https://miweb.com/api/perfil")
    
    assert response.status == 200
    data = response.json()
    assert data["email"] == "usuario@test.com"

Usando APIRequestContext de forma independiente

Para tests de API puros sin necesidad de un navegador, puedes crear un contexto HTTP independiente:

python

import pytest
from playwright.sync_api import Playwright

@pytest.fixture
def api_context(playwright: Playwright):
    context = playwright.request.new_context(
        base_url="https://api.miweb.com"
    )
    yield context
    context.dispose()

Tu primer test de API con Playwright

Aquí va un ejemplo completo de tests de API usando Playwright con Python:

python

import pytest
from playwright.sync_api import Playwright, APIRequestContext

@pytest.fixture(scope="session")
def api_context(playwright: Playwright):
    context = playwright.request.new_context(
        base_url="https://jsonplaceholder.typicode.com"
    )
    yield context
    context.dispose()

def test_get_usuarios(api_context: APIRequestContext):
    response = api_context.get("/users")
    
    assert response.status == 200
    usuarios = response.json()
    assert len(usuarios) > 0
    assert "name" in usuarios[0]
    assert "email" in usuarios[0]

def test_get_usuario_por_id(api_context: APIRequestContext):
    response = api_context.get("/users/1")
    
    assert response.status == 200
    usuario = response.json()
    assert usuario["id"] == 1
    assert usuario["name"] == "Leanne Graham"

def test_crear_post(api_context: APIRequestContext):
    nuevo_post = {
        "title": "Mi post de prueba",
        "body": "Contenido del post",
        "userId": 1
    }
    
    response = api_context.post("/posts", data=nuevo_post)
    
    assert response.status == 201
    post_creado = response.json()
    assert post_creado["title"] == "Mi post de prueba"
    assert "id" in post_creado

def test_actualizar_post(api_context: APIRequestContext):
    datos_actualizados = {
        "title": "Título actualizado"
    }
    
    response = api_context.patch("/posts/1", data=datos_actualizados)
    
    assert response.status == 200
    post = response.json()
    assert post["title"] == "Título actualizado"

def test_eliminar_post(api_context: APIRequestContext):
    response = api_context.delete("/posts/1")
    assert response.status == 200

Hacer requests con autenticación

La mayoría de APIs reales requieren autenticación. Playwright permite configurar headers de autenticación a nivel del contexto para que se apliquen a todas las requests:

python

@pytest.fixture(scope="session")
def api_autenticada(playwright: Playwright):
    context = playwright.request.new_context(
        base_url="https://api.miweb.com",
        extra_http_headers={
            "Authorization": "Bearer mi-token-de-api",
            "Content-Type": "application/json"
        }
    )
    yield context
    context.dispose()

def test_endpoint_protegido(api_autenticada: APIRequestContext):
    response = api_autenticada.get("/usuario/perfil")
    assert response.status == 200

Obtener el token mediante login y usarlo en las requests

Una situación muy común es necesitar hacer login primero para obtener un token y luego usarlo en el resto de tests:

python

import pytest
from playwright.sync_api import Playwright, APIRequestContext

@pytest.fixture(scope="session")
def token(playwright: Playwright):
    context = playwright.request.new_context(
        base_url="https://api.miweb.com"
    )
    
    response = context.post("/auth/login", data={
        "email": "usuario@test.com",
        "password": "password123"
    })
    
    assert response.status == 200
    return response.json()["token"]

@pytest.fixture(scope="session")
def api_autenticada(playwright: Playwright, token):
    context = playwright.request.new_context(
        base_url="https://api.miweb.com",
        extra_http_headers={"Authorization": f"Bearer {token}"}
    )
    yield context
    context.dispose()

def test_obtener_pedidos(api_autenticada: APIRequestContext):
    response = api_autenticada.get("/pedidos")
    assert response.status == 200
    pedidos = response.json()
    assert isinstance(pedidos, list)

Combinar API testing y UI testing en el mismo test

Aquí es donde Playwright realmente brilla frente a otras herramientas de API testing. Puedes preparar el estado de la aplicación via API y luego verificar la UI, o al revés:

python

def test_crear_usuario_y_verificar_en_ui(
    page: Page,
    api_context: APIRequestContext
):
    # Crear usuario via API
    response = api_context.post("/usuarios", data={
        "nombre": "Test User",
        "email": "testuser@test.com",
        "password": "password123"
    })
    assert response.status == 201
    usuario_id = response.json()["id"]
    
    # Verificar que el usuario aparece en la UI de administración
    page.goto("https://miweb.com/admin/usuarios")
    assert page.get_by_text("testuser@test.com").is_visible()
    
    # Limpiar — eliminar el usuario via API
    api_context.delete(f"/usuarios/{usuario_id}")

Cuándo usar Playwright para APIs y cuándo usar Postman

Usa Playwright para API testing cuando ya tienes un proyecto Playwright y quieres mantener todo en el mismo framework, cuando necesitas combinar tests de UI y API en el mismo test, o cuando quieres reutilizar la sesión del navegador en los tests de API.

Usa Postman cuando quieras explorar y documentar APIs de forma interactiva, cuando el equipo no es técnico y necesita una interfaz visual, o cuando quieras compartir colecciones de tests con el equipo de desarrollo.

Si quieres profundizar en Playwright puedes leer cómo usar locators en Playwright o cómo interceptar peticiones de red.

Y si necesitas implementar una estrategia de API testing en tu proyecto puedes ver mis servicios en fatimaqa.com.

Scroll al inicio