Ecrire les étapes en utilisant des keywords (style Gherkin simplifié)

Les keywords : les actions fondamentales de vos tests Robot Framework

Au coeur de Robot Framework se trouve le concept de "keyword" (mot-clé). Un keyword représente une action discrète que votre test doit exécuter, comme "Ouvrir le navigateur", "Cliquer sur un bouton", "Vérifier que le texte est présent" ou encore "Entrer du texte dans un champ". L'écriture des étapes d'un test consiste essentiellement à assembler une séquence logique de ces keywords pour simuler un scénario utilisateur ou vérifier une fonctionnalité spécifique.

Ces keywords peuvent provenir de différentes sources : la librairie standard `BuiltIn` de Robot Framework (offrant des actions génériques comme `Log`, `Should Be Equal`, `Run Keyword If`), des librairies externes importées (par exemple, `SeleniumLibrary` pour l'interaction avec les navigateurs web, `RequestsLibrary` pour les tests d'API), ou encore des keywords que vous définissez vous-même (User Keywords) pour encapsuler des logiques métier ou des séquences d'actions réutilisables. La puissance de Robot Framework réside dans cette capacité à combiner et à abstraire la complexité derrière des keywords simples et expressifs.

La syntaxe pour utiliser un keyword est directe : le nom du keyword est suivi de ses arguments (s'il en a), le tout séparé par au moins deux espaces. Cette simplicité syntaxique est l'une des raisons pour lesquelles Robot Framework est apprécié pour sa lisibilité. Même sans être un expert en programmation, on peut comprendre la finalité d'un test en lisant la séquence de ses keywords.

S'inspirer du Gherkin pour une lisibilité accrue : une approche simplifiée

Bien que Robot Framework n'impose pas strictement la syntaxe Gherkin (utilisée par des outils comme Cucumber avec ses clauses `Given`, `When`, `Then`, `And`, `But`), s'en inspirer peut grandement améliorer la clarté et la structure de vos tests. L'idée est d'organiser vos keywords de manière à raconter une histoire, décrivant le contexte, l'action et le résultat attendu. Cela rend les tests plus compréhensibles, non seulement pour les automaticiens, mais aussi pour les parties prenantes non techniques (chefs de projet, product owners, etc.).

Dans Robot Framework, vous n'avez pas besoin d'utiliser explicitement les mots-clés `Given`, `When`, `Then`. La structure du test elle-même, à travers la séquence des keywords, peut refléter cette logique. Cependant, rien ne vous empêche de nommer vos User Keywords d'une manière qui évoque ces étapes, ou même d'utiliser des commentaires pour structurer visuellement votre test. L'objectif principal est la lisibilité et la communication de l'intention du test.

Par exemple, au lieu d'une simple liste de keywords techniques, vous pouvez organiser vos actions ainsi :

*** Test Cases ***
Recherche De Produit Réussie
    # ETANT DONNE que l'utilisateur est sur la page d'accueil
    Naviguer Vers La Page D'accueil
    La Page D'accueil Devrait Etre Affichée

    # QUAND l'utilisateur recherche un produit spécifique
    Entrer "Mon Produit" Dans La Barre De Recherche
    Cliquer Sur Le Bouton "Rechercher"

    # ALORS les résultats de la recherche devraient s'afficher correctement
    La Page Des Résultats Devrait Contenir "Mon Produit"
    Au Moins Un Résultat Devrait Etre Visible

Dans cet exemple, `Naviguer Vers La Page D'accueil`, `Entrer "Mon Produit" Dans La Barre De Recherche`, etc., sont des keywords (soit de librairie, soit des User Keywords). Les commentaires (lignes commençant par `#`) aident à structurer le test selon une logique Gherkin simplifiée, améliorant sa compréhension.

Structurer les étapes pour la maintenabilité et la clarté

L'écriture des étapes ne se limite pas à lister des keywords. Une bonne structuration est essentielle pour la maintenabilité à long terme de vos suites de tests. Chaque test case devrait se concentrer sur la vérification d'un aspect spécifique de la fonctionnalité. Si un test devient trop long ou vérifie trop de choses différentes, il sera plus difficile à comprendre, à déboguer et à maintenir.

Utilisez des User Keywords pour regrouper des séquences d'actions répétitives ou logiquement connectées. Par exemple, les étapes de connexion à une application peuvent être encapsulées dans un User Keyword `Se Connecter Avec Les Identifiants`. Cela rendra vos tests plus concis et plus lisibles, car le test case principal décrira le scénario à un plus haut niveau d'abstraction.

*** Settings ***
Library    SeleniumLibrary
Resource   ressources_communes.resource  # Fichier contenant le User Keyword "Se Connecter"

*** Variables ***
${URL_LOGIN}       https://monapplication.com/login
${USER_NAME}       testuser
${PASSWORD}        securepassword

*** Test Cases ***
Accéder Au Tableau De Bord Après Connexion
    Se Connecter    ${URL_LOGIN}    ${USER_NAME}    ${PASSWORD}
    Vérifier La Redirection Vers Le Tableau De Bord
    Le Titre Du Tableau De Bord Devrait Etre Correct

*** Keywords ***
# Exemple de User Keyword défini dans ce fichier (ou dans ressources_communes.resource)
Se Connecter
    [Arguments]    ${url}    ${username}    ${password}
    Open Browser    ${url}    chrome
    Input Text      id=username_field    ${username}
    Input Password  id=password_field    ${password}
    Click Button    id=login_button
    Page Should Not Contain    Erreur de connexion

Vérifier La Redirection Vers Le Tableau De Bord
    Location Should Be    https://monapplication.com/dashboard

Le Titre Du Tableau De Bord Devrait Etre Correct
    Title Should Be    Mon Tableau de Bord

Dans cet exemple, le test `Accéder Au Tableau De Bord Après Connexion` utilise le User Keyword `Se Connecter`, ce qui rend le corps du test plus clair et centré sur le flux principal. Les détails techniques de la connexion sont masqués dans le User Keyword. L'utilisation de variables (comme `${URL_LOGIN}`) améliore également la maintenabilité, car les valeurs peuvent être modifiées en un seul endroit. Adopter ce style d'écriture, en combinant la puissance des keywords avec une structure inspirée de Gherkin, vous permettra de créer des tests robustes, lisibles et faciles à faire évoluer.