• Comprendre la différence entre tests unitaires, d’intégration, fonctionnels et de performance.
• Savoir écrire et exécuter des tests avec un framework (en Java avec JUnit / en PHP avec PHPUnit).
• Prendre conscience de l’importance de l’automatisation et des bonnes pratiques de validation.

Vous travaillez pour une startup qui développe une application de gestion de bibliothèque. L’application doit permettre :

• La gestion d’un catalogue de livres.
• L’ajout et la suppression d’utilisateurs.
• La gestion des emprunts (règle : un utilisateur ne peut pas emprunter plus de 3 livres).

Vous allez développer et tester progressivement ce projet.

1. récupérer le projet sur gitea

1. Étudier les classes fournies (Livre, Utilisateur).
2. exécuter les tests existants / être capable de les expliquer
3. Compléter les méthodes manquantes (ex. calcul du prix TTC d’un livre, ajout d’un livre dans la liste d’un utilisateur).

1. Écrire des tests unitaires avec JUnit pour :
   1. vérifier les méthodes de la classe Utilisateur
   2. Vérifier le calcul du prix TTC.
   3. Vérifier que l’ajout d’un livre à un utilisateur fonctionne.
   4. Ajouter au moins 2 tests supplémentaires par classe pour couvrir des cas limites (ex. : emprunter plus de 3 livres, prix négatif, etc.).
2. Exécuter les tests et corriger les bugs si nécessaire.

Les tests d'intégration : Vous aller vérifier que plusieurs composants du système fonctionnent correctement ensemble.

Contrairement aux tests unitaires qui testent une seule classe/méthode, le test d’intégration vérifie la collaboration entre classes.

1. Tester qu’un utilisateur peut emprunter un livre uniquement si :
   • le livre n’est pas déjà emprunté
   • l’utilisateur a moins de 3 emprunts
2. Vérifier que l’état du livre et la liste des emprunts de l’utilisateur sont correctement mis à jour.

Un test unitaire est un test automatisé écrit en même temps, voire même avant le programme lui même. Il ne valide qu'une portion très réduite du code source (par exemple certaines méthodes d'une seule classe). Il permet de vérifier le bon fonctionnement d'une partie spécifique d'une application. (Une unité = un module, une classe, une méthode …).

Les tests unitaires vont permettre d'apporter une réponse à 3 problèmes récurrents :

• Problème de coordination entre développeurs

Une application est souvent réalisée par plusieurs développeurs qui travaillent en parallèle sur une base de code commune. il est fréquent que des modifications effectuées par un programmeur entrainent à son insu des dysfonctionnements sur d'autres parties du code que la sienne. Les autres programmeurs constatent alors avec surprise que leurs parties du projet ne fonctionnent plus, sans qu'ils aient modifié quoi que ce soit au code. En pratique, ces “effets de bord” néfastes constituent souvent les erreurs les plus frustrantes et les plus difficiles à résoudre dans le cycle de développement logiciel.

• Problème de maintenance

En entreprise, la fin du codage initial ne signifie pas la fin du projet : il y aura forcément des bugs à corriger, des améliorations demandées par le client, des modifications, etc. Il n'est pas rare que la durée de vie couvre plusieurs années au-delà de son développement initial. Les tests permettront de vérifier que le programme fonctionne toujours après une modification.

• Besoin de rassurer le client

Aucun client n'acceptera de payer un logiciel sans savoir s'il fonctionne correctement.

Le principe des tests unitaires est le suivant : au lieu d'effectuer des tests de façon intuitive en exécutant le programme selon divers paramètres ou d'écrire isolément des morceaux de code de test non réutilisables, on ajoute au projet une série de tests automatisés ciblant chacun une partie précise du projet.

Si toutes les parties essentielles du code source sont validées par des tests unitaires, alors le projet global a de bonnes chances de fonctionner correctement.

Les tests unitaires sont montrables au client souhaitant faire des vérifications.

De plus, les tests unitaires étant toujours à disposition, ils permettront de valider facilement et rapidement toute modification apportée ultérieurement au code source, ce qui évite l'introduction de nouveaux bugs dans le projet.