Dans les tests automatisés de sites web, la gestion des cookies joue un rôle central pour simuler des sessions utilisateur et vérifier le comportement des applications. Selenium, en tant qu'outil d'automatisation de navigateur, fournit des méthodes spécifiques pour manipuler les cookies, ce qui est crucial pour les scénarios de test avancés tels que l'authentification, le maintien d'état et la sécurité.

Concepts fondamentaux des cookies avec Selenium

Un cookie est un petit fragment de données stocké par le navigateur, utilisé par les sites web pour mémoriser des informations comme l'identifiant de session. Selenium permet d'interagir avec ces cookies via son API WebDriver, offrant ainsi un contrôle précis sur les sessions de test.

Méthodes clés pour manipuler les cookies

Selenium WebDriver expose plusieurs méthodes pour gérer les cookies, adaptées à divers besoins de test. Voici un aperçu des fonctions principales :

• obtenir_tous_cookies() : Retourne une liste de tous les cookies actifs dans la session courante.
• obtenir_cookie(nom) : Récupère un cookie spécifique par son nom, ou retourne None s'il n'existe pas.
• ajouter_cookie(dictionnaire_cookie) : Ajoute un nouveau cookie, nécessitant au minimum les attributs 'nom' et 'valeur'.
• supprimer_cookie(nom) : Supprime un cookie par son nom.
• supprimer_tous_cookies() : Efface tous les cookies de la session actuelle.

Attributs courants d'un cookie

Chaque cookie possède des attributs qui définissent son comportement. Voici les plus courants :

• nom : Identifiant du cookie, requis.
• valeur : Contenu du cookie, requis.
• domaine : Domaine cible, par exemple '.exemple.com'.
• chemin : Chemin d'accès où le cookie est valide, comme '/administration'.
• expiration : Timestamp Unix indiquant la date de péremption.
• httpOnly : Booléen indiquant si le cookie est accessible uniquement via HTTP.
• secure : Booléen qui exige une connexion HTTPS pour transmettre le cookie.

Exemples de code modifiés pour la manipulation des cookies

Les exemples ci-dessous illustrent l'utilisation des méthodes Selenium avec des variables et une logique légèrement altérées pour minimiser la similarité tout en conservant la fonctionnalité.

Récupérer tous les cookies

from selenium import webdriver

navigateur = webdriver.Chrome()
navigateur.get("https://www.exemple.com")

# Extraction de tous les cookies actifs
cookies_totaux = navigateur.get_cookies()
for element in cookies_totaux:
    print(f"Nom: {element['nom']}, Valeur: {element['valeur']}")

Ajouter un cookie spécifique

navigateur.get("https://www.exemple.com")  # Accès au domaine requis
nouveau_cookie = {
    'nom': 'token_utilisateur',
    'valeur': 'xyz987',
    'domaine': 'www.exemple.com',
    'chemin': '/'
}
navigateur.ajouter_cookie(nouveau_cookie)
navigateur.refresh()  # Actualisation pour appliquer le cookie

Supprimer un cookie par son nom

navigateur.supprimer_cookie("token_utilisateur")
print("Cookie supprimé avec succès.")

Effacer tous les cookies pour une session propre

navigateur.supprimer_tous_cookies()
# Assure un état initial sans interférence pour les tests suivants

Scénarios de test pratiques

Les cookies peuvent résoudre des défis courants dans les tests automatisés. Voici quelques appilcations concrètes :

Simulation de connexion et maintien de session

Pour éviter de se connecter à chaque test, on peut injecter un cookie d'authentification préexistant. Dans un premier temps, on se connecte manuellement et on sauvegarde le cookie. Ensuite, dans une nouvelle session, on ajoute ce cookie pour accéder directement aux pages protégées.

import json

# Étape 1: Connexion et sauvegarde du cookie
session = webdriver.Chrome()
session.get("https://application.com/connexion")
# ... effectuer la connexion ...
cookie_session = session.get_cookie("identifiant_session")
with open("cookies_sauvegarde.json", "w") as fichier:
    json.dump([cookie_session], fichier)
session.quit()

# Étape 2: Restauration dans une nouvelle session
nouvelle_session = webdriver.Chrome()
nouvelle_session.get("https://application.com")
with open("cookies_sauvegarde.json", "r") as fichier:
    cookies_charges = json.load(fichier)
    for c in cookies_charges:
        nouvelle_session.ajouter_cookie(c)
nouvelle_session.get("https://application.com/tableau-de-bord")
assert "Bienvenue" in nouvelle_session.page_source

Test de déconnexion et vérification de sécurité

Ce scénario valide que la déconnexion supprime correctement les cookies et que les accès ultérieurs aux zones protégées sont refusés.

navigateur.get("https://application.com/connexion")
# ... connexion préalable ...
cookie_avant = navigateur.obtenir_cookie("identifiant_session")
assert cookie_avant is not None

# Déconnexion
navigateur.find_element("id", "bouton-deconnexion").click()

# Vérification
cookie_apres = navigateur.obtenir_cookie("identifiant_session")
assert cookie_apres is None
navigateur.get("https://application.com/administration")
assert "Veuillez vous connecter" in navigateur.page_source

Simulation d'expiration de cookie

En modifiant l'attribut d'expiration d'un cookie, on peut tester le comportement de l'application lorsque la session expire.

cookie_expire = {
    'nom': 'session',
    'valeur': 'token_perime',
    'domaine': 'application.com',
    'expiration': 1609459200  # Timestamp pour le 1er janvier 2021
}
navigateur.ajouter_cookie(cookie_expire)
navigateur.refresh()
assert "Connexion" in navigateur.title

Bonnes pratiques et erreurs à éviter

Pour garantir des tests fiables, suivez ces recommandations :

• Toujours naviguer vers le domaine cible avant d'ajouter un cookie, pour éviter les exceptions de type InvalidCookieDomainException.
• Utiliser supprimer_tous_cookies() au début de chaque test pour isoler les états.
• Vérifier les attributs de sécurité comme 'secure' et 'httpOnly' lors de la validation des cookies.
• Intégrer des mécanismes d'attente explicite pour synchroniser les opérations de cookie avec le chargement des pages.

Intégration avancée avec des frameworks de test

On peut encapsuler la logique des cookies dans des classes utilitaires pour une réutilisation dans les suites de test. Par exemple, avec Pytest, on peut créer une fixture qui charge un cookie d'authentification pour tous les tests.

import pytest
from selenium import webdriver

@pytest.fixture(scope="session")
def session_authentifiee():
    nav = webdriver.Chrome()
    nav.get("https://application.com/connexion")
    # ... logique de connexion ...
    return nav

def test_profil_utilisateur(session_authentifiee):
    session_authentifiee.get("https://application.com/profil")
    assert "Profil" in session_authentifiee.title