Tests automatisés / unitaires 🧪
À la fin de la séance, tu seras capable de :
- écrire un prompt qui permet à une IA de générer des tests unitaires utiles;
- exécuter ces tests et juger s'ils sont pertinents;
- corriger ou compléter les tests quand l'IA se trompe.
- Lire la capsule théorique.
- Commencer les exercices de la semaine. Arrêter après 2 heures de travail.
- Vérifier que vous avez activé le Pack Éducation
- Installer le plugin GitHub Copilot dans IntelliJ et Android Studio (un peu de recherche sur Google)
- Activer votre Copilot Pro
- Compléter les exercices de la semaine
- Continuer le troisième travail
Tests unitaires (rappel)
Comme nous l'avons vu plus tôt cette session, un test unitaire est un petit programme qui appelle une méthode et vérifie que le résultat est celui attendu. Nous avons également vu qu'un plan de test est nécessaire pour identifier les cas représentatifs qui permettent de vérifier les comportements importants d'une méthode.
Jusqu'ici, vous avez écrit vos tests manuellement. Vous ne serez pas surpris d'apprendre qu'une IA peut maintenant les écrire en quelques secondes. Par contre, elle ne connaît pas votre projet comme vous. Par moment, elle en devine certains bouts, et c'est votre responsabilité de vérifier ce qu'elle produit. Votre plan de test vous sera d'ailleurs utile pour juger si les cas qu'elle propose sont suffisants !
Écrire un "bon" prompt
En règle générale, plus votre prompt est précis, moins l'IA sera portée à inventer. Voici quelques principes clés à incorporer dans votre prompt :
| Principe | Pourquoi | Exemple |
|---|---|---|
| 1. Donnez le code source | Sans le code source, l'IA se mettra à inventer | Collez votre service, le lien vers le DAO, le squelette de la classe de tests |
| 2. Précisez le contexte technique | Sinon l'IA choisira au hasard ses outils | Android Studio, Kotlin, JUnit 4, le dossier androidTest |
| 3. Exigez des cas variés | Un seul test normal n'est pas suffisant... | Cas normal, cas limites, cas d'erreur |
| 4. Fixez le format de la réponse | La réponse sera plus facile à lire et à copier ! | L'ordre Arrange - Act - Assert, des noms de tests clairs |
| 5. Avancez par petites étapes | Cela vous permettra de vérifier progressivement le travail de l'IA... et de garder un sentiment de contrôle | Demandez à l'IA de tester 2 ou 3 méthodes à la fois, pas tout en même temps |
| 6. Demandez les hypothèses | Vous pourrez voir les suppositions de l'IA | « Liste tes hypothèses à la fin » |
- Cas normal : une utilisation correcte (ex. ajouter un sujet de 20 caractères)
- Cas limite : à la frontière de ce qui est permis (ex. un sujet de 5 caractères)
- Cas d'erreur : une utilisation incorrecte qui doit lever une exception (ex. un sujet vide)
Exemple de prompt
Contexte :
- Projet Android Studio, Kotlin
- Tests dans androidTest, avec JUnit 4
Voici mon service :
<colle ici le service au complet>
Voici le DAO et les classes de la librairie :
<colle ici SujetVoteDAO, Sujet, Vote>
Voici les exceptions :
<colle ici tes exceptions>
Voici un squelette de la classe de tests :
<colle ici la classe de tests>
Tâche :
écris les tests de ces méthodes seulement :
- ajouterSujet()
- ajouterVote()
Exigences :
- Pour chaque méthode : un cas normal, au moins deux cas limites et chaque exception possible
- Noms de tests au format methode_condition_resultatAttendu
- Structure Arrange / Act / Assert avec des commentaires
- Si mon code est difficile à tester, dis-le et propose un petit changement
- À la fin, liste tes hypothèses
Valider les tests
Avant de faire confiance à un test, vérifiez ces quatre points :
- Remplacez le corps de la méthode testée par
throw UnsupportedOperationException(). Si le code n'est pas fait, le test devrait échouer. - Le test réussit quand le code fonctionne.
- Il couvre les exceptions prévues par le service.
- Il utilise la BD de test, pas celle de l'émulateur.
assertTrue(true)réussit toujours.- Un test sans
assertne vérifie rien. - L'IA devine le comportement attendu à partir du code. Si votre code contient un bug, elle peut écrire un test qui valide ce bug... soyez vigilants !
- Prenez le temps de relire chaque test proposé. Vous devez pouvoir expliquer ce qu'il vérifie et pourquoi.
- N'hésitez pas à challenger l'IA en lui demandant quels cas importants il n'a pas couvert !
- Les quotas sont limités. Écrivez un prompt complet plutôt que beaucoup de petits messages.
- Collez seulement le code utile. Pas tout le projet.
- Conversation trop longue. L'IA peut oublier le début et se mettre à halluciner. Ouvrez une nouvelle conversation et recollez votre prompt au besoin.
Exercice 0 : plan de test (max 20 min)
À partir des méthodes de ton service du TP3, élabore un premier plan de test. Ton plan n'a pas besoin d'être parfait. Le but de cet exercice est de réfléchir aux tests à inclure avant de demander quoi que ce soit à l'IA.
Exercice 1 : un premier prompt simple (max 15 min)
But : voir ce que donne un prompt sans précisions.
- Colle ce prompt dans ChatGPT, avec le code de ton service du TP3 :
ChatGPT, peux-tu me générer des tests unitaires Android pour mon service dont voici le code source [CODE SOURCE]
- Copie les tests dans ta classe de tests, dans
androidTest. - Exécute-les. Note ce qui ne compile pas ou ne fonctionne pas (classes inventées, mauvais outils, etc.).
Pour Copilot (au lieu de ChatGPT) :
- Ouvre ta classe de tests.
- Écris un commentaire
// test de la fonction xxx, puis saute une ligne. - Copilot suggère un test. Appuie sur
Tabpour l'ajouter. Note ce qui ne compile pas ou ne fonctionne pas. - Tu peux aussi utiliser Copilot Chat comme ChatGPT.
Exercice 2 : un meilleur prompt
But : appliquer les six principes et comparer avec l'exercice 1.
- Écris un nouveau prompt en t'inspirant de l'exemple de la théorie, avec ton code.
- Vérifie que ton prompt respecte les six principes.
- Exécute les tests obtenus.
- Compare avec l'exercice 1 :
- Y a-t-il moins d'erreurs de compilation?
- Y a-t-il plus de cas limites et d'exceptions?
- Les hypothèses listées par l'IA étaient-elles justes?
- Compare les tests proposés à ceux identifiés dans ton plan de test :
- L'IA a-t-elle omis des tests pertinents que tu avais identifié ?
- L'IA a-t-elle identifié des cas pertinents auxquels tu n'avais pas pensé ?
- L'IA a-t-elle suggéré des modifications à ton code source ? Sont-elles pertinentes ?
Exercice 3 : est-ce que l'IA a fait une bonne job?
Partie A : les 4 points de validation
Vérifie les quatre points de la section « Valider les tests » avec les tests obtenus à l'exercice 2.
Partie B : les cas limites
L'IA a-t-elle couvert les cas limites suivants :
- un vote avec un id qui ne correspond à rien
- un nom de votant de 4000 caractères
- un contenu de sujet de 4000 caractères
- pensez-vous à d'autres cas limites ?
Partie C : un test à améliorer
Admettons qu'on remplace le code de ajouterSujet par le code suivant :
fun ajouterSujet(contenu: String) : Long{
val sujet = Sujet()
sujet.contenu = contenu
val id = dao.ajouterSujet(sujet) // retourne l'id du sujet ajouté
// validation du contenu
if (contenu.length == 0){
throw TexteVideException()
}
if (contenu.length < 5){
throw TexteCourtException()
}
val existant : Optional<Sujet> = dao.sujetParContenu(contenu)
if (existant.isPresent){
throw DejaPresentException()
}
return id
}
- Est-ce que tes tests passent avec ce code ?
- Est-ce que le code est ok ?
(Optionnel) Exercice 4 : retour sur le TP1
En partant de ton code du TP1, crée des tests unitaires pour les différents méthodes. Tu peux utiliser un assistant IA pour t'aider à produire tes tests.
Cela n'est possible que si tu avais découpé ton code en méthodes pendant la séance du refactoring.