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
// 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èle | Exemple | Description |
|---|---|---|
| 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 |
| Fonction | url => url.includes('/api/') | Correspondance par logique programmatique |
route.abort() Annuler les requêtes
Exemple
// 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
// 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
// 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
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
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éthode | Portée | Cas d'utilisation |
|---|---|---|
page.route() | Page actuelle uniquement | Simulation réseau pour une seule page |
context.route() | Toutes les pages dans ce contexte | Règles de simulation partagées par plusieurs pages |
Exemple
// 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
// 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/
Autres extensionsLes 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.