Les variables pour des tests dynamiques et maintenables

Découvrez comment utiliser les variables scalaires et de liste dans Robot Framework pour créer des tests automatisés dynamiques, lisibles et faciles à maintenir. Explorez leur portée.

Les variables : l'ingrédient clé pour des tests flexibles et robustes

Dans l'univers de l'automatisation des tests, la capacité à gérer des données de manière flexible est primordiale. C'est là que les variables entrent en jeu dans Robot Framework. Les variables vous permettent de stocker et de réutiliser des informations – qu'il s'agisse d'URLs, d'identifiants de connexion, de chemins de fichiers, de résultats attendus, ou de toute autre donnée susceptible de changer ou d'être utilisée à plusieurs endroits dans vos scripts. L'utilisation judicieuse des variables rend vos tests non seulement plus dynamiques, mais aussi significativement plus lisibles et plus faciles à maintenir.

Au lieu de coder en dur des valeurs directement dans vos étapes de test (une pratique qui mène rapidement à des cauchemars de maintenance), vous définissez ces valeurs une seule fois sous forme de variables. Si une donnée change, vous n'avez qu'à la modifier à un seul endroit – dans la définition de la variable – et le changement se répercute partout où cette variable est utilisée.

Ce chapitre va explorer les types de variables les plus courants dans Robot Framework : les variables scalaires et les variables de liste. Nous aborderons leur syntaxe, leur utilisation pratique, et un concept crucial : la portée des variables, qui détermine où et quand une variable est accessible.

Les variables scalaires (`${MA_VARIABLE}`) : stocker des valeurs uniques

Une variable scalaire est conçue pour contenir une unique valeur. Cette valeur peut être une chaîne de caractères, un nombre, un booléen, ou même `None` (la représentation de null en Python, que Robot Framework utilise sous le capot). La syntaxe pour définir et utiliser une variable scalaire est simple et distinctive : elle commence par un dollar `$` suivi d'accolades `{}` entourant le nom de la variable.

Définition :

Les variables scalaires sont le plus souvent définies dans la section `*** Variables ***` d'un fichier de test ou d'un fichier de ressources.

*** Variables ***
${URL_ACCUEIL}       https://www.certiquizz.com
${NAVIGATEUR_DEFAUT} chrome
${TIMEOUT_COURT}     5s
${NOMBRE_MAX_ESSAIS} 3
${UTILISATEUR_ADMIN} admin@example.com
${FLAG_ACTIF}        ${True}  # Variable booléenne
${VALEUR_NULLE}      ${None}

Notez que pour les booléens (`${True}`, `${False}`) et pour `${None}`, les accolades sont également utilisées autour de la valeur elle-même lors de l'assignation pour s'assurer qu'elles sont interprétées correctement comme des types Python spécifiques et non comme des chaînes de caractères "True" ou "None". Les nombres peuvent être écrits directement.

Utilisation :

Une fois définie, vous pouvez utiliser une variable scalaire dans vos cas de test ou keywords en utilisant la même syntaxe `${NOM_VARIABLE}`.

*** Settings ***
Library    SeleniumLibrary

*** Variables ***
${URL_SITE}      https://the-internet.herokuapp.com/login
${BROWSER}       firefox
${USER_LOGIN}    tomsmith

*** Test Cases ***
Test de Connexion Utilisant des Variables Scalaires
    Open Browser    ${URL_SITE}    ${BROWSER}
    Maximize Browser Window
    Page Should Contain    Login Page
    Input Text    id:username    ${USER_LOGIN}
    Log    L'URL du site testé est : ${URL_SITE}
    Log    Le navigateur utilisé est : ${BROWSER}
    [Teardown]    Close Browser

Création dynamique :

Vous pouvez également créer ou modifier des variables scalaires dynamiquement pendant l'exécution d'un test en utilisant des keywords `BuiltIn` comme `Set Variable`, `Set Test Variable`, `Set Suite Variable`, ou `Set Global Variable`, selon la portée souhaitée.

*** Test Cases ***
Test de Création Dynamique de Variable
    ${message_accueil}    Set Variable    Bienvenue sur CertiQuizz !
    Log    ${message_accueil}

    ${code_produit}    Generate Random String    8    [NUMBERS]
    Log    Code produit généré : ${code_produit}
    Set Test Variable    ${CODE_PRODUIT_TEST}    ${code_produit} # Disponible pour le reste de ce cas de test

Les variables scalaires sont le type de variable le plus fondamental et le plus couramment utilisé pour rendre les tests paramétrables et faciles à gérer.

Les variables de liste (`@{MA_LISTE}`) : gérer des ensembles ordonnés de valeurs

Lorsqu'il s'agit de manipuler une collection ordonnée d'éléments, les variables de liste entrent en scène. Une variable de liste, identifiable par sa syntaxe commençant par un arobase `@` suivi d'accolades `{}`, peut contenir zéro, un ou plusieurs items. Ces items peuvent être de types différents (chaînes, nombres, autres variables).

Définition :

Les variables de liste sont également définies principalement dans la section `*** Variables ***`. Les éléments de la liste sont séparés par au moins deux espaces.

*** Variables ***
@{NAVIGATEURS_A_TESTER}    chrome    firefox    edge
@{IDENTIFIANTS_TEST}      user1@example.com    Pass123    user2@example.com    AutrePass
@{CODES_ERREUR_ATTENDUS}   400    401    403    500
@{LISTE_VIDE}             # Ceci définit une liste vide
@{LISTE_UN_ELEMENT}       seul_item

Utilisation :

Les variables de liste sont particulièrement utiles avec les boucles `FOR` ou lorsque vous avez besoin de passer plusieurs arguments à un keyword. Vous pouvez accéder à des éléments individuels d'une liste en utilisant un index (commençant à 0) avec la syntaxe `${NOM_LISTE}[index]`.

*** Variables ***
@{FRUITS}           Pomme    Banane    Orange    Fraise
${PREMIER_FRUIT}    ${FRUITS}[0]  # Contient "Pomme"
${DERNIER_FRUIT}    ${FRUITS}[-1] # Contient "Fraise"

*** Test Cases ***
Parcourir une Liste de Fruits
    Log    Le premier fruit est : ${PREMIER_FRUIT}
    Log    Le dernier fruit est : ${DERNIER_FRUIT}
    Log    Tous les fruits : @{FRUITS}

    FOR    ${fruit}    IN    @{FRUITS}
        Log    Fruit actuel : ${fruit}
        Run Keyword If    '${fruit}' == 'Orange'    Log    J'ai trouvé une orange !
    END

Passer une Liste comme Arguments Séparés
    Mon Keyword Avec Plusieurs Arguments    @{FRUITS} # Equivaut à appeler : Mon Keyword Avec Plusieurs Arguments    Pomme    Banane    Orange    Fraise

Le keyword `Mon Keyword Avec Plusieurs Arguments` recevrait alors `Pomme` comme premier argument, `Banane` comme deuxième, etc. Si le keyword attendait une liste unique, vous le passeriez comme `${FRUITS}`.

Manipulation de listes :

La librairie `Collections` (qui doit être importée avec `Library Collections` dans `*** Settings ***`) offre de nombreux keywords pour manipuler les listes : `Append To List`, `Get From List`, `List Should Contain Value`, `Combine Lists`, `Sort List`, etc.

*** Settings ***
Library    Collections

*** Variables ***
@{MA_LISTE_INITIALE}    item1    item2

*** Test Cases ***
Manipulation de Liste
    Append To List    ${MA_LISTE_INITIALE}    item3
    Log List    ${MA_LISTE_INITIALE}  # Affiche [ 'item1', 'item2', 'item3' ]

    ${element_recupere}    Get From List    ${MA_LISTE_INITIALE}    1 # Index 1
    Should Be Equal    ${element_recupere}    item2

    List Should Contain Value    ${MA_LISTE_INITIALE}    item1
    Remove Values From List    ${MA_LISTE_INITIALE}    item2
    Log List    ${MA_LISTE_INITIALE}  # Affiche [ 'item1', 'item3' ]

Les variables de liste sont essentielles pour les tests data-driven (où vous exécutez le même test avec différents ensembles de données) et pour gérer des collections d'éléments de manière programmatique.

Portée des variables : quand et où sont-elles accessibles ?

La portée (ou "scope" en anglais) d'une variable définit la partie de votre code de test où cette variable est reconnue et peut être utilisée. Comprendre la portée est crucial pour éviter les erreurs de type "variable not found" et pour gérer correctement l'état de vos tests.

Robot Framework distingue plusieurs niveaux de portée pour les variables :

Portée globale (Global Scope) : Les variables avec une portée globale sont accessibles partout, dans toutes les suites de tests, tous les cas de test et tous les keywords, pendant toute la durée de l'exécution des tests. Elles sont créées avec le keyword `Set Global Variable`. A utiliser avec prudence, car un usage excessif peut rendre les tests difficiles à suivre et à déboguer en raison d'effets de bord potentiels.
Portée de la suite (Suite Scope) : Les variables définies avec `Set Suite Variable` sont accessibles n'importe où dans la suite de tests où elles ont été créées (c'est-à-dire dans tous les cas de test et keywords de cette suite). Elles sont également accessibles dans les suites enfants si la suite parente est initialisée. Les variables définies dans la section `*** Variables ***` d'un fichier de test ont implicitement une portée de suite.
Portée du cas de test (Test Case Scope) : Les variables créées avec `Set Test Variable` ne sont accessibles que pendant l'exécution du cas de test spécifique où elles ont été définies. Elles sont "oubliées" une fois le cas de test terminé. C'est une bonne pratique pour les variables temporaires qui n'ont de sens que pour un scénario particulier.
Portée locale (Local Scope) : Les variables créées à l'intérieur d'un keyword utilisateur (par exemple, avec `Set Variable`, ou les arguments reçus par le keyword) ont une portée locale. Elles ne sont accessibles qu'à l'intérieur de ce keyword et des keywords qu'il pourrait appeler. Si un keyword utilisateur retourne une valeur, cette valeur peut être assignée à une variable ayant une portée plus large dans le contexte appelant.

Exemples illustrant la portée :

*** Settings ***
Suite Setup    Definir Variable de Suite

*** Variables ***
${VAR_FICHIER_TEST}    Valeur au niveau du fichier (portée suite implicite)

*** Test Cases ***
Test Portée 1
    Log    Variable de fichier : ${VAR_FICHIER_TEST}
    Log    Variable de suite : ${VAR_DE_SUITE}
    Set Test Variable    ${VAR_DE_TEST_1}    Valeur pour Test 1
    Log    Variable de test : ${VAR_DE_TEST_1}
    Mon Keyword Local
    # Log    ${VAR_LOCALE_KEYWORD}    # ERREUR: Non visible ici

Test Portée 2
    Log    Variable de fichier : ${VAR_FICHIER_TEST}
    Log    Variable de suite : ${VAR_DE_SUITE}
    # Log    ${VAR_DE_TEST_1}    # ERREUR: Non visible ici, car définie dans Test Portée 1
    ${resultat_kw}    Mon Keyword Avec Retour
    Log    Résultat du keyword : ${resultat_kw}

*** Keywords ***
Definir Variable de Suite
    Set Suite Variable    ${VAR_DE_SUITE}    Je suis une variable de suite

Mon Keyword Local
    ${VAR_LOCALE_KEYWORD}    Set Variable    Je suis locale à ce keyword
    Log    Dans Mon Keyword Local : ${VAR_LOCALE_KEYWORD}

Mon Keyword Avec Retour
    [Return]    Valeur retournée par le keyword
    ${val_locale}    Set Variable    Locale et retournée
    RETURN    ${val_locale}

En résumé :

Utilisez la section `*** Variables ***` pour les données qui sont constantes pour toute la suite de tests.
Utilisez `Set Test Variable` pour les données spécifiques à un cas de test.
Les variables à l'intérieur des keywords sont locales par défaut. Utilisez `[Return]` pour passer des résultats à l'appelant.
Réservez `Set Suite Variable` et `Set Global Variable` pour des cas où le partage d'état est explicitement nécessaire, en étant conscient des implications sur la maintenabilité.

Une bonne gestion de la portée des variables contribue à créer des tests plus isolés, plus prévisibles et donc plus fiables.

◄ Précédent Suivant ►

く