Interception et simulation réseau avec Playwright

Ce chapitre explique comment utiliser Playwright pour intercepter, modifier et simuler des requêtes réseau, permettant des tests indépendants qui ne dépendent pas des API backend.


Qu'est-ce que l'interception réseau

L'interception réseau vous permet de lorsque le navigateur effectue des requêtes HTTP.

Vous pouvezbloquer des requêtes, modifier des réponses et renvoyer des simulacres, des tests indépendants des API externes ou de l'état du réseau.


page.route() Intercepter les requêtes

page.route(url, handler)Utilisé pour intercepter toutes les requêtes réseau correspondant à un motif d'URL spécifié.

Interception de base

Exemple

test('Intercepter toutes les requêtes d'images', async ({ page }) => {
  // Intercepter toutes les images PNG et JPEG
  await page.route('**/*.{png,jpg,jpeg}', route => route.abort());

  // Naviguer vers la page (les images ne seront pas chargées)
  await page.goto('https://www.example.com/');
  // La page peut se charger plus rapidement car aucune image n'est téléchargée
});

Modèles de correspondance d'URLPrend en charge les formats suivants :

ModèleExempleDescription
URL complète'https://api.example.com/users'Correspondance exacte
Caractère générique Glob'**/api/**'**Correspond à n'importe quel chemin
Expression régulière/\/api\/v\d\/users/Correspondance flexible
Fonctionurl => url.includes('/api/')Correspondance par logique programmatique

route.abort() Annuler les requêtes

Exemple

test('Bloquer les scripts d'analyse tiers', async ({ page }) => {
  // Bloquer les scripts d'analyse tels que Google Analytics
  await page.route('**/*analytics*', route => route.abort());
  // Bloquer les fichiers CSS
  await page.route('**/*.css', route => route.abort());

  await page.goto('https://www.example.com/');
  // La page se charge sans styles, mais les tests fonctionnels ne sont pas affectés
});

route.fulfill() Simuler des réponses

route.fulfill()C'est la méthode de simulation la plus puissante, capable de renvoyer n'importe quelle réponse personnalisée.

Données JSON simulées

Exemple

test('API simulée de liste d'utilisateurs', async ({ page }) => {
  // Intercepter l'API de liste d'utilisateurs et renvoyer des données simulées
  await page.route('**/api/users', async route => {
    await route.fulfill({
      status: 200,
      contentType: 'application/json',
      json: [
        { id: 1, name: 'example_user', email: 'user@example.com' },
        { id: 2, name: 'test_user', email: 'test@example.com' },
      ],
    });
  });

  await page.goto('https://www.example.com/users');
  // La page affichera des données simulées au lieu des données réelles de l'API
});

Réponses d'erreur simulées

Exemple

test('Test de gestion des erreurs d'API', async ({ page }) => {
  // Simuler une erreur serveur 500
  await page.route('**/api/data', async route => {
    await route.fulfill({
      status: 500,
      contentType: 'application/json',
      json: { error: 'Erreur interne du serveur' },
    });
  });

  await page.goto('https://www.example.com/dashboard');
  // Vérifier que le message d'erreur est affiché correctement
  await expect(page.getByText('Erreur interne du serveur')).toBeVisible();
});

route.continue() Modifier et continuer

Plutôt que de renvoyer directement des données simulées, il modifie la requête ou la réponse réelle, puis continue à l'envoyer au serveur.

Exemple

test('Modifier les en-têtes de requête', async ({ page }) => {
  await page.route('**/api/**', async (route, request) => {
    // Modifier les en-têtes de requête et ajouter des en-têtes personnalisés
    const headers = {
      ...en-têtes.de requête(),
      'X-Custom-Header': 'EXAMPLE-TEST',
    };
    await route.continue({ headers });
  });

  await page.goto('https://www.example.com/');
});

test('Modifier les données POST', async ({ page }) => {
  await page.route('**/api/login', async (route, request) => {
    // Remplacer le corps des requêtes POST
    const postData = JSON.parse(request.postData() || '{}');
    postData.mode = 'test';  // Ajouter un marqueur de test
    await route.continue({
      postData: JSON.stringify(postData),
    });
  });
});

route.fetch() Requêtes réelles

Dans la fonction de gestionnaire de mock, vous pouvez utiliserroute.fetch()pour réellement envoyer la requête, obtenir la réponse réelle, puis la modifier.

Exemple

test('Modifier la vraie réponse', async ({ page }) => {
  await page.route('**/api/products', async route => {
    // Récupérer d'abord la vraie réponse
    const response = await route.fetch();
    const body = await response.json();

    // Modifier les données de la réponse
    body.items[0].name = 'EXEMPLE nom de produit modifié';

    // Renvoyer les données modifiées
    await route.fulfill({
      status: response.status(),
      contentType: 'application/json',
      json: body,
    });
  });
});

Interception au niveau du contexte vs interception au niveau de la page

MéthodePortéeCas d'utilisation
page.route()Page actuelle uniquementSimulation réseau pour une seule page
context.route()Toutes les pages dans ce contexteRègles de simulation partagées par plusieurs pages

Exemple

test.beforeEach(async ({ context }) => {
  // Intercepter dans tout le contexte ; s'applique à toutes les pages
  await context.route('**/*.css', route => route.abort());
});

test('Test 1', async ({ page }) => { /* Pas de CSS */ });
test('Test 2', async ({ page }) => { /* Pas de CSS */ });

Enregistrement et lecture de fichier HAR

Un fichier HAR (HTTP Archive) enregistre toutes les requêtes réseau d'une page et peut ensuite les rejouer ou les simuler.

Exemple

test('Utiliser un fichier HAR pour simuler', async ({ page }) => {
  // Charger les enregistrements réseau depuis le fichier HAR et les rejouer
  await page.routeFromHAR('tests/hars/api-responses.har');

  await page.goto('https://www.example.com/');
  // Toutes les requêtes correspondantes recevront les réponses du fichier HAR
});
# 录制 HAR 文件
npx playwright open --save-har=tests/hars/api-responses.har https://www.example.com/

Les fichiers HAR conviennent pour simuler des réponses API volumineuses ou complexes. Enregistrez une fois, et les tests suivants rejouent à partir du HAR sans dépendre d'un serveur réel.

Autres extensions