Etapes : Ouvrir le navigateur, naviguer vers l'URL, remplir les champs, cliquer, vérifier la connexion

Initialisation : ouvrir le navigateur et atteindre la page de connexion

La toute première phase de notre script d'automatisation consiste à préparer l'environnement de test, c'est-à-dire à lancer un navigateur web et à le diriger vers la page spécifique où se trouve le formulaire de connexion. Ces actions sont fondamentales car sans elles, aucune interaction ultérieure ne serait possible.

Pour ouvrir le navigateur et charger une URL, Robot Framework, via la librairie SeleniumLibrary, met à notre disposition le keyword `Open Browser`. Ce keyword prend généralement deux arguments principaux : l'URL de la page à ouvrir et le nom du navigateur à utiliser (par exemple, Chrome, Firefox, Edge). Il est crucial que le WebDriver correspondant au navigateur choisi soit correctement installé et accessible dans le PATH de votre système.

*** Settings ***
Library    SeleniumLibrary

*** Variables ***
${URL_LOGIN}       https://the-internet.herokuapp.com/login
${BROWSER}         Chrome

*** Test Cases ***
Scenario De Connexion
    Open Browser    ${URL_LOGIN}    ${BROWSER}

Dans cet exemple, nous utilisons des variables `${URL_LOGIN}` et `${BROWSER}` pour plus de flexibilité. Une fois le navigateur ouvert, il est souvent utile de maximiser la fenêtre pour s'assurer que tous les éléments sont visibles, à l'aide du keyword `Maximize Browser Window`.

Le choix du navigateur peut impacter l'exécution des tests, car chaque navigateur a son propre moteur de rendu. Il est donc recommandé de tester sur les navigateurs cibles de votre application. La configuration du WebDriver est une étape préliminaire essentielle ; sans elle, SeleniumLibrary ne pourra pas piloter le navigateur. Assurez-vous d'avoir téléchargé le ChromeDriver (pour Chrome), GeckoDriver (pour Firefox), etc., et que son emplacement est ajouté à la variable d'environnement PATH de votre système.

Interaction avec le formulaire : saisir les identifiants

Une fois sur la page de connexion, l'étape suivante consiste à interagir avec les champs du formulaire, c'est-à-dire saisir le nom d'utilisateur et le mot de passe. Pour cela, il faut d'abord identifier les sélecteurs uniques de ces champs (par exemple, leur `id`, `name`, ou un sélecteur CSS). Cette identification se fait en amont, en inspectant le code HTML de la page avec les outils de développement du navigateur.

Pour saisir du texte dans un champ, SeleniumLibrary offre le keyword `Input Text`. Il prend comme arguments le sélecteur de l'élément et le texte à saisir. Pour le nom d'utilisateur, cela ressemblerait à ceci :

*** Variables ***
${USERNAME_FIELD}  id:username
${USERNAME_VALID}  tomsmith

*** Test Cases ***
Scenario De Connexion
    # ... (Open Browser et Maximize Browser Window) ...
    Input Text    ${USERNAME_FIELD}    ${USERNAME_VALID}

Ici, `${USERNAME_FIELD}` contiendrait le sélecteur (par exemple, `id:username`) et `${USERNAME_VALID}` le nom d'utilisateur effectif.

Pour le champ du mot de passe, il est préférable d'utiliser le keyword `Input Password`. Sa syntaxe est identique à `Input Text`, mais il a l'avantage de ne pas afficher la valeur saisie dans les logs générés par Robot Framework, ce qui est une bonne pratique de sécurité pour éviter l'exposition de données sensibles.

*** Variables ***
${PASSWORD_FIELD}  id:password
${PASSWORD_VALID}  SuperSecretPassword!

*** Test Cases ***
Scenario De Connexion
    # ... (Open Browser, Maximize, Input Text username) ...
    Input Password    ${PASSWORD_FIELD}    ${PASSWORD_VALID}

L'utilisation de variables pour les sélecteurs (comme `${USERNAME_FIELD}`) et les données de test (comme `${USERNAME_VALID}`) est fortement recommandée. Cela rend les scripts plus lisibles, plus faciles à maintenir (si un sélecteur change, il suffit de le modifier à un seul endroit) et permet de paramétrer les tests plus aisément.

Actionner la connexion : le clic sur le bouton

Après avoir rempli les champs du formulaire avec les identifiants, l'action suivante est de soumettre ces informations, ce qui se fait généralement en cliquant sur un bouton de connexion. Tout comme pour les champs de saisie, il faut d'abord identifier le sélecteur unique de ce bouton.

SeleniumLibrary propose plusieurs keywords pour simuler un clic, le plus courant étant `Click Button`. Si l'élément n'est pas sémantiquement un bouton mais se comporte comme tel (par exemple, un lien stylisé ou un `div` cliquable), `Click Element` peut être plus approprié. Pour un bouton standard, `Click Button` est souvent suffisant et plus explicite.

*** Variables ***
${LOGIN_BUTTON}    css:button[type='submit'] # Ou un autre sélecteur pertinent

*** Test Cases ***
Scenario De Connexion
    # ... (Open Browser, Maximize, Input Text, Input Password) ...
    Click Button    ${LOGIN_BUTTON}

Le keyword `Click Button` prend en argument le sélecteur du bouton. Une fois cette action exécutée, le navigateur va typiquement envoyer les données du formulaire au serveur et initier une navigation vers une nouvelle page ou recharger la page actuelle avec un message de statut.

Il est important de noter qu'après un clic qui déclenche une navigation ou une mise à jour de la page, un certain temps de chargement peut être nécessaire. Les étapes suivantes du test, notamment les vérifications, devront en tenir compte pour éviter des échecs dus à des éléments non encore apparus sur la page. Robot Framework et SeleniumLibrary offrent des mécanismes d'attente (implicites et explicites) pour gérer ces situations, que nous aborderons lors de l'étape de vérification.

Validation du résultat : vérifier le succès de la connexion

L'étape cruciale de tout test automatisé est la vérification : s'assurer que l'action effectuée a produit le résultat attendu. Dans notre scénario de connexion, il s'agit de confirmer que l'utilisateur a bien été connecté. Sans cette étape de validation (assertion), le test ne ferait que naviguer et cliquer sans jamais confirmer si l'objectif est atteint.

Pour vérifier une connexion réussie, plusieurs indicateurs peuvent être utilisés :

• L'apparition d'un message de bienvenue spécifique (ex: "Welcome, tomsmith!").
• La présence d'un élément spécifique à la page post-connexion (ex: un lien de déconnexion, un tableau de bord).
• Un changement d'URL vers une page sécurisée ou un tableau de bord.

Sur le site "The Internet - Heroku App", après une connexion réussie avec "tomsmith" et "SuperSecretPassword!", un message "You logged into a secure area!" s'affiche. Nous allons donc vérifier la présence de ce message.

SeleniumLibrary offre plusieurs keywords d'assertion. Pour vérifier qu'un élément contenant un texte spécifique est présent et visible, on peut utiliser une combinaison d'attente et de vérification. Il est primordial d'attendre que la page ou l'élément se charge avant de tenter une vérification. Le keyword `Wait Until Page Contains Element` attend qu'un élément soit disponible, puis `Element Should Contain` ou `Element Text Should Be` peut vérifier son contenu.

*** Variables ***
${SUCCESS_MESSAGE_AREA}  id:flash # Sélecteur de la zone où le message apparaît
${SUCCESS_TEXT}          You logged into a secure area!

*** Test Cases ***
Scenario De Connexion
    # ... (Etapes précédentes : Open Browser, Inputs, Click Button) ...
    Wait Until Page Contains Element    ${SUCCESS_MESSAGE_AREA}    timeout=10s
    Element Should Contain            ${SUCCESS_MESSAGE_AREA}    ${SUCCESS_TEXT}
    # Alternative pour une correspondance exacte du texte:
    # Element Text Should Be         ${SUCCESS_MESSAGE_AREA}    ${SUCCESS_TEXT}

Le `timeout=10s` dans `Wait Until Page Contains Element` indique que Robot Framework attendra jusqu'à 10 secondes que l'élément apparaisse. Si l'élément n'est pas trouvé dans ce délai, le keyword échoue, et donc le test. Si l'élément est trouvé, `Element Should Contain` vérifie ensuite que cet élément contient bien le texte attendu. S'il ne le contient pas, le test échoue à cette étape.

D'autres keywords utiles pour les assertions incluent `Page Should Contain` (pour vérifier la présence d'un texte n'importe où sur la page), `Location Should Be` (pour vérifier l'URL actuelle), ou `Title Should Be` (pour vérifier le titre de la page). Le choix du keyword dépendra de ce qui constitue l'indicateur le plus fiable et le plus précis du succès de l'action. L'utilisation judicieuse des keywords d'attente (`Wait Until...`) avant les assertions est la clé pour créer des tests robustes et éviter les faux négatifs dus à des problèmes de synchronisation.

Finalisation du test : le nettoyage de l'environnement

Une fois toutes les actions et vérifications de notre scénario de test effectuées, il est important de remettre l'environnement dans un état propre. Dans le contexte des tests d'interface utilisateur web, cela signifie généralement fermer le navigateur qui a été ouvert au début du test. Cette étape de nettoyage est cruciale pour plusieurs raisons : elle libère des ressources système, évite l'accumulation de fenêtres de navigateur ouvertes (surtout lors de l'exécution de nombreuses suites de tests), et prépare le terrain pour une exécution propre du test suivant.

Robot Framework permet de définir des actions de "démontage" (teardown) qui s'exécutent à la fin d'un cas de test ou d'une suite de tests, que le test ait réussi ou échoué. Pour fermer le navigateur, SeleniumLibrary fournit le keyword `Close Browser`. S'il y a un risque que plusieurs navigateurs soient ouverts (bien que moins courant pour un test simple), `Close All Browsers` peut être utilisé pour fermer toutes les instances de navigateurs ouvertes par SeleniumLibrary au cours de la session.

*** Test Cases ***
Scenario De Connexion
    # ... (Toutes les étapes précédentes : Open Browser, Inputs, Click Button, Verifications) ...
    [Teardown]    Close Browser

L'instruction `[Teardown]` est placée à la fin de la définition du cas de test. Le keyword spécifié après `[Teardown]` (ici, `Close Browser`) sera automatiquement exécuté une fois que toutes les autres étapes du test `Scenario De Connexion` seront terminées, ou si une erreur interrompt le test prématurément. Cela garantit que le navigateur est fermé dans la plupart des situations, contribuant à la stabilité et à la fiabilité de l'ensemble du processus de test automatisé.

En intégrant cette étape de nettoyage, notre scénario de connexion est maintenant complet, couvrant le cycle de vie entier d'un test automatisé : initialisation, exécution des actions, vérification des résultats, et enfin, nettoyage. Chaque étape est essentielle pour construire des tests automatisés robustes, maintenables et fiables.