Certains setups de test sont trop coûteux à répéter pour chaque test. Se connecter une fois au lieu de par test, alimenter la base de données une fois au lieu de par suite. Démarrer un serveur mock une fois au lieu de par worker. Le global setup et teardown de Playwright gère ça.

Ce qu'est le global setup

Playwright exécute une fonction globalSetup une fois avant que toute la suite de tests démarre, et une fonction globalTeardown une fois après que tout se termine. Ces fonctions s'exécutent dans le processus principal, avant que les workers de navigateur démarrent.

Utilisez le global setup pour :

  • S'authentifier et sauvegarder storageState (cas le plus courant)
  • Alimenter la base de données de test avec des données de base
  • Démarrer un serveur mock ou de test
  • Générer des fichiers de données de test

Configuration de base

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

export default defineConfig({
  globalSetup: require.resolve('./global-setup'),
  globalTeardown: require.resolve('./global-teardown'),
  use: {
    baseURL: 'http://localhost:3000',
  },
});

Le cas le plus courant : sauvegarder l'état d'auth

// global-setup.ts
import { chromium, FullConfig } from '@playwright/test';

async function globalSetup(config: FullConfig) {
  const { baseURL } = config.projects[0].use;
  const browser = await chromium.launch();
  const page = await browser.newPage();

  await page.goto(`${baseURL}/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: 'Se connecter' }).click();
  await page.waitForURL(`${baseURL}/dashboard`);

  // Sauvegarder cookies + localStorage pour réutilisation
  await page.context().storageState({ path: 'playwright/.auth/user.json' });
  await browser.close();
}

export default globalSetup;

// playwright.config.ts — utiliser l'auth sauvegardée dans tous les tests
use: {
  storageState: 'playwright/.auth/user.json',
},

Chaque test démarre maintenant déjà authentifié. Pas d'étape de connexion. Pas de setup de session par test. La connexion n'a lieu qu'une fois.

Plusieurs rôles utilisateur

Pour les applications avec des rôles admin et utilisateur standard :

// global-setup.ts
async function globalSetup(config: FullConfig) {
  const { baseURL } = config.projects[0].use;
  const browser = await chromium.launch();

  // Sauvegarder l'auth admin
  const adminPage = await browser.newPage();
  await loginAs(adminPage, `${baseURL}`, process.env.ADMIN_EMAIL!, process.env.ADMIN_PASSWORD!);
  await adminPage.context().storageState({ path: 'playwright/.auth/admin.json' });
  await adminPage.close();

  // Sauvegarder l'auth utilisateur standard
  const userPage = await browser.newPage();
  await loginAs(userPage, `${baseURL}`, process.env.USER_EMAIL!, process.env.USER_PASSWORD!);
  await userPage.context().storageState({ path: 'playwright/.auth/user.json' });
  await userPage.close();

  await browser.close();
}

async function loginAs(page: Page, baseURL: string, email: string, password: string) {
  await page.goto(`${baseURL}/login`);
  await page.getByLabel('Email').fill(email);
  await page.getByLabel('Password').fill(password);
  await page.getByRole('button', { name: 'Se connecter' }).click();
  await page.waitForURL(`${baseURL}/dashboard`);
}

Utilisez ensuite différents états d'auth par projet :

// playwright.config.ts
projects: [
  {
    name: 'admin-tests',
    use: { storageState: 'playwright/.auth/admin.json' },
    testMatch: '**/admin/**/*.spec.ts',
  },
  {
    name: 'user-tests',
    use: { storageState: 'playwright/.auth/user.json' },
    testMatch: '**/user/**/*.spec.ts',
  },
],

Alimenter la base de données dans le global setup

// global-setup.ts
import { Pool } from 'pg';

async function globalSetup() {
  const pool = new Pool({ connectionString: process.env.DATABASE_URL });

  // Insérer les données de base une seule fois
  await pool.query(`
    INSERT INTO users (email, password_hash, role)
    VALUES ('testuser@example.com', $1, 'user')
    ON CONFLICT (email) DO NOTHING
  `, [hashedPassword]);

  await pool.end();
}

L'alimentation de la base de données dans le global setup fonctionne pour les données de base statiques. Pour les données spécifiques à un test qui doivent être isolées et nettoyées, utilisez des fixtures : elles s'exécutent par test et se nettoient automatiquement.

Global teardown

// global-teardown.ts
import { Pool } from 'pg';

async function globalTeardown() {
  // Nettoyer les données de test après toute la suite
  const pool = new Pool({ connectionString: process.env.DATABASE_URL });
  await pool.query("DELETE FROM users WHERE email LIKE '%@test.example.com'");
  await pool.end();

  // Arrêter les serveurs démarrés dans globalSetup
  // (si vous avez stocké une référence sur process ou global)
}

export default globalTeardown;

Partager des données entre global setup et tests

Le global setup s'exécute dans un processus séparé des tests. Vous ne pouvez pas passer des objets JavaScript directement. Deux options :

Fichiers : sauvegardez les données sur disque dans le global setup, lisez-les dans les tests. 

// global-setup.ts
import fs from 'fs';

async function globalSetup() {
  const testData = { userId: '123', orderId: '456' };
  fs.writeFileSync('playwright/.test-data.json', JSON.stringify(testData));
}

// dans les tests
import testData from '../playwright/.test-data.json';

test('utilise les données seedées', async ({ page }) => {
  await page.goto(`/orders/${testData.orderId}`);
});

Variables d'environnement : définissez-les dans le global setup avec process.env.KEY = value. Elles sont disponibles dans les processus workers des tests. Utiles pour les valeurs simples (IDs, tokens).

Lancer le global setup conditionnellement

Ignorez le global setup lors de l'exécution de tests individuels en local :

// global-setup.ts
async function globalSetup() {
  // Ignorer si le fichier d'auth existe et est récent
  const authFile = 'playwright/.auth/user.json';
  if (fs.existsSync(authFile)) {
    const stats = fs.statSync(authFile);
    const ageMinutes = (Date.now() - stats.mtimeMs) / 60000;
    if (ageMinutes < 30) {
      console.log('État d\'auth récent, connexion ignorée...');
      return;
    }
  }

  // Sinon, se connecter et sauvegarder
  // ...
}

Cela accélère les exécutions locales répétées : l'étape de connexion n'a lieu que quand l'auth sauvegardée est manquante ou périmée.

→ See also: Gérer l'Authentification dans Playwright avec storageState (Sans Se Connecter à Chaque Test) | Fixtures Playwright Expliquées: Des Intégrées aux Personnalisées | Isolation des Tests: Pourquoi Chaque Test Playwright Doit Être sans État