Playwright

Fonctionnalités principales

Screenshot and Video Recording

Description: Playwright permet de prendre des captures d'écran et des enregistrements vidéo de votre navigateur pendant les tests. Utilité: Cela aide à la détection rapide de problèmes visuels et offre une meilleure compréhension du comportement du navigateur sous test. Exemple:

page.screenshot(path="example.png")
page.pause()

Interactions avec les éléments Web

Description: Playwright permet d'interagir avec des éléments web, comme cliquer sur des boutons, entrer du texte, sélectionner des options de menu, etc. Utilité: Cela est essentiel pour tester l'usabilité et la fonctionnalité des interfaces utilisateur. Exemple:

page.click('text="Submit"')
page.fill('input[name="username"]', 'myuser')

Gestion des Cookies et Sessions

Description: Playwright permet de gérer les cookies et de simuler une session utilisateur. Utilité: Cela est utile pour tester des fonctionnalités qui dépendent du contexte utilisateur, comme le panier d'achat ou les notifications personnalisées. Exemple:

page.set_cookie(name="token", value="myToken")

Gestion des Réponses HTTP

Description: Playwright permet de contrôler et de vérifier les réponses HTTP. Utilité: Cela peut être utilisé pour tester des API ou pour simuler des conditions spécifiques. Exemple:

response = await page.goto("http://example.com")
assert response.status == 200

Support Multi-Environnements et Navigations Asynchrones

Description: Playwright prend en charge de multiples navigateurs (Chrome, Firefox, WebKit) et permet des opérations asynchrones. Utilité: Cela permet d'écrire des tests qui s'exécutent efficacement sur différents environnements et de tester des fonctionnalités asynchrones. Exemple:

page.wait_for_selector('text="Hello"')

Gestion des Exceptions et Assertions

Description: Playwright offre des outils puissants pour la gestion des exceptions et les assertions. Utilité: Cela permet de créer des tests robustes qui peuvent gérer différentes conditions d'erreur. Exemple:

with page.expect_event('requestfinished') as request_info:
    await page.click('button')
assert request_info.value.ok, "Request failed"

Gestion des Fenêtres et Pop-Ups

Description: Playwright permet de gérer les fenêtres et les pop-ups. Utilité: Cela est utile pour tester des fonctionnalités qui ouvrent des fenêtres supplémentaires, comme des modales ou des pop-ups de connexion. Exemple:

popup = await page.wait_for_event('popup')
await popup.fill('input[name="username"]', 'myuser')

Gestion des Cookies et Authentification

Description: Playwright permet de gérer les cookies et d'effectuer une authentification. Utilité: Cela est essentiel pour tester des applications nécessitant une connexion utilisateur. Exemple:

page.fill('input[name="username"]', 'myuser')
page.fill('input[name="password"]', 'mypassword')
page.click('button[type="submit"]')

Gestion des Cookies et Sessions

Description: Playwright permet de gérer les cookies et d'effectuer une authentification. Utilité: Cela est essentiel pour tester des applications nécessitant une connexion utilisateur. Exemple:

page.fill('input[name="username"]', 'myuser')
page.fill('input[name="password"]', 'mypassword')
page.click('button[type="submit"]')

Installation et configuration

Installation

Pour installer Playwright, vous pouvez utiliser pip :

pip install playwright

Ensuite, installez les navigateurs que vous souhaitez utiliser :

playwright install chrome firefox webkit

Configuration

Vous pouvez configurer Playwright en créant un fichier de configuration playwright.config.ts :

import { defineConfig } from '@playwright/test';

export default defineConfig({
  projects: [
    {
      name: 'chromium',
      use: {
        browserName: 'chromium',
      },
    },
    {
      name: 'firefox',
      use: {
        browserName: 'firefox',
      },
    },
    {
      name: 'webkit',
      use: {
        browserName: 'webkit',
      },
    },
  ],
});

Cas d'utilisation concrets

Test d'une page de connexion

import pytest
from playwright.sync_api import sync_playwright

def test_login():
    with sync_playwright() as p:
        browser = p.chromium.launch()
        context = browser.new_context()
        page = context.new_page()
        page.goto('http://example.com/login')
        page.fill('input[name="username"]', 'myuser')
        page.fill('input[name="password"]', 'mypassword')
        page.click('button[type="submit"]')
        assert page.url == 'http://example.com/dashboard'
        browser.close()

Test d'une fonctionnalité AJAX

import pytest
from playwright.sync_api import sync_playwright

def test_ajax():
    with sync_playwright() as p:
        browser = p.chromium.launch()
        context = browser.new_context()
        page = context.new_page()
        page.goto('http://example.com/ajax')
        page.click('button[type="submit"]')
        response = await page.wait_for_response('**/ajax-endpoint')
        assert response.ok
        data = await response.json()
        assert data['status'] == 'success'
        browser.close()

Test d'une redirection

import pytest
from playwright.sync_api import sync_playwright

def test_redirect():
    with sync_playwright() as p:
        browser = p.chromium.launch()
        context = browser.new_context()
        page = context.new_page()
        page.goto('http://example.com/redirect')
        await page.click('button[type="submit"]')
        assert page.url == 'http://example.com/target'
        browser.close()

Test d'une page avec des cookies

import pytest
from playwright.sync_api import sync_playwright

def test_cookies():
    with sync_playwright() as p:
        browser = p.chromium.launch()
        context = browser.new_context()
        page = context.new_page()
        page.set_cookie(name="token", value="myToken")
        page.goto('http://example.com/protected')
        assert 'Welcome' in page.text_content()
        browser.close()

Test d'une page avec des pop-ups

import pytest
from playwright.sync_api import sync_playwright

def test_popups():
    with sync_playwright() as p:
        browser = p.chromium.launch()
        context = browser.new_context()
        page = context.new_page()
        page.goto('http://example.com/popups')
        await page.click('button[type="submit"]')
        popup = await page.wait_for_event('popup')
        assert 'Popup' in popup.title()
        browser.close()

Points forts et limites

Avantages

1. Support Multi-Environnements: Playwright fonctionne sur Chrome, Firefox et WebKit.
2. Interactions Asynchrones: Les opérations sont asynchrones pour une meilleure performance.
3. Assertions et Exceptions: Gestion robuste des assertions et des exceptions.
4. Cookies et Sessions: Facilite la gestion des cookies et des sessions utilisateur.
5. Enregistrement vidéo: Permet de capturer les interactions avec le navigateur.

Limites

1. Apprentissage Curve: Le langage de configuration peut être complexe pour les débutants.
2. Performance sur des Environnements Séquentiels: Les tests en série peuvent être plus lents que ceux parallèles.
3. Complexité des Tests Asynchrones: Gérer les opérations asynchrones peut être compliqué.
4. Dépendance à Python: Playwright est spécifique à Python, ce qui peut limiter sa portée.
5. Manque de Compatibilité avec Tous les Navigateurs: Bien que multi-plateforme, il peut ne pas fonctionner parfaitement sur tous les navigateurs.

Conseils d'expert

1. Utilisez des Sélecteurs Spécifiques: Assurez-vous d'utiliser des sélecteurs CSS spécifiques pour éviter les erreurs de sélection.
2. Gérez les Exceptions Correctement: Utilisez try-except pour gérer les exceptions et assurer la continuité du test.
3. Optimisez les Tests Asynchrones: Utilisez async/await pour optimiser les tests asynchrones.
4. Utilisez des Environnements Séparés: Créez des environnements séparés pour chaque test pour éviter les conflits entre les tests.
5. Documentez Vos Tests: Documentez vos tests pour faciliter la maintenance et la compréhension par d'autres développeurs.

## Tableau comparatif

| Critère | Playwright | Puppeteer | Cypress | Selenium | TestCafe |
|---|---|---|---|---|---|
| Prix | Gratuit (open source) | Gratuit (open source) | Gratuit (open source) | Oui (licences payantes disponibles) | Gratuit (open source) |
| Points forts | API moderne et fluide, supporte les navigateurs principaux, permet l'exécution sur les systèmes d'exploitation Windows, macOS et Linux, test asynchrone | Exécuté dans le navigateur de Chrome, automatisation complète des tests fonctionnels, excellente documentation | Tests end-to-end facilement configurables, supporte les navigateurs principaux, excellente communauté et documentation, tests réactifs en temps réel | Large compatibilité avec tous les navigateurs web, soutenu par une grande communauté, outils de reporting avancés | API simple et fluide, permet l'exécution sur les systèmes d'exploitation Windows, macOS et Linux, supporte TypeScript |
| Limites | Pas forcément la plus performante parmi les alternatives | Pas aussi flexible que Playwright pour des tests basés sur le réseau | Temps de configuration et d'apprentissage plus longs | Difficile à utiliser pour les tests réactifs en temps réel | Tests asynchrones limités |
| Ideal pour | Tests automatisés end-to-end, tests rapides et asynchrones | Tests fonctionnels sur Chrome, tests automatisés web | Tests e2e simples et rapide | Tests automatisés sur tous les navigateurs, tests UI | Tests simples et rapides, tests basés sur TypeScript |

### Puppeteer

**Puppeteer** est une bibliothèque Node.js qui permet de contrôler des navigateurs Chrome et Chromium à partir d'un script JavaScript. Ses points forts principaux sont sa simplicité d'utilisation et son support complet pour les tests fonctionnels sur Chrome. Cependant, il a quelques limites en termes de performance et d'adaptabilité avec d'autres navigateurs. Si vous avez besoin d'exécuter des tests spécifiquement sur Google Chrome, Puppeteer est une excellente alternative.

### Cypress

**Cypress** est un framework pour les tests end-to-end basés sur le navigateur. Ses points forts sont sa simplicité et sa facilité de configuration, ainsi que son support réactif en temps réel des tests. Cependant, il a un apprenement plus longue et nécessite une bonne connaissance du JavaScript. Si vous cherchez un framework facile à utiliser pour les tests e2e simples et rapides, Cypress est une excellente option.

### Selenium

**Selenium** est un outil open source de test automatisé qui prend en charge tous les navigateurs web. Ses points forts sont sa large compatibilité et son soutien par une grande communauté. Cependant, il a des limites en termes de performance et d'adaptabilité avec les navigateurs récents. Si vous avez besoin de tester sur un grand éventail de navigateurs et que la compatibilité est une priorité, Selenium est le choix approprié.

### TestCafe

**TestCafe** est un framework pour les tests automatisés basés sur Node.js. Ses points forts sont sa simplicité d'utilisation, son support pour TypeScript et son API fluide. Cependant, il a des limites en termes de performance et d'adaptabilité avec certains navigateurs. Si vous cherchez un framework simple à utiliser et qui prend en charge le développement moderne (TypeScript), TestCafe est une excellente option.