Variables scalaires (`${MA_VARIABLE}`)

Explorez en détail les variables scalaires `${MA_VARIABLE}` dans Robot Framework : définition, utilisation, types de données et création dynamique pour des tests flexibles.

Les variables scalaires : l'unité de base pour vos données de test

Au coeur de la gestion des données dans Robot Framework se trouvent les variables scalaires. Reconnaissables à leur syntaxe distinctive `${NOM_DE_LA_VARIABLE}`, elles sont conçues pour stocker une unique valeur. Cette valeur peut prendre diverses formes : une chaîne de caractères pour un nom d'utilisateur, un nombre pour un identifiant, une valeur booléenne pour un indicateur d'état, ou même l'absence de valeur représentée par `${None}`. La simplicité de leur déclaration et de leur utilisation en fait un outil fondamental pour quiconque souhaite écrire des tests automatisés qui soient à la fois dynamiques et faciles à maintenir.

L'objectif principal de l'utilisation des variables scalaires est d'éviter le "codage en dur" (hardcoding) des valeurs directement dans les étapes de vos tests. En centralisant vos données dans des variables, vous gagnez en flexibilité : si une donnée change (par exemple, une URL de test ou un mot de passe par défaut), il vous suffit de la mettre à jour à un seul endroit, dans la définition de la variable, plutôt que de la chercher et la remplacer dans de multiples cas de test.

Ce sous-chapitre se concentrera sur la définition, les types de données courants, l'utilisation pratique et la création dynamique des variables scalaires, illustrant leur rôle essentiel dans la construction de scénarios de test robustes et adaptables.

Définition et syntaxe des variables scalaires

La manière la plus courante de définir des variables scalaires est au sein de la section `*** Variables ***` de vos fichiers Robot Framework (`.robot` ou `.resource`). La syntaxe est directe : le nom de la variable, encadré par `${` et `}`, est suivi par au moins deux espaces, puis par sa valeur.

Syntaxe de base :

*** Variables ***
${URL_APPLICATION}    https://mon-site-de-test.com
${LOGIN_STANDARD}     utilisateur_test
${MOT_DE_PASSE_STD}   P@$$wOrd123!
${PORT_API}           8080
${DELAI_ATTENTE}      15s  # Les unités de temps (s, ms, min, h) sont supportées
${MESSAGE_ERREUR}     L'opération a échoué. Veuillez réessayer.
${CHEMIN_FICHIER}     C:/Users/Testeur/Documents/donnees.csv

Le nom de la variable peut contenir des lettres, des chiffres et des underscores (`_`). Bien que Robot Framework soit insensible à la casse pour les noms de variables (c'est-à-dire que `${mavariable}` et `${MaVariable}` font référence à la même variable), il est de bonne pratique d'adopter une convention cohérente, comme l'utilisation de majuscules avec des underscores (`ALL_CAPS_WITH_UNDERSCORES`) pour les constantes, ou le CamelCase (`maVariableScalaire`) pour d'autres usages.

Lorsque vous utilisez une variable dans vos cas de test ou keywords, vous employez la même syntaxe `${NOM_DE_LA_VARIABLE}`. Robot Framework remplacera alors cette expression par la valeur stockée dans la variable au moment de l'exécution.

*** Test Cases ***
Accéder à l'application et se loguer
    Open Browser         ${URL_APPLICATION}    chrome
    Input Text           id:username          ${LOGIN_STANDARD}
    Input Password       id:password          ${MOT_DE_PASSE_STD}
    Click Button         id:login_button
    Page Should Contain  Bienvenue, ${LOGIN_STANDARD}

Dans cet exemple, `${URL_APPLICATION}`, `${LOGIN_STANDARD}` et `${MOT_DE_PASSE_STD}` seront remplacées par leurs valeurs respectives lors de l'exécution des keywords `Open Browser`, `Input Text`, et `Input Password`.

Types de données courants pour les variables scalaires

Bien que Robot Framework traite de nombreuses variables comme des chaînes de caractères par défaut, il est capable de reconnaître et de travailler avec plusieurs types de données sous-jacents, notamment grâce à l'intégration avec Python. Voici les types les plus courants pour les variables scalaires :

Chaînes de caractères (Strings) : Le type le plus fréquent. Toute séquence de caractères. Si votre chaîne contient des espaces significatifs au début ou à la fin, ou si elle est vide, il est parfois utile d'utiliser le keyword `Set Variable` ou de s'assurer que la syntaxe est bien interprétée.
```
*** Variables ***
${NOM_COMPLET}      Jean Dupont
${VILLE}            Paris
${CHAINE_VIDE}      ${EMPTY}  # ${EMPTY} est une variable BuiltIn pour une chaîne vide
${ESPACES_AUTOUR}   ${{'  espaces  '}} # Forcer l'interprétation comme chaîne avec espaces
```
Nombres (Entiers et Flottants) : Les nombres peuvent être définis directement. Robot Framework essaiera de les convertir en types numériques appropriés lorsque nécessaire (par exemple, avec des keywords comme `Should Be Equal As Numbers`).
```
*** Variables ***
${AGE_UTILISATEUR}    30
${PRIX_ARTICLE}       19.99
${QUANTITE}           -5   # Les nombres négatifs sont permis
```
Booléens (Booleans) : Les valeurs booléennes vraies ou fausses. Elles sont définies en utilisant les variables spéciales `${True}` et `${False}`.
```
*** Variables ***
${EST_ADMIN}          ${True}
${MODE_DEBUG_ACTIF}   ${False}
```
L'utilisation de `${True}` (avec un T majuscule) assure que la variable contient la valeur booléenne Python `True`, et non la chaîne de caractères "True".
None (Aucune valeur) : Représente l'absence de valeur, similaire à `null` dans d'autres langages. Définie avec la variable spéciale `${None}`.
```
*** Variables ***
${RESULTAT_OPTIONNEL}    ${None}
```
Variables d'environnement : Vous pouvez accéder aux variables d'environnement du système en utilisant la syntaxe `%{NOM_VARIABLE_ENV}`. Elles sont traitées comme des variables scalaires.
```
*** Test Cases ***
Afficher le chemin utilisateur
    Log    Le répertoire utilisateur est : %{USERPROFILE}  # Sur Windows
    Log    Ou : %{HOME} # Sur Linux/macOS
```

Il est important de noter que lors des comparaisons ou des opérations, Robot Framework peut tenter des conversions de type. Par exemple, si vous comparez `${AGE_UTILISATEUR}` (qui vaut 30) avec la chaîne "30" en utilisant `Should Be Equal`, la comparaison peut réussir car Robot Framework essaie d'être flexible. Cependant, pour des comparaisons strictes de type, ou pour des opérations numériques, il est préférable d'utiliser des keywords spécifiques comme `Should Be Equal As Integers` ou `Convert To Integer`.

Création et modification dynamiques de variables scalaires

Outre la définition statique dans la section `*** Variables ***`, les variables scalaires peuvent être créées ou leur valeur peut être modifiée pendant l'exécution d'un test ou d'un keyword. Cela se fait principalement à l'aide de keywords de la librairie `BuiltIn`.

Le keyword le plus fondamental pour cela est `Set Variable` :

*** Test Cases ***
Création dynamique de variable
    ${nom_produit}    Set Variable    Mon Super Produit
    Log    Le nom du produit est : ${nom_produit}

    ${timestamp}    Get Time    epoch    # Récupère le timestamp actuel
    ${id_unique_transaction}    Set Variable    TRANS_${timestamp}
    Log    ID de transaction généré : ${id_unique_transaction}

La portée par défaut d'une variable créée avec `Set Variable` est locale au keyword ou au cas de test où elle est définie. Pour des portées différentes, Robot Framework propose :

`Set Test Variable` : Crée une variable accessible n'importe où dans le cas de test courant. Si une variable du même nom existe déjà au niveau du test, sa valeur est écrasée pour ce test uniquement.

*** Test Cases ***
Utilisation de Set Test Variable
    Set Test Variable    ${CODE_CLIENT}    CLI007
    Effectuer Action Client
    Vérifier Résultat Client

*** Keywords ***
Effectuer Action Client
    Log    Action pour le client : ${CODE_CLIENT}

Vérifier Résultat Client
    Log    Vérification pour le client : ${CODE_CLIENT}

`Set Suite Variable` : Crée une variable accessible dans toute la suite de tests où elle est définie (y compris dans les `Suite Setup` et `Suite Teardown`, et dans tous les cas de test et keywords de cette suite).

*** Settings ***
Suite Setup    Initialiser Données de Suite

*** Test Cases ***
Test 1 utilisant variable de suite
    Log    Donnée partagée de suite : ${DONNEE_COMMUNE_SUITE}

Test 2 utilisant variable de suite
    Should Be Equal    ${DONNEE_COMMUNE_SUITE}    valeur_initiale_suite

*** Keywords ***
Initialiser Données de Suite
    Set Suite Variable    ${DONNEE_COMMUNE_SUITE}    valeur_initiale_suite

`Set Global Variable` : Crée une variable avec une portée globale, accessible depuis n'importe quelle suite de tests, cas de test ou keyword pendant toute la session d'exécution. Son utilisation doit être limitée pour éviter de rendre les tests trop interdépendants et difficiles à déboguer.

Les variables scalaires sont également souvent le résultat de keywords qui retournent une valeur. Lorsqu'un keyword retourne une seule valeur, vous l'assignez à une variable scalaire :

*** Test Cases ***
Récupérer et utiliser une valeur retournée
    ${element_text}    Get Text    id:message_important
    Should Contain    ${element_text}    Succès    Le message devrait indiquer un succès.

    ${nombre_elements}    Get Element Count    xpath=//ul/li
    Log    Il y a ${nombre_elements} éléments dans la liste.

En maîtrisant la définition, les types et la création dynamique des variables scalaires, vous disposez d'un outil puissant pour rendre vos tests Robot Framework plus flexibles, plus lisibles et plus robustes face aux changements.

◄ Précédent Suivant ►

く