Les keywords, vos briques de construction

Explorez les keywords Robot Framework : intégrés (BuiltIn), de librairies (SeleniumLibrary), et la création de keywords utilisateurs pour des tests modulaires et lisibles.

Les keywords : le coeur de l'action dans Robot Framework

Si la structure d'un script Robot Framework en est le squelette, les keywords en sont assurément les muscles et les organes vitaux. Ce sont eux qui réalisent les actions, effectuent les vérifications et donnent vie à vos scénarios de test. Un keyword, dans l'univers de Robot Framework, est une instruction qui accomplit une tâche spécifique. Il peut s'agir d'une action simple comme cliquer sur un bouton, d'une vérification comme s'assurer qu'un texte est présent sur une page, ou d'une opération plus complexe regroupant plusieurs étapes.

La puissance de Robot Framework réside en grande partie dans son système de keywords. Il en existe de plusieurs types, chacun ayant sa source et son utilité : les keywords intégrés (BuiltIn), qui fournissent les fonctionnalités de base ; les keywords provenant de librairies externes, qui étendent les capacités de Robot Framework à des domaines spécifiques comme les tests web (SeleniumLibrary) ou les API (RequestsLibrary) ; et enfin, les keywords utilisateurs, que vous créez vous-même pour encapsuler des logiques de test réutilisables.

Comprendre comment utiliser ces différents types de keywords et, surtout, comment concevoir vos propres keywords utilisateurs, est fondamental pour écrire des tests automatisés efficaces, maintenables et lisibles. Dans ce chapitre, nous allons explorer en détail ces briques de construction, avec des exemples concrets pour illustrer leur utilisation et leur potentiel.

La fondation : les keywords intégrés (BuiltIn)

Robot Framework est livré avec une librairie standard appelée `BuiltIn`. Cette librairie est automatiquement disponible dans tous vos fichiers de test ; vous n'avez pas besoin de l'importer explicitement via la section `*** Settings ***`. Elle fournit un ensemble de keywords génériques et fondamentaux, indispensables pour la plupart des tâches d'automatisation et la logique de base des tests.

Ces keywords couvrent un large éventail de fonctionnalités, notamment :

Logging et rapport : `Log`, `Log To Console`, `Comment`.
Assertions et vérifications : `Should Be Equal`, `Should Contain`, `Should Be True`, `Run Keyword And Expect Error`.
Manipulation de variables : `Set Variable`, `Set Suite Variable`, `Get Variable Value`.
Contrôle de flux : `Run Keyword If`, `Run Keywords`, `FOR ... IN ... END` (boucles), `WHILE ... END` (boucles).
Exécution de keywords : `Run Keyword`, `Wait Until Keyword Succeeds`.
Gestion des erreurs : `Run Keyword And Continue On Failure`.
Utilitaires divers : `Sleep` (pour les pauses, à utiliser avec parcimonie), `Convert To Integer`, `Get Time`.

L'utilisation de ces keywords est directe. Par exemple, pour afficher un message dans le log et vérifier une égalité :

*** Test Cases ***
Exemple Keywords BuiltIn
    Log    Début du test avec des keywords intégrés.
    ${variable_a}    Set Variable    CertiQuizz
    ${variable_b}    Set Variable    CertiQuizz
    Should Be Equal    ${variable_a}    ${variable_b}    Les deux variables devraient être égales.

    ${nombre_attendu}    Set Variable    10
    ${nombre_obtenu}     Convert To Integer    10
    Should Be Equal As Integers    ${nombre_obtenu}    ${nombre_attendu}

    Run Keyword If    ${nombre_obtenu} > 5    Log    Le nombre est supérieur à 5.
    ...    ELSE    Log    Le nombre n'est pas supérieur à 5.

La documentation officielle de Robot Framework détaille exhaustivement tous les keywords de la librairie `BuiltIn` et leurs arguments. Il est crucial de bien connaître ces keywords de base, car ils constituent la fondation sur laquelle vous construirez des tests plus complexes et des keywords utilisateurs.

Extension des capacités : les keywords de librairies externes (exemple avec SeleniumLibrary)

Si les keywords `BuiltIn` fournissent les outils de base, la véritable force de Robot Framework pour des tests spécifiques (web, API, mobile, etc.) vient de son écosystème de librairies externes. Ces librairies sont développées par la communauté ou par des tiers et offrent des ensembles de keywords spécialisés pour interagir avec des technologies ou des applications particulières.

L'une des librairies les plus populaires et les plus utilisées est `SeleniumLibrary`. Elle permet d'automatiser les interactions avec les navigateurs web en s'appuyant sur le projet Selenium. Pour utiliser une librairie externe, vous devez d'abord l'installer (généralement via `pip install robotframework-seleniumlibrary`) puis l'importer dans la section `*** Settings ***` de votre fichier de test.

*** Settings ***
Library    SeleniumLibrary    timeout=10s    # Importe SeleniumLibrary avec un timeout par défaut de 10s pour les actions

Une fois importée, `SeleniumLibrary` met à votre disposition une vaste collection de keywords pour manipuler les navigateurs et les éléments web :

Gestion du navigateur : `Open Browser`, `Close Browser`, `Maximize Browser Window`, `Go To`.
Localisation d'éléments : `Input Text`, `Click Element`, `Page Should Contain Element`, `Get WebElement`. Les éléments sont localisés via des stratégies comme `id`, `name`, `xpath`, `css`, etc.
Assertions sur la page : `Page Should Contain`, `Title Should Be`, `Location Should Be`.
Interactions avancées : `Execute Javascript`, `Select From List By Value`, `Mouse Over`, `Drag And Drop`.
Gestion des attentes (waits) : `Wait Until Page Contains`, `Wait Until Element Is Visible`.

Voici un exemple illustrant l'utilisation de quelques keywords de `SeleniumLibrary` :

*** Variables ***
${URL_SITE}      https://www.certiquizz.com
${NAVIGATEUR}    chrome

*** Test Cases ***
Exemple avec SeleniumLibrary
    Open Browser    ${URL_SITE}    ${NAVIGATEUR}
    Maximize Browser Window
    Page Should Contain    Bienvenue sur CertiQuizz
    Input Text    id:search_query    Robot Framework
    Click Button    id:search_button
    Wait Until Page Contains Element    css:.search-results    timeout=5s
    Element Should Contain    css:.search-results-summary    Robot Framework
    Close Browser

Chaque librairie possède sa propre documentation listant les keywords disponibles, leurs arguments et leur fonctionnement. Il existe des librairies pour tester des API REST (`RequestsLibrary`), des applications mobiles (`AppiumLibrary`), des bases de données (`DatabaseLibrary`), et bien d'autres. Le choix des librairies dépendra des technologies que vous devez tester.

La puissance de l'abstraction : création de vos propres keywords utilisateurs (User Keywords)

Au-delà des keywords intégrés et de ceux fournis par les librairies, Robot Framework vous permet de créer vos propres keywords, appelés "User Keywords" (ou keywords utilisateurs). C'est une fonctionnalité essentielle pour structurer vos tests, améliorer leur lisibilité et favoriser la réutilisabilité du code. Un keyword utilisateur regroupe une séquence d'appels à d'autres keywords (qu'ils soient `BuiltIn`, de librairie, ou même d'autres User Keywords) sous un nom unique et significatif.

Les keywords utilisateurs sont définis dans la section `*** Keywords ***` de votre fichier de test ou dans un fichier de ressources (`.resource`) que vous pouvez ensuite importer.

Les avantages de créer des keywords utilisateurs sont nombreux :

Abstraction : Ils masquent la complexité des étapes techniques derrière un nom de keyword plus orienté métier. Par exemple, un keyword `Se Connecter en Tant Qu'Administrateur` est plus parlant qu'une suite de `Input Text`, `Input Password`, `Click Button`.
Réutilisabilité : Si une séquence d'actions est nécessaire dans plusieurs cas de test, vous la définissez une seule fois et l'appelez où besoin.
Maintenabilité : Si la logique d'une action commune change (par exemple, le formulaire de connexion est modifié), vous n'avez qu'à mettre à jour le keyword utilisateur correspondant, et tous les tests l'utilisant bénéficieront de la modification.
Lisibilité des cas de test : Les cas de test deviennent plus courts, plus clairs et se concentrent sur le "quoi" plutôt que sur le "comment".

Voici un exemple de définition et d'utilisation de keywords utilisateurs :

*** Settings ***
Library    SeleniumLibrary

*** Variables ***
${URL_LOGIN}     https://monapp.com/login
${ADMIN_USER}    admin@certiquizz.com
${ADMIN_PASS}    SuperSecret123!

*** Test Cases ***
Connexion Administrateur Réussie
    Se Connecter En Tant Qu    ${ADMIN_USER}    ${ADMIN_PASS}
    Vérifier Que L'Utilisateur Est Sur Le Tableau De Bord Admin
    Se Déconnecter

*** Keywords ***
Ouvrir La Page De Connexion
    Open Browser    ${URL_LOGIN}    chrome
    Maximize Browser Window
    Page Should Contain    Page de Connexion

Saisir Les Identifiants
    [Arguments]    ${username}    ${password}
    Input Text        id:username_field    ${username}
    Input Password    id:password_field    ${password}

Cliquer Sur Le Bouton De Connexion
    Click Button    id:login_submit_button

Se Connecter En Tant Qu
    [Arguments]    ${email}    ${mot_de_passe}
    [Documentation]    Keyword de haut niveau pour se connecter à l'application.
    Ouvrir La Page De Connexion
    Saisir Les Identifiants    ${email}    ${mot_de_passe}
    Cliquer Sur Le Bouton De Connexion

Vérifier Que L'Utilisateur Est Sur Le Tableau De Bord Admin
    Wait Until Page Contains Element    id:admin_dashboard_header    timeout=10s
    Location Should Be    ${URL_LOGIN}/admin/dashboard

Se Déconnecter
    Click Element    id:logout_link
    Page Should Contain    Vous avez été déconnecté.

Dans cet exemple, le cas de test `Connexion Administrateur Réussie` est très lisible grâce à l'utilisation des keywords utilisateurs `Se Connecter En Tant Qu`, `Vérifier Que L'Utilisateur Est Sur Le Tableau De Bord Admin`, et `Se Déconnecter`. Ces keywords utilisateurs encapsulent les détails techniques des interactions avec SeleniumLibrary. Les keywords utilisateurs peuvent prendre des `[Arguments]` et aussi retourner des valeurs avec `[Return]`, ce qui les rend encore plus flexibles.

Maîtriser la création de keywords utilisateurs est une étape clé pour passer de scripts de test basiques à des frameworks d'automatisation robustes et maintenables. C'est l'art de décomposer des problèmes complexes en briques logicielles plus petites, gérables et réutilisables.

◄ Précédent Suivant ►

く