Isolamento de Testes: Por que Cada Teste Playwright Deve Ser sem Estado

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

test('admin consegue desativar uma conta de usuário', async ({ page, request }) => {
  // Cria os dados que este teste precisa, de propriedade exclusiva deste teste
  const createResponse = await request.post('/api/users', {
    data: {
      name: 'Temporary User',
      email: `temp-${Date.now()}@example.com`,
      role: 'member'
    }
  });
  expect(createResponse.ok()).toBeTruthy();
  const { id: userId } = await createResponse.json();

  try {
    // O teste em si
    await page.goto(`/admin/users/${userId}`);
    await page.getByRole('button', { name: 'Deactivate account' }).click();
    await page.getByRole('button', { name: 'Confirm' }).click();
    await expect(page.getByTestId('account-status')).toHaveText('Inactive');
  } finally {
    // Limpeza roda mesmo se o teste falhar
    await request.delete(`/api/users/${userId}`);
  }
});

// fixtures/api-fixtures.ts
import { test as base, expect } from '@playwright/test';

type ApiFixtures = {
  createUser: (overrides?: Partial<{ name: string; email: string; role: string }>) => Promise<{ id: number; email: string }>;
};

export const test = base.extend<ApiFixtures>({
  createUser: async ({ request }, use) => {
    const createdIds: number[] = [];

    const factory = async (overrides = {}) => {
      const response = await request.post('/api/users', {
        data: {
          name: 'Test User',
          email: `test-${Date.now()}-${Math.random().toString(36).slice(2, 6)}@example.com`,
          role: 'member',
          ...overrides
        }
      });
      const user = await response.json();
      createdIds.push(user.id);
      return user;
    };

    await use(factory);

    // Limpa todos os usuários criados por este teste, roda após cada teste automaticamente
    for (const id of createdIds) {
      await request.delete(`/api/users/${id}`);
    }
  }
});

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

test('editor consegue atualizar o perfil do usuário', async ({ page, createUser }) => {
  const user = await createUser({ name: 'Jane', role: 'editor' });

  await page.goto(`/users/${user.id}`);
  await page.getByRole('button', { name: 'Edit profile' }).click();
  await page.getByLabel('Display name').fill('Jane Updated');
  await page.getByRole('button', { name: 'Save' }).click();

  await expect(page.getByRole('heading', { name: 'Jane Updated' })).toBeVisible();
});

// tests/auth.setup.ts roda uma vez por worker antes da suite
import { test as setup, expect } from '@playwright/test';
import path from 'path';

const authFile = path.join(__dirname, '../.auth/user.json');

setup('autenticar', async ({ page }) => {
  await page.goto('/login');
  await page.getByLabel('Email').fill(process.env.TEST_USER_EMAIL!);
  await page.getByLabel('Password').fill(process.env.TEST_USER_PASSWORD!);
  await page.getByRole('button', { name: 'Sign in' }).click();

  // Aguarda passar da página de login
  await page.waitForURL('/dashboard');
  await expect(page.getByRole('navigation')).toBeVisible();

  // Salva o estado de autenticação
  await page.context().storageState({ path: authFile });
});

// playwright.config.ts
import { defineConfig } from '@playwright/test';
import path from 'path';

export default defineConfig({
  projects: [
    {
      name: 'setup',
      testMatch: '**/auth.setup.ts',
    },
    {
      name: 'authenticated tests',
      dependencies: ['setup'],
      use: {
        storageState: path.join(__dirname, '.auth/user.json'),
      },
      testMatch: '**/*.spec.ts',
    },
  ],
});

// playwright.config.ts. Só funciona se os testes forem verdadeiramente isolados.
import { defineConfig } from '@playwright/test';

export default defineConfig({
  testDir: './tests',
  fullyParallel: true,   // Cada teste em cada arquivo roda de forma concorrente
  workers: process.env.CI ? 4 : '50%',
  retries: process.env.CI ? 1 : 0,
  use: {
    baseURL: process.env.BASE_URL || 'http://localhost:3000',
    trace: 'on-first-retry',
  },
});

# A suite passa em sequência?
npx playwright test --workers=1

# Ainda passa com paralelismo?
npx playwright test --workers=4

// Faça grep nos seus arquivos de teste por esses padrões. Cada um é um vazamento potencial.

// Variável de nível de módulo sendo atribuída dentro de um teste
let userId: number;
let authToken: string;
let createdRecord: any;

// test.beforeAll criando dados usados por vários testes
test.beforeAll(async ({ request }) => {
  // Se algo aqui cria estado mutável compartilhado, você tem um vazamento
});

// Emails fixos, nomes de usuário ou qualquer identificador único fixo
data: { email: 'fixed@test.com' }
data: { username: 'testadmin' }
data: { id: 1 }

const user = await createUser({
  name: `Test user for: ${test.info().title}`,
  email: `test-${Date.now()}@example.com`
});