Les assertions : valider les résultats attendus (`Should Be...`, `Page Should Contain...`)

L'importance cruciale des assertions dans les tests automatisés

Dans le domaine de l'automatisation des tests, une assertion est l'instruction qui vérifie si une condition spécifique est vraie. Sans assertions, un script de test ne ferait qu'exécuter une série d'actions sans jamais confirmer si l'application se comporte comme attendu. Les assertions sont donc le coeur de la validation : elles transforment une simple exécution de scénario en un véritable test capable de détecter des régressions ou des anomalies. Robot Framework propose une panoplie de keywords dédiés à cette tâche, permettant de réaliser des vérifications précises et variées.

L'objectif d'une assertion est de comparer un résultat actuel, observé lors de l'exécution du test, à un résultat attendu, défini au préalable. Si la comparaison est positive (la condition est vraie), l'assertion passe et le test continue. Si la comparaison est négative (la condition est fausse), l'assertion échoue, ce qui entraîne généralement l'échec du test case et signale un problème potentiel dans l'application testée ou dans le script de test lui-même. Une bonne stratégie d'assertion est donc essentielle pour la fiabilité de votre suite de tests.

Il est primordial de choisir des assertions qui sont à la fois significatives et robustes. Une assertion trop vague pourrait laisser passer des erreurs, tandis qu'une assertion trop stricte ou dépendant d'éléments volatiles (comme des identifiants dynamiques mal gérés) pourrait entraîner des échecs intempestifs (faux positifs). L'équilibre réside dans la sélection de points de contrôle pertinents qui reflètent fidèlement le comportement attendu de la fonctionnalité testée.

Les keywords `Should Be...` : vérifications fondamentales d'égalité et d'état

La famille de keywords commençant par `Should Be...` est fournie principalement par la librairie `BuiltIn` de Robot Framework. Ces keywords sont utilisés pour effectuer des comparaisons directes et des vérifications d'état. Ils constituent la base de nombreuses validations.

Voici quelques-uns des keywords `Should Be...` les plus couramment utilisés :

• Should Be Equal / Should Be Equal As Strings / Should Be Equal As Integers / Should Be Equal As Numbers : Ces keywords comparent deux valeurs pour vérifier leur égalité. Il est important de choisir la version la plus appropriée en fonction du type de données que vous comparez (chaînes de caractères, entiers, nombres à virgule flottante).
  

  ${variable_obtenue} =    Get Text    id=mon_element
  Should Be Equal As Strings    ${variable_obtenue}    Texte Attendu

• Should Not Be Equal : L'inverse de Should Be Equal, vérifie que deux valeurs sont différentes.
• Should Be True / Should Be False : Evalue une condition booléenne. Utile pour vérifier le résultat d'opérations logiques ou l'état d'indicateurs.
  

  ${element_est_visible} =    Run Keyword And Return Status    Element Should Be Visible    id=bouton_optionnel
  Should Be True    ${element_est_visible}    Le bouton optionnel devrait être visible.

• Should Be Empty / Should Not Be Empty : Vérifie si une variable, une chaîne de caractères ou une liste est vide ou non.
  

  @{liste_resultats} =    Obtenir Les Résultats De Recherche
  Should Not Be Empty    ${liste_resultats}    La recherche devrait retourner des résultats.

• Should Be Type : Vérifie qu'une variable est d'un type Python spécifique (par exemple, `string`, `integer`, `list`).

Ces keywords sont la première ligne de défense pour s'assurer que les valeurs individuelles et les états simples de votre application correspondent à vos attentes. Ils sont souvent utilisés pour valider le contenu de variables, les résultats de calculs ou les propriétés basiques d'éléments.

Les keywords `...Should Contain...` et `Page Should Contain...` : valider la présence de contenu

Lorsqu'il s'agit de vérifier la présence de contenu, que ce soit dans une chaîne de caractères, une liste, ou directement sur une page web, les keywords contenant `...Should Contain...` sont particulièrement utiles. Ils permettent de s'assurer que des informations clés sont présentes là où elles devraient l'être.

Principaux keywords de cette catégorie :

• Should Contain (de la librairie `BuiltIn`) : Ce keyword polyvalent vérifie si une chaîne de caractères contient une sous-chaîne, ou si une liste contient un élément spécifique.
  

  ${message_erreur} =    Get Text    css=.error-message
  Should Contain    ${message_erreur}    Veuillez remplir tous les champs obligatoires.    ignore_case=True

• Should Not Contain (de la librairie `BuiltIn`) : S'assure qu'une chaîne ou une liste ne contient pas un élément donné.

Pour les tests d'applications web, la librairie `SeleniumLibrary` (ou des librairies similaires pour d'autres types d'interfaces) enrichit considérablement les possibilités d'assertion de contenu :

• Page Should Contain : C'est l'un des keywords les plus utilisés en test web. Il vérifie que le texte spécifié est présent quelque part sur la page web actuellement chargée dans le navigateur. C'est un moyen rapide et efficace de confirmer que des informations importantes sont affichées à l'utilisateur.
  

  Login    utilisateur_test    motdepasse123
  Page Should Contain    Bienvenue, utilisateur_test !

• Page Should Not Contain : Vérifie que le texte spécifié n'est PAS présent sur la page. Utile pour s'assurer que des messages d'erreur ont disparu après une action corrective, par exemple.
• Page Should Contain Element : Plus spécifique que Page Should Contain, ce keyword vérifie la présence d'un élément web identifié par un sélecteur (ID, XPath, CSS, etc.). Il ne vérifie pas le contenu textuel de l'élément, mais son existence dans le DOM.
  

  Page Should Contain Element    id=bouton_de_confirmation

• Element Should Contain : Vérifie que le texte d'un élément web spécifique (identifié par un sélecteur) contient le texte attendu.
  

  Element Should Contain    xpath=//h1    Mon Panier

• Element Text Should Be : Similaire à `Element Should Contain`, mais vérifie que le texte de l'élément correspond exactement au texte attendu (et pas seulement qu'il le contient).

L'utilisation combinée de ces différents types d'assertions permet de construire des vérifications complètes et fiables. Par exemple, après avoir soumis un formulaire, vous pourriez utiliser `Page Should Contain` pour vérifier un message de succès global, puis `Element Should Contain` pour vérifier que des données spécifiques ont été correctement affichées dans un tableau de résultats, et enfin `Should Be Equal` pour comparer une valeur calculée avec une référence. La clé est de choisir l'assertion la plus appropriée et la plus précise pour chaque point de contrôle de votre scénario.