Les tests logiciels, qu'ils soient manuels ou automatisés, nécessitent des conditions initiales, des étapes d'exécution, des résultats observés et des résultats attendus. L'exactitude d'une fonctionnalité est confirmée uniquement lorsque les résultats observés correspondent aux résultats attendus. Dans la création de scripts de test automatisés, il est crucial non seulement d'exécuter les étapes, mais aussi de vérifier que chaque action produit l'effet escompté. Sans comparaison entre résultats observés et attendus, un cas de test est invalide. Lors des tests automatisés via Appium, le framwork unittest fournit des mécanismes d'assertion dans sa classe TestCase, permettant de valider l'état des données et des contrôles de l'interface.

Les assertions dans unittest se classent en quatre catégories principales :

Assertions booléennes

Elles vérifient une condition vraie ou fausse.

import unittest

class TestAssertions(unittest.TestCase):

    def test_vérification_positive(self):
        valeur = 15
        # Vérifie que la condition est vraie
        self.assertTrue(valeur > 10)

    def test_vérification_négative(self):
        valeur = 15
        # Vérifie que la condition est fausse
        self.assertFalse(valeur <= 10)

if __name__ == '__main__':
    unittest.main()

Assertions de comparaison

Elles comparent des valeurs, utiles pour vérifier des textes, messages, présence d'éléments ou états de contrôles dans l'application.

Vérification du texte dans l'application :

    def test_vérifier_texte_article(self, contenu_article):
        self.naviguer_vers_article()
        self.publier_article(contenu_article)
        sleep(3)
        # Clique sur le bouton "communauté" en haut à gauche
        self.pilote.find_element(*self.localisateurs.accueil_communauté.communautés).click()
        try:
            # Extrait les 5 premiers caractères de l'article attendu
        attendu = contenu_article[0:5]
            # Texte du premier article dans la communauté
            observé = self.pilote.find_element(*self.localisateurs.accueil_communauté.premier_article).text
            cinq_caractères = observé[0:5]
            # Compare les valeurs
            self.assertEqual(attendu, cinq_caractères)
        except AssertionError as erreur:
            print("Échec de l'assertion", erreur)

Vérification de la présence d'un élément :

    def est_élément_présent(self, méthode, identifiant):
        """
        Détermine si un élément existe.
        :param méthode: Mode de localisation
        :param identifiant: Valeur de l'attribut de l'élément
        :return: True si l'élément existe, False sinon
        """
        try:
            self.pilote.find_element(méthode, identifiant)
            return True
        except NoSuchElementException:
            return False

Assertions complexes

Moins courantes, elles vérifient des structures comme des listes ou tuples.

Assertions d'exceptions

Elles valident que des méthodes lèvent des exceptions spécifiques.

    def test_exception_élément_introuvable(self):
        # Attend une exception pour l'élément "salut"
        with self.assertRaises(NoSuchElementException):
            self.pilote.find_element(MobileBy.ID, "salut")

    def test_exception_division_par_zéro(self):
        # Attend une exception de division par zéro
        with self.assertRaises(ZeroDivisionError):
            1 / 0