Test et débogage de script pour garantir la stabilité

1. Méthodes pour tester les scripts

Bienvenue à notre cours dédié au processus préféré de tous les développeurs : le débogage et les tests ! Si tu as déjà appris à créer un super bot avec Selenium, il est temps d'apprendre comment le transformer d'un robot un peu "fou" en un exécuteur fiable, qui non seulement fonctionne, mais le fait de manière stable. Personne ne veut que son bot décide soudainement de "prendre une pause" au moment le plus critique.

On va commencer par discuter les différentes méthodes pour tester tes scripts. Les tests, c'est un peu comme une visite chez le médecin : ça ne fait plaisir à personne, mais c'est nécessaire. Même le script le plus brillant a besoin d'être vérifié pour sa robustesse et sa fiabilité. La bonne nouvelle, c'est qu'en Python, il y a plein d'outils pour t'aider dans cette tâche.

Tests unitaires

Tout commence par les tests unitaires. Ils sont comme des petits mouvements précis d'horlogerie suisse, vérifiant chaque rouage de ton mécanisme. En Python, la bibliothèque unittest est le standard de facto pour écrire des tests unitaires. L'idée principale est de tester des "unités" spécifiques ou des parties de ton code isolément.

import unittest
from my_selenium_script import my_function

class TestMyFunction(unittest.TestCase):

    def test_success_case(self):
        result = my_function("expected input")
        self.assertEqual(result, "expected output")

unittest.main()

Cet exemple simple illustre comment tu peux vérifier des fonctions spécifiques de ton code. Bien sûr, dans la pratique, tu testeras non seulement les cas de succès, mais aussi des cas limites et des entrées incorrectes.

Tests d'intégration

Une fois que tu te sens en confiance avec chaque "unité", il est temps de vérifier leur interaction ensemble. Les tests d'intégration, comme un rendez-vous parfait, montrent comment les composants individuels fonctionnent ensemble. Tu peux utiliser les mêmes bibliothèques, mais en abordant les tests sous un autre angle.

class TestIntegration(unittest.TestCase):

    def test_full_workflow(self):
        # Imagine que chaque étape correspond à l'appel d'une fonction dans ton algorithme
        open_page()
        fill_form()
        submit_form()
        self.assertTrue(check_results())

Les tests d'intégration peuvent être plus complexes et prendre plus de temps, mais ils donnent l'assurance que tout le système fonctionne comme une unité cohérente.

2. Débogage et correction des erreurs

Maintenant qu'on a parlé des tests, plongeons dans la partie la plus intrigante : le débogage. Le débogage, c'est quand ton bot décide d'improviser et que tu dois le ramener sur scène pour qu'il suive le scénario.

Outils pour le débogage

Un outil génial pour le débogage en Python est pdb. Il te permet de mettre l'exécution de ton script en pause et d'explorer son état, étape par étape. Voici un exemple :

import pdb

def some_function(value):
    pdb.set_trace()  # Ici l'exécution sera suspendue
    result = value + 1
    return result

some_function(3)

            

En exécutant ce code, tu entreras dans un environnement interactif où tu peux avancer dans le code, voir les valeurs des variables, les modifier et même continuer l'exécution étape par étape. Cela simplifie grandement la tâche quand ton script semble avoir un comportement inattendu.

Visualisation de l'état de la page

Pour le débogage visuel, il peut être utile de sauvegarder des captures d'écran de la page à chaque étape de l'exécution du script. Cela permet de voir quels éléments sont affichés à l'écran et comment la page apparaît au moment de l'erreur.

driver.save_screenshot("page_state.png")

Stratégies de recherche et correction d'erreurs

Malheureusement, aucun débogueur ne te dira où dans le code une erreur fondamentale de logique a été commise. C'est ici que les stratégies suivantes peuvent être utiles :

• Ajout de journaux : Ajoutes-en partout. Comme quelqu'un de sage l'a dit, "si tu ne sais pas ce qui se passe avec le code, c'est que tu n'as pas assez de journaux". Utiliser la bibliothèque logging permet de ne pas encombrer ton code avec des fonctions print() et offre plus de contrôle.
• Lire le code à haute voix : Parfois, notre cerveau fonctionne mieux lorsqu'on dit à voix haute ce que fait le code. Ça peut sembler bizarre, mais ça marche !
• Modulariser le code : Divise clairement ton code en modules ou fonctions. Cela te permettra d'identifier plus facilement où une erreur s'est produite.

3. Analyse des scripts Selenium

Pour créer un script fiable, il est important de le tester dans divers scénarios. Voici quelques exemples de tels scénarios :

Absence d'éléments sur la page

Lors du débogage, il est important de s'assurer que tous les éléments nécessaires sont présents sur la page et disponibles pour l'interaction. Utilise la méthode find_elements() et vérifie la longueur de la liste retournée pour éviter les erreurs NoSuchElementException.

elements = driver.find_elements_by_class_name("class_name")
if len(elements) == 0:
    logging.warning("Éléments introuvables")
else:
    logging.info("Éléments trouvés avec succès")

            

États inattendus de la page

Par exemple, des pages avec divers types de chargement ou différents éléments apparaissant selon les conditions. Le script doit être prêt à gérer de telles situations.

try:
    special_offer = driver.find_element(By.ID, "special_offer")
    logging.info("Offre spéciale trouvée et actions effectuées")
except NoSuchElementException:
    logging.info("Offre spéciale non trouvée, on continue sans elle")

            

Éléments variables sur la page

Lors des tests, prends en compte que sur une même page, les éléments peuvent changer (par exemple, différents bannières ou blocs publicitaires). Teste ton script pour tenir compte des différents états de la page.

Tests sur différents navigateurs

Les différents navigateurs peuvent traiter les pages différemment, c'est pourquoi, pour garantir la stabilité, il est utile de tester le script sur plusieurs navigateurs (comme Chrome, Firefox, Edge). Selenium permet d'exécuter des tests sur différents navigateurs via divers drivers web.

from selenium import webdriver

# Exécution sur Chrome
driver = webdriver.Chrome()

# Exécution sur Firefox
driver = webdriver.Firefox()

# Exécution sur Edge
driver = webdriver.Edge()

4. Automatisation des tests de script

Écriture de tests avec unittest

Utilise la bibliothèque unittest pour exécuter automatiquement des tests pour les différentes parties de ton script. Cela te permettra de vérifier régulièrement le bon fonctionnement de chaque élément.

import unittest
from selenium import webdriver

class SeleniumTest(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome()
        self.driver.get("https://example.com")

    def test_element_presence(self):
        driver = self.driver
        element = driver.find_element_by_id("submit_button")
        self.assertIsNotNone(element, "Élément introuvable sur la page")

    def tearDown(self):
        self.driver.quit()

unittest.main()

Création d'un ensemble de tests avec des paramètres

Crée des ensembles de tests pour vérifier différentes combinaisons d'éléments et de scénarios. Par exemple, tu peux tester des pages avec différents paramètres, comme diverses données dans un formulaire d'entrée.

Tests de stabilité et de performance

• Test de la stabilité du script sur de gros volumes de données : Assure-toi que le script est capable de gérer des volumes importants de données et de fonctionner pendant de longues périodes.
• Tests réguliers : Exécute régulièrement des tests pour surveiller la stabilité du script, surtout si le site avec lequel tu travailles est souvent mis à jour.
• Évaluation de la performance : Évite les longues attentes et les éléments lents. Utilise des timers pour évaluer le temps d'exécution de chaque étape et optimise-les si nécessaire.