Erreurs, exceptions et tests

Erreurs, exceptions et tests

1. Exceptions

   Un programme échoue : on ne supprime pas l'erreur, on la traite au bon endroit. try/except sert à anticiper un échec attendu, pas à tout attraper.

   def lire_nombre():
       saisie = input("Un nombre : ")
       try:
           return int(saisie)
       except ValueError:
           print("Ce n'est pas un nombre entier, recommencez.")
           return None

   Capter juste ce qui peut échouer

   # TROP LARGE : masque les vraies erreurs de logique
   try:
       traitement(utilisateur)
   except Exception:
       pass
   
   # JUSTE : on ne traite que l'échec prévu
   try:
       resultat = 10 / diviseur
   except ZeroDivisionError:
       resultat = None

   Lever, propager, documenter

   def retirer(compte, montant):
       if montant <= 0:
           raise ValueError("le montant doit être positif")
       if montant > compte.solde:
           raise ValueError("solde insuffisant")
       compte.deposer(-montant)

   raise signale une situation impossible à contourner. Dans une bibliothèque, on laisse remonter l'exception : l'appelant décidera.

   finally et gestionnaires de contexte

   fichier = None
   try:
       fichier = open("data.txt", encoding="utf-8")
       contenu = fichier.read()
   except FileNotFoundError:
       print("fichier absent")
   else:
       print(f"{len(contenu)} caractères")
   finally:
       if fichier is not None:
           fichier.close()

   En pratique, le with remplace ce try/finally et gère aussi l'echec. Et un objet qui se ferme tout seul peut être écrit avec __enter__ et __exit__.

   Créer sa propre exception

   class SoldeInsuffisant(Exception):
       def __init__(self, manquant: float):
           self.manquant = manquant
           super().__init__(f"il manque {manquant:.2f}")

2. Tests automatisés

   Un test vérifie une seule chose et échoue clairement. La bibliothèque standard unittest suffit, sans dépendance supplémentaire.

   import unittest
   
   class TestCompteBancaire(unittest.TestCase):
   
       def setUp(self):
           # exécuté avant chaque test : on repart d'un état propre
           self.compte = CompteBancaire("Alice", 100.0)
   
       def test_depot_ajoute_au_solde(self):
           self.compte.deposer(50.0)
           self.assertEqual(self.compte.solde, 150.0)
   
       def test_montant_negatif_refuse(self):
           self.assertFalse(self.compte.deposer(-10.0))
           self.assertEqual(self.compte.solde, 100.0)
   
       def test_solde_vide_leve_une_erreur(self):
           with self.assertRaises(ValueError):
               moyenne([])

   Les assertions utiles

   • assertEqual, assertTrue, assertIs (identité, pour None)
   • assertIn, assertAlmostEqual pour les flottants
   • assertRaises quand on attend une erreur

   Ce qui rend un test utile

   1. Un nom qui dit ce qui est vérifié (test_montant_negatif_refuse).
   2. Un seul comportement par test : sinon le diagnostic est impossible.
   3. Les cas limites : vide, zéro, négatif, accents, très grand nombre d'éléments.

   Exécuter

   python -m unittest discover -v
   python -m unittest tests.test_calculs

3. Exercices

   1. Conversion sécurisée : écrivez vers_entier(texte) qui renvoie un entier ou None, et n'utilisez jamais except: seul.
   2. Tester avant de corriger : écrivez trois tests qui échouent sur la version actuelle d'une de vos fonctions, puis corrigez-la. C'est l'ordre professionnel : on ne corrige pas à l'aveugle.
   3. Contexte personnalisé : écrivez une classe Fichier utilisable avec with, qui ouvre le fichier et le ferme automatiquement.