Techniques avancées / Blogs / Perficient

Dans le monde de l’automatisation des tests, Selenium associé à Pytest constitue une combinaison puissante. Même si les interactions Web de base peuvent être facilement automatisées, scénarios de tests complexes nécessitent souvent des techniques avancées. Ces scénarios peuvent impliquer de gérer des éléments dynamiques, plusieurs fenêtres de navigateur, d’interagir avec cadresmanutention Appels AJAXou gérer les téléchargements de fichiers. Dans ce blog, nous explorerons quelques-uns stratégies avancées pour gérer ces situations complexes, en garantissant la robustesse et la fiabilité de vos tests.

Gestion des éléments dynamiques dans Selenium

Les applications Web d’aujourd’hui sont très dynamiques et s’appuient souvent sur JavaScript et AJAX pour charger ou mettre à jour le contenu. Le sélénium peut avoir du mal à éléments qui apparaissent ou changent dynamiquement sur la page. Heureusement, attentes explicites dans Selenium peut vous aider à gérer ces situations.

Attentes explicites assurez-vous que le test attend qu’une condition spécifique soit remplie avant de continuer. Ceci est crucial lors de l’interaction avec des éléments dynamiques qui se chargent après le rendu de la page.

python
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By

# Wait for an element to be visible
wait = WebDriverWait(driver, 10)
dynamic_element = wait.until(EC.visibility_of_element_located((By.ID, "dynamicElementId")))
dynamic_element.click()

Meilleure pratique: utilisez toujours des attentes explicites pour les éléments qui se chargent après le chargement de la page ou changent d’état en fonction de l’interaction de l’utilisateur (par exemple, les boutons qui deviennent cliquables après la fin d’AJAX).

Travailler avec des iFrames

Dans les applications Web modernes, les iFrames (frames en ligne) intègrent du contenu tel que des vidéos, des formulaires ou des publicités dans une page Web. Selenium interagit avec le document principal par défaut, donc interagir avec les éléments à l’intérieur des iFrames nécessite une gestion spéciale.

Vous devez d’abord passer au cadre pour interagir avec les éléments à l’intérieur d’un iFrame.

python
# Switch to an iFrame by index, name, or WebElement
driver.switch_to.frame(0)  # Switch to the first iFrame on the page

# Interact with elements inside the iFrame
button = driver.find_element_by_id("submit_button")
button.click()

# Switch back to the main document
driver.switch_to.default_content()

Meilleure pratique: revenez toujours au contenu par défaut après avoir interagi avec des éléments dans un iFrame pour éviter les problèmes avec les commandes suivantes.

Gestion de plusieurs fenêtres ou onglets

Vous devrez peut-être souvent interagir avec plusieurs fenêtres ou onglets dans les applications Web. Selenium gère ce scénario en utilisant des handles de fenêtre. Lorsqu’une nouvelle fenêtre ou un nouvel onglet est ouvert, il obtient un identifiant unique que vous pouvez utiliser pour basculer entre les fenêtres.

python
# Get the current window handle
main_window = driver.current_window_handle

# Perform actions that open a new window or tab
driver.find_element_by_id("open_window_button").click()

# Get all window handles and switch to the new window
all_windows = driver.window_handles
for window in all_windows:
    if window != main_window:
        driver.switch_to.window(window)
        break

# Interact with the new window
driver.find_element_by_id("new_window_element").click()

# Switch back to the main window
driver.switch_to.window(main_window)

Meilleure pratique: Stockez toujours la poignée de la fenêtre principale avant de passer à de nouvelles fenêtres ou onglets pour revenir facilement après avoir terminé les tâches dans la nouvelle fenêtre.

Gestion des requêtes AJAX

Les appels AJAX (JavaScript asynchrone et XML) sont souvent utilisés pour charger des données de manière dynamique sans recharger la page entière. Cependant, cela peut compliquer les tests, car Selenium peut essayer d’interagir avec les éléments avant de terminer la requête AJAX.

Pour gérer efficacement les appels AJAX, nous utilisons attentes explicites en conjonction avec des conditions garantissant que la page est entièrement chargée ou que les requêtes AJAX nécessaires sont terminées.

python
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Wait until an AJAX request is complete (e.g., waiting for an element to be visible after AJAX content loads)
wait = WebDriverWait(driver, 10)
wait.until(EC.presence_of_element_located((By.ID, "ajax_loaded_element")))

Meilleure pratique: utilisez des attentes explicites pour le chargement d’éléments AJAX spécifiques avant d’interagir avec eux. Évitez d’utiliser des attentes implicites à l’échelle mondiale, car elles peuvent ralentir vos tests.

Téléchargements de fichiers avec Selenium

Les téléchargements de fichiers sont une exigence fréquente dans de nombreuses applications Web, comme la soumission d’un formulaire avec une pièce jointe. Dans Selenium, vous pouvez interagir avec les éléments d’entrée de fichier à l’aide du envoyer_clés() méthode pour télécharger un fichier directement.

python
file_input = driver.find_element_by_id("file_upload")
file_input.send_keys("/path/to/file.txt")

Meilleure pratique: assurez-vous que le chemin du fichier est correct et testez dans différents environnements pour gérer les scénarios dans lesquels les chemins de fichiers peuvent varier.

Prendre des captures d’écran pour le débogage

Pendant l’exécution des tests, la capture de captures d’écran est cruciale pour faciliter le débogage des échecs. Selenium vous permet de capturer des captures d’écran à tout moment pendant le test.

python
driver.get_screenshot_as_file('screenshot.png')

Meilleure pratique: prenez des captures d’écran après chaque étape de test ou en cas d’échec de capture de l’état de l’application, ce qui facilite le débogage des problèmes.

Tests basés sur les données avec Pytest

Manutention plusieurs ensembles de données d’entrée dans les tests est essentiel, surtout lorsque vous souhaitez exécuter le même test avec différents ensembles d’entrées. Avec Pytestvous pouvez utiliser des luminaires ou paramétrer pour transmettre d’autres ensembles de données à la fonction de test.

python
import pytest

@pytest.mark.parametrize("username, password", [("user1", "pass1"), ("user2", "pass2")])
def test_login(username, password):
    driver.get("http://example.com/login")
    driver.find_element_by_id("username").send_keys(username)
    driver.find_element_by_id("password").send_keys(password)
    driver.find_element_by_id("login_button").click()
    assert "Welcome" in driver.page_source

Meilleure pratique: Utiliser paramétrer pour exécuter le même test avec différentes entrées de données. Cela garantit que vos tests sont complets et réduit le besoin de code répétitif.

Conclusion

La gestion de scénarios de test complexes nécessite une combinaison des bons outils et techniques. Selenium et Pytest offrent des mécanismes puissants pour gérer les éléments dynamiques, les iFrames, les fenêtres multiples, les requêtes AJAX, etc. Vous pouvez créer des solutions d’automatisation des tests plus robustes, fiables et efficaces en maîtrisant ces techniques avancées.

Lorsque vous travaillez avec des applications dynamiques et complexes, assurez-vous toujours que vous exploitez toutes les fonctionnalités de Selenium (telles que les attentes, les poignées de fenêtre et les téléchargements de fichiers) lorsque vous utilisez Pytest pour gérer les données de test, structurer les tests et gérer efficacement les échecs. Cela vous aidera à automatiser efficacement les tests et à maintenir la qualité dans des applications complexes.