Playwright Fixtures y parametrización
Este capítulo presenta el mecanismo de Fixtures de Playwright, cómo crear Fixtures personalizados y técnicas de pruebas parametrizadas.
Qué es un Fixture
Un Fixture (dispositivo) es el mecanismo de inyección de dependencias para los parámetros de las funciones de prueba en Playwright.
Cada prueba obtiene los Fixtures necesarios mediante la desestructuración de parámetros (por ejemplo{ page }), Playwright se encarga de crearlos y limpiarlos.
Ejemplo
test('Usar Fixture integrado', async ({ page, context }) => {
// Playwright crea automáticamente page y context
// Se limpia automáticamente al final de la prueba
await page.goto('https://www.example.com/');
});
Referencia rápida de Fixtures integrados
| Fixture | Tipo | Descripción |
|---|---|---|
page | Page | Pestaña de navegador independiente |
context | BrowserContext | Contexto del navegador |
browser | Browser | Instancia del navegador |
browserName | string | Nombre del navegador actual |
request | APIRequestContext | Cliente de solicitudes HTTP |
Fixture personalizado
Mediantetest.extend()Se pueden crear Fixtures personalizados para inyectar dependencias adicionales o sobrescribir Fixtures integrados.
Ejemplo
import { test as base, expect } from '@playwright/test';
// Definir el tipo de Fixture personalizado
type MyFixtures = {
todoPage: { goto: () => Promise<void>; addTodo: (text: string) => Promise<void> };
authenticatedPage: any;
};
export const test = base.extend<MyFixtures>({
// Fixture personalizado: objeto de página Todo
todoPage: async ({ page }, use) => {
// Crear
const todoPage = {
goto: async () => {
await page.goto('https://demo.playwright.dev/todomvc');
},
addTodo: async (text: string) => {
await page.getByPlaceholder('What needs to be done?').fill(text);
await page.keyboard.press('Enter');
},
};
// Inyectar en la prueba
await use(todoPage);
// Lógica de limpieza (si es necesario)
},
// Fixture personalizado: página autenticada
authenticatedPage: async ({ browser }, use) => {
const context = await browser.newContext({
storageState: 'playwright/.auth/user.json',
});
const page = await context.newPage();
await use(page);
await context.close();
},
});
export { expect };
Usar un Fixture personalizado
Ejemplo
import { test, expect } from './fixtures';
test('Añadir Todo', async ({ todoPage }) => {
await todoPage.goto();
await todoPage.addTodo('Aprender Playwright');
await todoPage.addTodo('Dominar Fixtures');
// Verificar...
});
Ámbito de los Fixtures
Los Fixtures tienen tres ámbitos, controlados mediantescopela opción.
| Ámbito | Valor | Ciclo de vida |
|---|---|---|
| Nivel de prueba (predeterminado) | scope: 'test' | Se crea una vez por prueba |
| Nivel Worker | scope: 'worker' | Se crea una vez por proceso Worker; todas las pruebas dentro del mismo Worker lo comparten |
Ejemplo
const test = base.extend({
sharedResource: [async ({}, use) => {
const resource = await createExpensiveResource();
await use(resource);
await resource.dispose();
}, { scope: 'worker' }], // Nota sobre la sintaxis de arrays
});
Los Fixtures de nivel Worker se comparten entre varias pruebas dentro del mismo proceso Worker; son adecuados para recursos con alto costo de creación, como conexiones de bases de datos.
Sobrescribir Fixtures integrados
Puedes sobrescribir los Fixtures integrados para cambiar el comportamiento predeterminado.
Ejemplo
// Sobrescribe el fixture integrado page para cambiar el viewport predeterminado
page: async ({ baseURL, page }, use) => {
await page.setViewportSize({ width: 1920, height: 1080 });
await use(page);
},
// Sobrescribir storageState
storageState: 'playwright/.auth/admin.json',
});
Limpieza automática de Fixtures
La lógica de limpieza del Fixture se ejecuta después deuse()la llamada, de manera similar aafterEachel efecto de.
Ejemplo
tempUser: async ({ request }, use) => {
// Crear un usuario temporal
const resp = await request.post('/api/users', {
data: { name: 'temp_' + Date.now() },
});
const user = await resp.json();
// Inyectar en la prueba
await use(user);
// Limpieza automática: eliminar el usuario temporal
await request.delete(`/api/users/${user.id}`);
},
});
Pruebas parametrizadas
Playwright no tiene un mecanismo de parametrización integrado, pero se pueden generar pruebas dinámicamente mediante bucles.
Ejemplo
const testCases = [
{ username: 'admin', password: 'admin123', expected: 'Panel de control' },
{ username: 'user', password: 'user123', expected: 'Centro personal' },
{ username: 'guest', password: 'guest123', expected: 'Página de visitante' },
];
for (const { username, password, expected } of testCases) {
test(`Usuario ${username}después de iniciar sesión ve ${expected}`, async ({ page }) => {
await page.goto('/login');
await page.getByLabel('Nombre de usuario').fill(username);
await page.getByLabel('Contraseña').fill(password);
await page.getByRole('button', { name: 'Iniciar sesión' }).click();
await expect(page.getByText(expected)).toBeVisible();
});
}
Anotaciones de prueba (Annotations)
Las anotaciones se utilizan para añadir metadatos a las pruebas; se pueden ver y filtrar en el informe.
Ejemplo
// Añadir anotación (dentro del cuerpo de la función de prueba)
test.info().annotations.push({
type: 'issue',
description: 'https://github.com/ejemplo/bug/123',
});
test.info().annotations.push({
type: 'description',
description: 'Esta prueba cubre todas las ramas del flujo de inicio de sesión',
});
// Lógica de la prueba...
});
// Usar Tag (en el nombre de la prueba)
test('Prueba de humo rápida @smoke @critical', async ({ page }) => {
// Puedes ejecutar solo esta prueba con npx playwright test --grep "@smoke"
});