Module 4 - Le coeur du réacteur by Benoit Gantaume

Module 4 - Le coeur du réacteur

Niveau 4 : écrire des tests unitaires

Tu le sais déjà...

Les tests unitaires, c’est important.
Et pourtant tu n’en n’écris pas. 
Ca fait peut-être même parti de ta ‘définition de terminé’, la règle dans le SCRUM qui dit quand tu as fini une story. Mais en réalité personne n'en n'écrit vraiment.

Peut-être même que tu te dis des trucs comme : 
« Au fond à quoi bon ? »
« Est-ce vraiment utile ? »
« Est-ce fait pour moi ? Je suis pas convaincu »
« Après tout, je m’en sors très bien sans jusqu’à maintenant »
Ah oui ? Vraiment ? 
Si ton code ne contient pas de bug, que tu es zen comme Bouddha à la fin de sa méditation quand tu mets en production, que tu gardes une vitesse de développement véloce, si t’as tout ça sans avoir besoin d’écrire de tests unitaires, tu peux fermer cette page et retourner dans la matrice.

Mais si comme beaucoup de développeurs que je connais tu n’écris pas vraiment de tests et :
  • Tu as des bugs dans ton application. Et oui je sais, en 2019 ça existe encore les bugs...
  • Tu fêtes une mise en production à grand renfort de sucre et d’alcool car tu viens d’accomplir un exploit.
  • Tu gaspilles du temps à comprendre pourquoi ce que tu viens d’écrire ne marche pas.
  • Tu utilises un debugger au quotidien. 
  • Tu as des sueurs froides en écoutant ton client te parler de sa prochaine idée qui va déchirer rien qu’en pensant à l’implémentation
  • T’as la boule au ventre le matin en venant bosser alors que tu aimes ton travail
  • Tu passes un temps de dingue à faire du support et régler les problèmes en urgence.
  • T’as peur de refactorer ton code car tu sais pas si tu vas pas casser un truc.

Alors j’ai un quelque chose pour toi.

LE truc essentiel

Les tests unitaires c’est pas un truc important.
C’est LE truc fondamental. C’est la base de ta stratégie de tests.

Avec des tests, tu éradiques les bugs, t’es ultra zen, tu peux refactorer ton code à volonté et en continu.

Les tests unitaires, c’est le premier pas vers un monde épanouïssant. Et oui, le monde des bisounours existe.

Les tests, c’est la vie du code !

Dans ce module, je t’apprends à écrire tes premiers tests unitaires. Je t’explique pourquoi tester c’est douter (je veux dire vraiment), quels sont les différents types de test, comment structurer un test et quels sont les critères d’un bon test. On aborde aussi la dimension psychologique qui joue un rôle essentiel dans l'adoption de cette pratique. Le tout illustré avec notre bon vieux kata greetings qui nous accompagne depuis le début du cursus.
On y parlera bien sûr TDD qui est pour moi la seule manière d’écrire des tests valables.

Mon objectif est que tu sois en capacité d’écrire tes premiers tests d’ici la fin du module. 

Des tests ou des chèvres !

Tu peux prendre le cursus en cours de route et commencer par ce module, mais il vaut mieux avoir suivi les autres d’abord : la pédagogie en escalator ne fonctionne que si tu suis la progression.

La pédagogie en escalator c'est quand il y a un double effet : 
  • Ecrire des tests, c'est difficile, on va pas se le cacher. La courbe d'apprentissage est raide. Donc j'ai découpé en étapes progressives pour rendre ça accessible. D'où les différents modules en escalier.
  • La progression en douceur donne confiance et te gonfle à bloc de motivation pour attaquer des problèmes de plus en plus difficiles. C'est le moteur de l'escalator.
Je crois tellement en cette pédagogie en escalator que si tu as suivi ce cursus depuis le premier module, je te garantie que tu auras écrit tes premiers tests d’ici la fin de cette formation.
Si ce n’est pas le cas, j’exige que tu m’écrives pour me dire sur quoi tu bloques. Si tu n’as pas écrit le moindre test unitaire après notre échange, je te rembourse et je m’en vais élever des chèvres en Ardèche.

Tu pourrais me dire que c’est trop simple. Qu’écrire UN test unitaire, c'est facile.
Je ne suis pas d’accord. C’est comme mettre en route un moteur : le premier tour est celui qui consomme le plus d’énergie.
Le premier test est le plus difficile à écrire.
C’est le plus dur car il t’oblige à dépasser tes croyances limitantes, à prendre un risque en sortant de ta zone de confort. A accepter que tu fais peut-être fausse route depuis tant d’années.
Et puis il faut bien commencer quelque part : un voyage de mille lieues commence par un premier pas. C’est Lao Tseu qui disait ça. Enfin il paraît. A vrai dire je l’ai jamais entendu parler ce monsieur. Mais ça fait sérieux de citer un vieux sage Chinois. Et puis en plus il dit des trucs sensés.

Bienvenue dans le monde réel

Avec les tests unitaires tu pourras :
  • Éradiquer les bugs dans ton application
  • Mettre en prod comme tu mettrais une chemise propre
  • Passer plus de temps à créer de la valeur que jouer à l’archéologue
  • Supprimer le debugger de ton quotidien
  • Innover en permanence et prendre 3 longueurs d’avance sur la concurrence
  • Venir le matin au boulot avec un sourire insolent
  • Bâtir sereinement une application durable
  • Refactorer ton code en continu pour l’améliorer

Tu n'es pas obligé de me croire sur parole : essaie, tu ne risques rien. Si tu n'es pas convaincu, tu as 30 jours te faire rembourser.

Alors si t’as décidé de mettre en place des tests unitaires dans ton projet, c’est ici que ça commence.

Vous allez recevoir :

Video Icon 13 vidéos File Icon 9 des dossiers

Contenu

Module 4 - Mind Map
66,2 ko
1. Introduction
2 min
2. Tester, c'est douter
8 min
3. Les différents types de tests
5 min
4. La famille xUnit
6 min
5. La structure d'un test
10 min
6. Des tests FIRST
7 min
7. Quelques conseils pour commencer
15 min
8. Le cycle TDD
11 min
9. Kata chiffres romains
25 min
10. La clef - le feedback
8 min
11. Utiliser des bouchons
9 min
12. Screencast Utilisation d'un bouchon
10 min
13. Conclustion
1 min
Module 4 - Quizz & Exercice
50,4 ko
Feedback sur ce module
Automatiser ses tests avec JUnit - Chapitre 5.pdf
544 ko
Bonjour.pdf
22,6 ko
Chiffres Romains.pdf
27 ko
Jeu du bowling.pdf
27,9 ko
Kata Potter.pdf
23,5 ko
Pile d'entier.pdf
20,2 ko

Le cursus Artisan Développeur

Le cursus complet se découpe en 8 modules :
  1. Les trois clefs d’une conception durable
  2. Ranger chaque objet à sa juste place
  3. Dompter les dépendances 
  4. Le coeur du réacteur (ce module)
  5. Reprendre le pouvoir
  6. La fin des bugs
  7. Quality gate
  8. Communiquer avec le métier
Pour l'instant seuls les modules 1, 2,  3 et 4 sont disponibles. 

Ce cursus est le fruit de dizaines d’heures de travail, de centaines d’heures de lectures, de milliers d’heures d’expérience accumulées pendant 18 ans de carrière.
Alors tu as le choix entre lire des tonnes de livres et tâtonner pendant des années, ce qui est une bonne option, ou alors tu n’as pas ce temps et tu veux un condensé structuré que tu vas directement pouvoir mettre en oeuvre.

Tu peux acheter chaque module indépendamment : mon objectif est de permettre au plus grand nombre d'y accéder à son rythme.
Ce module de formation correspond au quatrième module du cursus. Si tu ne le découvres que maintenant, je t’invite à commencer par le premier module !

Ton formateur

Benoit Gantaume est tombé dans la marmite de la startup depuis l’école d’ingénieur. Les startups sont des environnements particulièrement exigeants sur la vélocité et la capacité d’adaptation. Cela se traduit par des changements de directions fréquents qu’il faut savoir gérer pour garder une base de code saine. C’est avant tout son expérience qu’il partage dans ses écrits sur artisandeveloppeur.fr, son livre sur 'JUnit et l’écriture de tests automatiques' ou le podcast quotidien qu’il anime.
Développeur, auteur, formateur, vacataire, consultant sont autant de manières différentes d’exprimer une même passion pour le code.

Photo by Quino Al on Unsplash

FAQs

Je n’ai pas le temps de suivre cette formation

Justement, je l’ai pensée pour les gens qui ont peu de temps et qui veulent des choses utiles dans leur quotidien. Je garderai les modules les plus condensés possibles. Mon but est que tu codes plus et mieux, pas que tu mates des vidéos à longueur de journées.

Se faire rembourser ?

Tu as 30 jours pour me dire si tu n'y trouves pas ton compte. Il te suffit de m'expliquer ce qui ne te convient pas ou ce qui t'a manqué et je te rembourse sans autre condition.

Est-ce que j'accéderai tout de suite à ma formation ?

Oui, la formation est en ligne.

Est-ce que ça va marcher pour moi ?

Que tu sois en Freelance ou employé, que tu lances un nouveau projet ou que tu bosses sur du legacy, cela s’applique à toi.

Si j’ai une question ?

Tu m’envoies un email et je te répondrai !

Je ne suis intéressé que par ce module, est-ce embêtant ?

Je pense qu'il vaut mieux suivre le cursus dans l'ordre car a pédagogie en escalator marche mieux comme ça, mais tu fais comme tu veux !

Quel est le format de contenu ?

La formation sera sous forme vidéo.
Je joins également deux fiches pdf qui contiennent :
  • la mind map du cours pour te repérer
  • le quizz pour travailler la mémorisation
  • les exercices de mise en application pour ancrer les concepts

Quels sont les pré-requis ?

Il faut que tu saches déjà écrire du code objet dans un langage de ton choix.
Idéalement tu as commencé par le module 1 qui pose les bases du travail.
Il faut connaitre les pattern de refactoring de base et savoir appliquer le principe de responsabilité unique tel qu'enseigné dans le module 2 et gérer les dépendances tel qu'expliqué dans le module 3.